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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.25.3.dev1
+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.dev1 → ouroboros_ai-0.25.3.dev3}/docs/cli-reference.md

@@ -83,7 +83,7 @@ ouroboros init [start] [OPTIONS] [CONTEXT]
 |--------|-------------|
 | `-r, --resume TEXT` | Resume an existing interview by ID |
 | `--state-dir DIRECTORY` | Custom directory for interview state files |
-| `-o, --orchestrator` | Use Claude Code (Max Plan) instead of LiteLLM. No API key required |
+| `-o, --orchestrator` | Use Claude Code (Max Plan) instead of Anthropic API. No API key required |
 | `-d, --debug` | Show verbose logs including debug messages |
 
 **Examples:**
@@ -493,21 +493,21 @@ ouroboros run seed.yaml
 ouroboros monitor
 ```
 
-### Using LiteLLM (External API)
+### Using Anthropic API (Default Non-Orchestrator Path)
 
-Requires API key (OPENROUTER_API_KEY, ANTHROPIC_API_KEY, etc.)
+Requires `ANTHROPIC_API_KEY`.
 
 ```bash
 # 1. Initialize configuration
 ouroboros config init
 
-# 2. Set your API key
-ouroboros config set providers.openrouter.api_key $OPENROUTER_API_KEY
+# 2. Export your API key
+export ANTHROPIC_API_KEY=your-key-here
 
 # 3. Start interview
 ouroboros init "Build a REST API for task management"
 
-# 4. Execute workflow (use --no-orchestrator for LiteLLM path)
+# 4. Execute workflow (use --no-orchestrator for the standard path)
 ouroboros run seed.yaml --no-orchestrator
 ```
 
@@ -517,8 +517,8 @@ ouroboros run seed.yaml --no-orchestrator
 
 | Variable | Description |
 |----------|-------------|
-| `OPENROUTER_API_KEY` | OpenRouter API key for LiteLLM |
-| `ANTHROPIC_API_KEY` | Anthropic API key for LiteLLM |
+| `OPENROUTER_API_KEY` | OpenRouter API key for optional LiteLLM-based integrations |
+| `ANTHROPIC_API_KEY` | Anthropic API key for direct Anthropic-backed interview mode |
 | `OPENAI_API_KEY` | OpenAI API key for LiteLLM |
 
 ---

{ouroboros_ai-0.25.3.dev1 → ouroboros_ai-0.25.3.dev3}/docs/running-with-claude-code.md

@@ -136,7 +136,7 @@ The orchestrator uses `claude-agent-sdk` which connects directly to your authent
 # Start interactive interview (Claude Code)
 uv run ouroboros init start --orchestrator "Your idea here"
 
-# Start interactive interview (LiteLLM - needs API key)
+# Start interactive interview (Anthropic API - needs ANTHROPIC_API_KEY)
 uv run ouroboros init start "Your idea here"
 
 # Resume an interrupted interview

{ouroboros_ai-0.25.3.dev1 → 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.dev1'
-__version_tuple__ = version_tuple = (0, 25, 3, 'dev1')
+__version__ = version = '0.25.3.dev3'
+__version_tuple__ = version_tuple = (0, 25, 3, 'dev3')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.25.3.dev1 → ouroboros_ai-0.25.3.dev3}/src/ouroboros/bigbang/ambiguity.py

@@ -20,12 +20,7 @@ import structlog
 from ouroboros.bigbang.interview import InterviewState
 from ouroboros.core.errors import ProviderError
 from ouroboros.core.types import Result
-from ouroboros.providers.base import CompletionConfig, Message, MessageRole
-
-try:
-    from ouroboros.providers.litellm_adapter import LiteLLMAdapter
-except ImportError:
-    LiteLLMAdapter = None  # type: ignore[assignment,misc]
+from ouroboros.providers.base import CompletionConfig, LLMAdapter, Message, MessageRole
 
 log = structlog.get_logger()
 
@@ -138,7 +133,7 @@ class AmbiguityScorer:
         max_retries: Maximum retry attempts, or None for unlimited (default).
 
     Example:
-        scorer = AmbiguityScorer(llm_adapter=LiteLLMAdapter())
+        scorer = AmbiguityScorer(llm_adapter=some_adapter)
 
         result = await scorer.score(interview_state)
         if result.is_ok:
@@ -151,7 +146,7 @@ class AmbiguityScorer:
                 questions = scorer.generate_clarification_questions(ambiguity.breakdown)
     """
 
-    llm_adapter: LiteLLMAdapter
+    llm_adapter: LLMAdapter
     model: str = DEFAULT_MODEL
     temperature: float = SCORING_TEMPERATURE
     initial_max_tokens: int = 2048
@@ -414,17 +409,14 @@ Analyze each component and provide scores with justifications."""
         except json.JSONDecodeError as e:
             raise ValueError(f"Invalid JSON response: {e}") from e
 
-        # Validate all required fields are present
-        required_fields = [
+        # Numeric score fields must be present. Missing justifications are recoverable.
+        required_score_fields = [
             "goal_clarity_score",
-            "goal_clarity_justification",
             "constraint_clarity_score",
-            "constraint_clarity_justification",
             "success_criteria_clarity_score",
-            "success_criteria_clarity_justification",
         ]
 
-        for field_name in required_fields:
+        for field_name in required_score_fields:
             if field_name not in data:
                 raise ValueError(f"Missing required field: {field_name}")
 
@@ -433,6 +425,15 @@ Analyze each component and provide scores with justifications."""
             score = float(value)
             return max(0.0, min(1.0, score))
 
+        def justification_for(field_name: str, component_name: str) -> str:
+            value = data.get(field_name)
+            if value is None:
+                return f"{component_name} justification not provided by model."
+            text = str(value).strip()
+            if not text:
+                return f"{component_name} justification not provided by model."
+            return text
+
         # Select weights based on project type
         if is_brownfield:
             goal_weight = BROWNFIELD_GOAL_CLARITY_WEIGHT
@@ -450,7 +451,10 @@ Analyze each component and provide scores with justifications."""
                 name="Context Clarity",
                 clarity_score=clamp_score(data["context_clarity_score"]),
                 weight=BROWNFIELD_CONTEXT_CLARITY_WEIGHT,
-                justification=str(data.get("context_clarity_justification", "")),
+                justification=justification_for(
+                    "context_clarity_justification",
+                    "Context Clarity",
+                ),
             )
 
         return ScoreBreakdown(
@@ -458,19 +462,28 @@ Analyze each component and provide scores with justifications."""
                 name="Goal Clarity",
                 clarity_score=clamp_score(data["goal_clarity_score"]),
                 weight=goal_weight,
-                justification=str(data["goal_clarity_justification"]),
+                justification=justification_for(
+                    "goal_clarity_justification",
+                    "Goal Clarity",
+                ),
             ),
             constraint_clarity=ComponentScore(
                 name="Constraint Clarity",
                 clarity_score=clamp_score(data["constraint_clarity_score"]),
                 weight=constraint_weight,
-                justification=str(data["constraint_clarity_justification"]),
+                justification=justification_for(
+                    "constraint_clarity_justification",
+                    "Constraint Clarity",
+                ),
             ),
             success_criteria_clarity=ComponentScore(
                 name="Success Criteria Clarity",
                 clarity_score=clamp_score(data["success_criteria_clarity_score"]),
                 weight=criteria_weight,
-                justification=str(data["success_criteria_clarity_justification"]),
+                justification=justification_for(
+                    "success_criteria_clarity_justification",
+                    "Success Criteria Clarity",
+                ),
             ),
             context_clarity=context_clarity,
         )

{ouroboros_ai-0.25.3.dev1 → ouroboros_ai-0.25.3.dev3}/src/ouroboros/cli/commands/init.py

@@ -1,7 +1,7 @@
 """Init command for starting interactive interview.
 
 This command initiates the Big Bang phase interview process.
-Supports both LiteLLM (external API) and Claude Code (Max Plan) modes.
+Supports both direct Anthropic API and Claude Code (Max Plan) modes.
 """
 
 import asyncio
@@ -27,13 +27,9 @@ from ouroboros.bigbang.seed_generator import SeedGenerator
 from ouroboros.cli.formatters import console
 from ouroboros.cli.formatters.panels import print_error, print_info, print_success, print_warning
 from ouroboros.observability import LoggingConfig, configure_logging
+from ouroboros.providers.anthropic_adapter import AnthropicAdapter
 from ouroboros.providers.base import LLMAdapter
 
-try:
-    from ouroboros.providers.litellm_adapter import LiteLLMAdapter
-except ImportError:
-    LiteLLMAdapter = None  # type: ignore[assignment,misc]
-
 
 class SeedGenerationResult(Enum):
     """Result of seed generation attempt."""
@@ -140,7 +136,7 @@ def _get_adapter(
     """Get the appropriate LLM adapter.
 
     Args:
-        use_orchestrator: If True, use Claude Code (Max Plan). Otherwise LiteLLM.
+        use_orchestrator: If True, use Claude Code (Max Plan). Otherwise Anthropic API.
         for_interview: If True, enable Read/Glob/Grep tools for codebase exploration.
         debug: If True, show streaming messages (thinking, tool use).
 
@@ -160,8 +156,7 @@ def _get_adapter(
                 on_message=_make_message_callback(debug),
             )
         return ClaudeCodeAdapter()
-    else:
-        return LiteLLMAdapter()
+    return AnthropicAdapter()
 
 
 async def _run_interview_loop(
@@ -262,7 +257,7 @@ async def _run_interview(
         initial_context: Initial context or idea for the interview.
         resume_id: Optional interview ID to resume.
         state_dir: Optional custom state directory.
-        use_orchestrator: If True, use Claude Code (Max Plan) instead of LiteLLM.
+        use_orchestrator: If True, use Claude Code (Max Plan) instead of Anthropic API.
     """
     # Initialize components
     llm_adapter = _get_adapter(use_orchestrator, for_interview=True, debug=debug)
@@ -500,7 +495,7 @@ def start(
         typer.Option(
             "--orchestrator",
             "-o",
-            help="Use Claude Code (Max Plan) instead of LiteLLM. No API key required.",
+            help="Use Claude Code (Max Plan) instead of Anthropic API. No API key required.",
         ),
     ] = False,
     debug: Annotated[
@@ -553,7 +548,7 @@ def start(
     if orchestrator:
         print_info("Using Claude Code (Max Plan) - no API key required")
     else:
-        print_info("Using LiteLLM - API key required")
+        print_info("Using Anthropic API - ANTHROPIC_API_KEY required")
 
     # Run interview
     try:
@@ -581,7 +576,7 @@ def list_interviews(
     ] = None,
 ) -> None:
     """List all interview sessions."""
-    llm_adapter = LiteLLMAdapter()
+    llm_adapter = AnthropicAdapter()
     engine = InterviewEngine(
         llm_adapter=llm_adapter,
         state_dir=state_dir or Path.home() / ".ouroboros" / "data",

{ouroboros_ai-0.25.3.dev1 → 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.dev1 → 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.dev1 → 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.dev1 → 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.dev1 → 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.dev1 → ouroboros_ai-0.25.3.dev3}/tests/e2e/test_cli_commands.py

@@ -74,7 +74,7 @@ class TestInitCommand:
     ) -> None:
         """Test init start with context argument."""
         # Mock the LLM adapter and asyncio.run
-        with patch("ouroboros.cli.commands.init.LiteLLMAdapter") as mock_adapter_class:
+        with patch("ouroboros.cli.commands.init.AnthropicAdapter") as mock_adapter_class:
             mock_adapter = MagicMock()
             mock_adapter.complete = mock_interview_llm_provider.complete
             mock_adapter_class.return_value = mock_adapter
@@ -107,7 +107,7 @@ class TestInitCommand:
 
     def test_init_list_no_interviews(self, temp_state_dir: Path) -> None:
         """Test init list when no interviews exist."""
-        with patch("ouroboros.cli.commands.init.LiteLLMAdapter"):
+        with patch("ouroboros.cli.commands.init.AnthropicAdapter"):
             with patch("ouroboros.cli.commands.init.asyncio.run") as mock_run:
                 mock_run.return_value = []
 
@@ -121,7 +121,7 @@ class TestInitCommand:
 
     def test_init_resume_missing_interview(self, temp_state_dir: Path) -> None:
         """Test init resume with non-existent interview ID."""
-        with patch("ouroboros.cli.commands.init.LiteLLMAdapter") as mock_adapter_class:
+        with patch("ouroboros.cli.commands.init.AnthropicAdapter") as mock_adapter_class:
             mock_adapter = MagicMock()
             mock_adapter_class.return_value = mock_adapter