ouroboros-ai 0.25.3.dev2__tar.gz → 0.25.3.dev3__tar.gz

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.25.3.dev2
+Version: 0.25.3.dev3
 Summary: Self-Improving AI Workflow System
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/src/ouroboros/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.25.3.dev2'
-__version_tuple__ = version_tuple = (0, 25, 3, 'dev2')
+__version__ = version = '0.25.3.dev3'
+__version_tuple__ = version_tuple = (0, 25, 3, 'dev3')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/src/ouroboros/cli/commands/run.py

@@ -52,6 +52,14 @@ def _derive_quality_bar(seed: Seed) -> str:
     return "The execution must satisfy all acceptance criteria:\n" + "\n".join(ac_lines)
 
 
+def _get_verification_artifact(summary: dict[str, Any], final_message: str) -> str:
+    """Prefer the structured verification report when present."""
+    verification_report = summary.get("verification_report")
+    if isinstance(verification_report, str) and verification_report:
+        return verification_report
+    return final_message or ""
+
+
 def _load_seed_from_yaml(seed_file: Path) -> dict[str, Any]:
     """Load seed configuration from YAML file.
 
@@ -238,7 +246,7 @@ async def _run_orchestrator(
 
                     qa_result = await qa_handler.handle(
                         {
-                            "artifact": res.final_message or "",
+                            "artifact": _get_verification_artifact(res.summary, res.final_message),
                             "artifact_type": "test_output",
                             "quality_bar": quality_bar,
                             "seed_content": yaml.dump(seed_data, default_flow_style=False),

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/src/ouroboros/evolution/loop.py

@@ -888,7 +888,15 @@ class EvolutionaryLoop:
                 exec_result = await self.executor(current_seed, parallel=parallel)
                 if hasattr(exec_result, "is_ok") and exec_result.is_ok:
                     orch_result = exec_result.value
-                    execution_output = getattr(orch_result, "final_message", str(orch_result))
+                    summary = getattr(orch_result, "summary", {})
+                    verification_report = (
+                        summary.get("verification_report") if isinstance(summary, dict) else None
+                    )
+                    execution_output = (
+                        verification_report
+                        if isinstance(verification_report, str) and verification_report
+                        else getattr(orch_result, "final_message", str(orch_result))
+                    )
                     # Log structured metadata for observability
                     logger.info(
                         "evolution.generation.executed",

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/src/ouroboros/mcp/tools/definitions.py

@@ -290,7 +290,10 @@ class ExecuteSeedHandler:
                 quality_bar = self._derive_quality_bar(seed)
                 qa_result = await qa_handler.handle(
                     {
-                        "artifact": exec_result.final_message or "",
+                        "artifact": self._get_verification_artifact(
+                            exec_result.summary,
+                            exec_result.final_message,
+                        ),
                         "artifact_type": "test_output",
                         "quality_bar": quality_bar,
                         "seed_content": seed_content,
@@ -335,6 +338,14 @@ class ExecuteSeedHandler:
         ac_lines = [f"- {ac}" for ac in seed.acceptance_criteria]
         return "The execution must satisfy all acceptance criteria:\n" + "\n".join(ac_lines)
 
+    @staticmethod
+    def _get_verification_artifact(summary: dict[str, Any], final_message: str) -> str:
+        """Prefer the structured verification report when present."""
+        verification_report = summary.get("verification_report")
+        if isinstance(verification_report, str) and verification_report:
+            return verification_report
+        return final_message or ""
+
     @staticmethod
     def _format_execution_result(exec_result, seed: Seed) -> str:
         """Format execution result as human-readable text.

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/src/ouroboros/orchestrator/parallel_executor.py

@@ -78,6 +78,7 @@ _STALL_SENTINEL = "__STALL_DETECTED__"  # Sentinel error for stall results
 _MIN_FREE_MEMORY_GB = 2.0
 _MEMORY_CHECK_INTERVAL_SECONDS = 5.0
 _MEMORY_WAIT_MAX_SECONDS = 120.0
+_MAX_LEAF_RESULT_CHARS = 1200
 
 
 def _get_available_memory_gb() -> float | None:
@@ -189,6 +190,152 @@ class ParallelExecutionResult:
         return self.success_count > 0
 
 
+def _normalize_command(command: str) -> str:
+    """Normalize Bash commands for stable audit output."""
+    return " ".join(command.split())
+
+
+def _truncate_text(text: str, limit: int = _MAX_LEAF_RESULT_CHARS) -> str:
+    """Truncate long evidence blocks while preserving their beginning."""
+    stripped = text.strip()
+    if len(stripped) <= limit:
+        return stripped
+    return stripped[:limit].rstrip() + "\n[TRUNCATED]"
+
+
+def _extract_leaf_evidence_lines(result: ACExecutionResult) -> list[str]:
+    """Extract normalized command, file, and result evidence for a leaf AC."""
+    lines: list[str] = []
+    seen_commands: set[str] = set()
+    seen_file_ops: set[tuple[str, str]] = set()
+
+    for message in result.messages:
+        if not message.tool_name:
+            continue
+        tool_input = message.data.get("tool_input", {})
+        if not isinstance(tool_input, dict):
+            tool_input = {}
+
+        if message.tool_name == "Bash":
+            command = tool_input.get("command")
+            if isinstance(command, str):
+                normalized = _normalize_command(command)
+                if normalized and normalized not in seen_commands:
+                    if not lines:
+                        lines.append("Commands Run:")
+                    lines.append(f"- Bash: {normalized}")
+                    seen_commands.add(normalized)
+            continue
+
+        if message.tool_name in ("Write", "Edit", "NotebookEdit"):
+            path_key = "notebook_path" if message.tool_name == "NotebookEdit" else "file_path"
+            file_path = tool_input.get(path_key)
+            if isinstance(file_path, str) and file_path:
+                file_op = (message.tool_name, file_path)
+                if file_op not in seen_file_ops:
+                    if "File Changes:" not in lines:
+                        lines.append("File Changes:")
+                    lines.append(f"- {message.tool_name}: {file_path}")
+                    seen_file_ops.add(file_op)
+
+    result_text = result.final_message or (f"Error: {result.error}" if result.error else "")
+    if result_text:
+        lines.append("Result:")
+        lines.append(_truncate_text(result_text))
+    return lines
+
+
+def _render_ac_section(
+    result: ACExecutionResult,
+    *,
+    index_path: tuple[int, ...],
+    heading_level: int,
+    include_header: bool = True,
+) -> list[str]:
+    """Render a single AC or Sub-AC section for verification/audit output."""
+    lines: list[str] = []
+    if include_header:
+        status = "PASS" if result.success else "FAIL"
+        label = "AC" if len(index_path) == 1 else "Sub-AC"
+        lines.append(
+            f"{'#' * heading_level} {label} {'.'.join(str(i) for i in index_path)}: "
+            f"[{status}] {result.ac_content}"
+        )
+
+    if result.is_decomposed and result.sub_results:
+        lines.append(f"Decomposed into {len(result.sub_results)} Sub-ACs")
+        for idx, sub_result in enumerate(result.sub_results, start=1):
+            if lines:
+                lines.append("")
+            lines.extend(
+                _render_ac_section(
+                    sub_result,
+                    index_path=index_path + (idx,),
+                    heading_level=min(heading_level + 1, 6),
+                )
+            )
+        return lines
+
+    evidence_lines = _extract_leaf_evidence_lines(result)
+    if evidence_lines:
+        lines.extend(evidence_lines)
+    else:
+        lines.append("Result:")
+        lines.append("No final result message captured.")
+    return lines
+
+
+def render_parallel_verification_report(
+    parallel_result: ParallelExecutionResult,
+    total_acceptance_criteria: int,
+) -> str:
+    """Build the canonical QA artifact for parallel execution results."""
+    lines = [
+        "Parallel Execution Verification Report",
+        f"Success: {parallel_result.success_count}/{total_acceptance_criteria}",
+    ]
+    if parallel_result.failure_count > 0:
+        lines.append(f"Failed: {parallel_result.failure_count}")
+    if parallel_result.skipped_count > 0:
+        lines.append(f"Skipped: {parallel_result.skipped_count}")
+
+    lines.append("")
+    lines.append("## AC Results")
+    for result in parallel_result.results:
+        lines.append("")
+        lines.extend(
+            _render_ac_section(
+                result,
+                index_path=(result.ac_index + 1,),
+                heading_level=3,
+            )
+        )
+    return "\n".join(lines)
+
+
+def render_parallel_completion_message(
+    parallel_result: ParallelExecutionResult,
+    total_acceptance_criteria: int,
+) -> str:
+    """Build a concise operator-facing completion summary."""
+    lines = [
+        "Parallel Execution Complete",
+        f"Success: {parallel_result.success_count}/{total_acceptance_criteria}",
+    ]
+    if parallel_result.failure_count > 0:
+        lines.append(f"Failed: {parallel_result.failure_count}")
+    if parallel_result.skipped_count > 0:
+        lines.append(f"Skipped: {parallel_result.skipped_count}")
+
+    lines.append("")
+    lines.append("AC Status:")
+    for result in parallel_result.results:
+        status = "PASS" if result.success else "FAIL"
+        suffix = f" ({len(result.sub_results)} sub-ACs)" if result.is_decomposed else ""
+        lines.append(f"- AC {result.ac_index + 1}: [{status}] {result.ac_content}{suffix}")
+    return "\n".join(lines)
+
+
 # =============================================================================
 # Parallel Executor
 # =============================================================================
@@ -988,7 +1135,23 @@ class ParallelACExecutor:
                     ac_content=ac_content,
                     success=all_success,
                     messages=(),
-                    final_message=f"Decomposed into {len(sub_acs)} Sub-ACs",
+                    final_message="\n".join(
+                        _render_ac_section(
+                            ACExecutionResult(
+                                ac_index=ac_index,
+                                ac_content=ac_content,
+                                success=all_success,
+                                messages=(),
+                                duration_seconds=duration,
+                                is_decomposed=True,
+                                sub_results=tuple(sub_results),
+                                depth=depth,
+                            ),
+                            index_path=(ac_index + 1,),
+                            heading_level=3,
+                            include_header=False,
+                        )
+                    ),
                     duration_seconds=duration,
                     is_decomposed=True,
                     sub_results=tuple(sub_results),

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/src/ouroboros/orchestrator/runner.py

@@ -1144,7 +1144,11 @@ class OrchestratorRunner:
             Result containing OrchestratorResult on success.
         """
         from ouroboros.orchestrator.dependency_analyzer import DependencyAnalyzer
-        from ouroboros.orchestrator.parallel_executor import ParallelACExecutor
+        from ouroboros.orchestrator.parallel_executor import (
+            ParallelACExecutor,
+            render_parallel_completion_message,
+            render_parallel_verification_report,
+        )
 
         log.info(
             "orchestrator.runner.parallel_mode_enabled",
@@ -1234,43 +1238,30 @@ class OrchestratorRunner:
         # Determine overall success
         success = parallel_result.all_succeeded
 
-        # Build summary message with per-AC results for downstream evaluation.
-        # The evaluator uses final_message as the artifact to judge compliance,
-        # so a bare "Success: 6/6" gives it no evidence to work with.
-        summary_parts = [
-            "Parallel Execution Complete",
-            f"Success: {parallel_result.success_count}/{len(seed.acceptance_criteria)}",
-        ]
-        if parallel_result.failure_count > 0:
-            summary_parts.append(f"Failed: {parallel_result.failure_count}")
-        if parallel_result.skipped_count > 0:
-            summary_parts.append(f"Skipped: {parallel_result.skipped_count}")
-
-        summary_parts.append("\n## AC Results")
-        for r in parallel_result.results:
-            status = "PASS" if r.success else "FAIL"
-            ac_label = f"AC {r.ac_index + 1}"
-            summary_parts.append(f"\n### {ac_label}: [{status}] {r.ac_content}")
-            if r.final_message:
-                # Include last 500 chars of agent output as evidence
-                evidence = r.final_message[-500:] if len(r.final_message) > 500 else r.final_message
-                summary_parts.append(evidence)
-            elif r.error:
-                summary_parts.append(f"Error: {r.error}")
-
-        final_message = "\n".join(summary_parts)
+        final_message = render_parallel_completion_message(
+            parallel_result,
+            len(seed.acceptance_criteria),
+        )
+        verification_report = render_parallel_verification_report(
+            parallel_result,
+            len(seed.acceptance_criteria),
+        )
+        execution_summary = {
+            "goal": seed.goal,
+            "acceptance_criteria_count": len(seed.acceptance_criteria),
+            "parallel_execution": True,
+            "success_count": parallel_result.success_count,
+            "failure_count": parallel_result.failure_count,
+            "skipped_count": parallel_result.skipped_count,
+            "total_levels": dependency_graph.total_levels,
+            "verification_report": verification_report,
+        }
 
         # Emit completion event
         if success:
             completed_event = create_session_completed_event(
                 session_id=tracker.session_id,
-                summary={
-                    "parallel_execution": True,
-                    "success_count": parallel_result.success_count,
-                    "failure_count": parallel_result.failure_count,
-                    "skipped_count": parallel_result.skipped_count,
-                    "total_levels": dependency_graph.total_levels,
-                },
+                summary=execution_summary,
                 messages_processed=parallel_result.total_messages,
             )
             await self._event_store.append(completed_event)
@@ -1327,14 +1318,7 @@ class OrchestratorRunner:
                 success=success,
                 session_id=tracker.session_id,
                 execution_id=exec_id,
-                summary={
-                    "goal": seed.goal,
-                    "acceptance_criteria_count": len(seed.acceptance_criteria),
-                    "parallel_execution": True,
-                    "success_count": parallel_result.success_count,
-                    "failure_count": parallel_result.failure_count,
-                    "skipped_count": parallel_result.skipped_count,
-                },
+                summary=execution_summary,
                 messages_processed=parallel_result.total_messages,
                 final_message=final_message,
                 duration_seconds=duration,

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/tests/unit/mcp/tools/test_qa_integration.py

@@ -112,7 +112,11 @@ class TestExecuteSeedHandlerQA:
         """QA is called after successful execution and result includes verdict."""
         handler = ExecuteSeedHandler()
 
-        fake_exec = FakeExecResult()
+        fake_exec = FakeExecResult(
+            summary={
+                "verification_report": "### AC 1: [PASS] All tests pass\nResult:\nDetailed proof"
+            }
+        )
         mock_runner = AsyncMock()
         mock_runner.execute_seed = AsyncMock(return_value=Result.ok(fake_exec))
 
@@ -138,6 +142,7 @@ class TestExecuteSeedHandlerQA:
         # QA handler was called
         mock_qa_handle.assert_awaited_once()
         qa_args = mock_qa_handle.call_args[0][0]
+        assert qa_args["artifact"] == fake_exec.summary["verification_report"]
         assert qa_args["artifact_type"] == "test_output"
         assert "All tests pass" in qa_args["quality_bar"]
         assert "No lint errors" in qa_args["quality_bar"]

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/tests/unit/orchestrator/test_runner.py

@@ -521,6 +521,122 @@ class TestOrchestratorRunner:
         assert captured_init["inherited_runtime_handle"] == inherited_handle
         assert captured_execute["tools"] == ["Read", "mcp__chrome-devtools__click"]
 
+    @pytest.mark.asyncio
+    async def test_execute_parallel_emits_verification_report_for_decomposed_acs(
+        self,
+        mock_event_store: AsyncMock,
+        mock_console: MagicMock,
+        sample_seed: Seed,
+    ) -> None:
+        """Parallel execution should preserve decomposed Sub-AC evidence for QA."""
+        from ouroboros.core.types import Result
+        from ouroboros.orchestrator.dependency_analyzer import ACNode, DependencyGraph
+        from ouroboros.orchestrator.parallel_executor import (
+            ACExecutionResult,
+            ParallelExecutionResult,
+        )
+
+        runner = OrchestratorRunner(MagicMock(), mock_event_store, mock_console)
+        tracker = SessionTracker.create("exec_parallel", sample_seed.metadata.seed_id)
+
+        sub_result = ACExecutionResult(
+            ac_index=100,
+            ac_content="Create task storage",
+            success=True,
+            messages=(
+                AgentMessage(
+                    type="tool",
+                    content="Running tests",
+                    tool_name="Bash",
+                    data={
+                        "tool_input": {"command": "uv   run pytest\n tests/unit/test_runner.py -q"}
+                    },
+                ),
+                AgentMessage(
+                    type="tool",
+                    content="Writing file",
+                    tool_name="Write",
+                    data={"tool_input": {"file_path": "/tmp/project/task_store.py"}},
+                ),
+            ),
+            final_message="Implemented task storage and verified behavior.",
+        )
+
+        class FakeParallelExecutor:
+            def __init__(self, *args: Any, **kwargs: Any) -> None:
+                pass
+
+            async def execute_parallel(self, **kwargs: Any) -> ParallelExecutionResult:
+                return ParallelExecutionResult(
+                    results=(
+                        ACExecutionResult(
+                            ac_index=0,
+                            ac_content=sample_seed.acceptance_criteria[0],
+                            success=True,
+                            is_decomposed=True,
+                            sub_results=(sub_result,),
+                            final_message="Decomposed placeholder should not leak",
+                        ),
+                        ACExecutionResult(
+                            ac_index=1,
+                            ac_content=sample_seed.acceptance_criteria[1],
+                            success=True,
+                            final_message="Listed tasks correctly.",
+                        ),
+                        ACExecutionResult(
+                            ac_index=2,
+                            ac_content=sample_seed.acceptance_criteria[2],
+                            success=True,
+                            final_message="Deleted tasks correctly.",
+                        ),
+                    ),
+                    success_count=3,
+                    failure_count=0,
+                    total_messages=4,
+                    total_duration_seconds=0.2,
+                )
+
+        dependency_graph = DependencyGraph(
+            nodes=tuple(
+                ACNode(index=index, content=ac)
+                for index, ac in enumerate(sample_seed.acceptance_criteria)
+            ),
+            execution_levels=(tuple(range(len(sample_seed.acceptance_criteria))),),
+        )
+
+        with (
+            patch(
+                "ouroboros.orchestrator.dependency_analyzer.DependencyAnalyzer.analyze",
+                AsyncMock(return_value=Result.ok(dependency_graph)),
+            ),
+            patch(
+                "ouroboros.orchestrator.parallel_executor.ParallelACExecutor",
+                FakeParallelExecutor,
+            ),
+            patch.object(runner, "_check_cancellation", AsyncMock(return_value=False)),
+            patch.object(
+                runner._session_repo, "mark_completed", AsyncMock(return_value=Result.ok(None))
+            ),
+        ):
+            result = await runner._execute_parallel(
+                seed=sample_seed,
+                exec_id="exec_parallel",
+                tracker=tracker,
+                merged_tools=["Read", "Write", "Bash"],
+                system_prompt="system",
+                start_time=datetime.now(UTC),
+            )
+
+        assert result.is_ok
+        assert "Commands Run:" not in result.value.final_message
+        assert "AC Status:" in result.value.final_message
+        verification_report = result.value.summary["verification_report"]
+        assert "### AC 1: [PASS] Tasks can be created" in verification_report
+        assert "#### Sub-AC 1.1: [PASS] Create task storage" in verification_report
+        assert "Bash: uv run pytest tests/unit/test_runner.py -q" in verification_report
+        assert "Write: /tmp/project/task_store.py" in verification_report
+        assert "Decomposed placeholder should not leak" not in verification_report
+
 
 class TestOrchestratorError:
     """Tests for OrchestratorError."""

{ouroboros_ai-0.25.3.dev2 → ouroboros_ai-0.25.3.dev3}/tests/unit/test_artifact_collector.py

@@ -93,3 +93,22 @@ class TestArtifactCollector:
         bundle = collector.collect(output, project_dir=tmpdir)
         assert len(bundle.files) == 1
         assert 1 in bundle.files[0].ac_indices  # AC 2 → 0-based index 1
+
+    def test_collects_file_from_sub_ac_report_format(self) -> None:
+        tmpdir = self._create_project({"task_store.py": "TASKS = []\n"})
+        path = os.path.join(tmpdir, "task_store.py")
+        output = (
+            "### AC 1: [PASS] Create tasks\n"
+            "Decomposed into 1 Sub-ACs\n\n"
+            "#### Sub-AC 1.1: [PASS] Create task storage\n"
+            "File Changes:\n"
+            f"- Write: {path}\n"
+            "Result:\n"
+            "Implemented storage.\n"
+        )
+
+        collector = ArtifactCollector()
+        bundle = collector.collect(output, project_dir=tmpdir)
+        assert len(bundle.files) == 1
+        assert bundle.files[0].file_path == path
+        assert bundle.files[0].ac_indices == (0,)