ouroboros-ai 0.42.2.dev4__tar.gz → 0.42.2.dev5__tar.gz

{ouroboros_ai-0.42.2.dev4 → ouroboros_ai-0.42.2.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.42.2.dev4
+Version: 0.42.2.dev5
 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.42.2.dev4 → ouroboros_ai-0.42.2.dev5}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.42.2.dev4'
-__version_tuple__ = version_tuple = (0, 42, 2, 'dev4')
+__version__ = version = '0.42.2.dev5'
+__version_tuple__ = version_tuple = (0, 42, 2, 'dev5')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.42.2.dev4 → ouroboros_ai-0.42.2.dev5}/src/ouroboros/orchestrator/copilot_cli_runtime.py

@@ -53,6 +53,9 @@ log = structlog.get_logger(__name__)
 # uses everywhere; permission mode is mapped through ``copilot_permissions``.
 _COPILOT_PERMISSION_MODES = frozenset({"default", "acceptEdits", "bypassPermissions"})
 _COPILOT_DEFAULT_PERMISSION_MODE = "default"
+# Levels Copilot CLI's --reasoning-effort flag accepts (verified via --help).
+# Allow-listed so an unexpected effort string is never forwarded to the flag.
+_COPILOT_REASONING_EFFORT_LEVELS = frozenset({"none", "low", "medium", "high", "xhigh", "max"})
 
 #: Maximum Ouroboros nesting depth to prevent fork bombs when Copilot
 #: spawns Ouroboros which spawns Copilot.
@@ -101,6 +104,16 @@ class CopilotCliRuntime(CodexCliRuntime):
             system_prompt_support=ParamSupport.TRANSLATED,
             tool_restriction_support=ParamSupport.TRANSLATED,
             permission_mode_support=ParamSupport.NATIVE,
+            # Copilot CLI enforces effort via a per-invocation --reasoning-effort
+            # flag (verified via --help: none/low/medium/high/xhigh/max).
+            reasoning_effort_support=ParamSupport.NATIVE,
+            # Declare the exact vocabulary the flag accepts. Without this, the
+            # shared contract treats an omitted set as "every level is enforced",
+            # so a caller using a level outside _COPILOT_REASONING_EFFORT_LEVELS
+            # would record an "enforced" proof row while _build_command silently
+            # drops the flag. Pinning the vocabulary downgrades such a level to
+            # "advised" in decide_effort, keeping the proof rows honest.
+            enforceable_reasoning_efforts=_COPILOT_REASONING_EFFORT_LEVELS,
         )
 
     def __init__(
@@ -179,6 +192,7 @@ class CopilotCliRuntime(CodexCliRuntime):
         resume_session_id: str | None = None,
         prompt: str | None = None,
         runtime_handle: RuntimeHandle | None = None,
+        reasoning_effort: str | None = None,
     ) -> list[str]:
         """Build the Copilot CLI command for non-interactive execution.
 
@@ -225,6 +239,13 @@ class CopilotCliRuntime(CodexCliRuntime):
                         mapped = map_to_copilot_model(normalized_runtime_model)
                         command.extend(["--model", mapped])
 
+        # Effort-first investment dial (RFC #1405). Copilot CLI honors a
+        # per-invocation --reasoning-effort flag (verified via --help), so the
+        # orchestrator's chosen level is ENFORCED. Allow-listed so an unexpected
+        # value can never be forwarded.
+        if reasoning_effort and reasoning_effort in _COPILOT_REASONING_EFFORT_LEVELS:
+            command.extend(["--reasoning-effort", reasoning_effort])
+
         command.extend(["-p", prompt or ""])
         return command
 

{ouroboros_ai-0.42.2.dev4 → ouroboros_ai-0.42.2.dev5}/src/ouroboros/orchestrator/gemini_cli_runtime.py

@@ -215,6 +215,10 @@ class GeminiCLIRuntime(CodexCliRuntime):
         resume_session_id: str | None = None,
         prompt: str | None = None,
         runtime_handle: RuntimeHandle | None = None,
+        # Accepted to honor the shared CodexCliRuntime contract, but ignored:
+        # the Gemini CLI exposes no per-invocation effort flag (capabilities
+        # declares reasoning_effort_support=IGNORED, so it is surfaced as advised).
+        reasoning_effort: str | None = None,
     ) -> list[str]:
         """Build the Gemini CLI command arguments for non-interactive execution.
 
@@ -277,6 +281,11 @@ class GeminiCLIRuntime(CodexCliRuntime):
             # guidance rather than enforcing a Gemini-native allow-list.
             system_prompt_support=ParamSupport.TRANSLATED,
             tool_restriction_support=ParamSupport.TRANSLATED,
+            # Reasoning effort is advised, not enforced: the Gemini API has a
+            # thinkingBudget, but no per-invocation effort flag on the Gemini CLI
+            # has been verified. Declared IGNORED (also the default) until a real
+            # per-call mechanism is confirmed — revisit if the CLI exposes one.
+            reasoning_effort_support=ParamSupport.IGNORED,
         )
 
     # -- Event parsing and normalization -----------------------------------

{ouroboros_ai-0.42.2.dev4 → ouroboros_ai-0.42.2.dev5}/src/ouroboros/orchestrator/goose_runtime.py

@@ -112,6 +112,10 @@ class GooseCliRuntime(CodexCliRuntime):
             # guidance rather than enforcing a Goose-native allow-list.
             system_prompt_support=ParamSupport.TRANSLATED,
             tool_restriction_support=ParamSupport.TRANSLATED,
+            # Reasoning effort is advised, not enforced: `goose run` exposes no
+            # per-invocation effort flag (verified via --help). Declared IGNORED
+            # explicitly (also the default) to document the verified decision.
+            reasoning_effort_support=ParamSupport.IGNORED,
         )
 
     def _resolve_permission_mode(self, permission_mode: str | None) -> str:
@@ -163,6 +167,10 @@ class GooseCliRuntime(CodexCliRuntime):
         resume_session_id: str | None = None,
         prompt: str | None = None,
         runtime_handle: RuntimeHandle | None = None,
+        # Accepted to honor the shared CodexCliRuntime contract, but ignored:
+        # `goose run` exposes no per-invocation effort flag (capabilities declares
+        # reasoning_effort_support=IGNORED, so it is surfaced as advised).
+        reasoning_effort: str | None = None,
     ) -> list[str]:
         """Build ``goose run`` args. Prompt is fed through stdin.
 

{ouroboros_ai-0.42.2.dev4 → ouroboros_ai-0.42.2.dev5}/src/ouroboros/orchestrator/hermes_runtime.py

@@ -238,11 +238,17 @@ class HermesCliRuntime(AgentRuntime):
         # message rather than passing native runtime parameters, and hermes chat
         # has no permission-mode flag. Surface both truthfully for degradation
         # notices.
+        # Reasoning effort is advised, not enforced: `hermes chat` exposes only
+        # -q/--image/-m/-t — no per-invocation effort flag and no `-c` config
+        # override (its config.yaml reasoning_effort is global, not per-call), so
+        # the level cannot be routed deterministically per AC. Declared IGNORED
+        # explicitly (it is also the default) to document the verified decision.
         return replace(
             FULL_CAPABILITIES,
             system_prompt_support=ParamSupport.TRANSLATED,
             tool_restriction_support=ParamSupport.TRANSLATED,
             permission_mode_support=ParamSupport.IGNORED,
+            reasoning_effort_support=ParamSupport.IGNORED,
         )
 
     @property

ouroboros_ai-0.42.2.dev5/tests/unit/orchestrator/test_reasoning_effort_routing.py

@@ -0,0 +1,181 @@
+"""Effort-first investment dial routing across agent runtimes (RFC #1405).
+
+These tests pin the Agent-OS contract: the orchestrator hands every runtime an
+abstract ``reasoning_effort`` level, and each runtime either ENFORCES it through
+its native per-call mechanism (declaring ``reasoning_effort_support = NATIVE``)
+or honestly declares that it cannot (the IGNORED default → advised). The proof's
+"enforced rows" depend on this distinction being truthful, so it is tested
+directly rather than assumed.
+"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+from ouroboros.orchestrator.adapter import (
+    FULL_CAPABILITIES,
+    ParamSupport,
+    RuntimeCapabilities,
+)
+from ouroboros.orchestrator.codex_cli_runtime import (
+    _CODEX_REASONING_EFFORT_LEVELS,
+    CodexCliRuntime,
+)
+
+
+class TestCapabilityDeclarations:
+    def test_default_and_full_capabilities_ignore_effort(self) -> None:
+        """A runtime that does not opt in must NOT claim native effort support.
+
+        Guards the latent bug flagged in review: ``replace(FULL_CAPABILITIES, …)``
+        runtimes (opencode, gjc, …) must inherit IGNORED, never a stray NATIVE.
+        """
+        bare = RuntimeCapabilities(
+            skill_dispatch=True, targeted_resume=True, structured_output=True
+        )
+        assert bare.reasoning_effort_support is ParamSupport.IGNORED
+        assert FULL_CAPABILITIES.reasoning_effort_support is ParamSupport.IGNORED
+        # An inheriting runtime that overrides only other fields stays IGNORED.
+        inherited = replace(FULL_CAPABILITIES, system_prompt_support=ParamSupport.TRANSLATED)
+        assert inherited.reasoning_effort_support is ParamSupport.IGNORED
+
+    def test_codex_runtime_declares_native_effort(self) -> None:
+        runtime = CodexCliRuntime(cli_path="codex", cwd="/tmp")
+        assert runtime.capabilities.reasoning_effort_support is ParamSupport.NATIVE
+
+    def test_copilot_runtime_declares_native_effort(self) -> None:
+        from ouroboros.orchestrator.copilot_cli_runtime import (
+            _COPILOT_REASONING_EFFORT_LEVELS,
+            CopilotCliRuntime,
+        )
+
+        runtime = CopilotCliRuntime(cli_path="copilot", cwd="/tmp")
+        assert runtime.capabilities.reasoning_effort_support is ParamSupport.NATIVE
+        # The enforceable vocabulary must be declared so a level the flag does not
+        # accept is downgraded to advised instead of recorded as a false "enforced"
+        # row. It must match exactly the allow-list _build_command applies.
+        assert (
+            runtime.capabilities.enforceable_reasoning_efforts == _COPILOT_REASONING_EFFORT_LEVELS
+        )
+
+    def test_gemini_and_goose_declare_advised_effort(self) -> None:
+        from ouroboros.orchestrator.gemini_cli_runtime import GeminiCLIRuntime
+        from ouroboros.orchestrator.goose_runtime import GooseCliRuntime
+
+        gemini = GeminiCLIRuntime(cli_path="gemini", cwd="/tmp")
+        goose = GooseCliRuntime(cli_path="goose", cwd="/tmp")
+        assert gemini.capabilities.reasoning_effort_support is ParamSupport.IGNORED
+        assert goose.capabilities.reasoning_effort_support is ParamSupport.IGNORED
+
+
+class TestCopilotEffortEnforcement:
+    def _runtime(self):
+        from ouroboros.orchestrator.copilot_cli_runtime import CopilotCliRuntime
+
+        return CopilotCliRuntime(cli_path="copilot", cwd="/tmp")
+
+    def test_known_level_is_enforced_via_flag(self) -> None:
+        command = self._runtime()._build_command("out.txt", prompt="hi", reasoning_effort="high")
+        assert "--reasoning-effort" in command
+        idx = command.index("--reasoning-effort")
+        assert command[idx + 1] == "high"
+
+    def test_unknown_level_is_not_injected(self) -> None:
+        command = self._runtime()._build_command(
+            "out.txt", prompt="hi", reasoning_effort="; rm -rf /"
+        )
+        assert "--reasoning-effort" not in command
+
+    def test_no_effort_emits_no_flag(self) -> None:
+        command = self._runtime()._build_command("out.txt", prompt="hi", reasoning_effort=None)
+        assert "--reasoning-effort" not in command
+
+    def test_subclasses_accept_effort_kwarg_without_error(self) -> None:
+        """codex execute_task forwards reasoning_effort to _build_command on every
+        CodexCliRuntime subclass — each override must accept it (regression guard).
+        """
+        from ouroboros.orchestrator.gemini_cli_runtime import GeminiCLIRuntime
+        from ouroboros.orchestrator.goose_runtime import GooseCliRuntime
+
+        for runtime in (
+            GeminiCLIRuntime(cli_path="gemini", cwd="/tmp"),
+            GooseCliRuntime(cli_path="goose", cwd="/tmp"),
+        ):
+            # Must not raise; gemini/goose accept-and-ignore (no per-call flag).
+            runtime._build_command("out.txt", prompt="hi", reasoning_effort="high")
+
+    def test_supported_level_is_enforced_unsupported_is_advised(self) -> None:
+        """The capability vocabulary keeps proof rows honest end to end.
+
+        decide_effort must mark a level inside Copilot's enforceable set as
+        ``enforced`` and a level outside it (e.g. Codex-only ``minimal``) as
+        ``advised`` even though Copilot declares NATIVE — because _build_command
+        silently drops a flag value it does not accept.
+        """
+        from ouroboros.orchestrator.copilot_cli_runtime import (
+            _COPILOT_REASONING_EFFORT_LEVELS,
+        )
+        from ouroboros.orchestrator.effort_routing import decide_effort
+
+        enforced = decide_effort(
+            ParamSupport.NATIVE,
+            base_effort="high",
+            is_decomposed_child=False,
+            enforceable_levels=_COPILOT_REASONING_EFFORT_LEVELS,
+        )
+        assert enforced.is_enforced
+        assert enforced.mode == "enforced"
+
+        advised = decide_effort(
+            ParamSupport.NATIVE,
+            base_effort="minimal",  # in EFFORT_LADDER, not in Copilot's flag vocab
+            is_decomposed_child=False,
+            enforceable_levels=_COPILOT_REASONING_EFFORT_LEVELS,
+        )
+        assert not advised.is_enforced
+        assert advised.mode == "advised"
+        assert advised.level == "minimal"  # still recorded, just not guaranteed
+
+
+class TestCodexEffortEnforcement:
+    def _runtime(self) -> CodexCliRuntime:
+        return CodexCliRuntime(cli_path="codex", cwd="/tmp")
+
+    def test_known_level_is_enforced_via_config_override(self) -> None:
+        command = self._runtime()._build_command(
+            output_last_message_path="/tmp/out.txt",
+            reasoning_effort="high",
+        )
+        # Codex enforces it as a per-invocation config override, contiguous pair.
+        assert "-c" in command
+        idx = command.index("-c")
+        assert command[idx + 1] == "model_reasoning_effort=high"
+
+    def test_no_effort_emits_no_override(self) -> None:
+        command = self._runtime()._build_command(
+            output_last_message_path="/tmp/out.txt",
+            reasoning_effort=None,
+        )
+        assert "model_reasoning_effort=high" not in command
+        assert not any(
+            isinstance(arg, str) and arg.startswith("model_reasoning_effort=") for arg in command
+        )
+
+    def test_unknown_level_is_not_injected(self) -> None:
+        """An unexpected token must never reach the ``key=value`` override."""
+        command = self._runtime()._build_command(
+            output_last_message_path="/tmp/out.txt",
+            reasoning_effort="; rm -rf /",
+        )
+        assert not any(
+            isinstance(arg, str) and arg.startswith("model_reasoning_effort=") for arg in command
+        )
+
+    def test_every_advertised_level_is_accepted(self) -> None:
+        runtime = self._runtime()
+        for level in _CODEX_REASONING_EFFORT_LEVELS:
+            command = runtime._build_command(
+                output_last_message_path="/tmp/out.txt",
+                reasoning_effort=level,
+            )
+            assert f"model_reasoning_effort={level}" in command

ouroboros_ai-0.42.2.dev4/tests/unit/orchestrator/test_reasoning_effort_routing.py

@@ -1,88 +0,0 @@
-"""Effort-first investment dial routing across agent runtimes (RFC #1405).
-
-These tests pin the Agent-OS contract: the orchestrator hands every runtime an
-abstract ``reasoning_effort`` level, and each runtime either ENFORCES it through
-its native per-call mechanism (declaring ``reasoning_effort_support = NATIVE``)
-or honestly declares that it cannot (the IGNORED default → advised). The proof's
-"enforced rows" depend on this distinction being truthful, so it is tested
-directly rather than assumed.
-"""
-
-from __future__ import annotations
-
-from dataclasses import replace
-
-from ouroboros.orchestrator.adapter import (
-    FULL_CAPABILITIES,
-    ParamSupport,
-    RuntimeCapabilities,
-)
-from ouroboros.orchestrator.codex_cli_runtime import (
-    _CODEX_REASONING_EFFORT_LEVELS,
-    CodexCliRuntime,
-)
-
-
-class TestCapabilityDeclarations:
-    def test_default_and_full_capabilities_ignore_effort(self) -> None:
-        """A runtime that does not opt in must NOT claim native effort support.
-
-        Guards the latent bug flagged in review: ``replace(FULL_CAPABILITIES, …)``
-        runtimes (opencode, gjc, …) must inherit IGNORED, never a stray NATIVE.
-        """
-        bare = RuntimeCapabilities(
-            skill_dispatch=True, targeted_resume=True, structured_output=True
-        )
-        assert bare.reasoning_effort_support is ParamSupport.IGNORED
-        assert FULL_CAPABILITIES.reasoning_effort_support is ParamSupport.IGNORED
-        # An inheriting runtime that overrides only other fields stays IGNORED.
-        inherited = replace(FULL_CAPABILITIES, system_prompt_support=ParamSupport.TRANSLATED)
-        assert inherited.reasoning_effort_support is ParamSupport.IGNORED
-
-    def test_codex_runtime_declares_native_effort(self) -> None:
-        runtime = CodexCliRuntime(cli_path="codex", cwd="/tmp")
-        assert runtime.capabilities.reasoning_effort_support is ParamSupport.NATIVE
-
-
-class TestCodexEffortEnforcement:
-    def _runtime(self) -> CodexCliRuntime:
-        return CodexCliRuntime(cli_path="codex", cwd="/tmp")
-
-    def test_known_level_is_enforced_via_config_override(self) -> None:
-        command = self._runtime()._build_command(
-            output_last_message_path="/tmp/out.txt",
-            reasoning_effort="high",
-        )
-        # Codex enforces it as a per-invocation config override, contiguous pair.
-        assert "-c" in command
-        idx = command.index("-c")
-        assert command[idx + 1] == "model_reasoning_effort=high"
-
-    def test_no_effort_emits_no_override(self) -> None:
-        command = self._runtime()._build_command(
-            output_last_message_path="/tmp/out.txt",
-            reasoning_effort=None,
-        )
-        assert "model_reasoning_effort=high" not in command
-        assert not any(
-            isinstance(arg, str) and arg.startswith("model_reasoning_effort=") for arg in command
-        )
-
-    def test_unknown_level_is_not_injected(self) -> None:
-        """An unexpected token must never reach the ``key=value`` override."""
-        command = self._runtime()._build_command(
-            output_last_message_path="/tmp/out.txt",
-            reasoning_effort="; rm -rf /",
-        )
-        assert not any(
-            isinstance(arg, str) and arg.startswith("model_reasoning_effort=") for arg in command
-        )
-
-    def test_every_advertised_level_is_accepted(self) -> None:
-        runtime = self._runtime()
-        for level in _CODEX_REASONING_EFFORT_LEVELS:
-            command = runtime._build_command(
-                output_last_message_path="/tmp/out.txt",
-                reasoning_effort=level,
-            )
-            assert f"model_reasoning_effort={level}" in command