utim-cli 2.3.0__tar.gz → 2.3.1__tar.gz

{utim_cli-2.3.0 → utim_cli-2.3.1}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [2.3.1] - 2026-08-19
+
+### 🛠️ Fixes & Enhancements
+- Major bug fixes in agent loop and enhancements
+
 ## [2.3.0] - 2026-08-18
 
 ### 🚀 Features & Enhancements

{utim_cli-2.3.0/utim_cli.egg-info → utim_cli-2.3.1}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.0"
+version = "2.3.1"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
@@ -93,7 +93,7 @@ utimlite = "utim_cli.utim:main_cli_entry"
 
 
 [tool.setuptools.packages.find]
-include = ["utim_cli*"]
+include = ["utim*", "utim_cli*"]
 exclude = ["tests*", "landing*", "scripts*"]
 
 [tool.setuptools.package-data]
@@ -101,6 +101,7 @@ utim_cli = ["mcp_registry.json", "_version.py", "utimmodel.txt", "models.txt", "
 
 
 [tool.pytest.ini_options]
+addopts = "-m 'not benchmark and not slow and not integration' --ignore=tests/test_benchmark.py --ignore=tests/bench_agent.py"
 markers = [
     "smoke: fast install validation tests (no live credentials required)",
     "slow: tests that make network calls or take more than 10 seconds",

utim_cli-2.3.1/utim/__init__.py

@@ -0,0 +1,76 @@
+"""
+UTIM Developer SDK
+------------------
+Unified autonomous coding agent SDK.
+
+Quickstart:
+    import utim
+
+    session = utim.Session()
+    async for event in session.send_message("Explain this codebase"):
+        if event.type == utim.EventType.TOKEN:
+            print(event.text, end="", flush=True)
+"""
+try:
+    from utim_cli._version import VERSION as __version__
+except ImportError:
+    __version__ = "2.3.0"
+
+# Developer-friendly core classes (similar to `import genai` / `import openai`)
+from utim_cli.sdk.session import UtimSession as Session
+from utim_cli.sdk.config import UtimConfig as Config
+from utim_cli.sdk.context import IDEContext, Diagnostic
+from utim_cli.sdk.events import (
+    AgentEvent,
+    UtimEventType as EventType,
+    TokenStreamEvent,
+    ThoughtStreamEvent,
+    ToolCallStartEvent,
+    ToolCallEndEvent,
+    FileEditEvent,
+    CommandExecEvent,
+    ConfirmationRequestEvent,
+    PlanUpdateEvent,
+    SubagentEvent,
+    TurnEndEvent,
+)
+from utim_cli.sdk.handlers import (
+    ConfirmationHandler,
+    AutoApprovalHandler,
+    CallbackApprovalHandler,
+)
+from utim_cli.sdk.sidecar import UtimSidecarServer as SidecarServer
+
+# Backwards compatible alias names
+UtimSession = Session
+UtimConfig = Config
+UtimEventType = EventType
+UtimSidecarServer = SidecarServer
+
+__all__ = [
+    "__version__",
+    "Session",
+    "Config",
+    "IDEContext",
+    "Diagnostic",
+    "EventType",
+    "AgentEvent",
+    "TokenStreamEvent",
+    "ThoughtStreamEvent",
+    "ToolCallStartEvent",
+    "ToolCallEndEvent",
+    "FileEditEvent",
+    "CommandExecEvent",
+    "ConfirmationRequestEvent",
+    "PlanUpdateEvent",
+    "SubagentEvent",
+    "TurnEndEvent",
+    "ConfirmationHandler",
+    "AutoApprovalHandler",
+    "CallbackApprovalHandler",
+    "SidecarServer",
+    "UtimSession",
+    "UtimConfig",
+    "UtimEventType",
+    "UtimSidecarServer",
+]

{utim_cli-2.3.0 → utim_cli-2.3.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.3.0"
+    __version__ = "2.3.1"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.0 → utim_cli-2.3.1}/utim_cli/_version.py

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

{utim_cli-2.3.0 → utim_cli-2.3.1}/utim_cli/context_pruner.py

@@ -102,27 +102,40 @@ def _strip_thinking_blocks(messages: List[Dict], keep_last: int = 1) -> List[Dic
     return result
 
 
-def _deduplicate_tool_outputs(messages: List[Dict]) -> List[Dict]:
-    """Compress repeated identical tool responses to a one-liner stub.
+def _deduplicate_tool_outputs(messages: List[Dict], keep_last_tools: int = 5) -> List[Dict]:
+    """Compress repeated identical tool responses to a one-liner stub,
+    WHILE STRICTLY PRESERVING the most recent `keep_last_tools` tool outputs 100% verbatim.
 
-    When the agent calls the same tool with the same arguments repeatedly and gets
-    the same output (e.g. re-reading an unchanged file multiple times), only the
-    first occurrence is kept verbatim. Subsequent duplicates are replaced with:
-      [Duplicate tool output — identical to earlier result, omitted to save tokens]
+    The last 5 tool outputs must NEVER be deduplicated, truncated, or stubbed out,
+    even if they are duplicates of earlier reads, because the model requires the exact
+    code lines and context to execute precise file edits and tool actions.
     """
-    # Map: (tool_call_id_of_preceding_assistant_call -> output_hash)
-    # We key on (tool_name, args_hash) -> first_output_hash seen
-    seen: dict = {}  # (tool_name_or_id, content_hash) -> True
+    # Identify indices of all tool messages
+    tool_msg_indices = [i for i, m in enumerate(messages) if m.get("role") == "tool"]
+    exempt_indices = set(tool_msg_indices[-keep_last_tools:]) if len(tool_msg_indices) >= 1 else set()
+
+    seen: dict = {}  # (tool_name, content_hash) -> True
     result = []
 
-    for msg in messages:
+    for i, msg in enumerate(messages):
         if msg.get("role") == "tool":
             content = msg.get("content") or ""
             tool_name = msg.get("name", "")
+
+            # CRITICAL: Never deduplicate or stub any of the last 5 tool calls!
+            if i in exempt_indices:
+                result.append(msg)
+                continue
+
+            # Never deduplicate tool error messages
+            if isinstance(content, str) and any(err in content.lower() for err in ["error", "exception", "failed", "failure", "traceback", "syntaxerror", "not found"]):
+                result.append(msg)
+                continue
+
             # Use first 300 chars of content for the hash to avoid hashing huge outputs
             content_key = (tool_name, hashlib.md5(content[:300].encode(errors="replace")).hexdigest())
             if content_key in seen and len(content) > 200:
-                # Replace with stub
+                # Replace older duplicate with stub
                 msg = dict(msg)
                 msg["content"] = (
                     f"[Duplicate {tool_name!r} output — identical to earlier result, "
@@ -320,13 +333,13 @@ def resolve_model_context_envelope(model_id: str, raw_context_window: int = 0) -
     }
 
 
-def sanitize_message_sequence(messages: List[Dict]) -> List[Dict]:
+def sanitize_message_sequence(messages: List[Dict], keep_last_tools: int = 5) -> List[Dict]:
     """
     Ensure the messages list is valid for LLM API calls.
     - Each tool message must have a preceding assistant message with the matching tool_call_id.
     - Each assistant message with tool_calls must have corresponding tool messages.
     - Strips <think> blocks from non-current assistant messages to save tokens.
-    - Deduplicates repeated identical tool outputs.
+    - Deduplicates older repeated identical tool outputs (strictly preserving the last 5 tool calls verbatim).
     """
     if not messages:
         return messages
@@ -334,8 +347,8 @@ def sanitize_message_sequence(messages: List[Dict]) -> List[Dict]:
     # Strip thinking blocks from older assistant messages
     messages = _strip_thinking_blocks(messages)
 
-    # Compress duplicate tool outputs
-    messages = _deduplicate_tool_outputs(messages)
+    # Compress older duplicate tool outputs while protecting last 5 tool calls
+    messages = _deduplicate_tool_outputs(messages, keep_last_tools=keep_last_tools)
         
     # Step 1: Identify all tool call IDs present in tool messages
     present_tool_ids = {
@@ -387,7 +400,7 @@ def sanitize_message_sequence(messages: List[Dict]) -> List[Dict]:
 def soft_prune_messages(
     messages: List[Dict],
     turn_msg_start: int = 1,
-    keep_last_tools: int = 4,
+    keep_last_tools: int = 5,
     max_char_threshold: int = 1200,
 ) -> List[Dict]:
     """
@@ -395,7 +408,7 @@ def soft_prune_messages(
 
     Balanced policy ('not too aggressive, not too light'):
     - Anchors: System prompt (idx 0) and the root User prompt (turn_msg_start) are strictly preserved.
-    - Active Working Tail: The most recent `keep_last_tools` tool results & their assistant calls are kept 100% verbatim.
+    - Active Working Tail: The most recent `keep_last_tools` (at least 5) tool results & their assistant calls are kept 100% verbatim.
     - Errors / Failures: Any tool output containing error keywords (e.g. 'error', 'exception', 'failed', 'traceback', 'syntaxerror') is preserved verbatim to prevent debugging amnesia.
     - Read / Search Outputs (older than tail): If longer than `max_char_threshold`, softly truncates the middle (keeps head 350 chars + tail 200 chars) with a clean diagnostic placeholder.
     - Successful Mutation / Command Outputs: If verbose, compacted to clean status indicators without losing file targets.
@@ -417,7 +430,7 @@ def soft_prune_messages(
 
     # If not enough tool messages have accumulated in this turn, just sanitize and return
     if len(tool_indices) <= keep_last_tools:
-        return sanitize_message_sequence(cleaned_messages)
+        return sanitize_message_sequence(cleaned_messages, keep_last_tools=keep_last_tools)
 
     # Older tool message indices that are eligible for soft pruning
     eligible_tool_indices = set(tool_indices[:-keep_last_tools])
@@ -523,7 +536,7 @@ def soft_prune_messages(
 
         result_messages.append(msg)
 
-    return sanitize_message_sequence(result_messages)
+    return sanitize_message_sequence(result_messages, keep_last_tools=keep_last_tools)
 
 
 def score_message_importance(message: Dict, llm_key: str = None) -> float:

{utim_cli-2.3.0 → utim_cli-2.3.1}/utim_cli/orchestrator.py

@@ -893,6 +893,104 @@ def _lesson_relevant_to_task(lesson_line: str, active_task: str) -> bool:
         return True
 
 
+def _clean_summary_text(text: str, max_len: int = 100) -> str:
+    """Clean terminal box-drawing characters, ANSI escapes, and multi-line clutter for summaries."""
+    if not text:
+        return ""
+    # Strip ANSI escape sequences
+    text = re.sub(r"\x1b\[[0-9;]*[a-zA-Z]", "", text)
+    # Strip box-drawing and decorative border characters
+    box_chars = "╭╮╯╰─│┌┐└┘├┤┬┴┼═║╒╓╔╕╖╗╘╙╚╛╜╝▀▄█▌▐░▒▓■□▲▼◆◇○●❯❮"
+    for ch in box_chars:
+        text = text.replace(ch, " ")
+    
+    # Filter out empty lines or pure duration/border strings
+    clean_lines = []
+    for line in text.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        # Skip pure timestamp/duration lines (e.g. "4m 49s", "12s")
+        if re.match(r"^\d+[mshd]\s*\d*[mshd]?$", line):
+            continue
+        clean_lines.append(line)
+        
+    if not clean_lines:
+        return ""
+        
+    first_line = clean_lines[0]
+    # Collapse multiple whitespace
+    first_line = re.sub(r"\s+", " ", first_line).strip()
+    if len(first_line) > max_len:
+        first_line = first_line[:max_len].rstrip() + "..."
+    return first_line
+
+
+def _format_session_history_summary(turn_history: Optional[List[Dict[str, Any]]], max_turns: int = 5) -> str:
+    """Generate a clean, structured, non-truncated summary of recent completed turns."""
+    if not turn_history:
+        return ""
+    # Only consider completed turns (ignore in-progress turns and background system events)
+    completed_turns = [
+        t for t in turn_history 
+        if t.get("user_msg") and not t.get("is_in_progress") and not t.get("is_system_event")
+    ]
+    if not completed_turns:
+        return ""
+        
+    recent_turns = completed_turns[-max_turns:]
+    summary_lines = []
+    for idx, t in enumerate(recent_turns, 1):
+        raw_msg = t.get("user_msg", "")
+        req_clean = _clean_summary_text(raw_msg, max_len=100)
+        if not req_clean:
+            continue
+            
+        changes = t.get("changes", [])
+        changed_names = list({
+            os.path.basename(c.get("file_path", "") or c.get("path", "")) 
+            for c in changes 
+            if c.get("file_path") or c.get("path")
+        })
+        
+        status = "Aborted by user" if t.get("aborted") else "Completed"
+        
+        # Check if there are tool actions or messages
+        msgs = t.get("messages", [])
+        last_assistant_msg = ""
+        tools_used = []
+        for m in msgs:
+            if m.get("role") == "assistant":
+                if m.get("tool_calls"):
+                    for tc in m["tool_calls"]:
+                        fn = tc.get("function", {}).get("name")
+                        if fn and fn not in tools_used:
+                            tools_used.append(fn)
+                elif m.get("content"):
+                    last_assistant_msg = m.get("content")
+                    
+        action_parts = []
+        if changed_names:
+            action_parts.append(f"modified {', '.join(f'`{n}`' for n in changed_names[:4])}")
+        elif tools_used:
+            action_parts.append(f"used {', '.join(f'`{t}`' for t in tools_used[:3])}")
+            
+        action_summary = f" ({', '.join(action_parts)})" if action_parts else ""
+        
+        # Outcome summary
+        outcome = ""
+        if last_assistant_msg:
+            clean_ast = _clean_summary_text(last_assistant_msg, max_len=80)
+            if clean_ast and clean_ast != req_clean:
+                outcome = f" → Outcome: {clean_ast}"
+                
+        summary_lines.append(f"- Step {idx}: \"{req_clean}\" [{status}]{action_summary}{outcome}")
+        
+    if not summary_lines:
+        return ""
+    return "\n".join(summary_lines)
+
+
 def get_system_prompt(user_prompt: str = "", current_iteration: int = 0, elapsed_seconds: int = 0, turn_history: Optional[List[Dict]] = None, messages: Optional[List[Dict]] = None) -> str:
     """Gets the dynamic system prompt with active MCP servers and semantically fetched Hugging Face vector memories."""
     # If the user prompt is just a casual greeting/message, return a minimal prompt to save tokens
@@ -1070,16 +1168,45 @@ def get_system_prompt(user_prompt: str = "", current_iteration: int = 0, elapsed
     except Exception:
         pass
 
-    # 4. Situational Active Skills Scoring & Injection
+    # ── 4. Inject Structured Session Summary Memory ──
+    session_summary = _format_session_history_summary(turn_history, max_turns=5)
+    session_prompt = ""
+    if session_summary:
+        session_prompt = f"\n\n### SESSION HISTORY (Previous Steps Completed in this Session) ###\n{session_summary}\n"
+
+    # ── 5. Situational Active Skills Scoring & Injection (Analyzed from Active Summarized Context) ──
     skills_prompt = ""
     try:
         from utim_cli.bootstrap import scan_available_skills, rank_relevant_skills
         skills = scan_available_skills()
         if skills:
+            # Build comprehensive active summarized context query:
+            # Combines user prompt, derived ongoing task, completed turn summaries, and modified files
+            context_query_parts = []
+            if user_prompt and user_prompt.strip():
+                context_query_parts.append(user_prompt.strip())
+
             active_task = _get_active_task(user_prompt, messages=messages) if user_prompt else ""
-            
-            # Rank skills using BM25, IDF, and Domain Intent scoring (threshold 14.0)
-            ranked_skills = rank_relevant_skills(active_task or user_prompt or "", skills=skills, min_score=14.0, max_results=4)
+            if active_task and active_task != user_prompt:
+                context_query_parts.append(active_task)
+
+            if session_summary:
+                context_query_parts.append(session_summary)
+
+            # Include recent touched files from turn_history to capture architectural domain
+            if turn_history:
+                recent_changes = []
+                for t in turn_history[-3:]:
+                    for ch in t.get("changes", []):
+                        if isinstance(ch, dict) and ch.get("path"):
+                            recent_changes.append(ch.get("path"))
+                if recent_changes:
+                    context_query_parts.append("Files: " + " ".join(recent_changes[-6:]))
+
+            active_summarized_context = "\n".join(context_query_parts).strip()
+
+            # Rank skills using BM25, IDF, and Domain Intent scoring on active summarized context (threshold 14.0)
+            ranked_skills = rank_relevant_skills(active_summarized_context or user_prompt or "", skills=skills, min_score=14.0, max_results=4)
             relevant_skills = [name for name, _ in ranked_skills]
                     
             # Filter out already read/seen skills
@@ -1135,36 +1262,6 @@ def get_system_prompt(user_prompt: str = "", current_iteration: int = 0, elapsed
                     )
     except Exception:
         pass
-
-    # ── 5. Inject Structured Session Summary Memory ──
-    session_summary = ""
-    import os
-    from utim_cli.config import get_utim_dir
-    summary_path = get_utim_dir() / "session_summary.md"
-    if os.path.exists(summary_path):
-        try:
-            with open(summary_path, "r", encoding="utf-8") as sf:
-                raw_summary = sf.read().strip()
-                # Take only the last 3 lines to prevent checklist bloat
-                session_summary = "\n".join(raw_summary.splitlines()[-3:])
-        except Exception:
-            pass
-            
-    if not session_summary and turn_history:
-        # Generate a LEAN summary: only last 8 turns, one-line per request + changed files
-        recent_turns = turn_history[-8:]
-        summary_lines = []
-        for idx, t in enumerate(recent_turns):
-            req = t.get("user_msg", "").strip().split("\n")[0][:80]
-            changes = t.get("changes", [])
-            changed_names = list({os.path.basename(c.get("file_path", "") or c.get("path", "")) for c in changes if c.get("file_path") or c.get("path")})
-            files_str = ", ".join(f"`{n}`" for n in changed_names[:5]) if changed_names else "—"
-            summary_lines.append(f"- Turn {idx+1}: {req} → {files_str}")
-        session_summary = "\n".join(summary_lines)
-
-    session_prompt = ""
-    if session_summary:
-        session_prompt = f"\n\n### SESSION HISTORY ###\n{session_summary}\n"
     # ── 6. Inject Live User Hint Directives (System Prompt Override) ──
     hint_prompt = ""
     try:
@@ -1539,16 +1636,19 @@ class Orchestrator:
                     "",
                     "## Completed Actions",
                 ]
-                if not clean_turn_history:
+                # Only include finished user actions in the completed actions log
+                completed_actions = [t for t in clean_turn_history if not t.get("is_in_progress") and not t.get("is_system_event")]
+                if not completed_actions:
                     summary_lines.append("*No actions completed yet in this session.*")
                 else:
-                    for idx, t in enumerate(clean_turn_history):
+                    for idx, t in enumerate(completed_actions):
                         req = t.get("user_msg", "").strip()
-                        req_short = req.split("\n")[0][:120]
-                        if len(req.split("\n")) > 1 or len(req) > 120:
-                            req_short += "..."
+                        req_short = _clean_summary_text(req, max_len=120)
+                        if not req_short:
+                            req_short = "Action"
+                        status = " [Aborted by user]" if t.get("aborted") else ""
                         
-                        summary_lines.append(f"### Step {idx+1}: {req_short}")
+                        summary_lines.append(f"### Step {idx+1}: {req_short}{status}")
                         
                         # Add files modified
                         changes = t.get("changes", [])
@@ -4740,30 +4840,48 @@ class Orchestrator:
                 joined_context = joined_context[:SUBAGENT_CONTEXT_BUDGET_CHARS] + "\n... [context budget reached] ..."
             active_context = joined_context
         else:
-            # Main Agent Checklist
-            active_context = "\n\n### ACTIVE CONTEXT CHECKLIST:"
+            # Main Agent Active Context Checklist (3000 Token Budget / ~12000 Chars)
+            MAIN_AGENT_CONTEXT_BUDGET_CHARS = 12000
+            main_items = [
+                "\n\n### ACTIVE CONTEXT CHECKLIST (3000 Token Budget) ###",
+                f"- **Execution Progress**: Iteration {task_iter + 1} ({task_elapsed}s elapsed)",
+            ]
 
-            # A. Find active file path dynamically from recent messages
-            active_file = ""
-            for msg in reversed(messages_snapshot):
+            # 1. Extract touched/inspected files dynamically across messages
+            touched_files = []
+            for msg in messages_snapshot:
                 if msg.get("role") == "assistant" and msg.get("tool_calls"):
                     for tc in msg["tool_calls"]:
                         func = tc.get("function", {})
-                        if func.get("name") in ("write_file", "edit_file", "read_file"):
+                        if func.get("name") in ("write_file", "edit_file", "read_file", "delete_file", "view_file", "replace_file_content"):
                             try:
-                                args = json.loads(func.get("arguments", "{}"))
-                                active_file = args.get("filepath", args.get("path", ""))
-                                if active_file:
-                                    break
+                                args = json.loads(func.get("arguments", "{}")) if isinstance(func.get("arguments"), str) else func.get("arguments", {})
+                                fp = args.get("filepath", args.get("path", args.get("AbsolutePath", args.get("TargetFile", ""))))
+                                if fp and fp not in touched_files:
+                                    touched_files.append(fp)
                             except Exception:
                                 pass
-                    if active_file:
-                        break
-            if active_file:
-                active_context += f"\n- **Current File**: {active_file}"
+            if touched_files:
+                main_items.append(f"- **Files Inspected/Modified**: {', '.join(f'`{f}`' for f in touched_files[-15:])}")
+
+            # 2. Recent Tool Action History (Last 8 actions with arguments & outputs)
+            if hasattr(self, "tool_results") and self.tool_results:
+                action_history = []
+                recent_actions = self.tool_results[-8:]
+                for idx, tr in enumerate(recent_actions):
+                    fname = tr.get("func_name", "tool")
+                    args_obj = tr.get("arguments", {})
+                    args_summary = ""
+                    if isinstance(args_obj, dict):
+                        args_summary = ", ".join(f"{k}={repr(v)[:50]}" for k, v in list(args_obj.items())[:3])
+                    elif isinstance(args_obj, str) and args_obj.strip():
+                        args_summary = args_obj[:80]
+                    fres = str(tr.get("result", ""))[:300].replace("\n", " ")
+                    action_history.append(f"  {idx + 1}. `{fname}({args_summary})` → {fres}")
+                if action_history:
+                    main_items.append("- **Recent Tool Actions**:\n" + "\n".join(action_history))
 
-            # B. Get latest command status from the most recent run_command output
-            last_command_output = ""
+            # 3. Latest Command Output / Exit Codes
             for msg in reversed(messages_snapshot):
                 if msg.get("role") == "tool" and msg.get("name") == "run_command":
                     content = msg.get("content", "")
@@ -4771,49 +4889,53 @@ class Orchestrator:
                     if lines:
                         exit_code_line = next((l for l in lines if "exit_code:" in l), "")
                         err_lines = [l for l in lines if "error" in l.lower() or "failed" in l.lower() or "exception" in l.lower()]
-                        last_command_output = f"Command exit: {exit_code_line or 'unknown'}"
+                        cmd_summary = f"Exit: {exit_code_line or '0'}"
                         if err_lines:
-                            last_command_output += f" | Errors: {'; '.join(err_lines[:2])}"
+                            cmd_summary += f" | Errors: {'; '.join(err_lines[:3])}"
                         else:
-                            last_command_output += f" | Output: {'; '.join(lines[:2])}"
+                            cmd_summary += f" | Output: {'; '.join(lines[:3])}"
+                        main_items.append(f"- **Latest Shell Command**: {cmd_summary}")
                         break
-            if last_command_output:
-                active_context += f"\n- **Latest Command Status**: {last_command_output}"
 
-            # C. Read active todos from todos.json
-            active_todo_checklist = ""
+            # 4. Active Project Todos / Task Checklist (from todos.json)
             todo_file = ".utim_tmp/todos.json"
             if os.path.exists(todo_file):
                 try:
                     with open(todo_file, "r", encoding="utf-8") as f:
                         todos = json.load(f)
                     if todos and isinstance(todos, dict):
-                        active_todo_checklist = "\n### ACTIVE TASK CHECKLIST:\n"
-                        for tid, t in todos.items():
+                        todo_lines = []
+                        for tid, t in list(todos.items())[:15]:
                             status_mark = "[x]" if t.get("status") == "done" else "[ ]"
-                            active_todo_checklist += f"{status_mark} {t.get('description', '')}\n"
+                            todo_lines.append(f"  {status_mark} {t.get('description', '')}")
+                        if todo_lines:
+                            main_items.append("- **Project Task Checklist**:\n" + "\n".join(todo_lines))
                 except Exception:
                     pass
 
-            if active_todo_checklist:
-                active_context += active_todo_checklist
-            else:
-                # BUG 7 FIX: Guard against effective_turn_start being out-of-bounds
-                # after _compress_intra_turn shortens self.messages.  Without this
-                # 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):
-                    raw_content = messages_snapshot[effective_turn_start].get("content") or ""
-                    if isinstance(raw_content, list):
-                        text_parts = []
-                        for part in raw_content:
-                            if isinstance(part, dict) and part.get("type") == "text":
-                                text_parts.append(part.get("text", ""))
-                        text_str = " ".join(text_parts)
-                    else:
-                        text_str = str(raw_content)
-                    obj = text_str[:600]
-                    active_context += f"\n- **Active Objective**: {obj}..."
+            # 5. Background Processes & Subagent Tasks
+            try:
+                from utim_cli.tools import _BACKGROUND_PROCESSES
+                if _BACKGROUND_PROCESSES:
+                    bg_list = []
+                    for pid, proc in list(_BACKGROUND_PROCESSES.items())[:5]:
+                        status = "running" if proc.poll() is None else f"exit:{proc.returncode}"
+                        bg_list.append(f"  • [{pid}] ({status})")
+                    if bg_list:
+                        main_items.append("- **Background Processes**:\n" + "\n".join(bg_list))
+            except Exception:
+                pass
+
+            # Multi-iteration deep loop context: if iteration > 0 and no todos, maintain high-level goal
+            if task_iter > 0 and user_prompt and not any("Project Task Checklist" in item for item in main_items):
+                clean_goal = _clean_summary_text(user_prompt, max_len=300)
+                if clean_goal:
+                    main_items.append(f"- **Task In-Progress**: \"{clean_goal}\"")
+
+            joined_context = "\n".join(main_items)
+            if len(joined_context) > MAIN_AGENT_CONTEXT_BUDGET_CHARS:
+                joined_context = joined_context[:MAIN_AGENT_CONTEXT_BUDGET_CHARS] + "\n... [context budget reached] ..."
+            active_context = joined_context
 
         system_msg["content"] += active_context
 
@@ -5499,6 +5621,7 @@ class Orchestrator:
             "messages": list(self.messages[turn_msg_start:]),
             "changes": [],
             "is_system_event": is_system_msg,
+            "is_in_progress": True,
         })
         task_start_time = time.time()
 
@@ -6055,6 +6178,7 @@ class Orchestrator:
                 "msg_end": len(self.messages),
                 "messages": list(self.messages[turn_msg_start:]),
                 "changes": list(self._turn_changes),
+                "is_in_progress": True,
             })
 
             # Execute tools - use parallel execution for better performance
@@ -6594,6 +6718,7 @@ class Orchestrator:
                 "msg_end": len(self.messages),
                 "messages": list(self.messages[turn_msg_start:]),
                 "changes": list(self._turn_changes),
+                "is_in_progress": True,
             })
             
             tool_duration = time.time() - t_tool_start
@@ -6713,6 +6838,7 @@ class Orchestrator:
             "step_timings": list(self.turn_step_timings),
             "aborted": is_aborted,
             "is_system_event": is_system_msg,
+            "is_in_progress": False,
         }
 
         self.turn_history.append(turn_entry)