utim-cli 2.0.0__tar.gz → 2.0.1__tar.gz

{utim_cli-2.0.0 → utim_cli-2.0.1}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [2.0.1] - 2026-08-04 - Bugfix & Adaptive Iteration Budget
+
+### 🛠️ Fixes
+- **Fixed `unhashable type: 'slice'` crash in `_get_display_arg`**: `run_command` args are now defensively coerced to strings (handles malformed LLM args that arrive as list/dict instead of str).
+- **Fixed thinking spinner persisting after response ends**: `STATE["thinking_topic"]` is cleared immediately after the response completes, so the spinner stops instead of animating through the entire response-end compression.
+- **Response-end compression now runs in a background thread**: The elapsed-time rule prints instantly; context compression happens silently behind the scenes without blocking the UI.
+
+### 🧠 Adaptive Iteration Budget (Window-Aware)
+- **Removed hardcoded "45 iterations max" from system directives**: The iteration budget is now computed at runtime from the model's context window.
+- **Budget scales with context window** using the same buckets as compression intervals:
+  - `< 200k` context: budget `25`
+  - `200k – 500k` context: budget `35`
+  - `500k – 1M` context: budget `40`
+  - `1M+` context: budget `45`
+- **One-shot milestone warnings**: Mid-task warning, "5 iterations left" urgent warning, and "+5 granted" notice each fire exactly once per model/iteration (tracked via `_milestones_fired` set) instead of repeating on every request.
+
 ## [2.0.0] - 2026-08-04 - UTIM V2.0 RELEASE
 
 ### 🚀 Major Release: UTIM V2.0 — Creators Ecosystem & Adaptive Intelligence

{utim_cli-2.0.0/utim_cli.egg-info → utim_cli-2.0.1}/PKG-INFO

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

{utim_cli-2.0.0 → utim_cli-2.0.1}/pyproject.toml

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

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

utim_cli-2.0.1/utim_cli/_check_obj.py

@@ -0,0 +1,9 @@
+f = open('orchestrator.py', encoding='utf-8').read()
+idx = f.find('Active Objective')
+snippet = f[idx:idx+150]
+print('Found:', 'Active Objective' in snippet)
+print('Has 600:', '[:600]' in snippet)
+print('Has 200:', '[:200]' in snippet)
+# Write to file to avoid encoding issues
+open('_check.txt', 'w', encoding='utf-8').write(snippet)
+print('Written to _check.txt')

utim_cli-2.0.1/utim_cli/_find_mcp.py

@@ -0,0 +1,9 @@
+f = open('orchestrator.py', encoding='utf-8').read()
+idx = f.find('class Orchestrator')
+idx2 = f.find('def __init__', idx)
+# Find mcp_tool_names references
+import re
+for m in re.finditer(r'mcp_tool_names', f):
+    line = f[:m.start()].count('\n') + 1
+    context = f[max(0,m.start()-80):m.end()+80]
+    print(f"Line {line}: ...{repr(context)}...")

utim_cli-2.0.1/utim_cli/_find_plan.py

@@ -0,0 +1,12 @@
+f = open('tools.py', encoding='utf-8').read()
+idx = f.find('def plan_project')
+# Find the next def or the end of the function
+rest = f[idx:]
+# Find the save-to-file part
+save_idx = rest.find('.utim_tmp/plans/')
+print(f"plan_project starts at: {idx}")
+print(f"save file reference at: {idx + save_idx}")
+print()
+# Show the save block
+block = rest[save_idx-100:save_idx+500]
+print(block)

utim_cli-2.0.1/utim_cli/_find_tool.py

@@ -0,0 +1,10 @@
+f = open('orchestrator.py', encoding='utf-8').read()
+# Find all "role": "tool" append blocks
+import re
+for m in re.finditer(r'role":\s*"tool"', f):
+    start = max(0, m.start() - 100)
+    end = min(len(f), m.end() + 300)
+    snippet = f[start:end]
+    print(f"--- Match at {m.start()} ---")
+    print(snippet)
+    print()

utim_cli-2.0.1/utim_cli/_patch_multimodal.py

@@ -0,0 +1,125 @@
+f = open('orchestrator.py', encoding='utf-8').read()
+
+# Find the single tool append (second occurrence of _cap_tool_result)
+idx1 = f.find('result = _cap_tool_result(func_name, result)')
+idx2 = f.find('result = _cap_tool_result(func_name, result)', idx1 + 50)
+
+# The single append starts at idx2 and ends at the "# --- Repeated Tool" line
+end_marker = '\n            # --- Repeated Tool '
+end_idx = f.find(end_marker, idx2)
+
+old_block = f[idx2:end_idx]
+print("=== OLD BLOCK ===")
+print(repr(old_block))
+print()
+
+# Build new block
+new_block = '''result = _cap_tool_result(func_name, result)
+
+                    # If result is an [Image: path] marker and model is vision-capable,
+                    # inject the actual image as multimodal content
+                    _img_match = __import__("re").match(r"^\\[Image:\\s+(.+)\\]$", result.strip())
+                    if _img_match and func_name in ("read_file",):
+                        try:
+                            from utim_cli.tools import is_model_vision_capable
+                            if is_model_vision_capable():
+                                _img_path = _img_match.group(1)
+                                _multimodal = _tool_result_to_multimodal(result, _img_path)
+                                self.messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tc_id,
+                                        "name": func_name,
+                                        "content": _multimodal,
+                                    }
+                                )
+                            else:
+                                self.messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tc_id,
+                                        "name": func_name,
+                                        "content": result,
+                                    }
+                                )
+                        except Exception:
+                            self.messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": tc_id,
+                                    "name": func_name,
+                                    "content": result,
+                                }
+                            )
+                    else:
+                        self.messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": tc_id,
+                                "name": func_name,
+                                "content": result,
+                            }
+                        )'''
+
+f = f.replace(old_block, new_block)
+
+# Now do the parallel one (first occurrence)
+idx1_end = f.find(end_marker, f.find('result = _cap_tool_result(func_name, result)'))
+# Actually the parallel one ends differently - find its actual end
+# It's followed by "            else:" not "# --- Repeated Tool"
+old_para_end_marker = '\n            else:\n                # Single tool'
+old_para_start = f.find('result = _cap_tool_result(func_name, result)')
+old_para_end = f.find(old_para_end_marker, old_para_start)
+old_para_block = f[old_para_start:old_para_end]
+
+new_para_block = '''result = _cap_tool_result(func_name, result)
+
+                    # If result is an [Image: path] marker and model is vision-capable,
+                    # inject the actual image as multimodal content
+                    _img_match = __import__("re").match(r"^\\[Image:\\s+(.+)\\]$", result.strip())
+                    if _img_match and func_name in ("read_file",):
+                        try:
+                            from utim_cli.tools import is_model_vision_capable
+                            if is_model_vision_capable():
+                                _img_path = _img_match.group(1)
+                                _multimodal = _tool_result_to_multimodal(result, _img_path)
+                                self.messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tc_id,
+                                        "name": func_name,
+                                        "content": _multimodal,
+                                    }
+                                )
+                            else:
+                                self.messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tc_id,
+                                        "name": func_name,
+                                        "content": result,
+                                    }
+                                )
+                        except Exception:
+                            self.messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": tc_id,
+                                    "name": func_name,
+                                    "content": result,
+                                }
+                            )
+                    else:
+                        self.messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": tc_id,
+                                "name": func_name,
+                                "content": result,
+                            }
+                        )'''
+
+f = f.replace(old_para_block, new_para_block)
+
+open('orchestrator.py', 'w', encoding='utf-8').write(f)
+print("OK: both tool append blocks replaced")

utim_cli-2.0.1/utim_cli/_test_regex.py

@@ -0,0 +1,22 @@
+import re
+
+# Test the full noise string
+text = "System.Management.Automation.PSCustomObjectSystem.Object1Preparing modules for first use.0-1-1Completed-1"
+
+# Broader pattern: match the whole PowerShell startup noise line
+_PS_NOISE_RE = re.compile(
+    r'System\.Management\.Automation\..*?(?:Completed-\d+|$)|'
+    r'Preparing modules for first use\..*?(?:Completed-\d+|$)|'
+    r'out-file\s*:\s*FileStream was asked to open a device.*?(?:$|\n)|'
+    r'For support for devices like.*?(?:$|\n)|'
+    r'call CreateFile, then use the FileStream.*?(?:$|\n)|'
+    r'CategoryInfo\s*:\s*OpenError.*?(?:$|\n)|'
+    r'FullyQualifiedErrorId\s*:\s*FileOpenFailure.*?(?:$|\n)|'
+    r'At line:\d+ char:\d+.*?(?:$|\n)',
+    re.IGNORECASE | re.DOTALL
+)
+
+result = _PS_NOISE_RE.sub("", text).strip()
+print(f"Input:  {repr(text)}")
+print(f"Output: {repr(result)}")
+print(f"Empty:  {result == ''}")

{utim_cli-2.0.0 → utim_cli-2.0.1}/utim_cli/_version.py

@@ -11,4 +11,4 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.0.0"
+VERSION = "2.0.1"

{utim_cli-2.0.0 → utim_cli-2.0.1}/utim_cli/orchestrator.py

@@ -767,8 +767,10 @@ def _get_dynamic_directives(is_compressed: bool, messages: Optional[List[Dict]]
         "5. **Think-Create-Verify**: Execute tools directly without conversational preambles or text planning. Verify edits with `run_command` (compile/build/test).",
         "6. **Execution**: Invoke native function-calling schemas directly. Never output raw JSON, <think> tags, or conversational text before tool calls.",
         "7. **Output & Summary**: Be concise, professional, and clear. Upon finishing, provide a comprehensive summary of completion.",
-        "8. **Iteration Budget**: Complete all task execution and verification within **45 iterations max**.",
     ]
+    # NOTE: 'Iteration Budget' directive intentionally removed.
+    # Iteration limits are now enforced dynamically (window-aware) at runtime
+    # via milestone warnings, not hardcoded into the system prompt.
 
     return "\n".join(directives)
 
@@ -1239,6 +1241,10 @@ class Orchestrator:
         self.active_tag: Optional[str] = None                  # e.g. '@refactor-bot'
         self.active_tag_system_prompt: Optional[str] = None    # custom system prompt text
 
+        # ── MCP tool name registry ───────────────────────────────────────
+        # Populated by _discover_mcp_tools() or left empty if MCP is disabled.
+        self.mcp_tool_names: set = set()
+
         # Eager session create removed for local mode - sessions are created by _persist_messages
 
     def abort(self) -> None:
@@ -2391,7 +2397,16 @@ class Orchestrator:
             if not cmd:
                 cmds = arguments.get("commands", [])
                 if cmds and isinstance(cmds, list):
-                    cmd = "; ".join(cmds)
+                    cmd = "; ".join(str(c) for c in cmds)
+            # Defensive coercion: cmd may be a list, dict, or other non-string type
+            # if the LLM emitted malformed arguments. Coerce to string safely.
+            if not isinstance(cmd, str):
+                if isinstance(cmd, (list, tuple)):
+                    cmd = "; ".join(str(c) for c in cmd)
+                elif isinstance(cmd, dict):
+                    cmd = " ".join(f"{k}={v}" for k, v in cmd.items())
+                else:
+                    cmd = str(cmd) if cmd is not None else ""
             display = (cmd or "")[:80] + ("…" if len(cmd or "") > 80 else "")
             dir_p = arguments.get("dir_path", "")
             if dir_p:
@@ -3246,6 +3261,22 @@ class Orchestrator:
                     and param.kind not in (inspect.Parameter.VAR_KEYWORD, inspect.Parameter.VAR_POSITIONAL)
                     and name not in filtered_args
                 ]
+                if still_missing:
+                    # ── Auto-recovery: if the LLM emitted empty args (raw_args == '{}'),
+                    #    try to recover 'filepath' from recent tool-call history.
+                    #    This handles the common case where the model forgets to pass
+                    #    arguments on follow-up calls (e.g. "read that file again").
+                    if "filepath" in still_missing and not call_args:
+                        try:
+                            if not hasattr(self, "_recent_filepaths"):
+                                from collections import deque
+                                self._recent_filepaths = deque(maxlen=20)
+                            if self._recent_filepaths:
+                                _recovered = self._recent_filepaths[-1]
+                                filtered_args["filepath"] = _recovered
+                                still_missing = [n for n in still_missing if n != "filepath"]
+                        except Exception:
+                            pass
                 if still_missing:
                     _raw_preview = (raw_args or "")[:200]
                     result = (
@@ -3256,6 +3287,15 @@ class Orchestrator:
                         f"Check _ARG_ALIASES['{func_name}'] or the tool-call parser."
                     )
                 else:
+                    # Track successful filepath usage for future auto-recovery
+                    if "filepath" in filtered_args and isinstance(filtered_args["filepath"], str):
+                        try:
+                            if not hasattr(self, "_recent_filepaths"):
+                                from collections import deque
+                                self._recent_filepaths = deque(maxlen=20)
+                            self._recent_filepaths.append(filtered_args["filepath"])
+                        except Exception:
+                            pass
                     result = func(**filtered_args)
             except TypeError as e:
                 import traceback
@@ -3750,6 +3790,37 @@ class Orchestrator:
             pass
         return 10
     
+    def _get_iteration_budget(self) -> int:
+        """Return the max iteration budget for the current model, scaled by context window.
+
+        Uses the SAME 4-tier buckets as _get_compression_interval:
+          - < 200k context:        budget = 25 (small / local models)
+          - 200k - 500k context:   budget = 35
+          - 500k - 1M context:     budget = 40
+          - 1M+ context:           budget = 45 (Llama 4 Scout, Gemini 2.5 Pro)
+        """
+        try:
+            from .server.models import get_model
+            model_entry = get_model(self.model_id)
+            cw = int(getattr(model_entry, "context_window", 0) or 0)
+        except Exception:
+            cw = 128_000
+        if cw < 200_000:
+            return 25
+        if cw < 500_000:
+            return 35
+        if cw < 1_000_000:
+            return 40
+        return 45
+
+    def _get_iteration_milestones(self) -> tuple:
+        """Return (budget, halfway, last5, grant_extra) for current model."""
+        budget = self._get_iteration_budget()
+        halfway = max(1, budget // 2)
+        last_5 = max(1, budget - 5)
+        grant_extra = budget
+        return budget, halfway, last_5, grant_extra
+
     def set_model(self, new_model_id: str) -> None:
         """Set active model ID and instantly update compression threshold and interval."""
         self._update_model_threshold(new_model_id)
@@ -3992,7 +4063,7 @@ class Orchestrator:
             # guard the IndexError is silently swallowed and the model gets no
             # active objective in its system prompt for the rest of the turn.
             if 0 < effective_turn_start < len(messages_snapshot):
-                obj = (messages_snapshot[effective_turn_start].get("content") or "")[:200]
+                obj = (messages_snapshot[effective_turn_start].get("content") or "")[:600]
                 active_context += f"\n- **Active Objective**: {obj}..."
 
         system_msg["content"] += active_context
@@ -4210,7 +4281,7 @@ class Orchestrator:
 
                 if text_parts:
                     if instruction:
-                        self.console.print("\n[dim magenta]⊘ Agent requested context compression: condensing intermediate tool logs...[/dim magenta]")
+                        pass  # Compression indicator suppressed
                     else:
                         est_tokens = self._estimate_tokens(self.messages)
                         msg_count  = len(self.messages)
@@ -4586,26 +4657,39 @@ class Orchestrator:
             turn_iteration = iteration + 1
 
             # ── Milestone Warnings (Non-hardcoded iteration limits) ────────────
-            if turn_iteration == 1:
-                self.messages.append({
-                    "role": "user",
-                    "content": "⚠️ [SYSTEM DIRECTIVE] Finish the task within 45 tool uses."
-                })
-            elif turn_iteration == 23:
-                self.messages.append({
-                    "role": "user",
-                    "content": "⚠️ [SYSTEM WARNING] You have already used 23 iterations. Task is still not finished, you have only 22 iterations left. Try to finish within the limit."
-                })
-            elif turn_iteration == 40:
-                self.messages.append({
-                    "role": "user",
-                    "content": "⚠️ [SYSTEM URGENT] Only 5 iterations left. Finish the task fast."
-                })
-            elif turn_iteration == 45:
-                self.messages.append({
-                    "role": "user",
-                    "content": "⚠️ [SYSTEM NOTICE] +5 iterations granted. No more will be provided. Finish the task."
-                })
+            # Window-aware, one-shot iteration guidance. Budget scales with the
+            # model's context window using the same buckets as _get_compression_interval.
+            try:
+                if not hasattr(self, "_milestones_fired"):
+                    self._milestones_fired = set()
+                _budget, _halfway, _last5, _grant = self._get_iteration_milestones()
+                _uid = f"{self.model_id}:{turn_iteration}"
+                if turn_iteration == 1 and ("intro", _uid) not in self._milestones_fired:
+                    self.messages.append({
+                        "role": "user",
+                        "content": f"⚠️ [SYSTEM DIRECTIVE] Finish the task within {_budget} tool uses (scaled by model context window).",
+                    })
+                    self._milestones_fired.add(("intro", _uid))
+                elif turn_iteration == _halfway and ("halfway", _uid) not in self._milestones_fired:
+                    self.messages.append({
+                        "role": "user",
+                        "content": f"⚠️ [SYSTEM WARNING] You have already used {turn_iteration} iterations. Task is still not finished, you have only {_budget - turn_iteration} iterations left. Try to finish within the limit (total budget: {_budget}).",
+                    })
+                    self._milestones_fired.add(("halfway", _uid))
+                elif turn_iteration == _last5 and ("last5", _uid) not in self._milestones_fired:
+                    self.messages.append({
+                        "role": "user",
+                        "content": f"⚠️ [SYSTEM URGENT] Only 5 iterations left (of {_budget} total). Finish the task fast.",
+                    })
+                    self._milestones_fired.add(("last5", _uid))
+                elif turn_iteration == _grant and ("grant", _uid) not in self._milestones_fired:
+                    self.messages.append({
+                        "role": "user",
+                        "content": f"⚠️ [SYSTEM NOTICE] +5 iterations granted (previous budget was {_budget}). No more will be provided. Finish the task within this limit.",
+                    })
+                    self._milestones_fired.add(("grant", _uid))
+            except Exception:
+                pass
 
             # Check for cancellation before each LLM call
             if self.cancel_event.is_set():
@@ -5452,14 +5536,50 @@ class Orchestrator:
                     func_name = tc.get("function", {}).get("name", "")
                     result = _cap_tool_result(func_name, result)
 
-                    self.messages.append(
-                        {
-                            "role": "tool",
-                            "tool_call_id": tc_id,
-                            "name": func_name,
-                            "content": result,
-                        }
-                    )
+                    # If result is an [Image: path] marker and model is vision-capable,
+                    # inject the actual image as multimodal content
+                    _img_match = __import__("re").match(r"^\[Image:\s+(.+)\]$", result.strip())
+                    if _img_match and func_name in ("read_file",):
+                        try:
+                            from utim_cli.tools import is_model_vision_capable
+                            if is_model_vision_capable():
+                                _img_path = _img_match.group(1)
+                                _multimodal = _tool_result_to_multimodal(result, _img_path)
+                                self.messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tc_id,
+                                        "name": func_name,
+                                        "content": _multimodal,
+                                    }
+                                )
+                            else:
+                                self.messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tc_id,
+                                        "name": func_name,
+                                        "content": result,
+                                    }
+                                )
+                        except Exception:
+                            self.messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": tc_id,
+                                    "name": func_name,
+                                    "content": result,
+                                }
+                            )
+                    else:
+                        self.messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": tc_id,
+                                "name": func_name,
+                                "content": result,
+                            }
+                        )
             else:
                 # Single tool - execute directly
                 for tc in tool_calls:
@@ -5473,15 +5593,50 @@ class Orchestrator:
                     tc_id = tc.get("id") or str(tc.get("index", "0"))
                     result = _cap_tool_result(func_name, result)
 
-                    self.messages.append(
-                        {
-                            "role": "tool",
-                            "tool_call_id": tc_id,
-                            "name": func_name,
-                            "content": result,
-                        }
-                    )
-                
+                    # If result is an [Image: path] marker and model is vision-capable,
+                    # inject the actual image as multimodal content
+                    _img_match = __import__("re").match(r"^\[Image:\s+(.+)\]$", result.strip())
+                    if _img_match and func_name in ("read_file",):
+                        try:
+                            from utim_cli.tools import is_model_vision_capable
+                            if is_model_vision_capable():
+                                _img_path = _img_match.group(1)
+                                _multimodal = _tool_result_to_multimodal(result, _img_path)
+                                self.messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tc_id,
+                                        "name": func_name,
+                                        "content": _multimodal,
+                                    }
+                                )
+                            else:
+                                self.messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tc_id,
+                                        "name": func_name,
+                                        "content": result,
+                                    }
+                                )
+                        except Exception:
+                            self.messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": tc_id,
+                                    "name": func_name,
+                                    "content": result,
+                                }
+                            )
+                    else:
+                        self.messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": tc_id,
+                                "name": func_name,
+                                "content": result,
+                            }
+                        )
             # --- Repeated Tool Failure Loop Detection ---
             if not hasattr(self, "_tool_failure_counts"):
                 self._tool_failure_counts = {}
@@ -5578,7 +5733,7 @@ class Orchestrator:
             interval = getattr(self, "_compression_interval", None) or self._get_dynamic_interval()
             if turn_iteration > 0 and turn_iteration % interval == 0:
                 try:
-                    self.console.print(f"\n[dim magenta]⊘ Periodic context compression (iteration #{turn_iteration}, interval={interval}): condensing intermediate tool logs...[/dim magenta]")
+                    pass  # Periodic compression indicator suppressed
                     self._compress_intra_turn(turn_msg_start, f"Periodic iteration #{turn_iteration} compression")
                 except Exception:
                     pass
@@ -5662,12 +5817,36 @@ class Orchestrator:
         )
         self.console.print(Rule(f"[dim]⚙  {elapsed_str}[/dim]"))
 
-        # Response-end context compression (triggered after agent response ends)
+        # CRITICAL: Clear the thinking-topic spinner IMMEDIATELY after the response
+        # ends so the spinner stops animating. Otherwise the spinner keeps spinning
+        # while background compression runs, which looks like the agent is still working.
+        try:
+            from utim_cli.state import STATE
+            STATE["thinking_topic"] = None
+        except Exception:
+            pass
+
+        # Response-end context compression (triggered after agent response ends).
+        # MUST run in background so it doesn't block the main UI loop. The thinking
+        # indicator is already cleared above, so the user sees the response-end Rule
+        # immediately and compression happens silently behind the scenes.
         if not self.cancel_event.is_set():
             try:
-                self._compress_intra_turn(turn_msg_start, instruction="Response end compression")
+                import threading
+                _compress_thread = threading.Thread(
+                    target=self._compress_intra_turn,
+                    args=(turn_msg_start,),
+                    kwargs={"instruction": "Response end compression"},
+                    daemon=True,
+                    name="utim-response-compress",
+                )
+                _compress_thread.start()
             except Exception:
-                pass
+                # Fallback: if threading fails for any reason, run synchronously.
+                try:
+                    self._compress_intra_turn(turn_msg_start, instruction="Response end compression")
+                except Exception:
+                    pass
 
         # Save turn snapshot for /rewind (even if cancelled — partial work matters)
         # ALWAYS save the turn, even if there are no code changes, so the user can rewind the conversation