ouroboros-ai 0.42.1.dev2__tar.gz → 0.42.2.dev2__tar.gz

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/.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.42.1",
+      "version": "0.42.2",
       "author": {
         "name": "Q00",
         "email": "jqyu.lee@gmail.com"

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ouroboros",
-  "version": "0.42.1",
+  "version": "0.42.2",
   "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.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/PKG-INFO

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

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

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/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.1.dev2'
-__version_tuple__ = version_tuple = (0, 42, 1, 'dev2')
+__version__ = version = '0.42.2.dev2'
+__version_tuple__ = version_tuple = (0, 42, 2, 'dev2')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/bigbang/ambiguity.py

@@ -24,7 +24,7 @@ from ouroboros.bigbang.interview import (
     initial_context_summary_missing,
     prompt_safe_initial_context,
 )
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_llm_model_for_role
 from ouroboros.core.errors import ProviderError
 from ouroboros.core.types import Result
 from ouroboros.providers.base import CompletionConfig, LLMAdapter, Message, MessageRole
@@ -292,7 +292,7 @@ class AmbiguityScorer:
         """Resolve implicit default model while preserving explicit caller pins."""
         self.model_is_explicit = self.model is not None
         if self.model is None:
-            self.model = get_clarification_model()
+            self.model = get_llm_model_for_role("clarification")
 
     async def score(
         self,

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/bigbang/explore.py

@@ -19,7 +19,7 @@ from typing import TYPE_CHECKING, Any
 
 import structlog
 
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_llm_model_for_role
 
 if TYPE_CHECKING:
     from ouroboros.providers.base import LLMAdapter
@@ -158,7 +158,7 @@ class CodebaseExplorer:
         """Resolve implicit default model while preserving explicit caller pins."""
         self.model_is_explicit = self.model is not None
         if self.model is None:
-            self.model = get_clarification_model()
+            self.model = get_llm_model_for_role("brownfield")
 
     async def explore(
         self,

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/bigbang/interview.py

@@ -15,7 +15,7 @@ from typing import Any
 from pydantic import BaseModel, Field
 import structlog
 
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_llm_model_for_role
 from ouroboros.core.errors import ProviderError, ValidationError
 from ouroboros.core.file_lock import file_lock as _file_lock
 from ouroboros.core.security import InputValidator
@@ -337,7 +337,7 @@ class InterviewEngine:
         """Ensure state directory exists."""
         self.model_is_explicit = self.model is not None
         if self.model is None:
-            self.model = get_clarification_model()
+            self.model = get_llm_model_for_role("interview")
         self.state_dir.mkdir(parents=True, exist_ok=True)
 
     def _state_file_path(self, interview_id: str) -> Path:

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/bigbang/pm_document.py

@@ -18,7 +18,7 @@ from typing import TYPE_CHECKING
 import structlog
 
 from ouroboros.bigbang.pm_seed import PMSeed
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_llm_model_for_role
 from ouroboros.core.errors import ProviderError
 from ouroboros.core.types import Result
 from ouroboros.providers.base import (
@@ -257,7 +257,7 @@ class PMDocumentGenerator:
         """Resolve implicit default model while preserving explicit caller pins."""
         self.model_is_explicit = self.model is not None
         if self.model is None:
-            self.model = get_clarification_model()
+            self.model = get_llm_model_for_role("pm_interview")
 
     async def generate(
         self,

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/bigbang/pm_interview.py

@@ -43,7 +43,7 @@ from ouroboros.bigbang.question_classifier import (
     QuestionCategory,
     QuestionClassifier,
 )
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_llm_model_for_role
 from ouroboros.core.errors import ProviderError, ValidationError
 from ouroboros.core.types import Result
 from ouroboros.providers.base import (
@@ -231,7 +231,7 @@ class PMInterviewEngine:
         """Resolve implicit default model while preserving explicit caller pins."""
         self.model_is_explicit = self.model is not None
         if self.model is None:
-            self.model = get_clarification_model()
+            self.model = get_llm_model_for_role("pm_interview")
 
     # ──────────────────────────────────────────────────────────────
     # Brownfield repo management

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/bigbang/question_classifier.py

@@ -20,7 +20,7 @@ import re
 
 import structlog
 
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_llm_model_for_role
 from ouroboros.core.errors import ProviderError
 from ouroboros.core.types import Result
 from ouroboros.providers.base import (
@@ -211,7 +211,7 @@ class QuestionClassifier:
         """Resolve implicit default model while preserving explicit caller pins."""
         self.model_is_explicit = self.model is not None
         if self.model is None:
-            self.model = self.implicit_model or get_clarification_model()
+            self.model = self.implicit_model or get_llm_model_for_role("question_classification")
 
     async def classify(
         self,

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/bigbang/seed_generator.py

@@ -26,7 +26,7 @@ from ouroboros.bigbang.interview import (
     initial_context_summary_missing,
     prompt_safe_initial_context,
 )
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_llm_model_for_role
 from ouroboros.core.errors import ProviderError, ValidationError
 from ouroboros.core.seed import (
     BrownfieldContext,
@@ -84,7 +84,7 @@ class SeedGenerator:
         """Ensure output directory exists."""
         self.model_is_explicit = self.model is not None
         if self.model is None:
-            self.model = get_clarification_model()
+            self.model = get_llm_model_for_role("seed_generation")
         self.output_dir.mkdir(parents=True, exist_ok=True)
 
     async def generate(

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/config/__init__.py

@@ -47,6 +47,9 @@ from ouroboros.config.loader import (
     get_hermes_cli_path,
     get_kiro_cli_path,
     get_llm_backend,
+    get_llm_backend_for_role,
+    get_llm_backend_for_stage,
+    get_llm_model_for_role,
     get_llm_permission_mode,
     get_max_parallel_workers,
     get_mechanical_detector_model,
@@ -126,6 +129,9 @@ __all__ = [
     "get_agent_permission_mode",
     "get_assertion_extraction_model",
     "get_llm_backend",
+    "get_llm_backend_for_role",
+    "get_llm_backend_for_stage",
+    "get_llm_model_for_role",
     "get_max_parallel_workers",
     "get_llm_permission_mode",
     "get_clarification_model",

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/config/loader.py

@@ -34,6 +34,7 @@ Functions:
 """
 
 import ast
+from collections.abc import Callable
 import math
 import os
 from pathlib import Path
@@ -60,6 +61,15 @@ from ouroboros.config.models import (  # noqa: E402
     get_default_credentials,
 )
 from ouroboros.core.errors import ConfigError  # noqa: E402
+from ouroboros.orchestrator_stage import (  # noqa: E402
+    Stage,
+    UnknownLLMRoleError,
+    normalize_llm_role,
+    parse_stage,
+    resolve_runtime_for_llm_role,
+    resolve_runtime_for_stage,
+    stage_for_llm_role,
+)
 
 _CODEX_LLM_BACKENDS = frozenset({"codex", "codex_cli", "opencode", "opencode_cli"})
 _KIRO_LLM_BACKENDS = frozenset({"kiro", "kiro_cli"})
@@ -1322,6 +1332,232 @@ def get_llm_backend() -> str:
         return "claude_code"
 
 
+def _runtime_profile_stage_map(config: OuroborosConfig) -> dict[Stage, str] | None:
+    profile = config.orchestrator.runtime_profile
+    if profile is None:
+        return None
+    return {parse_stage(stage): backend for stage, backend in profile.stages.items()}
+
+
+def _runtime_profile_default(config: OuroborosConfig) -> str | None:
+    profile = config.orchestrator.runtime_profile
+    return profile.default if profile is not None else None
+
+
+def _explicit_llm_backend_override() -> str | None:
+    """Return an explicitly-configured LLM-only backend override, or ``None``.
+
+    Preserves the documented LLM-only contract — ``OUROBOROS_LLM_BACKEND``, an
+    LLM-capable ``OUROBOROS_RUNTIME``, or ``config.llm.backend`` set away from the
+    shipped ``"claude_code"`` default — so existing operator overrides keep
+    steering internal-LLM roles. Returns ``None`` when nothing is explicitly set,
+    letting per-stage routing fall through to the default agent runtime.
+    """
+    env_backend = os.environ.get("OUROBOROS_LLM_BACKEND", "").strip().lower()
+    if env_backend:
+        return env_backend
+
+    env_runtime = os.environ.get("OUROBOROS_RUNTIME", "").strip().lower()
+    runtime_capability = get_backend_capability(env_runtime)
+    if runtime_capability is not None and runtime_capability.supports_llm:
+        return "claude_code" if env_runtime == "claude_code" else runtime_capability.name
+
+    try:
+        configured = load_config().llm.backend
+    except ConfigError:
+        return None
+    if configured and configured != "claude_code":
+        return configured
+    return None
+
+
+def _internal_llm_fallback_backend(fallback_runtime_backend: str | None) -> str:
+    """Fallback backend for stages/roles with no per-stage routing.
+
+    Precedence: explicit legacy ``llm.backend`` / ``OUROBOROS_LLM_BACKEND``
+    override (the documented LLM-only contract) → the caller-provided default
+    agent runtime (e.g. ``create_ouroboros_server(runtime_backend=...)``) → the
+    orchestrator's configured default agent runtime. The LLM-only override wins
+    over the default agent so an explicit ``llm.backend`` is honored, while an
+    un-configured override still inherits the caller/config default agent.
+    """
+    return (
+        _explicit_llm_backend_override() or fallback_runtime_backend or get_agent_runtime_backend()
+    )
+
+
+def get_llm_backend_for_stage(
+    stage: Stage | str,
+    *,
+    explicit_backend: str | None = None,
+    fallback_runtime_backend: str | None = None,
+) -> str:
+    """Resolve the internal-LLM backend for a configured workflow stage.
+
+    Precedence: ``explicit_backend`` (direct API/CLI) → ``runtime_profile.stages``
+    (per-stage Agent) → ``runtime_profile.default`` → explicit legacy
+    ``llm.backend`` / ``OUROBOROS_LLM_BACKEND`` override → orchestrator default
+    agent runtime. Per-stage routing stays authoritative while existing LLM-only
+    overrides remain honored for un-mapped stages.
+    """
+    if explicit_backend:
+        return explicit_backend
+
+    parsed_stage = stage if isinstance(stage, Stage) else parse_stage(stage)
+    try:
+        config = load_config()
+        return resolve_runtime_for_stage(
+            parsed_stage,
+            stages=_runtime_profile_stage_map(config),
+            default=_runtime_profile_default(config),
+            fallback=_internal_llm_fallback_backend(fallback_runtime_backend),
+        )
+    except ConfigError:
+        # Config unreadable: still honor an env-level LLM override and the
+        # caller's default agent before the documented get_llm_backend() default.
+        return _explicit_llm_backend_override() or fallback_runtime_backend or get_llm_backend()
+
+
+def get_llm_backend_for_role(
+    role: str,
+    *,
+    explicit_backend: str | None = None,
+    fallback_runtime_backend: str | None = None,
+) -> str:
+    """Resolve the internal-LLM backend for a logical task role.
+
+    Same precedence as :func:`get_llm_backend_for_stage`: per-stage routing wins,
+    then the explicit legacy ``llm.backend`` / ``OUROBOROS_LLM_BACKEND`` override,
+    then the default agent runtime.
+    """
+    if explicit_backend:
+        return explicit_backend
+
+    try:
+        config = load_config()
+        return resolve_runtime_for_llm_role(
+            role,
+            stages=_runtime_profile_stage_map(config),
+            default=_runtime_profile_default(config),
+            fallback=_internal_llm_fallback_backend(fallback_runtime_backend),
+        )
+    except ConfigError:
+        # Config unreadable: still honor an env-level LLM override and the
+        # caller's default agent before the documented get_llm_backend() default.
+        return _explicit_llm_backend_override() or fallback_runtime_backend or get_llm_backend()
+
+
+# Legacy per-role model fields kept for backward compatibility. The stage
+# model is the default, but a user who explicitly pinned one of these (env var,
+# or a config field set away from its shipped default) still has it honored
+# instead of silently dropped. Maps role -> (env var, field accessor, shipped
+# default, dedicated getter name). The getter — resolved lazily because it is
+# defined later in this module — applies the role's own backend normalization
+# (e.g. snapping an opus pin to the "default" sentinel on codex backends).
+# ``mechanical_detection`` reuses the assertion-extraction getter (its historical
+# model source) to avoid recursing through ``get_mechanical_detector_model``.
+_LEGACY_ROLE_MODEL_FIELDS: dict[str, tuple[str, Callable[["OuroborosConfig"], str], str, str]] = {
+    "qa": ("OUROBOROS_QA_MODEL", lambda c: c.llm.qa_model, DEFAULT_SONNET_MODEL, "get_qa_model"),
+    "assertion_extraction": (
+        "OUROBOROS_ASSERTION_EXTRACTION_MODEL",
+        lambda c: c.evaluation.assertion_extraction_model,
+        DEFAULT_SONNET_MODEL,
+        "get_assertion_extraction_model",
+    ),
+    "mechanical_detection": (
+        "OUROBOROS_DETECTOR_MODEL",
+        lambda c: c.evaluation.assertion_extraction_model,
+        DEFAULT_SONNET_MODEL,
+        "get_assertion_extraction_model",
+    ),
+    "dependency_analysis": (
+        "OUROBOROS_DEPENDENCY_ANALYSIS_MODEL",
+        lambda c: c.llm.dependency_analysis_model,
+        DEFAULT_SONNET_MODEL,
+        "get_dependency_analysis_model",
+    ),
+    "ontology_analysis": (
+        "OUROBOROS_ONTOLOGY_ANALYSIS_MODEL",
+        lambda c: c.llm.ontology_analysis_model,
+        DEFAULT_SONNET_MODEL,
+        "get_ontology_analysis_model",
+    ),
+    "context_compression": (
+        "OUROBOROS_CONTEXT_COMPRESSION_MODEL",
+        lambda c: c.llm.context_compression_model,
+        "gpt-4",
+        "get_context_compression_model",
+    ),
+    "wonder": (
+        "OUROBOROS_WONDER_MODEL",
+        lambda c: c.resilience.wonder_model,
+        DEFAULT_OPUS_MODEL,
+        "get_wonder_model",
+    ),
+}
+
+
+def _explicit_legacy_role_model(role: str, backend: str | None) -> str | None:
+    """Return an explicitly-set legacy per-role model override, or ``None``.
+
+    "Explicit" means the role's env var is set, or its dedicated config field
+    differs from the shipped default. This preserves pre-existing configs that
+    pinned a per-role model before the stage-model consolidation. Resolution is
+    delegated to the role's dedicated getter so backend normalization stays
+    identical to the legacy path.
+    """
+    entry = _LEGACY_ROLE_MODEL_FIELDS.get(normalize_llm_role(role))
+    if entry is None:
+        return None
+    env_var, field_getter, shipped_default, getter_name = entry
+    # Env var wins and is returned raw, matching the legacy getters.
+    if os.environ.get(env_var, "").strip():
+        return os.environ[env_var].strip()
+    try:
+        config = load_config()
+    except ConfigError:
+        return None
+    if field_getter(config) != shipped_default:
+        getter: Callable[[str | None], str] = globals()[getter_name]
+        return getter(backend)
+    return None
+
+
+def get_llm_model_for_role(
+    role: str,
+    *,
+    backend: str | None = None,
+    explicit_model: str | None = None,
+) -> str:
+    """Resolve the configured model for a logical internal-LLM role.
+
+    Stage model fields are the default source of truth: interview roles use
+    ``clarification.default_model``, evaluate/execute roles use
+    ``evaluation.semantic_model``, and reflect roles use
+    ``resilience.reflect_model``. An explicitly-pinned legacy per-role field
+    (e.g. ``llm.qa_model``) still takes precedence for backward compatibility,
+    and an unmapped role degrades to the evaluate model rather than raising.
+    """
+    if explicit_model:
+        return explicit_model
+
+    resolved_backend = backend or get_llm_backend_for_role(role)
+
+    legacy_override = _explicit_legacy_role_model(role, resolved_backend)
+    if legacy_override is not None:
+        return legacy_override
+
+    try:
+        stage = stage_for_llm_role(role)
+    except UnknownLLMRoleError:
+        return get_semantic_model(resolved_backend)
+    if stage == Stage.INTERVIEW:
+        return get_clarification_model(resolved_backend)
+    if stage == Stage.REFLECT:
+        return get_reflect_model(resolved_backend)
+    return get_semantic_model(resolved_backend)
+
+
 def get_llm_permission_mode(backend: str | None = None) -> str:
     """Get default LLM permission mode from environment variable or config.
 
@@ -1617,15 +1853,13 @@ def get_assertion_extraction_model(backend: str | None = None) -> str:
 def get_mechanical_detector_model(backend: str | None = None) -> str:
     """Resolve the model used by the mechanical.toml AI detector.
 
-    Mirrors the assertion-extraction model resolution: env var override,
-    then ``OuroborosConfig.evaluation.assertion_extraction_model`` with
-    backend-safe fallback to the Codex ``"default"`` sentinel for
-    Codex/OpenCode backends.
+    The public helper remains for legacy imports, but the configured model
+    source is now the Evaluate stage model (``evaluation.semantic_model``).
     """
     env_model = os.environ.get("OUROBOROS_DETECTOR_MODEL", "").strip()
     if env_model:
         return env_model
-    return get_assertion_extraction_model(backend=backend)
+    return get_llm_model_for_role("mechanical_detection", backend=backend)
 
 
 def get_consensus_models(backend: str | None = None) -> tuple[str, ...]:

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/config_tui/app.py

@@ -28,7 +28,6 @@ from textual.widgets import (
 from textual.widgets.option_list import Option
 
 from ouroboros.backends import resolve_backend_alias, runtime_backend_choices
-from ouroboros.backends.capabilities import llm_backend_choices
 from ouroboros.backends.model_catalog import (
     DEFAULT_MODEL_SENTINEL,
     configured_default_model,
@@ -241,6 +240,9 @@ class SettingsApp(App[None]):
         # What the "default" sentinel resolves to per backend (config-file
         # hint, e.g. hermes → gpt-5.5). Cached: file reads once per backend.
         self._default_hints: dict[str, str | None] = {}
+        # Hidden legacy fallback sync for llm.backend after its visible field
+        # was removed from the TUI. The most recent Agent selection wins.
+        self._last_agent_backend_selection: str | None = None
 
     def on_mount(self) -> None:
         # Config-derived (not widget-derived): widgets may still be mounting.
@@ -422,27 +424,17 @@ class SettingsApp(App[None]):
                 for stage in Stage:
                     yield from self._compose_stage_card(stage)
 
-            with Collapsible(title="Advanced", collapsed=True):
-                yield from self._compose_select_field(
-                    GLOBAL_LLM_BACKEND_FIELD,
-                    options=[(name, name) for name in llm_backend_choices()],
-                    value=_canonical_backend(self._current(GLOBAL_LLM_BACKEND_FIELD.key)),
-                    select_id="global-llm-backend",
-                )
-                yield Static(
-                    "Engine for Ouroboros' own internal LLM calls (QA verdicts, "
-                    "semantic evaluation) — usually the same as the default agent.",
-                    classes="field-help",
-                )
-                for field in ADVANCED_MODEL_FIELDS:
-                    yield Static(field.label, classes="field-label")
-                    warning = _env_warning_text(field)
-                    if warning:
-                        yield Static(warning, classes="env-warning")
-                    yield Input(
-                        value=str(self._current(field.key) or ""),
-                        id=f"adv-{_slug(field.key)}",
-                    )
+            if ADVANCED_MODEL_FIELDS:
+                with Collapsible(title="Advanced", collapsed=True):
+                    for field in ADVANCED_MODEL_FIELDS:
+                        yield Static(field.label, classes="field-label")
+                        warning = _env_warning_text(field)
+                        if warning:
+                            yield Static(warning, classes="env-warning")
+                        yield Input(
+                            value=str(self._current(field.key) or ""),
+                            id=f"adv-{_slug(field.key)}",
+                        )
 
             with Container(id="action-bar"):
                 yield Button("Save", variant="primary", id="save-button")
@@ -531,10 +523,12 @@ class SettingsApp(App[None]):
         if select_id.startswith("stage-runtime-"):
             stage = Stage(select_id.removeprefix("stage-runtime-"))
             self._update_resolved_caption(stage)
+            self._remember_agent_selection(self._selected_runtime(stage))
             if stage in STAGE_MODEL_FIELDS:
                 self._refresh_stage_model_options(stage)
             self._refresh_install_warning(stage, event.value)
         elif select_id == "global-runtime":
+            self._remember_agent_selection(self._selected_default_runtime())
             # Cascade: every inheriting card re-resolves its agent and pulls
             # the matching model catalog. Guard per card so one failure
             # cannot skip the rest.
@@ -586,6 +580,9 @@ class SettingsApp(App[None]):
         caption = self.query_one(f"#stage-resolved-{stage.value}", Static)
         caption.update(f"→ runs on {self._selected_runtime(stage)}")
 
+    def _remember_agent_selection(self, backend: str) -> None:
+        self._last_agent_backend_selection = _canonical_backend(backend)
+
     def _selected_runtime(self, stage: Stage) -> str:
         runtime_select = self.query_one(f"#stage-runtime-{stage.value}", Select)
         value = runtime_select.value
@@ -600,13 +597,6 @@ class SettingsApp(App[None]):
             )
         return _canonical_backend(value)
 
-    def _selected_llm_backend(self) -> str:
-        llm_select = self.query_one("#global-llm-backend", Select)
-        value = llm_select.value
-        if _is_blank(value):
-            return _canonical_backend(self._current(GLOBAL_LLM_BACKEND_FIELD.key))
-        return _canonical_backend(value)
-
     def _refresh_stage_model_options(self, stage: Stage) -> None:
         """Repopulate the model select with the effective backend's catalog.
 
@@ -687,9 +677,6 @@ class SettingsApp(App[None]):
         global_runtime = self.query_one("#global-runtime", Select).value
         if not _is_blank(global_runtime):
             record_backend(GLOBAL_RUNTIME_FIELD.key, str(global_runtime))
-        llm_backend = self.query_one("#global-llm-backend", Select).value
-        if not _is_blank(llm_backend):
-            record_backend(GLOBAL_LLM_BACKEND_FIELD.key, str(llm_backend))
 
         for stage in Stage:
             runtime_field = stage_runtime_field(stage)
@@ -712,7 +699,7 @@ class SettingsApp(App[None]):
                 elif not _is_blank(model_value):
                     model_text = str(model_value)
                     if model_text == DEFAULT_MODEL_SENTINEL and not uses_default_model_sentinel(
-                        self._selected_llm_backend()
+                        self._selected_runtime(stage)
                     ):
                         if get_value(self._raw, model_field.key) == DEFAULT_MODEL_SENTINEL:
                             changes[model_field.key] = None
@@ -724,6 +711,18 @@ class SettingsApp(App[None]):
             if raw_value:
                 record(field.key, raw_value)
 
+        # Sync the hidden legacy llm.backend fallback ONLY when this save already
+        # changes backend routing (the default Agent or any stage Agent). On
+        # unrelated saves (e.g. editing only a model field) leave it untouched so
+        # an existing user-managed llm.backend is preserved, not clobbered.
+        routing_changed = GLOBAL_RUNTIME_FIELD.key in changes or any(
+            key.startswith("orchestrator.runtime_profile.stages.") for key in changes
+        )
+        if routing_changed:
+            new_backend = self._last_agent_backend_selection or self._selected_default_runtime()
+            if new_backend:
+                record_backend(GLOBAL_LLM_BACKEND_FIELD.key, new_backend)
+
         return changes
 
     def action_save(self) -> None:

{ouroboros_ai-0.42.1.dev2 → ouroboros_ai-0.42.2.dev2}/src/ouroboros/config_tui/fields.py

@@ -86,30 +86,7 @@ STAGE_MODEL_FIELDS: dict[Stage, SettingField] = {
     ),
 }
 
-ADVANCED_MODEL_FIELDS: tuple[SettingField, ...] = (
-    SettingField("llm.qa_model", "QA model", ("OUROBOROS_QA_MODEL",)),
-    SettingField(
-        "llm.dependency_analysis_model",
-        "Dependency analysis model",
-        ("OUROBOROS_DEPENDENCY_ANALYSIS_MODEL",),
-    ),
-    SettingField(
-        "llm.ontology_analysis_model",
-        "Ontology analysis model",
-        ("OUROBOROS_ONTOLOGY_ANALYSIS_MODEL",),
-    ),
-    SettingField(
-        "llm.context_compression_model",
-        "Context compression model",
-        ("OUROBOROS_CONTEXT_COMPRESSION_MODEL",),
-    ),
-    SettingField("resilience.wonder_model", "Wonder model", ("OUROBOROS_WONDER_MODEL",)),
-    SettingField(
-        "evaluation.assertion_extraction_model",
-        "Assertion extraction model",
-        ("OUROBOROS_ASSERTION_EXTRACTION_MODEL",),
-    ),
-)
+ADVANCED_MODEL_FIELDS: tuple[SettingField, ...] = ()
 
 
 def active_env_overrides(field: SettingField) -> tuple[str, ...]: