ouroboros-ai 0.40.2.dev9__tar.gz → 0.40.2.dev11__tar.gz

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.40.2.dev9
+Version: 0.40.2.dev11
 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.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.40.2.dev9'
-__version_tuple__ = version_tuple = (0, 40, 2, 'dev9')
+__version__ = version = '0.40.2.dev11'
+__version_tuple__ = version_tuple = (0, 40, 2, 'dev11')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/src/ouroboros/auto/state.py

@@ -79,6 +79,72 @@ class AutoWorktreePolicy(StrEnum):
     NONE = "none"
 
 
+WORKTREE_POLICY_ALIASES: dict[str, str] = {
+    # Natural-language / older gateway spellings for mandatory isolation.
+    "create_isolated_worktree": AutoWorktreePolicy.ALWAYS.value,
+    "isolated": AutoWorktreePolicy.ALWAYS.value,
+    "isolate": AutoWorktreePolicy.ALWAYS.value,
+    "required": AutoWorktreePolicy.ALWAYS.value,
+    "use_isolated_worktree": AutoWorktreePolicy.ALWAYS.value,
+    "always_create": AutoWorktreePolicy.ALWAYS.value,
+    # Explicit current-worktree spellings.
+    "current_worktree": AutoWorktreePolicy.CURRENT.value,
+    "reuse_current": AutoWorktreePolicy.CURRENT.value,
+    "use_current_worktree": AutoWorktreePolicy.CURRENT.value,
+    # Explicit opt-out spellings.
+    "no_worktree": AutoWorktreePolicy.NONE.value,
+    "disable_worktree": AutoWorktreePolicy.NONE.value,
+}
+
+
+def parse_auto_worktree_policy(value: str) -> AutoWorktreePolicy:
+    """Parse a worktree isolation policy, accepting stable aliases.
+
+    External callers often express the intent as ``create_isolated_worktree``
+    or ``required`` even though the durable enum is intentionally compact.
+    Normalizing those spellings at the boundary keeps the persisted state
+    canonical while making the MCP/CLI surface resilient to natural policy
+    names emitted by agents and gateways.
+    """
+    raw = value.strip()
+    normalized = raw.lower().replace("-", "_").replace(" ", "_")
+    canonical = WORKTREE_POLICY_ALIASES.get(normalized, normalized)
+    try:
+        return AutoWorktreePolicy(canonical)
+    except ValueError as exc:
+        valid = ", ".join(item.value for item in AutoWorktreePolicy)
+        alias_hint = "create_isolated_worktree → always"
+        msg = (
+            f"worktree_policy must be one of: {valid}. "
+            f"Accepted aliases include {alias_hint}. Got {raw!r}."
+        )
+        raise ValueError(msg) from exc
+
+
+COMPLETE_PRODUCT_MIN_PIPELINE_TIMEOUT_SECONDS: float = 1800.0
+
+
+def validate_complete_product_timeout(
+    *,
+    complete_product: bool,
+    pipeline_timeout_seconds: float | None,
+    option_name: str = "pipeline_timeout_seconds",
+) -> None:
+    """Fail fast when complete-product auto is given an impractical deadline."""
+    if (
+        complete_product
+        and pipeline_timeout_seconds is not None
+        and pipeline_timeout_seconds < COMPLETE_PRODUCT_MIN_PIPELINE_TIMEOUT_SECONDS
+    ):
+        msg = (
+            f"complete_product=true requires {option_name} >= "
+            f"{COMPLETE_PRODUCT_MIN_PIPELINE_TIMEOUT_SECONDS:g} seconds. "
+            f"Omit {option_name} to use the default 7200s long-running auto budget, "
+            "or pass a larger value for interview, Seed, run, and Ralph/QA phases."
+        )
+        raise ValueError(msg)
+
+
 class SeedOrigin(StrEnum):
     """Provenance of the persisted Seed for an auto session.
 
@@ -983,10 +1049,9 @@ class AutoPipelineState:
             msg = f"commit_policy must be one of {[item.value for item in AutoCommitPolicy]}"
             raise ValueError(msg) from exc
         try:
-            payload["worktree_policy"] = AutoWorktreePolicy(payload["worktree_policy"])
+            payload["worktree_policy"] = parse_auto_worktree_policy(payload["worktree_policy"])
         except ValueError as exc:
-            msg = f"worktree_policy must be one of {[item.value for item in AutoWorktreePolicy]}"
-            raise ValueError(msg) from exc
+            raise ValueError(str(exc)) from exc
         try:
             payload["seed_origin"] = SeedOrigin(payload["seed_origin"])
         except ValueError as exc:

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/src/ouroboros/cli/commands/auto.py

@@ -44,7 +44,8 @@ from ouroboros.auto.state import (
     AutoPhase,
     AutoPipelineState,
     AutoStore,
-    AutoWorktreePolicy,
+    parse_auto_worktree_policy,
+    validate_complete_product_timeout,
 )
 from ouroboros.auto.worktree import ensure_auto_worktree, release_auto_worktree
 from ouroboros.cli.formatters import console
@@ -356,6 +357,11 @@ async def _run_auto(
         raise ValueError("--attach-execution/--attach-job/--attach-session require --resume")
     if reconcile_run and not resume:
         raise ValueError("--reconcile-run requires --resume")
+    validate_complete_product_timeout(
+        complete_product=complete_product and not bool(resume),
+        pipeline_timeout_seconds=pipeline_timeout_seconds,
+        option_name="--timeout",
+    )
     if resume:
         if pipeline_timeout_seconds is not None:
             raise ValueError(
@@ -452,7 +458,7 @@ async def _run_auto(
     if commit_policy is not None:
         state.commit_policy = AutoCommitPolicy(commit_policy)
     if worktree_policy is not None:
-        state.worktree_policy = AutoWorktreePolicy(worktree_policy)
+        state.worktree_policy = parse_auto_worktree_policy(worktree_policy)
 
     if runtime == "opencode":
         # Q00/ouroboros#782 review-7 BLOCKING #3 + review-8 BLOCKING #1: keep

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/src/ouroboros/cli/commands/setup.py

@@ -351,7 +351,7 @@ _CODEX_ROLE_MODEL_OVERRIDE_DEFAULTS: dict[str, tuple[tuple[tuple[str, ...], obje
         (("consensus", "devil_model"), "openrouter/openai/gpt-4o"),
     ),
     "pm_interview": ((("clarification", "default_model"), "claude-opus-4-6"),),
-    "qa": ((("llm", "qa_model"), "claude-sonnet-4-20250514"),),
+    "qa": ((("llm", "qa_model"), "claude-sonnet-4-6"),),
     "reflect": ((("resilience", "reflect_model"), "claude-opus-4-6"),),
     "seed_generation": ((("clarification", "default_model"), "claude-opus-4-6"),),
     "semantic_evaluation": ((("evaluation", "semantic_model"), "claude-opus-4-6"),),
@@ -1588,7 +1588,7 @@ def _register_copilot_mcp_server() -> None:
 
 
 _COPILOT_DEFAULT_MODEL_TARGETS: tuple[tuple[str, str, str], ...] = (
-    ("llm", "qa_model", "claude-sonnet-4-20250514"),
+    ("llm", "qa_model", "claude-sonnet-4-6"),
     ("llm", "dependency_analysis_model", "claude-opus-4-6"),
     ("llm", "ontology_analysis_model", "claude-opus-4-6"),
     ("llm", "context_compression_model", "gpt-4"),

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/src/ouroboros/config/loader.py

@@ -1336,11 +1336,11 @@ def get_qa_model(backend: str | None = None) -> str:
         config = load_config()
         return _normalize_configured_model_for_backend(
             config.llm.qa_model,
-            default_model="claude-sonnet-4-20250514",
+            default_model="claude-sonnet-4-6",
             backend=backend,
         )
     except ConfigError:
-        return _default_model_for_backend("claude-sonnet-4-20250514", backend=backend)
+        return _default_model_for_backend("claude-sonnet-4-6", backend=backend)
 
 
 def get_dependency_analysis_model(backend: str | None = None) -> str:

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/src/ouroboros/config/models.py

@@ -131,7 +131,7 @@ class LLMConfig(BaseModel, frozen=True):
     ] = "claude_code"
     permission_mode: Literal["default", "acceptEdits", "bypassPermissions"] = "default"
     opencode_permission_mode: Literal["default", "acceptEdits", "bypassPermissions"] = "acceptEdits"
-    qa_model: str = "claude-sonnet-4-20250514"
+    qa_model: str = "claude-sonnet-4-6"
     dependency_analysis_model: str = "claude-opus-4-6"
     ontology_analysis_model: str = "claude-opus-4-6"
     context_compression_model: str = "gpt-4"

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/src/ouroboros/mcp/tools/auto_handler.py

@@ -61,7 +61,8 @@ from ouroboros.auto.state import (
     AutoPipelineState,
     AutoResumeCapability,
     AutoStore,
-    AutoWorktreePolicy,
+    parse_auto_worktree_policy,
+    validate_complete_product_timeout,
 )
 from ouroboros.auto.worktree import ensure_auto_worktree, release_auto_worktree
 from ouroboros.config import get_opencode_mode
@@ -331,6 +332,10 @@ class AutoHandler:
                 "pipeline_timeout_seconds cannot be changed on resume; the "
                 "original deadline is preserved across process restarts"
             )
+        validate_complete_product_timeout(
+            complete_product=complete_product and not (isinstance(resume, str) and resume),
+            pipeline_timeout_seconds=pipeline_timeout_seconds,
+        )
         # Distinguish "caller did not pass user_preferences" from "caller
         # passed an empty mapping". Only validate/parse when the caller
         # actually supplied the arg so a resume call can defer to persisted
@@ -661,6 +666,10 @@ class StartAutoHandler:
                 for field_name in ("attach_execution", "attach_job", "attach_session")
             )
             requested_pipeline_timeout = _optional_pipeline_timeout(arguments)
+            validate_complete_product_timeout(
+                complete_product=bool(arguments.get("complete_product", False)) and not has_resume,
+                pipeline_timeout_seconds=requested_pipeline_timeout,
+            )
         except ValueError as exc:
             return Result.err(MCPToolError(str(exc), tool_name="ouroboros_start_auto"))
         if attach_requested and not has_resume:
@@ -1016,7 +1025,7 @@ def _apply_requested_domain_and_policies(
 
     worktree_policy = _optional_text_arg(arguments, "worktree_policy")
     if worktree_policy is not None:
-        state.worktree_policy = AutoWorktreePolicy(worktree_policy)
+        state.worktree_policy = parse_auto_worktree_policy(worktree_policy)
 
 
 def _build_auto_subagent(

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/tests/integration/auto/test_dispatch_to_seed_e2e.py

@@ -415,7 +415,7 @@ async def test_ooo_auto_dispatch_reaches_seed_via_runtime(
         messages = [
             message
             async for message in runtime.execute_task(
-                f'ooo auto "{user_goal}" --complete-product --pipeline-timeout-seconds 600.5'
+                f'ooo auto "{user_goal}" --complete-product --pipeline-timeout-seconds 1800.5'
             )
         ]
 
@@ -449,7 +449,7 @@ async def test_ooo_auto_dispatch_reaches_seed_via_runtime(
         f"resolve_skill_dispatch must inject runtime cwd via $CWD; got {args!r}"
     )
     assert args["complete_product"] is True
-    assert args["pipeline_timeout_seconds"] == 600.5
+    assert args["pipeline_timeout_seconds"] == 1800.5
     assert isinstance(args["pipeline_timeout_seconds"], float)
 
     # AutoHandler._run actually executed: stub AutoPipeline observed the state.
@@ -461,7 +461,7 @@ async def test_ooo_auto_dispatch_reaches_seed_via_runtime(
     )
     assert captured.get("complete_product") is True
     assert captured.get("state_complete_product") is True
-    assert captured.get("state_pipeline_timeout_seconds") == 600.5
+    assert captured.get("state_pipeline_timeout_seconds") == 1800.5
 
     # The runtime must yield a single final result message carrying the Seed.
     assert len(messages) == 1, f"expected single dispatch result, got {messages!r}"

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/tests/unit/auto/test_pipeline_deadline.py

@@ -457,6 +457,24 @@ async def test_mcp_handler_rejects_timeout_below_floor() -> None:
     assert "pipeline_timeout_seconds must be between" in str(outcome.error)
 
 
+@pytest.mark.asyncio
+async def test_mcp_handler_rejects_complete_product_short_timeout_before_pipeline() -> None:
+    """Complete-product auto should fail fast when the explicit deadline is too short."""
+    from ouroboros.mcp.tools.auto_handler import AutoHandler
+
+    handler = AutoHandler()
+    outcome = await handler.handle(
+        {
+            "goal": "Build a product",
+            "complete_product": True,
+            "pipeline_timeout_seconds": 100,
+        }
+    )
+
+    assert outcome.is_err
+    assert "complete_product=true requires pipeline_timeout_seconds >= 1800" in str(outcome.error)
+
+
 @pytest.mark.asyncio
 async def test_mcp_handler_rejects_timeout_above_ceiling() -> None:
     """The MCP handler rejects ``pipeline_timeout_seconds`` above the 86400s ceiling."""

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/tests/unit/auto/test_state.py

@@ -93,6 +93,31 @@ def test_legacy_state_defaults_to_non_coding_policy() -> None:
     assert restored.final_checkpoint_attempted is False
 
 
+def test_worktree_policy_aliases_parse_to_canonical_values() -> None:
+    from ouroboros.auto.state import parse_auto_worktree_policy
+
+    assert parse_auto_worktree_policy("create_isolated_worktree") is AutoWorktreePolicy.ALWAYS
+    assert parse_auto_worktree_policy("required") is AutoWorktreePolicy.ALWAYS
+    assert parse_auto_worktree_policy("reuse-current") is AutoWorktreePolicy.CURRENT
+    assert parse_auto_worktree_policy("no worktree") is AutoWorktreePolicy.NONE
+
+
+def test_worktree_policy_aliases_load_from_state_payload() -> None:
+    payload = AutoPipelineState(goal="Build a CLI", cwd="/tmp/project").to_dict()
+    payload["worktree_policy"] = "create_isolated_worktree"
+
+    restored = AutoPipelineState.from_dict(payload)
+
+    assert restored.worktree_policy is AutoWorktreePolicy.ALWAYS
+
+
+def test_invalid_worktree_policy_names_suggest_alias() -> None:
+    from ouroboros.auto.state import parse_auto_worktree_policy
+
+    with pytest.raises(ValueError, match="create_isolated_worktree .* always"):
+        parse_auto_worktree_policy("make_new_tree")
+
+
 def test_terminal_state_is_not_stale() -> None:
     state = AutoPipelineState(goal="Build a CLI", cwd="/tmp/project")
     state.transition(AutoPhase.INTERVIEW, "starting")

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/tests/unit/cli/test_auto_command.py

@@ -410,6 +410,65 @@ def test_run_auto_policy_args_override_detected_coding_defaults(tmp_path, monkey
     assert captured["worktree_policy"] is AutoWorktreePolicy.CURRENT
 
 
+def test_run_auto_accepts_current_worktree_policy_alias(tmp_path, monkeypatch) -> None:
+    import asyncio
+
+    from ouroboros.auto.state import AutoWorktreePolicy
+    from ouroboros.cli.commands.auto import _run_auto
+
+    monkeypatch.chdir(tmp_path)
+    captured: dict[str, object] = {}
+
+    async def fake_pipeline_run(self, run_state):  # noqa: ARG001
+        captured["worktree_policy"] = run_state.worktree_policy
+        return AutoPipelineResult(
+            status="complete",
+            auto_session_id=run_state.auto_session_id,
+            phase="complete",
+            grade="A",
+        )
+
+    with patch("ouroboros.cli.commands.auto.AutoPipeline.run", new=fake_pipeline_run):
+        result = asyncio.run(
+            _run_auto(
+                goal="Build a CLI",
+                resume=None,
+                runtime="claude",
+                max_interview_rounds=None,
+                max_repair_rounds=None,
+                skip_run=True,
+                worktree_policy="reuse_current",
+            )
+        )
+
+    assert result.status == "complete"
+    assert captured["worktree_policy"] is AutoWorktreePolicy.CURRENT
+
+
+def test_run_auto_rejects_complete_product_short_timeout(tmp_path, monkeypatch) -> None:
+    import asyncio
+
+    import pytest
+
+    from ouroboros.cli.commands.auto import _run_auto
+
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(ValueError, match="complete_product=true requires --timeout >= 1800"):
+        asyncio.run(
+            _run_auto(
+                goal="Build a product",
+                resume=None,
+                runtime="claude",
+                max_interview_rounds=None,
+                max_repair_rounds=None,
+                skip_run=False,
+                complete_product=True,
+                pipeline_timeout_seconds=100,
+            )
+        )
+
+
 def test_resume_rejects_lower_bound_override(tmp_path) -> None:
     """Tightening a bound on resume must be refused — never trap a session further."""
     import asyncio

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/tests/unit/config/test_models.py

@@ -201,7 +201,7 @@ class TestLLMConfig:
         assert config.backend == "claude_code"
         assert config.permission_mode == "default"
         assert config.opencode_permission_mode == "acceptEdits"
-        assert config.qa_model == "claude-sonnet-4-20250514"
+        assert config.qa_model == "claude-sonnet-4-6"
         assert config.dependency_analysis_model == "claude-opus-4-6"
         assert config.ontology_analysis_model == "claude-opus-4-6"
         assert config.context_compression_model == "gpt-4"

{ouroboros_ai-0.40.2.dev9 → ouroboros_ai-0.40.2.dev11}/tests/unit/mcp/tools/test_start_auto.py

@@ -1089,6 +1089,61 @@ class TestBackgroundJobPath:
         assert state.commit_policy is AutoCommitPolicy.NONE
         assert state.worktree_policy is AutoWorktreePolicy.CURRENT
 
+    @pytest.mark.asyncio
+    async def test_new_auto_policy_args_accept_worktree_aliases(
+        self, event_store, tmp_path, fake_inner_auto
+    ) -> None:
+        job_manager = MagicMock()
+        snapshot = MagicMock()
+        snapshot.job_id = "job_auto_policy_alias"
+
+        async def _start_job(*, runner, **_):
+            if inspect.iscoroutine(runner):
+                runner.close()
+            return snapshot
+
+        job_manager.start_job = AsyncMock(side_effect=_start_job)
+        store = AutoStore(tmp_path / "store")
+        h = StartAutoHandler(event_store=event_store, job_manager=job_manager, store=store)
+        h._inner_auto = fake_inner_auto
+
+        result = await h.handle(
+            {
+                "goal": "build a CLI",
+                "cwd": str(tmp_path),
+                "worktree_policy": "create_isolated_worktree",
+            }
+        )
+
+        assert result.is_ok
+        state = store.load(result.value.meta["auto_session_id"])
+        assert state.worktree_policy is AutoWorktreePolicy.ALWAYS
+
+    @pytest.mark.asyncio
+    async def test_complete_product_with_short_timeout_fails_fast(
+        self, event_store, tmp_path, fake_inner_auto
+    ) -> None:
+        job_manager = MagicMock()
+        store = AutoStore(tmp_path / "store")
+        h = StartAutoHandler(event_store=event_store, job_manager=job_manager, store=store)
+        h._inner_auto = fake_inner_auto
+
+        result = await h.handle(
+            {
+                "goal": "build a product",
+                "cwd": str(tmp_path),
+                "complete_product": True,
+                "pipeline_timeout_seconds": 100,
+            }
+        )
+
+        assert result.is_err
+        assert "complete_product=true requires pipeline_timeout_seconds >= 1800" in str(
+            result.error
+        )
+        job_manager.start_job.assert_not_called()
+        fake_inner_auto.handle.assert_not_called()
+
     @pytest.mark.asyncio
     async def test_fresh_structured_goal_runner_resumes_without_preference_override(
         self, event_store, tmp_path