ouroboros-ai 0.38.3.dev99__tar.gz → 0.38.3.dev101__tar.gz

{ouroboros_ai-0.38.3.dev99 → ouroboros_ai-0.38.3.dev101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.38.3.dev99
+Version: 0.38.3.dev101
 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.38.3.dev99 → ouroboros_ai-0.38.3.dev101}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.38.3.dev99'
-__version_tuple__ = version_tuple = (0, 38, 3, 'dev99')
+__version__ = version = '0.38.3.dev101'
+__version_tuple__ = version_tuple = (0, 38, 3, 'dev101')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.38.3.dev99 → ouroboros_ai-0.38.3.dev101}/src/ouroboros/orchestrator/codex_cli_runtime.py

@@ -1279,18 +1279,37 @@ class CodexCliRuntime:
     def _extract_command_metadata(self, item: dict[str, Any]) -> dict[str, Any]:
         """Extract command result fields that can support verifier evidence."""
         data: dict[str, Any] = {}
-        for key in ("output", "stdout", "stderr", "result_preview", "status"):
-            value = item.get(key)
+        self._merge_command_metadata(data, item)
+        for container_key in ("output", "result", "metadata", "data"):
+            nested = item.get(container_key)
+            if isinstance(nested, dict):
+                self._merge_command_metadata(data, nested)
+        return data
+
+    def _merge_command_metadata(self, data: dict[str, Any], source: dict[str, Any]) -> None:
+        """Merge known command-result fields from one Codex event object."""
+        text_key_map = {
+            "output": "output",
+            "stdout": "stdout",
+            "stderr": "stderr",
+            "result_preview": "result_preview",
+            "resultPreview": "result_preview",
+            "text": "output",
+            "status": "status",
+        }
+        for key, target_key in text_key_map.items():
+            value = source.get(key)
             if isinstance(value, str) and value.strip():
-                data[key] = value.strip()
-        for key in ("exit_code", "exitCode"):
-            value = item.get(key)
+                data.setdefault(target_key, value.strip())
+        for key in ("exit_code", "exitCode", "returncode", "return_code"):
+            value = source.get(key)
             if isinstance(value, int):
-                data["exit_code"] = value
+                data.setdefault("exit_code", value)
                 break
-        if item.get("success") is True:
+        if source.get("success") is True:
+            data.setdefault("subtype", "success")
+        if source.get("ok") is True:
             data.setdefault("subtype", "success")
-        return data
 
     def _build_tool_message(
         self,

{ouroboros_ai-0.38.3.dev99 → ouroboros_ai-0.38.3.dev101}/src/ouroboros/orchestrator/parallel_executor.py

@@ -503,10 +503,13 @@ def _looks_like_test_command(command: str) -> bool:
 def _message_contains_test_success(message: AgentMessage) -> bool:
     """Return True when one message says a test command passed."""
     parts = [message.content]
-    for key in ("result_preview", "output", "stdout"):
+    for key in ("result_preview", "output", "stdout", "status", "subtype"):
         value = message.data.get(key)
         if isinstance(value, str):
             parts.append(value)
+    exit_code = message.data.get("exit_code")
+    if type(exit_code) is int:
+        parts.append(f"exit code {exit_code}")
     text = "\n".join(parts).lower()
     zero_failure_pattern = (
         r"\b(0\s+(failed|failures?|errors?)|no\s+(tests?\s+)?(failed|failures?|errors?))\b"

{ouroboros_ai-0.38.3.dev99 → ouroboros_ai-0.38.3.dev101}/tests/unit/orchestrator/test_codex_cli_runtime.py

@@ -685,6 +685,37 @@ class TestCodexCliRuntime:
         assert message.data["output"] == "1 passed in 0.01s"
         assert message.data["exit_code"] == 0
 
+    def test_convert_command_execution_preserves_nested_output_metadata(self) -> None:
+        """Codex command result fields may arrive under nested output/result objects."""
+        runtime = CodexCliRuntime(cli_path="codex")
+
+        messages = runtime._convert_event(
+            {
+                "type": "item.completed",
+                "item": {
+                    "type": "command_execution",
+                    "command": "/bin/zsh -lc 'python -m pytest test_hello.py'",
+                    "output": {
+                        "stdout": "1 passed in 0.01s",
+                        "exit_code": 0,
+                    },
+                    "result": {"status": "completed", "success": True},
+                },
+            },
+            current_handle=None,
+        )
+
+        assert len(messages) == 1
+        message = messages[0]
+        assert message.tool_name == "Bash"
+        assert message.data["tool_input"]["command"] == (
+            "/bin/zsh -lc 'python -m pytest test_hello.py'"
+        )
+        assert message.data["stdout"] == "1 passed in 0.01s"
+        assert message.data["exit_code"] == 0
+        assert message.data["status"] == "completed"
+        assert message.data["subtype"] == "success"
+
     def test_convert_file_change_event_emits_each_changed_file(self) -> None:
         """Multi-file Codex changes should create one proof message per path."""
         runtime = CodexCliRuntime(cli_path="codex")

{ouroboros_ai-0.38.3.dev99 → ouroboros_ai-0.38.3.dev101}/tests/unit/orchestrator/test_parallel_executor.py

@@ -95,6 +95,7 @@ def _make_replaying_event_store() -> tuple[AsyncMock, list[BaseEvent]]:
         ("no errors, 3 passed", True),
         ("no tests failed, 3 passed", True),
         ("exit code 0", True),
+        ("success", True),
         ("1 failed, 3 passed", False),
         ("2 errors, 1 passed", False),
         ("FAILED tests/test_app.py::test_auth", False),
@@ -2593,6 +2594,87 @@ class TestParallelACExecutor:
         )
         assert evidence_event.data["verifier_passed"] is False
 
+    @pytest.mark.asyncio
+    async def test_fat_harness_verifier_accepts_exit_code_only_test_success(self, tmp_path) -> None:
+        """Regression for #978 observation: Codex may omit pytest stdout but keep exit_code=0."""
+        hello_file = tmp_path / "hello.py"
+        test_file = tmp_path / "test_hello.py"
+        hello_file.write_text('def hello():\n    return "hello"\n', encoding="utf-8")
+        test_file.write_text(
+            "from hello import hello\n\n"
+            "def test_hello_returns_hello():\n"
+            "    assert hello() == 'hello'\n",
+            encoding="utf-8",
+        )
+
+        event_store, appended_events = _make_replaying_event_store()
+        executor = ParallelACExecutor(
+            adapter=_FinalMessageRuntime(
+                "```json\n"
+                "{\n"
+                '  "files_touched": ["hello.py", "test_hello.py"],\n'
+                '  "commands_run": ["python -m pytest test_hello.py"],\n'
+                '  "tests_passed": ["test_hello.py::test_hello_returns_hello"]\n'
+                "}\n"
+                "```",
+                native_session_id="codex-session-exit-code-only-pytest",
+                support_messages=(
+                    AgentMessage(
+                        type="assistant",
+                        content=f"Calling tool: Edit: {hello_file}",
+                        tool_name="Edit",
+                        data={"tool_input": {"file_path": str(hello_file)}},
+                    ),
+                    AgentMessage(
+                        type="assistant",
+                        content=f"Calling tool: Edit: {test_file}",
+                        tool_name="Edit",
+                        data={"tool_input": {"file_path": str(test_file)}},
+                    ),
+                    AgentMessage(
+                        type="assistant",
+                        content="Calling tool: Bash: /bin/zsh -lc 'python -m pytest test_hello.py'",
+                        tool_name="Bash",
+                        data={
+                            "tool_input": {
+                                "command": "/bin/zsh -lc 'python -m pytest test_hello.py'"
+                            },
+                            "exit_code": 0,
+                        },
+                    ),
+                ),
+                cwd=str(tmp_path),
+            ),
+            event_store=event_store,
+            console=MagicMock(),
+            enable_decomposition=False,
+            execution_profile=load_profile("code"),
+            fat_harness_mode=True,
+            task_cwd=str(tmp_path),
+        )
+
+        result = await executor._execute_atomic_ac(
+            ac_index=0,
+            ac_content='Create hello.py with hello() returning "hello".',
+            session_id="orch_123",
+            tools=["Read"],
+            tool_catalog=(MCPToolDefinition(name="Read", description="Read a file."),),
+            system_prompt="system",
+            seed_goal="Ship the feature",
+            depth=0,
+            start_time=datetime.now(UTC),
+        )
+
+        assert result.success is True
+        assert result.atomic_verifier_verdict is not None
+        assert result.atomic_verifier_verdict.passed is True
+        evidence_event = next(
+            event
+            for event in appended_events
+            if event.type == "execution.ac.typed_evidence.observed"
+        )
+        assert evidence_event.data["verifier_passed"] is True
+
     @pytest.mark.asyncio
     async def test_fat_harness_verifier_rejects_test_not_covered_by_success_chunk(
         self, tmp_path