utim-cli 2.3.12__tar.gz → 2.3.13__tar.gz

{utim_cli-2.3.12 → utim_cli-2.3.13}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [2.3.13] - 2026-08-28
+
+### 🐞 Minor Bug Fixes
+- Minor Bug Fixes
+
 ## [2.3.12] - 2026-08-27
 
 ### ⚡ Hedged TTFT Fallback Racing & Smart Nudge Improvements

{utim_cli-2.3.12/utim_cli.egg-info → utim_cli-2.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.12
+Version: 2.3.13
 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.3.12 → utim_cli-2.3.13}/pyproject.toml

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

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim/__init__.py

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

{utim_cli-2.3.12 → utim_cli-2.3.13}/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.3.12"
+    __version__ = "2.3.13"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/_version.py

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

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/agent.py

@@ -288,7 +288,7 @@ class ReActAgent:
 
             # Provider-safety pass: drop null/empty `tool_calls` keys from
             # history (strict providers 400 on `messages.N.tool_calls: null`).
-            kwargs["messages"] = sanitize_messages_for_api(kwargs.get("messages") or [])
+            kwargs["messages"] = sanitize_messages_for_api(kwargs.get("messages") or [], model_id=getattr(self, "model", None))
 
             # Call the LLM with streaming (retry once on transport errors so a
             # mid-stream failure doesn't silently kill the whole run)

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/bootstrap.py

@@ -150,7 +150,7 @@ def scan_available_skills(force_reload: bool = False):
 
     import os, re
     from pathlib import Path
-    from utim_cli.config import config as _cfg
+    from utim_cli.config import config as _cfg, get_all_utim_dirs
 
     disabled: list = _cfg.get("disabled_skills") or []
     if not isinstance(disabled, list):
@@ -163,11 +163,12 @@ def scan_available_skills(force_reload: bool = False):
         Path('.agents'),
         Path('.utim/skills'),
         Path('.utim/agentskills'),
-        UTIM_DIR / 'skills',
-        UTIM_DIR / 'agentskills',
-        Path.home() / '.utim' / 'skills',
-        Path.home() / '.utim' / 'agentskills',
+        Path('skills'),
     ]
+    for d in get_all_utim_dirs():
+        paths_to_check.append(d / 'skills')
+        paths_to_check.append(d / 'agentskills')
+        paths_to_check.append(d)
     
     for base_dir in paths_to_check:
         if not base_dir.exists():

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/client_utils.py

@@ -572,7 +572,7 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
         return requests.post("https://openrouter.ai/api/v1/chat/completions", json=json_data, headers=headers, stream=stream or json_data.get("stream"), timeout=timeout, verify=config.verify_ssl)
 
 
-def sanitize_messages_for_api(messages):
+def sanitize_messages_for_api(messages, model_id: Optional[str] = None):
     """Normalize conversation history into a provider-safe shape before sending.
 
     Fixes the Liquid/LFM-2.5 (and other strict OpenAI-compatible providers)
@@ -580,26 +580,85 @@ def sanitize_messages_for_api(messages):
     `messages.N.tool_calls`. Internal code paths persist assistant messages
     with `"tool_calls": None` (abort/quota returns, XML-fallback turns,
     session reloads). The OpenAI spec says the key must be omitted or an
-    array — never null. This function:
+    array — never null.
 
-      1. Drops `tool_calls` when it is None or an empty list.
-      2. Ensures every kept tool_call has id/type/function with string fields
-         (dict arguments are JSON-serialized to a string).
-      3. Ensures tool-role messages carry string content (None -> "").
-      4. Strips internal metadata keys some providers reject.
+    Also handles shifting between vision and non-vision models:
+    If target `model_id` is NOT vision-capable, converts any multimodal `image_url`
+    content blocks into text analysis blocks using precomputed background
+    analyses (from `analyze_image` / `_IMAGE_ANALYSIS_CACHE`) so non-vision models
+    do not trigger "No endpoints found which support images" from OpenRouter/providers.
 
     Returns a new list; the input list and its dicts are not mutated.
     """
     _INTERNAL_KEYS = (
         "reasoning_duration", "was_cut_off", "was_truncated_by_limit",
         "finish_reason", "completion_tokens", "cache_control", "aborted",
+        "_image_meta", "_image_path", "_image_analysis", "_image_entry", "_image_paths",
     )
+
+    # Check if target model supports vision
+    is_vision = True
+    if model_id:
+        try:
+            from utim_cli.tools import is_model_vision_capable
+            is_vision = is_model_vision_capable(model_id)
+        except Exception:
+            is_vision = True
+    else:
+        try:
+            from utim_cli.tools import is_model_vision_capable
+            is_vision = is_model_vision_capable()
+        except Exception:
+            is_vision = True
+
     clean = []
     for msg in messages:
         if not isinstance(msg, dict):
             continue  # never send non-dict junk to the API
         m = dict(msg)
         role = m.get("role")
+        content = m.get("content")
+
+        # Multimodal image handling: if the model is NOT vision capable,
+        # convert image_url blocks to text analysis!
+        if not is_vision and isinstance(content, list):
+            text_parts = []
+            for part in content:
+                if not isinstance(part, dict):
+                    text_parts.append(str(part))
+                    continue
+                p_type = part.get("type")
+                if p_type == "text":
+                    t = part.get("text", "")
+                    if t:
+                        text_parts.append(t)
+                elif p_type == "image_url":
+                    # Retrieve visual analysis
+                    analysis = m.get("_image_analysis")
+                    img_path = m.get("_image_path")
+                    img_meta = m.get("_image_meta")
+                    img_entry = m.get("_image_entry")
+                    if img_entry and isinstance(img_entry, dict) and img_entry.get("analysis"):
+                        analysis = img_entry.get("analysis")
+                    if not analysis and img_path:
+                        try:
+                            from utim_cli.tools import _IMAGE_ANALYSIS_CACHE
+                            analysis = _IMAGE_ANALYSIS_CACHE.get(img_path)
+                        except Exception:
+                            pass
+                    if not analysis and img_path and os.path.exists(img_path):
+                        try:
+                            from utim_cli.tools import analyze_image, _IMAGE_ANALYSIS_CACHE
+                            analysis = analyze_image(img_path, "Identify and describe this image in detail.")
+                            if analysis and not analysis.startswith("Error"):
+                                _IMAGE_ANALYSIS_CACHE[img_path] = analysis
+                        except Exception as _ae:
+                            analysis = f"Image {os.path.basename(img_path)} (Visual analysis unavailable: {_ae})"
+                    if not analysis:
+                        analysis = img_meta or "[Image visual content]"
+
+                    text_parts.append(f"[Visual Image Analysis]:\n{analysis}")
+            m["content"] = "\n\n".join(p for p in text_parts if p.strip())
 
         if role == "assistant":
             tc = m.get("tool_calls")

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/config.py

@@ -6,7 +6,7 @@ import shutil
 import time
 import hashlib
 import hmac
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, List
 
 logger = logging.getLogger("utim.config")
 
@@ -199,15 +199,113 @@ def _apply_ssl_session_patch(disable: bool) -> None:
     except Exception:
         pass
 
+def get_all_utim_dirs() -> List[pathlib.Path]:
+    """Return all valid candidate .utim directories across workspace, environment variables,
+    and user profiles (Windows USERPROFILE, APPDATA, HOME, Path.home(), etc.).
+    Ordered by priority.
+    """
+    candidates: List[pathlib.Path] = []
+    seen = set()
+
+    def _add(p):
+        if not p:
+            return
+        try:
+            resolved = pathlib.Path(p).expanduser().resolve()
+            r_str = str(resolved).lower()
+            if r_str not in seen:
+                seen.add(r_str)
+                candidates.append(resolved)
+        except Exception:
+            pass
+
+    # 1. Explicit environment variables (highest priority)
+    for env_var in ("UTIM_HOME", "UTIM_DIR", "UTIM_PATH", "AGY_HOME", "ANTIGRAVITY_HOME"):
+        val = os.environ.get(env_var)
+        if val:
+            _add(val)
+
+    # 2. PyTest environment check
+    import sys
+    if "pytest" in sys.argv[0] or "py.test" in sys.argv[0] or "PYTEST_CURRENT_TEST" in os.environ:
+        _add(pathlib.Path('.utim'))
+
+    # 3. Current workspace / project directories
+    try:
+        cwd = pathlib.Path.cwd()
+        _add(cwd / ".utim")
+        _add(cwd / ".agents")
+    except Exception:
+        pass
+
+    # 4. Standard User Home variants (handles Windows username differences, Git Bash, MSYS, Cygwin)
+    user_home_paths = []
+    if os.environ.get("USERPROFILE"):
+        user_home_paths.append(pathlib.Path(os.environ["USERPROFILE"]))
+    if os.environ.get("HOME"):
+        user_home_paths.append(pathlib.Path(os.environ["HOME"]))
+    if os.environ.get("HOMEDRIVE") and os.environ.get("HOMEPATH"):
+        user_home_paths.append(pathlib.Path(os.environ["HOMEDRIVE"] + os.environ["HOMEPATH"]))
+    try:
+        user_home_paths.append(pathlib.Path.home())
+    except Exception:
+        pass
+    try:
+        user_home_paths.append(pathlib.Path(os.path.expanduser("~")))
+    except Exception:
+        pass
+    if os.environ.get("APPDATA"):
+        user_home_paths.append(pathlib.Path(os.environ["APPDATA"]))
+    if os.environ.get("LOCALAPPDATA"):
+        user_home_paths.append(pathlib.Path(os.environ["LOCALAPPDATA"]))
+
+    for h in user_home_paths:
+        _add(h / ".utim")
+        _add(h / ".agents")
+
+    return candidates
+
+
 def get_utim_dir() -> pathlib.Path:
     """Return the centralized .utim directory path.
-    If running within a pytest environment, uses the current directory's .utim folder
-    to isolate test side-effects. Otherwise, resolves to the user's home directory.
+    Prioritizes explicit environment variables, existing .utim directories,
+    and falls back cleanly to the primary user profile directory.
     """
     import sys
     if "pytest" in sys.argv[0] or "py.test" in sys.argv[0] or "PYTEST_CURRENT_TEST" in os.environ:
         return pathlib.Path('.utim')
-    return pathlib.Path.home() / ".utim"
+
+    # Check explicit env var
+    for env_var in ("UTIM_HOME", "UTIM_DIR", "UTIM_PATH"):
+        val = os.environ.get(env_var)
+        if val:
+            try:
+                p = pathlib.Path(val).expanduser().resolve()
+                p.mkdir(parents=True, exist_ok=True)
+                return p
+            except Exception:
+                pass
+
+    # Check existing .utim directories from all candidate paths
+    all_dirs = get_all_utim_dirs()
+    for d in all_dirs:
+        if d.exists() and d.is_dir() and d.name == ".utim":
+            return d
+
+    # Default fallback to primary user home
+    try:
+        if os.environ.get("USERPROFILE"):
+            fallback = pathlib.Path(os.environ["USERPROFILE"]) / ".utim"
+        else:
+            fallback = pathlib.Path.home() / ".utim"
+    except Exception:
+        fallback = pathlib.Path(os.path.expanduser("~")) / ".utim"
+
+    try:
+        fallback.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass
+    return fallback
 
 
 class Config:

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/doctor.py

@@ -153,7 +153,7 @@ def run_diagnostics(console: Console = None, fix: bool = False, include_heavy: b
         from utim_cli.config import get_utim_dir
         utim_dir = get_utim_dir()
         local_utim = os.path.exists(utim_dir)
-        console.print(f"    * .utim/ directory:   {'[green]Exists[/green]' if local_utim else '[yellow]Missing[/yellow]'}")
+        console.print(f"    * .utim/ directory:   {'[green]Exists[/green]' if local_utim else '[yellow]Missing[/yellow]'} [dim]({utim_dir})[/dim]")
 
         config_exists = os.path.exists(os.path.join(utim_dir, "config.json"))
         console.print(f"    * config.json:        {'[green]Exists[/green]' if config_exists else '[yellow]Missing[/yellow]'}")

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/orchestrator.py

@@ -619,7 +619,23 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                                 "type": "image_url",
                                 "image_url": {"url": f"data:{mime};base64,{b64}"}
                             })
-                        self.messages.append({"role": "user", "content": multimodal_content})
+                            # Background analyze image for non-vision fallback
+                            def _bg_user_img_analyze(_p):
+                                try:
+                                    from utim_cli.tools import analyze_image, _IMAGE_ANALYSIS_CACHE
+                                    if _p not in _IMAGE_ANALYSIS_CACHE:
+                                        res = analyze_image(_p, "Identify and describe this image in detail.")
+                                        if res and not res.startswith("Error"):
+                                            _IMAGE_ANALYSIS_CACHE[_p] = res
+                                except Exception:
+                                    pass
+                            threading.Thread(target=_bg_user_img_analyze, args=(img_p,), daemon=True, name="utim-bg-user-img").start()
+
+                        self.messages.append({
+                            "role": "user",
+                            "content": multimodal_content,
+                            "_image_paths": valid_images,
+                        })
                     else:
                         # Text-only model fallback: analyze image to text context
                         for img_p in valid_images:
@@ -993,7 +1009,18 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                     self.console.print(f"\n[bold yellow]Parsed {len(tool_calls)} tool call(s) from assistant text response.[/bold yellow]")
 
             # If the model response was cut off mid-turn due to length/token limits, nudge it to continue
-            if msg.get("was_cut_off"):
+            # ONLY trigger when the response was genuinely truncated by token limits (never when finish_reason is "stop" or "end_turn")
+            _is_truly_token_truncated = (
+                not msg.get("aborted")
+                and not tool_calls
+                and msg.get("finish_reason") not in ("stop", "end_turn", "tool_calls", "repetition_loop")
+                and (
+                    msg.get("was_truncated_by_limit")
+                    or msg.get("finish_reason") in ("length", "max_tokens")
+                    or (msg.get("was_cut_off") and msg.get("finish_reason") not in ("stop", "end_turn"))
+                )
+            )
+            if _is_truly_token_truncated:
                 self.console.print("\n[bold yellow]Response truncated by token limits. Continuing response...[/bold yellow]\n")
                 self.messages.append(
                     {
@@ -1587,6 +1614,8 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
             # Clear any stale vision images from a previous iteration before
             # this batch of tools runs (defensive — shouldn't normally be set).
             _tools_module._pending_vision_images.clear()
+            _tools_module._cancel_event = self.cancel_event
+            _tools_module._active_model_id = self.model_id
 
             # Execute tools in parallel when beneficial
             if len(tool_calls) > 1:
@@ -1650,6 +1679,10 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                                 {"type": "text", "text": f"[Image from read_file: {_vimg['meta']}]"},
                                 {"type": "image_url", "image_url": {"url": f"data:{_vimg['mime']};base64,{_vimg['b64']}"}},
                             ],
+                            "_image_meta": _vimg.get("meta", ""),
+                            "_image_path": _vimg.get("filepath", ""),
+                            "_image_analysis": _vimg.get("analysis", "") or getattr(_tools_module, "_IMAGE_ANALYSIS_CACHE", {}).get(_vimg.get("filepath", ""), ""),
+                            "_image_entry": _vimg,
                         }
                     )
                 _vision_queue.clear()

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/orchestrator_helpers.py

@@ -386,7 +386,7 @@ SYSTEM_PROMPT = SYSTEM_PROMPT + _detect_environment()
 
 COMPRESSED_SYSTEM_PROMPT = f"""<identity>
 You are UTIM, an elite agentic AI coding assistant and CLI pair programmer.
-- Your identity is strictly UTIM (or UTIM AI). Never identify as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, or other base models.
+- Your identity is strictly UTIM (or UTIM AI). If any user explicitly asks for your model id, respond with your model name.
 - When greeted or asked who you are, introduce yourself concisely as UTIM.
 </identity>
 
@@ -1182,7 +1182,7 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
         return (
             "<identity>\n"
             "You are UTIM, an elite AI coding assistant and CLI pair programmer.\n"
-            "- Your identity is strictly UTIM (or UTIM AI). Never refer to yourself as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, or any other base model.\n"
+            "- Your identity is strictly UTIM (or UTIM AI).  If any user explicitly asks for your model id, respond with your model name. \n"
             "- If introducing yourself, introduce yourself as UTIM.\n"
             "</identity>\n\n"
             "Respond warmly and concisely in under 2 sentences."
@@ -1192,7 +1192,7 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
         identity = (
             "<identity>\n"
             "You are UTIM, an elite agentic AI coding assistant and CLI pair programmer operating autonomously inside the user's terminal.\n"
-            "- Your identity is strictly UTIM (or UTIM AI). Never identify as, mention, or adopt other model personas (such as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, LLaMA, Gemini, etc.).\n"
+            "- Your identity is strictly UTIM (or UTIM AI).  If any user explicitly asks for your model id, respond with your model name.\n"
             "- When greeted or asked who you are, introduce yourself warmly as UTIM.\n"
             "- You are autonomous, highly capable, proactive, and focused on writing correct code and executing tasks.\n"
             "</identity>\n\n"
@@ -1204,7 +1204,7 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
         identity = (
             "<identity>\n"
             "You are UTIM, an elite agentic AI coding assistant and CLI pair programmer.\n"
-            "- Your identity is strictly UTIM (or UTIM AI). Never identify as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, or other base models.\n"
+            "- Your identity is strictly UTIM (or UTIM AI).  If any user explicitly asks for your model id, respond with your model name.\n"
             "- When greeted or asked who you are, introduce yourself concisely as UTIM.\n"
             "</identity>\n\n"
         )

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/orchestrator_llm_transport.py

@@ -267,7 +267,7 @@ class LLMTransportMixin:
                     msg_copy.pop("completion_tokens", None)
                     clean_messages.append(msg_copy)
 
-                clean_messages = sanitize_messages_for_api(clean_messages)
+                clean_messages = sanitize_messages_for_api(clean_messages, model_id=cand_model)
                 if clean_messages and clean_messages[0].get("role") == "system":
                     clean_messages[0]["cache_control"] = {"type": "ephemeral"}
                 worker_tools = [dict(t) for t in all_tools] if all_tools else None
@@ -816,7 +816,7 @@ class LLMTransportMixin:
                 # Provider-safety pass: drop null/empty `tool_calls` keys and
                 # normalize tool-call/tool-message shapes. Strict providers
                 # (e.g. Liquid/LFM) 400 on `messages.N.tool_calls: null`.
-                clean_messages = sanitize_messages_for_api(clean_messages)
+                clean_messages = sanitize_messages_for_api(clean_messages, model_id=current_model)
 
                 # ── Step 1 Optimization: Prompt Caching (OpenRouter / Anthropic / DeepSeek) ──
                 # Inject ephemeral cache_control markers into system message and tool schema
@@ -1680,22 +1680,11 @@ class LLMTransportMixin:
                                 pass
 
                         # Heuristic abrupt-cutoff detector:
-                        # Some providers (e.g. OpenRouter) report finish_reason="stop" even
-                        # when the response is actually truncated mid-generation.  We catch
-                        # two reliable signals of abrupt cutoff:
-                        #   1. Unclosed code fence — an odd count of triple-backtick markers
-                        #      means the last ```...``` block was never closed.
-                        #   2. The response is large (>3 000 chars) and the last non-whitespace
-                        #      character is NOT a normal sentence terminator, suggesting the
-                        #      model was cut off mid-word or mid-line.
-                        if not was_cut_off and clean_content and not final_tool_calls:
+                        # Only check if finish_reason was NOT an explicit completion ("stop" / "end_turn")
+                        if not was_cut_off and clean_content and not final_tool_calls and _stream_finish_reason not in ("stop", "end_turn"):
                             _backtick_count = clean_content.count("```")
-                            _last_char = clean_content.rstrip()[-1] if clean_content.rstrip() else ""
-                            _terminal_chars = set(".?!`'\">)]}\\")
                             if _backtick_count % 2 != 0:
                                 was_cut_off = True  # unclosed code fence
-                            elif len(clean_content) > 3000 and _last_char not in _terminal_chars:
-                                was_cut_off = True  # large response ending abruptly
 
                         # Truncation diagnosis: was the stream cut short by output token limit?
                         _max_out = _get_model_max_output(current_model)

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/orchestrator_tool_exec.py

@@ -1560,6 +1560,8 @@ class ToolExecutionMixin:
         
         # Execute parallel-safe tools concurrently
         if parallel_calls:
+            _tools_module._cancel_event = self.cancel_event
+            _tools_module._active_model_id = self.model_id
             executor = ThreadPoolExecutor(max_workers=min(len(parallel_calls), 8))
             try:
                 future_to_idx = {executor.submit(self._execute_tool_timed, tc): (orig_idx, tc) 

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/server/auth.py

@@ -91,13 +91,21 @@ def process_user_refills(db: Session, user_id: str) -> None:
         return
 
     if _is_free_plan_id(db, sub.plan_id):
-        # Handle monthly cycle end — reset the counter
+        # ── Fix 2: Auto-degrade free plan if current_period_end is in the past ──
+        # Guard against stuck 'active' status where refills_processed hit 144 but
+        # the subscription row was never reset/cancelled.
         if sub.current_period_end and now >= sub.current_period_end:
+            # Cycle has expired — reset the counter and roll the period forward.
             sub.refills_processed = 0
+            sub.refill_intervals_processed = 0
             sub.current_period_start = now
             sub.current_period_end = now + datetime.timedelta(days=30)
             db.commit()
-            
+            logger.info(
+                "free_plan_cycle_reset user_id=%s new_period_end=%s",
+                user_id, sub.current_period_end,
+            )
+
         refills_used = getattr(sub, 'refills_processed', getattr(sub, 'refills_used', 0)) or 0
         if refills_used >= 144:
             return  # Hit monthly cap of 144 refills (3000 credits max)
@@ -125,6 +133,9 @@ def process_user_refills(db: Session, user_id: str) -> None:
                     
                     credit_row.balance = new_bal
                     sub.refills_processed = refills_used + intervals_to_apply
+                    sub.refill_intervals_processed = (
+                        (sub.refill_intervals_processed or 0) + intervals_to_apply
+                    )
                     sub.last_refill_at = last_refill + datetime.timedelta(seconds=intervals_to_apply * INTERVAL_SECONDS)
                     
                     if actual_added > 0:
@@ -141,19 +152,57 @@ def process_user_refills(db: Session, user_id: str) -> None:
                     db.commit()
                     logger.info("refill_processed", extra={"user_id": user_id, "intervals": intervals_to_apply, "new_balance": new_bal})
         return
-    
+
+    # ── PAID-PLAN BRANCH ────────────────────────────────────────────────────
     # Calculate how many 5-hour refills should have been processed by now
     cycle_days = (sub.current_period_end - sub.current_period_start).days
     is_yearly = cycle_days > 45
     max_refills = 1728 if is_yearly else 144
 
+    # ── Fix 3: Rescue a stuck paid-subscription row ──────────────────────────
+    # A row is "stuck" when:
+    #   1. refills_processed >= max_refills_for_cycle, AND
+    #   2. current_period_start is *recent* (i.e. the period was just
+    #      reset/renewed — by a Razorpay webhook, a manual admin edit, or a
+    #      previous auto-degrade that was rolled back) BUT
+    #   3. refills_processed was never reset to 0 alongside it.
+    #
+    # Symptom: the user is on an "active" paid plan, but the UI says all
+    # 144 (or 1728) refills have ended, and no new refills ever fire because
+    # `due = max_due - refills_processed` is negative. The auto-degrade check
+    # below is also skipped because current_period_end is in the future.
+    #
+    # Rescue rule: if refills_processed has hit the cycle cap but the period
+    # is still young (< 25 days for monthly, < 320 days for yearly), this
+    # is a stale counter. Reset it so the normal refill loop can take over.
+    refills_processed = sub.refills_processed or 0
+    if refills_processed >= max_refills:
+        period_age_seconds = (now - sub.current_period_start).total_seconds()
+        young_threshold_seconds = (320 if is_yearly else 25) * 24 * 3600
+        if 0 <= period_age_seconds < young_threshold_seconds:
+            logger.warning(
+                "stuck_paid_subscription_rescue user_id=%s plan=%s "
+                "refills_processed=%d max_refills=%d period_age_days=%.1f — "
+                "resetting counter so refills can resume",
+                user_id, sub.plan.name if sub.plan else "?",
+                refills_processed, max_refills, period_age_seconds / 86400.0,
+            )
+            sub.refills_processed = 0
+            sub.current_cycle_used = 0.0
+            sub.unallocated_deducted = 0.0
+            sub.last_refill_at = None
+            db.commit()
+            # Re-read the fresh values after the reset
+            refills_processed = 0
+            db.refresh(sub)
+
     if now >= sub.current_period_end:
         max_due = max_refills
     else:
         elapsed_seconds = (now - sub.current_period_start).total_seconds()
         max_due = min(max_refills, int(elapsed_seconds // (5 * 3600)))
-        
-    due = max_due - sub.refills_processed
+
+    due = max_due - refills_processed
     if due > 0:
         plan = sub.plan
         cycle_allowance = plan.credits_per_month / 144.0

{utim_cli-2.3.12 → utim_cli-2.3.13}/utim_cli/server/db.py

@@ -148,6 +148,9 @@ class UserSubscription(Base):
     # Overrides the default per-cycle credit allocation after a quota-share deduction
     refill_rate_override = Column(Float, nullable=True)
     unallocated_deducted = Column(Float, default=0.0, nullable=False)
+    # Free-plan only: tracks 5-hour refill intervals within the current 30-day cycle
+    # (separate from refills_processed which is used by paid plans for credit-pool refills)
+    refill_intervals_processed = Column(Integer, default=0, nullable=False)
     created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)
     updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow, nullable=False)
 
@@ -782,6 +785,8 @@ def init_db(silent: bool = True) -> None:
         _run_migration("feedbacks", "chat_history", "ALTER TABLE feedbacks ADD COLUMN IF NOT EXISTS chat_history TEXT", "postgres add chat_history")
         _run_migration("user_subscriptions", "refill_rate_override", "ALTER TABLE user_subscriptions ADD COLUMN IF NOT EXISTS refill_rate_override FLOAT", "postgres add refill_rate_override")
         _run_migration("user_subscriptions", "unallocated_deducted", "ALTER TABLE user_subscriptions ADD COLUMN IF NOT EXISTS unallocated_deducted FLOAT DEFAULT 0.0 NOT NULL", "postgres add unallocated_deducted")
+        # Fix: new column for free-plan refill cycle tracking (avoids overloading refills_processed)
+        _run_migration("user_subscriptions", "refill_intervals_processed", "ALTER TABLE user_subscriptions ADD COLUMN IF NOT EXISTS refill_intervals_processed INTEGER DEFAULT 0 NOT NULL", "postgres add refill_intervals_processed")
         _run_migration("marketplace_listings", "payment_type", "ALTER TABLE marketplace_listings ADD COLUMN IF NOT EXISTS payment_type VARCHAR(32) DEFAULT 'one_time'", "postgres add payment_type")
         _run_migration("marketplace_listings", "subscription_interval", "ALTER TABLE marketplace_listings ADD COLUMN IF NOT EXISTS subscription_interval VARCHAR(16)", "postgres add subscription_interval")
         _run_migration("marketplace_listings", "razorpay_plan_id", "ALTER TABLE marketplace_listings ADD COLUMN IF NOT EXISTS razorpay_plan_id VARCHAR(128)", "postgres add razorpay_plan_id")
@@ -817,6 +822,8 @@ def init_db(silent: bool = True) -> None:
         _run_migration("user_subscriptions", "current_cycle_used", "ALTER TABLE user_subscriptions ADD COLUMN current_cycle_used FLOAT DEFAULT 0.0 NOT NULL", "sqlite add current_cycle_used")
         _run_migration("user_subscriptions", "refill_rate_override", "ALTER TABLE user_subscriptions ADD COLUMN refill_rate_override FLOAT", "sqlite add refill_rate_override")
         _run_migration("user_subscriptions", "unallocated_deducted", "ALTER TABLE user_subscriptions ADD COLUMN unallocated_deducted FLOAT DEFAULT 0.0 NOT NULL", "sqlite add unallocated_deducted")
+        # Fix: new column for free-plan refill cycle tracking
+        _run_migration("user_subscriptions", "refill_intervals_processed", "ALTER TABLE user_subscriptions ADD COLUMN refill_intervals_processed INTEGER DEFAULT 0 NOT NULL", "sqlite add refill_intervals_processed")
         _run_migration("credits", "bonus_balance", "ALTER TABLE credits ADD COLUMN bonus_balance FLOAT DEFAULT 0.0 NOT NULL", "sqlite add bonus_balance")
         _run_migration("credits", "bonus_limit", "ALTER TABLE credits ADD COLUMN bonus_limit FLOAT DEFAULT 0.0 NOT NULL", "sqlite add bonus_limit")
         _run_migration("credits", "free_monthly_used", "ALTER TABLE credits ADD COLUMN free_monthly_used FLOAT DEFAULT 0.0 NOT NULL", "sqlite add free_monthly_used")