ouroboros-ai 0.26.6.dev1__tar.gz → 0.26.7.dev1__tar.gz

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "ouroboros",
       "description": "Transform vague ideas into validated seed specifications through Socratic questioning and ontological analysis",
-      "version": "0.26.5",
+      "version": "0.26.6",
       "author": {
         "name": "Q00",
         "email": "jqyu.lee@gmail.com"

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ouroboros",
-  "version": "0.26.5",
+  "version": "0.26.6",
   "description": "Self-improving AI workflow system. Crystallize requirements before execution with Socratic interview, ambiguity scoring, and 3-stage evaluation.",
   "author": {
     "name": "Q00",

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/PKG-INFO

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

@@ -246,7 +246,7 @@ A backup will be created: CLAUDE.md.bak
 **If "Preview first", show:**
 ````markdown
 <!-- ooo:START -->
-<!-- ooo:VERSION:0.26.5 -->
+<!-- ooo:VERSION:0.26.6 -->
 # Ouroboros — Specification-First AI Development
 
 > Before telling AI what to build, define what should be built.

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/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.6.dev1'
-__version_tuple__ = version_tuple = (0, 26, 6, 'dev1')
+__version__ = version = '0.26.7.dev1'
+__version_tuple__ = version_tuple = (0, 26, 7, 'dev1')
 
 __commit_id__ = commit_id = None

ouroboros_ai-0.26.7.dev1/src/ouroboros/core/json_utils.py

@@ -0,0 +1,93 @@
+"""Shared JSON extraction utilities for evaluation modules.
+
+Provides a robust bracket-matching JSON extractor used by semantic,
+consensus, and QA evaluation stages.
+"""
+
+import json
+import re
+
+
+def extract_json_payload(text: str) -> str | None:
+    """Extract the first valid JSON object or array from text.
+
+    Tries each ``{`` or ``[`` position via bracket-depth counting and
+    validates with ``json.loads``.  This handles LLM responses that
+    contain prose before the actual JSON payload.
+
+    Args:
+        text: Raw text potentially containing a JSON object or array
+
+    Returns:
+        Extracted JSON string, or None if no valid JSON is found
+    """
+    # Strip code fences first (```json ... ```)
+    fence_match = re.search(r"```(?:json)?\s*([\[{][\s\S]*?[}\]])\s*```", text)
+    if fence_match:
+        text = fence_match.group(1)
+
+    pos = 0
+    while True:
+        # Find the next { or [ opener
+        obj_start = text.find("{", pos)
+        arr_start = text.find("[", pos)
+
+        if obj_start == -1 and arr_start == -1:
+            return None
+
+        # Pick whichever comes first
+        if obj_start == -1:
+            start = arr_start
+        elif arr_start == -1:
+            start = obj_start
+        else:
+            start = min(obj_start, arr_start)
+
+        candidate = _bracket_extract(text, start)
+        if candidate is not None:
+            try:
+                json.loads(candidate)
+                return candidate
+            except (json.JSONDecodeError, ValueError):
+                pass
+
+        pos = start + 1
+
+
+def _bracket_extract(text: str, start: int) -> str | None:
+    """Extract a bracket-balanced substring starting at *start*.
+
+    Supports both ``{}`` (objects) and ``[]`` (arrays).  Returns the
+    substring ``text[start:end+1]`` where *end* is the position of
+    the matching closer, or ``None`` if brackets never balance.
+    """
+    open_char = text[start]
+    close_char = "}" if open_char == "{" else "]"
+    depth = 0
+    in_string = False
+    escape_next = False
+
+    for i, char in enumerate(text[start:], start=start):
+        if escape_next:
+            escape_next = False
+            continue
+
+        if char == "\\":
+            escape_next = True
+            continue
+
+        if char == '"' and not escape_next:
+            in_string = not in_string
+            continue
+
+        if in_string:
+            continue
+
+        if char == open_char:
+            depth += 1
+        elif char == close_char:
+            depth -= 1
+            if depth == 0:
+                return text[start : i + 1]
+
+    return None

ouroboros_ai-0.26.7.dev1/src/ouroboros/evaluation/json_utils.py

@@ -0,0 +1,5 @@
+"""Backwards-compatible re-export. Canonical location: ouroboros.core.json_utils."""
+
+from ouroboros.core.json_utils import extract_json_payload
+
+__all__ = ["extract_json_payload"]

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/src/ouroboros/orchestrator/events.py

@@ -545,9 +545,48 @@ def create_drift_measured_event(
     )
 
 
+def create_execution_terminal_event(
+    execution_id: str,
+    session_id: str,
+    status: str,
+    *,
+    summary: dict[str, Any] | None = None,
+    error_message: str | None = None,
+    messages_processed: int = 0,
+) -> BaseEvent:
+    """Mirror a session terminal state into the execution event stream.
+
+    The orchestrator stores lifecycle events (started/completed/failed)
+    under ``aggregate_type="session"`` while runtime progress events use
+    ``aggregate_type="execution"``.  TUI and other consumers that poll
+    only the execution stream would never see the terminal transition.
+
+    This helper emits an ``execution.terminal`` event under the execution
+    aggregate so that a single-stream consumer can detect completion
+    without polling a second channel.
+    """
+    data: dict[str, Any] = {
+        "session_id": session_id,
+        "status": status,
+        "messages_processed": messages_processed,
+        "timestamp": datetime.now(UTC).isoformat(),
+    }
+    if summary is not None:
+        data["summary"] = summary
+    if error_message is not None:
+        data["error_message"] = error_message
+    return BaseEvent(
+        type="execution.terminal",
+        aggregate_type="execution",
+        aggregate_id=execution_id,
+        data=data,
+    )
+
+
 __all__ = [
     "create_ac_stall_detected_event",
     "create_drift_measured_event",
+    "create_execution_terminal_event",
     "create_heartbeat_event",
     "create_mcp_tools_loaded_event",
     "create_progress_event",

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/src/ouroboros/orchestrator/runner.py

@@ -43,6 +43,7 @@ from ouroboros.orchestrator.adapter import (
 )
 from ouroboros.orchestrator.events import (
     create_drift_measured_event,
+    create_execution_terminal_event,
     create_mcp_tools_loaded_event,
     create_progress_event,
     create_session_completed_event,
@@ -1145,6 +1146,17 @@ class OrchestratorRunner:
                     error=str(cancel_result.error),
                 )
 
+        # Mirror cancellation into execution stream for TUI.
+        await self._event_store.append(
+            create_execution_terminal_event(
+                execution_id=execution_id,
+                session_id=session_id,
+                status="cancelled",
+                error_message="Execution cancelled by external request",
+                messages_processed=messages_processed,
+            )
+        )
+
         # Display cancellation notice
         self._console.print(
             Panel(
@@ -1532,6 +1544,19 @@ class OrchestratorRunner:
                     )
                 )
 
+            # Mirror terminal state into the execution event stream so
+            # single-stream consumers (TUI) detect completion without
+            # polling the separate session aggregate.
+            terminal_event = create_execution_terminal_event(
+                execution_id=exec_id,
+                session_id=tracker.session_id,
+                status="completed" if success else "failed",
+                summary=completion_summary if success else None,
+                error_message=final_message if not success else None,
+                messages_processed=messages_processed,
+            )
+            await self._event_store.append(terminal_event)
+
             log.info(
                 "orchestrator.runner.execute_completed",
                 execution_id=exec_id,
@@ -1586,6 +1611,15 @@ class OrchestratorRunner:
                 tracker.session_id,
                 str(e),
             )
+            await self._event_store.append(
+                create_execution_terminal_event(
+                    execution_id=exec_id,
+                    session_id=tracker.session_id,
+                    status="failed",
+                    error_message=str(e),
+                    messages_processed=messages_processed,
+                )
+            )
 
             return Result.err(
                 OrchestratorError(
@@ -1801,6 +1835,17 @@ class OrchestratorRunner:
                 )
             )
 
+        await self._event_store.append(
+            create_execution_terminal_event(
+                execution_id=exec_id,
+                session_id=tracker.session_id,
+                status="completed" if success else "failed",
+                summary=execution_summary if success else None,
+                error_message=final_message if not success else None,
+                messages_processed=parallel_result.total_messages,
+            )
+        )
+
         log.info(
             "orchestrator.runner.parallel_completed",
             execution_id=exec_id,
@@ -2131,6 +2176,20 @@ Note: This is a resumed session. Please continue from where execution was interr
                     )
                 )
 
+            # Mirror terminal state into execution stream for TUI.
+            terminal_status = (
+                "completed" if success else ("paused" if recoverable_resume_failure else "failed")
+            )
+            await self._event_store.append(
+                create_execution_terminal_event(
+                    execution_id=tracker.execution_id,
+                    session_id=session_id,
+                    status=terminal_status,
+                    error_message=final_message if not success else None,
+                    messages_processed=messages_processed,
+                )
+            )
+
             log.info(
                 "orchestrator.runner.resume_completed",
                 session_id=session_id,
@@ -2170,6 +2229,14 @@ Note: This is a resumed session. Please continue from where execution was interr
             self._unregister_session(tracker.execution_id, session_id)
             if self._task_workspace is not None:
                 release_lock(self._task_workspace.lock_path)
+            await self._event_store.append(
+                create_execution_terminal_event(
+                    execution_id=tracker.execution_id,
+                    session_id=session_id,
+                    status="failed",
+                    error_message=str(e),
+                )
+            )
 
             return Result.err(
                 OrchestratorError(

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/src/ouroboros/providers/claude_code_adapter.py

@@ -35,6 +35,7 @@ from pathlib import Path
 import structlog
 
 from ouroboros.core.errors import ProviderError
+from ouroboros.core.json_utils import extract_json_payload
 from ouroboros.core.types import Result
 from ouroboros.providers.base import (
     CompletionConfig,
@@ -48,6 +49,7 @@ log = structlog.get_logger(__name__)
 
 # Retry configuration for transient API errors
 _MAX_RETRIES = 5
+_MAX_JSON_RETRIES = 3  # Extra retries when response_format requires JSON but LLM returns prose
 _INITIAL_BACKOFF_SECONDS = 2.0  # Increased for custom CLI startup
 _RETRYABLE_ERROR_PATTERNS = (
     "concurrency",
@@ -244,13 +246,35 @@ class ClaudeCodeAdapter:
         # output. When callers request a schema, reinforce the requirement in the
         # prompt text and let downstream parsers extract JSON from the plain-text
         # response rather than depending on SDK-level structured_output.
-        if config.response_format and config.response_format.get("type") == "json_schema":
-            schema = config.response_format.get("json_schema", {})
-            schema_instruction = (
-                "Respond with ONLY a valid JSON object that matches this schema. "
-                "Do not use markdown fences, headers, or explanatory text.\n\n"
-                f"JSON schema:\n{json.dumps(schema, indent=2, sort_keys=True)}"
-            )
+        requires_json = bool(
+            config.response_format
+            and config.response_format.get("type") in ("json_schema", "json_object")
+        )
+        if requires_json:
+            fmt_type = config.response_format.get("type")
+            if fmt_type == "json_schema":
+                schema = config.response_format.get("json_schema", {})
+                # Derive the expected top-level type from the schema so the
+                # prompt instruction matches the schema contract (object, array, etc.)
+                top_type = schema.get("type", "object")
+                if top_type == "array":
+                    type_noun = "JSON array"
+                elif top_type == "object":
+                    type_noun = "JSON object"
+                else:
+                    # Primitive schemas (string, number, boolean, null)
+                    type_noun = "JSON value"
+                schema_instruction = (
+                    f"Respond with ONLY a valid {type_noun} that matches this schema. "
+                    "Do not use markdown fences, headers, or explanatory text.\n\n"
+                    f"JSON schema:\n{json.dumps(schema, indent=2, sort_keys=True)}"
+                )
+            else:
+                # json_object — no schema, but still steer toward JSON
+                schema_instruction = (
+                    "Respond with ONLY a valid JSON object. "
+                    "Do not use markdown fences, headers, or explanatory text."
+                )
             if system_prompt:
                 system_prompt = f"{system_prompt}\n\n{schema_instruction}"
             else:
@@ -269,6 +293,98 @@ class ClaudeCodeAdapter:
             has_system_prompt=system_prompt is not None,
         )
 
+        result = await self._complete_with_transient_retry(prompt, config, system_prompt)
+
+        # JSON enforcement layer: if response_format requires JSON,
+        # normalize or retry until we get valid JSON.
+        if requires_json and result.is_ok:
+            result = await self._enforce_json(result, prompt, config, system_prompt)
+
+        return result
+
+    def _normalize_json_content(
+        self, result: Result[CompletionResponse, ProviderError]
+    ) -> Result[CompletionResponse, ProviderError] | None:
+        """Try to extract and normalize JSON from a successful result.
+
+        Returns:
+            Normalized result if JSON found, None if no valid JSON in content.
+        """
+        if result.is_err:
+            return result
+        extracted = extract_json_payload(result.value.content)
+        if extracted:
+            result.value.content = extracted
+            return result
+        return None
+
+    async def _enforce_json(
+        self,
+        result: Result[CompletionResponse, ProviderError],
+        prompt: str,
+        config: CompletionConfig,
+        system_prompt: str | None,
+    ) -> Result[CompletionResponse, ProviderError]:
+        """Normalize JSON content or retry until valid JSON is obtained.
+
+        If the response contains valid JSON (even wrapped in prose/fences),
+        extract and return just the JSON. If no valid JSON, retry up to
+        _MAX_JSON_RETRIES times. If all retries fail, return an error.
+        """
+        # Try to normalize the initial result
+        normalized = self._normalize_json_content(result)
+        if normalized is not None:
+            return normalized
+
+        log.warning(
+            "claude_code_adapter.json_not_found",
+            max_json_retries=_MAX_JSON_RETRIES,
+            response_preview=result.value.content[:120],
+        )
+
+        for json_attempt in range(1, _MAX_JSON_RETRIES + 1):
+            log.info(
+                "claude_code_adapter.json_retry",
+                attempt=json_attempt,
+                max_json_retries=_MAX_JSON_RETRIES,
+            )
+            result = await self._complete_with_transient_retry(prompt, config, system_prompt)
+            if result.is_err:
+                return result
+            normalized = self._normalize_json_content(result)
+            if normalized is not None:
+                return normalized
+
+        # All retries exhausted — return error instead of prose
+        log.error(
+            "claude_code_adapter.json_retries_exhausted",
+            max_json_retries=_MAX_JSON_RETRIES,
+            response_preview=result.value.content[:120] if result.is_ok else "N/A",
+        )
+        return Result.err(
+            ProviderError(
+                message=(
+                    f"JSON format required but LLM returned prose after {_MAX_JSON_RETRIES} retries"
+                ),
+                details={
+                    "last_response_preview": (
+                        result.value.content[:200] if result.is_ok else "N/A"
+                    ),
+                },
+            )
+        )
+
+    async def _complete_with_transient_retry(
+        self,
+        prompt: str,
+        config: CompletionConfig,
+        system_prompt: str | None,
+    ) -> Result[CompletionResponse, ProviderError]:
+        """Inner retry loop for transient API errors (rate limits, timeouts, etc.).
+
+        This handles infrastructure-level failures only. JSON format
+        enforcement is handled by the caller.
+        """
         last_error: ProviderError | None = None
 
         for attempt in range(_MAX_RETRIES):

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/src/ouroboros/tui/app.py

@@ -257,6 +257,12 @@ class OuroborosTUI(App[None]):
             self._state.status = "failed"
         elif event_type == "orchestrator.session.cancelled":
             self._state.status = "cancelled"
+        elif event_type == "execution.terminal":
+            # Mirror event from the execution stream — ensures TUI sees
+            # terminal transitions even when only polling "execution".
+            terminal_status = data.get("status", "completed")
+            if terminal_status in {"completed", "failed", "cancelled"}:
+                self._state.status = terminal_status
         elif event_type == "orchestrator.session.paused":
             self._state.status = "paused"
             self._state.is_paused = True

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/src/ouroboros/tui/events.py

@@ -665,6 +665,14 @@ def create_message_from_event(event: BaseEvent) -> Message | None:
             data=data,
         )
 
+    elif event_type == "execution.terminal":
+        return ExecutionUpdated(
+            execution_id=event.aggregate_id,
+            session_id=data.get("session_id", ""),
+            status=data.get("status", "completed"),
+            data=data,
+        )
+
     elif event_type == "execution.phase.completed":
         return PhaseChanged(
             execution_id=event.aggregate_id,

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.7.dev1}/tests/unit/evaluation/test_json_utils.py

@@ -99,3 +99,51 @@ class TestExtractJsonPayload:
         result = extract_json_payload(text)
         assert result is not None
         assert '"valid": true' in result
+
+
+class TestExtractJsonArray:
+    """extract_json_payload must also handle top-level JSON arrays."""
+
+    def test_pure_array(self):
+        text = '[{"a": 1}, {"b": 2}]'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert '"a": 1' in result
+        assert result.startswith("[")
+
+    def test_array_in_code_fence(self):
+        text = '```json\n[{"item": "value"}]\n```'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert result.startswith("[")
+
+    def test_prose_before_array(self):
+        text = 'Here are the results:\n[{"score": 0.9}, {"score": 0.8}]'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert result.startswith("[")
+        assert '"score": 0.9' in result
+
+    def test_object_before_array_returns_object(self):
+        """When both object and array exist, return whichever comes first."""
+        text = '{"first": true} [1, 2, 3]'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert '"first": true' in result
+
+    def test_array_before_object_returns_array(self):
+        text = '[1, 2] {"second": true}'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert result == "[1, 2]"
+
+    def test_empty_array(self):
+        text = "prefix [] suffix"
+        result = extract_json_payload(text)
+        assert result == "[]"
+
+    def test_nested_array(self):
+        text = "[[1, 2], [3, 4]]"
+        result = extract_json_payload(text)
+        assert result is not None
+        assert result == "[[1, 2], [3, 4]]"