utim-cli 2.5.4__tar.gz → 2.6.0__tar.gz

{utim_cli-2.5.4 → utim_cli-2.6.0}/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [2.6.0] - 2026-11-03
+
+### ✨ New Theme
+- **Fresh UI Theme**: A brand-new visual theme for the CLI and website, with refreshed colours, cleaner spacing, and a sharper overall look.
+- **UI Enhancements**: Polish across menus, panels, and prompts for a more consistent and modern feel.
+
+### 🐛 Fixes
+- **Bug Fixes**: A round of stability and reliability fixes across the app.
+
+## [2.5.5] - 2026-10-29
+
+### 🐛 Fixes
+- **Free Models No Longer Gated On The Free Plan**: Added `is_free_zero_cost_model()` as the single source of truth for $0.00 pricing. Any model priced 0.00 is now always usable on the Free plan, regardless of whether a priced copy of the same slug lives in `hobby_models` / `pro_models` or whether the static registry has an entry for it. Fixes `nvidia/nemotron-3.5-lightning:free` being reported as unavailable on the Free plan.
+- **Registry Gate Bypass For Zero-Price Models**: The non-paid-plan registry check no longer rejects unregistered or `dynamic`-tagged models when their real price is 0.00.
+- **Picker And Endpoint Now Agree**: The public catalog's free classifier resolves explicit free slugs (`:free`, `/free`, `-free`, `_free`, `free/` prefix) *before* consulting the separated tier-table override, so a priced duplicate can no longer hide a free model from the website or the `/model` picker.
+- **Compression Pipeline Routed Through The Server**: New `POST /completions/compression` endpoint resolves the model the user is actually running plus the provider that actually serves it, eliminating the client-side `openrouter/free` fallback that kept returning empty content.
+
+## [2.5.4] - 2026-10-24
+
+### 🐛 Fixes
+- **Streamed Output Now Always Displays**: Fixed responses being received by the server but never printed — pending code-block buffers are now force-flushed at end-of-stream on all streaming paths, so content ending inside an unclosed code fence is no longer silently dropped.
+- **Adaptation Engine Over-Firing**: The truncation detector no longer re-fires continuation nudges on already-complete responses. False-positive heuristics (unclosed fence, mid-sentence) now fire at most once per task, while genuine token-limit continuations keep their full budget.
+- **Fence Detection Hardening**: Unclosed code-block detection now only counts real markdown fences (line-start markers), not inline backtick references in prose.
+
+### ✨ Improvements
+- **Dynamic Provider Adaptation Engine**: Enhanced reliability of provider health tracking, stitching, and continuation logic.
+
 ## [2.5.3] - 2026-10-20
 
 ### ✨ Improvements & Fixes

{utim_cli-2.5.4/utim_cli.egg-info → utim_cli-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.5.4
+Version: 2.6.0
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev

{utim_cli-2.5.4 → utim_cli-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.5.4"
+version = "2.6.0"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"

{utim_cli-2.5.4 → utim_cli-2.6.0}/utim/__init__.py

@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.5.4"
+    __version__ = "2.6.0"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

{utim_cli-2.5.4 → utim_cli-2.6.0}/utim_cli/__init__.py

@@ -5,7 +5,7 @@ try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
     # Fallback during first-install / editable-install edge cases
-    __version__ = "2.5.4"
+    __version__ = "2.6.0"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.5.4 → utim_cli-2.6.0}/utim_cli/_version.py

@@ -11,6 +11,6 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.5.4"
+VERSION = "2.6.0"
 
 

{utim_cli-2.5.4 → utim_cli-2.6.0}/utim_cli/agent.py

@@ -228,6 +228,42 @@ class ReActAgent:
         self.console.print(_pre)
         pre_plain = f"{meta['verb']}({primary_arg}) (ctrl+o to expand)" if primary_arg else f"{meta['verb']} (ctrl+o to expand)"
         self._last_running_indicator_len = len(pre_plain)
+        # Remember that a provisional line is on screen, and the paint
+        # generation at the moment we wrote it. _erase_running_line() uses
+        # both: a blind CSI-1F erase is only safe while nothing has painted
+        # since, otherwise it corrupts the screen or leaves a duplicate header
+        # (the "Verb(x) · running" + "Verb(x)" double print).
+        self._running_line_live = True
+        try:
+            from utim_cli.state import STATE as _STG
+            self._running_line_paint_gen = _STG.get("_paint_gen", 0)
+        except Exception:
+            self._running_line_paint_gen = None
+
+        def _erase_running_line() -> None:
+            """Guarded replacement for the blind CSI-1F erase loops below."""
+            if not getattr(self, "_running_line_live", False):
+                return
+            self._running_line_live = False
+            try:
+                from utim_cli.state import STATE as _ST
+                if _ST.get("_paint_gen", 0) != getattr(self, "_running_line_paint_gen", None):
+                    # Something repainted while the tool ran; the cursor is no
+                    # longer under our header. Do not blind-erase.
+                    return
+            except Exception:
+                pass
+            try:
+                width = self.console.size.width
+            except Exception:
+                width = 80
+            import math
+            num_lines = math.ceil(
+                getattr(self, "_last_running_indicator_len", 0) / max(1, width)
+            )
+            num_lines = max(0, min(num_lines, 5))   # never wipe more than 5 rows
+            for _ in range(num_lines):
+                self.console.print("\033[F\033[K", end="")
 
         if "__" in tool_name:
             server_name, actual_tool_name = tool_name.split("__", 1)
@@ -240,25 +276,11 @@ class ReActAgent:
                     # Temporarily register metadata for render
                     TOOL_META[tool_name] = {"icon": "", "verb": f"Calling {server_name} ➔ {actual_tool_name}", "color": "#cba6f7"}
                     # Erase the running line first
-                    try:
-                        width = self.console.size.width
-                    except Exception:
-                        width = 80
-                    import math
-                    num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
-                    for _ in range(num_lines):
-                        self.console.print("\033[F\033[K", end="")
+                    _erase_running_line()
                     self._render_tool_panel(tool_name, arguments, result)
                     return str(result)
             except Exception as e:
-                try:
-                    width = self.console.size.width
-                except Exception:
-                    width = 80
-                import math
-                num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
-                for _ in range(num_lines):
-                    self.console.print("\033[F\033[K", end="")
+                _erase_running_line()
                 return f"Error executing MCP tool {tool_name}: {str(e)}"
 
         utim_tools, tool_functions = get_tools()
@@ -275,25 +297,11 @@ class ReActAgent:
             filtered_args = dict(arguments) if has_var_kw else {k: v for k, v in arguments.items() if k in sig.parameters}
             result = tool_functions[tool_name](**filtered_args)
             # Erase the running line first
-            try:
-                width = self.console.size.width
-            except Exception:
-                width = 80
-            import math
-            num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
-            for _ in range(num_lines):
-                self.console.print("\033[F\033[K", end="")
+            _erase_running_line()
             self._render_tool_panel(tool_name, arguments, result)
             return str(result)
         except Exception as e:
-            try:
-                width = self.console.size.width
-            except Exception:
-                width = 80
-            import math
-            num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
-            for _ in range(num_lines):
-                self.console.print("\033[F\033[K", end="")
+            _erase_running_line()
 
             # Auto-repair: if the tool failed due to a syntax error in the
             # generated code, attempt an "on the go" syntax fix before

{utim_cli-2.5.4 → utim_cli-2.6.0}/utim_cli/ask_helper.py

@@ -5,8 +5,8 @@ A dedicated, lightweight helper miniagent sharing the core UTIM LLM execution ar
 Provides real-time project insight, chat explanation, and conversational companionship
 without interrupting the main agent's active execution loop.
 
-Uses 'nvidia/nemotron-3.5-lightning:free' as the primary model (first fallback), then falls
-back through all registered free models from the server model_registry.
+Uses a spare model from the user's current plan (chosen dynamically, never the main
+agent's model and never a hardcoded slug).
 Has access to exactly one tool: 'read_chat'.
 """
 
@@ -26,12 +26,10 @@ from rich import box
 
 # ── Sidecar Helper Model ───────────────────────────────────────────
 
-PRIMARY_HELPER_MODEL = "nvidia/nemotron-3.5-lightning:free"
-
-
 def get_free_models_fallback_chain() -> List[str]:
-    """Return single primary helper model (fallback chain disabled)."""
-    return [PRIMARY_HELPER_MODEL]
+    """Spare plan models for the sidecar helper (dynamic; main agent's model excluded)."""
+    from utim_cli.background_models import get_background_models
+    return get_background_models(limit=3)
 
 
 
@@ -340,7 +338,10 @@ def execute_ask_helper(
     if not console:
         console = Console(highlight=False, markup=True)
 
-    model = PRIMARY_HELPER_MODEL
+    from utim_cli.background_models import get_background_model
+    model = get_background_model()
+    if not model:
+        return "No spare model is available on your plan for the sidecar helper (the main agent's model is never shared)."
     
     # Pre-extract live session chat history and context
     chat_summary = read_chat_history(orchestrator, max_turns=12)

utim_cli-2.6.0/utim_cli/background_models.py

@@ -0,0 +1,187 @@
+"""Dynamic, plan-aware model selection for background (non-main-agent) work.
+
+No model slugs are hardcoded here. Background tasks (compression, reflection,
+sidecar helper, decision/judge calls, miniagents, ...) pick from the models the
+server says the *current plan* may use, and they NEVER pick a model that the main
+agent is occupying. If the plan has no spare model, an empty list is returned and
+callers must degrade gracefully (local heuristics / skip) instead of stealing the
+main agent's model.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Iterable, List, Optional
+
+_CACHE_TTL = 300.0
+_lock = threading.Lock()
+_cache: dict = {"ts": 0.0, "tier": None, "models": []}
+
+_NON_TEXT_KEYWORDS = (
+    "lyria", "music", "audio", "whisper", "tts", "elevenlabs", "suno", "udio",
+    "video", "bge-m3", "rerank", "embed", "image", "krea",
+)
+
+
+def _current_plan() -> str:
+    try:
+        from utim_cli.config import config
+        return str(config.get("user_plan") or "free").lower().strip() or "free"
+    except Exception:
+        return "free"
+
+
+def _is_text_model(m: dict) -> bool:
+    mid = str(m.get("model_id") or m.get("id") or "").lower()
+    if not mid or any(k in mid for k in _NON_TEXT_KEYWORDS):
+        return False
+    caps = [str(c).lower() for c in (m.get("capabilities") or [])]
+    if m.get("is_image_gen") or "image_generation" in caps or "imagegen" in caps:
+        return False
+    return True
+
+
+def _cost(m: dict) -> float:
+    try:
+        return float(m.get("cost_input_per_1m") or 0.0) + float(m.get("cost_output_per_1m") or 0.0)
+    except Exception:
+        return 0.0
+
+
+def get_plan_models(force: bool = False) -> List[str]:
+    """Text models available to the current plan, cheapest first (server-driven)."""
+    plan = _current_plan()
+    now = time.monotonic()
+    with _lock:
+        if (not force and _cache["tier"] == plan and _cache["models"]
+                and now - _cache["ts"] < _CACHE_TTL):
+            return list(_cache["models"])
+
+    rows: list = []
+    try:
+        from utim_cli.client_utils import fetch_remote_models_catalog
+        cat = fetch_remote_models_catalog() or {}
+        rows = list(cat.get("main_agent") or cat.get("all_text") or [])
+    except Exception:
+        rows = []
+
+    rows = [m for m in rows if isinstance(m, dict) and _is_text_model(m)]
+    rows.sort(key=_cost)
+    ids: List[str] = []
+    for m in rows:
+        mid = str(m.get("model_id") or m.get("id") or "").strip()
+        if mid and mid not in ids:
+            ids.append(mid)
+
+    with _lock:
+        if ids:
+            _cache.update(ts=now, tier=plan, models=ids)
+        elif _cache["tier"] == plan:
+            # Network failure: keep serving the last known plan list.
+            return list(_cache["models"])
+    return ids
+
+
+def occupied_main_models(extra: Iterable[Optional[str]] = ()) -> set:
+    """Model ids the main agent is using right now (never used for background)."""
+    used = {str(x).strip() for x in extra if x}
+    try:
+        from utim_cli.config import config
+        mm = config.get("main_model")
+        if mm:
+            used.add(str(mm).strip())
+    except Exception:
+        pass
+    try:
+        from utim_cli import tools as _tools
+        mid = getattr(_tools, "_active_model_id", "") or ""
+        if mid:
+            used.add(str(mid).strip())
+    except Exception:
+        pass
+    return used
+
+
+def get_background_models(main_model: Optional[str] = None, limit: int = 3) -> List[str]:
+    """Ordered background-capable models for the current plan, excluding main agent's."""
+    busy = occupied_main_models([main_model])
+    out = [m for m in get_plan_models() if m not in busy]
+    return out[:limit] if limit else out
+
+
+def get_background_model(main_model: Optional[str] = None) -> Optional[str]:
+    """Single best background model, or None when the plan has no spare model."""
+    models = get_background_models(main_model, limit=1)
+    return models[0] if models else None
+
+
+_gated: dict = {}  # model_id -> expiry (monotonic)
+_GATED_TTL = 600.0
+
+
+def mark_gated(model_id: Optional[str]) -> None:
+    """Remember a model the server refused so it is never chosen as a fallback again."""
+    if model_id:
+        _gated[str(model_id).strip()] = time.monotonic() + _GATED_TTL
+
+
+def _gated_now() -> set:
+    now = time.monotonic()
+    for k in [k for k, v in _gated.items() if v < now]:
+        _gated.pop(k, None)
+    return set(_gated)
+
+
+def _tier_catalog_rows() -> list:
+    """Plan-filtered catalog (server applies tier gating) — not the unfiltered /models list."""
+    try:
+        import requests
+        from utim_cli.auth import SERVER_URL, get_auth_headers
+        resp = requests.get(
+            f"{SERVER_URL.rstrip('/')}/models/catalog",
+            params={"tier": _current_plan()},
+            headers=get_auth_headers(),
+            timeout=4.0,
+        )
+        if resp.status_code == 200:
+            data = resp.json()
+            if isinstance(data, dict):
+                return list(data.get("main_agent") or data.get("all_text") or [])
+    except Exception:
+        pass
+    return []
+
+
+def get_plan_fallback_model(exclude: Iterable[Optional[str]] = ()) -> Optional[str]:
+    """Model to auto-switch the MAIN agent to when its current model is gated.
+
+    Dynamic and loop-safe: marks every excluded model as gated, then picks a free
+    model from the server's plan-filtered catalog that has not been gated before.
+    Returns None when nothing is left so the caller stops instead of ping-ponging.
+    """
+    for x in exclude:
+        mark_gated(x)
+    skip = _gated_now()
+
+    rows = [m for m in _tier_catalog_rows() if isinstance(m, dict) and _is_text_model(m)]
+    if not rows:
+        try:
+            from utim_cli.client_utils import fetch_remote_models_catalog
+            cat = fetch_remote_models_catalog() or {}
+            rows = [m for m in (cat.get("main_agent") or cat.get("all_text") or [])
+                    if isinstance(m, dict) and _is_text_model(m)]
+        except Exception:
+            rows = []
+    rows.sort(key=_cost)
+
+    def _id(m):
+        return str(m.get("model_id") or m.get("id") or "").strip()
+
+    def _free(m):
+        return bool(m.get("is_free") or str(m.get("tier", "")).lower() == "free" or _cost(m) == 0.0)
+
+    for m in rows:
+        if _id(m) and _id(m) not in skip and _free(m):
+            return _id(m)
+    return None

utim_cli-2.6.0/utim_cli/behavior_telemetry.py

@@ -0,0 +1,207 @@
+"""
+utim_cli/behavior_telemetry.py
+==============================
+Client-side interaction telemetry for the server's bot detector.
+
+Why this exists
+---------------
+The server can observe *what* an account sends but not *how* it was typed.
+Typing cadence and error-correction behaviour are strong, cheap human signals:
+a script producing pristine 40-char-per-second input is trivially separable
+from a person who types ~6 CPS and backspaces twice a sentence.
+
+Design constraints
+------------------
+1. **Privacy-first.** We never record prompt content, keystrokes themselves,
+   clipboard data, or anything identifying. Only *aggregate counters* over a
+   rolling window: characters typed, seconds spent typing, total keystrokes,
+   backspace count, paste events. No text ever leaves the machine.
+2. **Zero latency.** Counting is a few integer increments on the prompt_toolkit
+   input path. Nothing blocks, nothing is hashed, no I/O.
+3. **Advisory only.** The server treats this as corroborating evidence that may
+   raise suspicion but never lower it, and never convict on its own. A bug here
+   cannot get a legitimate user throttled.
+4. **Cheap to disable.** Set ``UTIM_TELEMETRY=0`` to stop sending entirely; the
+   server renormalises onto its own server-side signals.
+
+Window semantics
+----------------
+Counters accumulate over a sliding window (default 600s). After each request we
+emit the current window snapshot and reset the *typing* counters, so each
+request describes the effort that went into producing that specific prompt.
+"""
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+from typing import Any, Dict, Optional
+
+# Rolling window for accumulation. Long enough to cover composing a long prompt,
+# short enough that an idle tab does not dilute the rate to zero.
+_WINDOW_SECONDS = 600.0
+
+_lock = threading.Lock()
+
+_state: Dict[str, Any] = {
+    "window_start": 0.0,
+    "typing_chars": 0,
+    "typing_seconds": 0.0,
+    "keystrokes": 0,
+    "corrections": 0,
+    "paste_events": 0,
+    "session_start": 0.0,
+    "last_input_at": 0.0,
+    "idle_seconds": 0.0,
+}
+
+# Idle gaps longer than this are treated as "away from keyboard" and are not
+# counted as typing time (prevents a coffee break from tanking the CPS rate).
+_IDLE_GAP = 8.0
+
+
+def is_enabled() -> bool:
+    return os.environ.get("UTIM_TELEMETRY", "1") not in ("0", "false", "False", "no")
+
+
+def _now() -> float:
+    return time.monotonic()
+
+
+def _ensure_window(now: float) -> None:
+    """Reset accumulators when the rolling window has elapsed."""
+    start = _state["window_start"]
+    if start <= 0.0 or (now - start) > _WINDOW_SECONDS:
+        _state["window_start"] = now
+        _state["typing_chars"] = 0
+        _state["typing_seconds"] = 0.0
+        _state["keystrokes"] = 0
+        _state["corrections"] = 0
+        _state["paste_events"] = 0
+
+
+def _start_session() -> None:
+    if _state["session_start"] <= 0.0:
+        _state["session_start"] = _now()
+
+
+def record_keystroke(chars: int = 1) -> None:
+    """Record printable input. Call from the prompt input handler.
+
+    Kept deliberately trivial: this runs on every keystroke, so it must not
+    allocate, hash, or touch the filesystem.
+    """
+    if not is_enabled():
+        return
+    now = _now()
+    with _lock:
+        _start_session()
+        _ensure_window(now)
+
+        last = _state["last_input_at"]
+        if last > 0.0:
+            gap = now - last
+            if gap <= _IDLE_GAP:
+                _state["typing_seconds"] += gap
+            else:
+                _state["idle_seconds"] += gap
+        _state["last_input_at"] = now
+
+        if chars > 0:
+            _state["typing_chars"] += chars
+            _state["keystrokes"] += chars
+
+
+def record_correction() -> None:
+    """Record a backspace / delete. Humans correct; scripts rarely do."""
+    if not is_enabled():
+        return
+    now = _now()
+    with _lock:
+        _start_session()
+        _ensure_window(now)
+        _state["corrections"] += 1
+        _state["keystrokes"] += 1
+
+
+def record_paste(chars: int = 0) -> None:
+    """Record a paste event (bulk input is machine-assisted, not typed)."""
+    if not is_enabled():
+        return
+    now = _now()
+    with _lock:
+        _start_session()
+        _ensure_window(now)
+        _state["paste_events"] += 1
+        # Pasted characters are NOT counted as typing_chars — that is the whole
+        # point: they inflate volume without demonstrating human typing effort.
+        _state["keystrokes"] += max(0, chars)
+
+
+def snapshot(reset: bool = True) -> Optional[Dict[str, Any]]:
+    """Return the current window snapshot for transmission.
+
+    Returns None when telemetry is disabled or there is nothing meaningful to
+    report (so we do not send empty headers on every request).
+    """
+    if not is_enabled():
+        return None
+
+    now = _now()
+    with _lock:
+        _ensure_window(now)
+
+        typing_chars = _state["typing_chars"]
+        typing_seconds = _state["typing_seconds"]
+        keystrokes = _state["keystrokes"]
+        corrections = _state["corrections"]
+        paste_events = _state["paste_events"]
+        session_start = _state["session_start"]
+        idle_seconds = _state["idle_seconds"]
+
+        if reset:
+            _state["typing_chars"] = 0
+            _state["typing_seconds"] = 0.0
+            _state["keystrokes"] = 0
+            _state["corrections"] = 0
+            _state["paste_events"] = 0
+            _state["window_start"] = now
+
+    # Nothing worth reporting — avoid sending a misleading all-zero header,
+    # which the server would score as "pristine input".
+    if keystrokes <= 0 and typing_chars <= 0 and paste_events <= 0:
+        return None
+
+    session_seconds = (now - session_start) if session_start > 0.0 else 0.0
+
+    return {
+        "typing_chars": int(typing_chars),
+        "typing_seconds": round(float(typing_seconds), 2),
+        "keystrokes": int(keystrokes),
+        "corrections": int(corrections),
+        "paste_events": int(paste_events),
+        "session_seconds": round(float(session_seconds), 2),
+        "idle_seconds": round(float(idle_seconds), 2),
+    }
+
+
+def telemetry_header_value() -> Optional[str]:
+    """Compact JSON header value, or None when disabled/empty."""
+    snap = snapshot(reset=True)
+    if snap is None:
+        return None
+    try:
+        return json.dumps(snap, separators=(",", ":"))
+    except Exception:
+        return None
+
+
+def reset() -> None:
+    """Clear all counters (used by tests)."""
+    with _lock:
+        for k in ("typing_chars", "keystrokes", "corrections", "paste_events"):
+            _state[k] = 0
+        for k in ("typing_seconds", "idle_seconds", "window_start",
+                  "session_start", "last_input_at"):
+            _state[k] = 0.0

{utim_cli-2.5.4 → utim_cli-2.6.0}/utim_cli/brain.py

@@ -81,13 +81,14 @@ BRAIN_TOP_K_FORWARD   = 12     # MiniLM candidates from forward pass
 BRAIN_TOP_K_REVERSE   = 6      # MiniLM candidates per Qwen sub-query
 BRAIN_FINAL_LIMIT     = 6      # max memories injected into system prompt
 BRAIN_RELEVANCE_FLOOR = 0.30   # cosine similarity floor for injection
-QWEN_BRAIN_MODEL      = "qwen/qwen2.5-1.5b-instruct"   # fast reasoning model on server
 
-# Reuse the reflection model list so brain calls use the same fallback chain
-try:
-    from utim_cli.reflection import REFLECTION_MODELS
-except Exception:
-    REFLECTION_MODELS = ["openrouter/free", QWEN_BRAIN_MODEL]
+def _background_models():
+    """Dynamic, plan-aware background models (never hardcoded, never the main agent's)."""
+    try:
+        from utim_cli.background_models import get_background_models
+        return get_background_models(limit=3)
+    except Exception:
+        return []
 
 # ── Paths ──────────────────────────────────────────────────────────────────────
 
@@ -253,7 +254,7 @@ def _call_qwen_brain(prompt: str, system: str = "", max_tokens: int = 400) -> st
     import requests as _req
     _system = system or "You are a precise AI assistant. Be concise and accurate."
 
-    for model in REFLECTION_MODELS:
+    for model in _background_models():
         try:
             resp = _req.post(
                 "https://openrouter.ai/api/v1/chat/completions",
@@ -933,10 +934,9 @@ def _call_decision_model(
     if not prompt:
         return ""
 
-    candidates = list(models) if models else [
-        "respan/span-01-lite:free",
-        "openai/gpt-4o-mini",
-    ]
+    candidates = list(models) if models else _background_models()
+    if not candidates:
+        return ""
 
     # 1) Prefer the in-process proxy (session reuse / rate-limit headroom).
     try: