ripperdoc 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

ripperdoc/cli/ui/rich_ui.py

@@ -4,8 +4,10 @@ This module provides a clean, minimal terminal UI using Rich for the Ripperdoc a
 """
 
 import asyncio
+import json
 import sys
 import uuid
+import re
 from typing import List, Dict, Any, Optional, Union, Iterable
 from pathlib import Path
 
@@ -26,6 +28,7 @@ from ripperdoc.core.config import get_global_config, provider_protocol
 from ripperdoc.core.default_tools import get_default_tools
 from ripperdoc.core.query import query, QueryContext
 from ripperdoc.core.system_prompt import build_system_prompt
+from ripperdoc.core.skills import build_skill_summary, load_all_skills
 from ripperdoc.cli.commands import (
     get_slash_command,
     list_slash_commands,
@@ -39,13 +42,14 @@ from ripperdoc.cli.ui.context_display import context_usage_lines
 from ripperdoc.utils.message_compaction import (
     compact_messages,
     estimate_conversation_tokens,
-    estimate_tokens_from_text,
     estimate_used_tokens,
     get_context_usage_status,
     get_remaining_context_tokens,
     resolve_auto_compact_enabled,
 )
+from ripperdoc.utils.token_estimation import estimate_tokens
 from ripperdoc.utils.mcp import (
+    ensure_mcp_runtime,
     format_mcp_instructions,
     load_mcp_servers_async,
     shutdown_mcp_runtime,
@@ -62,6 +66,8 @@ from ripperdoc.utils.messages import (
     create_assistant_message,
 )
 from ripperdoc.utils.log import enable_session_file_logging, get_logger
+from ripperdoc.cli.ui.tool_renderers import ToolResultRendererRegistry
+
 
 # Type alias for conversation messages
 ConversationMessage = Union[UserMessage, AssistantMessage, ProgressMessage]
@@ -210,6 +216,8 @@ class RichUI:
         session_id: Optional[str] = None,
         log_file_path: Optional[Path] = None,
     ):
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
         self.console = console
         self.safe_mode = safe_mode
         self.verbose = verbose
@@ -243,6 +251,15 @@ class RichUI:
         self._permission_checker = (
             make_permission_checker(self.project_path, safe_mode) if safe_mode else None
         )
+        # Keep MCP runtime alive for the whole UI session. Create it on the UI loop up front.
+        try:
+            self._run_async(ensure_mcp_runtime(self.project_path))
+        except (OSError, RuntimeError, ConnectionError) as exc:
+            logger.warning(
+                "[ui] Failed to initialize MCP runtime at startup: %s: %s",
+                type(exc).__name__, exc,
+                extra={"session_id": self.session_id},
+            )
 
     def _context_usage_lines(
         self, breakdown: Any, model_label: str, auto_compact_enabled: bool
@@ -267,10 +284,11 @@ class RichUI:
         """Best-effort persistence of a message to the session log."""
         try:
             self._session_history.append(message)
-        except Exception:
+        except (OSError, IOError, json.JSONDecodeError) as exc:
             # Logging failures should never interrupt the UI flow
-            logger.exception(
-                "[ui] Failed to append message to session history",
+            logger.warning(
+                "[ui] Failed to append message to session history: %s: %s",
+                type(exc).__name__, exc,
                 extra={"session_id": self.session_id},
             )
 
@@ -281,9 +299,10 @@ class RichUI:
         session = self.get_prompt_session()
         try:
             session.history.append_string(text)
-        except Exception:
-            logger.exception(
-                "[ui] Failed to append prompt history",
+        except (AttributeError, TypeError, ValueError) as exc:
+            logger.warning(
+                "[ui] Failed to append prompt history: %s: %s",
+                type(exc).__name__, exc,
                 extra={"session_id": self.session_id},
             )
 
@@ -440,7 +459,8 @@ class RichUI:
     def _print_tool_result(
         self, sender: str, content: str, tool_data: Any, tool_error: bool = False
     ) -> None:
-        """Render a tool result summary."""
+        """Render a tool result summary using the renderer registry."""
+        # Check for failure states
         failed = tool_error
         if tool_data is not None:
             if isinstance(tool_data, dict):
@@ -448,7 +468,16 @@ class RichUI:
             else:
                 success = getattr(tool_data, "success", None)
                 failed = failed or (success is False)
+            failed = failed or bool(self._get_tool_field(tool_data, "is_error"))
+
+        # Extract warning/token info
+        warning_text = None
+        token_estimate = None
+        if tool_data is not None:
+            warning_text = self._get_tool_field(tool_data, "warning")
+            token_estimate = self._get_tool_field(tool_data, "token_estimate")
 
+        # Handle failure case
         if failed:
             if content:
                 self.console.print(f"  ⎿  [red]{escape(content)}[/red]")
@@ -456,168 +485,29 @@ class RichUI:
                 self.console.print(f"  ⎿  [red]{escape(sender)} failed[/red]")
             return
 
-        if not content:
-            self.console.print("  ⎿  [dim]Tool completed[/]")
-            return
-
-        if "Todo" in sender:
-            lines = content.splitlines()
-            if lines:
-                self.console.print(f"  ⎿  [dim]{escape(lines[0])}[/]")
-                for line in lines[1:]:
-                    self.console.print(f"      {line}", markup=False)
-            else:
-                self.console.print("  ⎿  [dim]Todo update[/]")
-            return
-
-        if "Read" in sender or "View" in sender:
-            lines = content.split("\n")
-            line_count = len(lines)
-            self.console.print(f"  ⎿  [dim]Read {line_count} lines[/]")
-            if self.verbose:
-                preview = lines[:30]
-                for line in preview:
-                    self.console.print(line, markup=False)
-                if len(lines) > len(preview):
-                    self.console.print(f"[dim]... ({len(lines) - len(preview)} more lines)[/]")
-            return
-
-        if "Write" in sender or "Edit" in sender or "MultiEdit" in sender:
-            if tool_data and (hasattr(tool_data, "file_path") or isinstance(tool_data, dict)):
-                file_path = self._get_tool_field(tool_data, "file_path")
-                additions = self._get_tool_field(tool_data, "additions", 0)
-                deletions = self._get_tool_field(tool_data, "deletions", 0)
-                diff_with_line_numbers = self._get_tool_field(
-                    tool_data, "diff_with_line_numbers", []
-                )
-
-                if not file_path:
-                    self.console.print("  ⎿  [dim]File updated successfully[/]")
-                    return
-
+        # Display warnings and token estimates
+        if warning_text:
+            self.console.print(f"  ⎿  [yellow]{escape(str(warning_text))}[/yellow]")
+            if token_estimate:
                 self.console.print(
-                    f"  ⎿  [dim]Updated {escape(str(file_path))} with {additions} additions and {deletions} removals[/]"
+                    f"      [dim]Estimated tokens: {escape(str(token_estimate))}[/dim]"
                 )
+        elif token_estimate and self.verbose:
+            self.console.print(f"  ⎿  [dim]Estimated tokens: {escape(str(token_estimate))}[/dim]")
 
-                if self.verbose:
-                    for line in diff_with_line_numbers:
-                        self.console.print(line, markup=False)
-            else:
-                self.console.print("  ⎿  [dim]File updated successfully[/]")
-            return
-
-        if "Glob" in sender:
-            files = content.split("\n")
-            file_count = len([f for f in files if f.strip()])
-            self.console.print(f"  ⎿  [dim]Found {file_count} files[/]")
-            if self.verbose:
-                for line in files[:30]:
-                    if line.strip():
-                        self.console.print(f"      {line}", markup=False)
-                if file_count > 30:
-                    self.console.print(f"[dim]... ({file_count - 30} more)[/]")
-            return
-
-        if "Grep" in sender:
-            matches = content.split("\n")
-            match_count = len([m for m in matches if m.strip()])
-            self.console.print(f"  ⎿  [dim]Found {match_count} matches[/]")
-            if self.verbose:
-                for line in matches[:30]:
-                    if line.strip():
-                        self.console.print(f"      {line}", markup=False)
-                if match_count > 30:
-                    self.console.print(f"[dim]... ({match_count - 30} more)[/]")
-            return
-
-        if "LS" in sender:
-            tree_lines = content.splitlines()
-            self.console.print(f"  ⎿  [dim]Directory tree ({len(tree_lines)} lines)[/]")
-            if self.verbose:
-                preview = tree_lines[:40]
-                for line in preview:
-                    self.console.print(f"      {line}", markup=False)
-                if len(tree_lines) > len(preview):
-                    self.console.print(f"[dim]... ({len(tree_lines) - len(preview)} more)[/]")
+        # Handle empty content
+        if not content:
+            self.console.print("  ⎿  [dim]Tool completed[/]")
             return
 
-        if "Bash" in sender:
-            stdout = ""
-            stderr = ""
-            stdout_lines: List[str] = []
-            stderr_lines: List[str] = []
-
-            exit_code = 0
-            duration_ms = 0
-            timeout_ms = 0
-
-            if tool_data:
-                exit_code = self._get_tool_field(tool_data, "exit_code", 0)
-                stdout = self._get_tool_field(tool_data, "stdout", "") or ""
-                stderr = self._get_tool_field(tool_data, "stderr", "") or ""
-                duration_ms = self._get_tool_field(tool_data, "duration_ms", 0) or 0
-                timeout_ms = self._get_tool_field(tool_data, "timeout_ms", 0) or 0
-                stdout_lines = stdout.splitlines() if stdout else []
-                stderr_lines = stderr.splitlines() if stderr else []
-
-            if not stdout_lines and not stderr_lines and content:
-                fallback_stdout, fallback_stderr = self._parse_bash_output_sections(content)
-                stdout_lines = fallback_stdout
-                stderr_lines = fallback_stderr
-
-            show_inline_stdout = (
-                stdout_lines and not stderr_lines and exit_code == 0 and not self.verbose
-            )
-
-            if show_inline_stdout:
-                preview = stdout_lines if self.verbose else stdout_lines[:5]
-                self.console.print(f"  ⎿  {preview[0]}", markup=False)
-                for line in preview[1:]:
-                    self.console.print(f"      {line}", markup=False)
-                if not self.verbose and len(stdout_lines) > len(preview):
-                    self.console.print(
-                        f"[dim]... ({len(stdout_lines) - len(preview)} more lines)[/]"
-                    )
-            else:
-                if tool_data:
-                    timing = ""
-                    if duration_ms:
-                        timing = f" ({duration_ms / 1000:.2f}s"
-                        if timeout_ms:
-                            timing += f" / timeout {timeout_ms / 1000:.0f}s"
-                        timing += ")"
-                    elif timeout_ms:
-                        timing = f" (timeout {timeout_ms / 1000:.0f}s)"
-                    self.console.print(f"  ⎿  [dim]Exit code {exit_code}{timing}[/]")
-                else:
-                    self.console.print("  ⎿  [dim]Command executed[/]")
-
-                if stdout_lines:
-                    preview = stdout_lines if self.verbose else stdout_lines[:5]
-                    self.console.print("[dim]stdout:[/]")
-                    for line in preview:
-                        self.console.print(f"      {line}", markup=False)
-                    if not self.verbose and len(stdout_lines) > len(preview):
-                        self.console.print(
-                            f"[dim]... ({len(stdout_lines) - len(preview)} more stdout lines)[/]"
-                        )
-                else:
-                    self.console.print("[dim]stdout:[/]")
-                    self.console.print("      [dim](no stdout)[/]")
-                if stderr_lines:
-                    preview = stderr_lines if self.verbose else stderr_lines[:5]
-                    self.console.print("[dim]stderr:[/]")
-                    for line in preview:
-                        self.console.print(f"      {line}", markup=False)
-                    if not self.verbose and len(stderr_lines) > len(preview):
-                        self.console.print(
-                            f"[dim]... ({len(stderr_lines) - len(preview)} more stderr lines)[/]"
-                        )
-                else:
-                    self.console.print("[dim]stderr:[/]")
-                    self.console.print("      [dim](no stderr)[/]")
+        # Use renderer registry for tool-specific rendering
+        registry = ToolResultRendererRegistry(
+            self.console, self.verbose, self._parse_bash_output_sections
+        )
+        if registry.render(sender, content, tool_data):
             return
 
+        # Fallback for unhandled tools
         self.console.print("  ⎿  [dim]Tool completed[/]")
 
     def _print_generic_tool(self, sender: str, content: str) -> None:
@@ -683,13 +573,40 @@ class RichUI:
             parts: List[str] = []
             for block in content:
                 text = getattr(block, "text", None)
+                if text is None:
+                    text = getattr(block, "thinking", None)
                 if not text and isinstance(block, dict):
-                    text = block.get("text")
+                    text = block.get("text") or block.get("thinking") or block.get("data")
                 if text:
                     parts.append(str(text))
             return "\n".join(parts)
         return ""
 
+    def _format_reasoning_preview(self, reasoning: Any) -> str:
+        """Best-effort stringify for reasoning/thinking traces."""
+        if reasoning is None:
+            return ""
+        if isinstance(reasoning, str):
+            preview = reasoning.strip()
+        else:
+            try:
+                preview = json.dumps(reasoning, ensure_ascii=False)
+            except (TypeError, ValueError, OverflowError):
+                preview = str(reasoning)
+        preview = preview.strip()
+        if len(preview) > 4000:
+            preview = preview[:4000] + "…"
+        return preview
+
+    def _print_reasoning(self, reasoning: Any) -> None:
+        """Display thinking traces in a dim style."""
+        preview = self._format_reasoning_preview(reasoning)
+        if not preview:
+            return
+        # Collapse excessive blank lines to keep the thinking block compact.
+        preview = re.sub(r"\n{2,}", "\n", preview)
+        self.console.print(f"[dim]🧠 Thinking: {escape(preview)}[/]")
+
     def _render_transcript(self, messages: List[ConversationMessage]) -> str:
         """Render a simple transcript for summarization."""
         lines: List[str] = []
@@ -717,14 +634,256 @@ class RichUI:
             return "\n".join(parts)
         return ""
 
+    async def _prepare_query_context(self, user_input: str) -> tuple[str, Dict[str, str]]:
+        """Load MCP servers, skills, and build system prompt.
+
+        Returns:
+            Tuple of (system_prompt, context_dict)
+        """
+        context: Dict[str, str] = {}
+        servers = await load_mcp_servers_async(self.project_path)
+        dynamic_tools = await load_dynamic_mcp_tools_async(self.project_path)
+
+        if dynamic_tools and self.query_context:
+            self.query_context.tools = merge_tools_with_dynamic(
+                self.query_context.tools, dynamic_tools
+            )
+
+        logger.debug(
+            "[ui] Prepared tools and MCP servers",
+            extra={
+                "session_id": self.session_id,
+                "tool_count": len(self.query_context.tools) if self.query_context else 0,
+                "mcp_servers": len(servers),
+                "dynamic_tools": len(dynamic_tools),
+            },
+        )
+
+        mcp_instructions = format_mcp_instructions(servers)
+        skill_result = load_all_skills(self.project_path)
+
+        for err in skill_result.errors:
+            logger.warning(
+                "[skills] Failed to load skill",
+                extra={
+                    "path": str(err.path),
+                    "reason": err.reason,
+                    "session_id": self.session_id,
+                },
+            )
+
+        skill_instructions = build_skill_summary(skill_result.skills)
+        additional_instructions: List[str] = []
+        if skill_instructions:
+            additional_instructions.append(skill_instructions)
+
+        memory_instructions = build_memory_instructions()
+        if memory_instructions:
+            additional_instructions.append(memory_instructions)
+
+        system_prompt = build_system_prompt(
+            self.query_context.tools if self.query_context else [],
+            user_input,
+            context,
+            additional_instructions=additional_instructions or None,
+            mcp_instructions=mcp_instructions,
+        )
+
+        return system_prompt, context
+
+    def _check_and_compact_messages(
+        self,
+        messages: List[ConversationMessage],
+        max_context_tokens: int,
+        auto_compact_enabled: bool,
+        protocol: str,
+    ) -> List[ConversationMessage]:
+        """Check context usage and compact if needed.
+
+        Returns:
+            Possibly compacted list of messages.
+        """
+        used_tokens = estimate_used_tokens(messages, protocol=protocol)  # type: ignore[arg-type]
+        usage_status = get_context_usage_status(
+            used_tokens, max_context_tokens, auto_compact_enabled
+        )
+
+        logger.debug(
+            "[ui] Context usage snapshot",
+            extra={
+                "session_id": self.session_id,
+                "used_tokens": used_tokens,
+                "max_context_tokens": max_context_tokens,
+                "percent_used": round(usage_status.percent_used, 2),
+                "auto_compact_enabled": auto_compact_enabled,
+            },
+        )
+
+        if usage_status.is_above_warning:
+            console.print(
+                f"[yellow]Context usage is {usage_status.percent_used:.1f}% "
+                f"({usage_status.total_tokens}/{usage_status.max_context_tokens} tokens).[/yellow]"
+            )
+            if not auto_compact_enabled:
+                console.print(
+                    "[dim]Auto-compaction is disabled; run /compact to trim history.[/dim]"
+                )
+
+        if usage_status.should_auto_compact:
+            original_messages = list(messages)
+            compaction = compact_messages(messages, protocol=protocol)  # type: ignore[arg-type]
+            if compaction.was_compacted:
+                if self._saved_conversation is None:
+                    self._saved_conversation = original_messages  # type: ignore[assignment]
+                console.print(
+                    f"[yellow]Auto-compacted conversation (saved ~{compaction.tokens_saved} tokens). "
+                    f"Estimated usage: {compaction.tokens_after}/{max_context_tokens} tokens.[/yellow]"
+                )
+                logger.info(
+                    "[ui] Auto-compacted conversation",
+                    extra={
+                        "session_id": self.session_id,
+                        "tokens_before": compaction.tokens_before,
+                        "tokens_after": compaction.tokens_after,
+                        "tokens_saved": compaction.tokens_saved,
+                        "cleared_tool_ids": list(compaction.cleared_tool_ids),
+                    },
+                )
+                return compaction.messages  # type: ignore[return-value]
+
+        return messages
+
+    def _handle_assistant_message(
+        self,
+        message: AssistantMessage,
+        tool_registry: Dict[str, Dict[str, Any]],
+    ) -> Optional[str]:
+        """Handle an assistant message from the query stream.
+
+        Returns:
+            The last tool name if a tool_use block was processed, None otherwise.
+        """
+        meta = getattr(getattr(message, "message", None), "metadata", {}) or {}
+        reasoning_payload = (
+            meta.get("reasoning_content")
+            or meta.get("reasoning")
+            or meta.get("reasoning_details")
+        )
+        if reasoning_payload:
+            self._print_reasoning(reasoning_payload)
+
+        last_tool_name: Optional[str] = None
+
+        if isinstance(message.message.content, str):
+            self.display_message("Ripperdoc", message.message.content)
+        elif isinstance(message.message.content, list):
+            for block in message.message.content:
+                if hasattr(block, "type") and block.type == "text" and block.text:
+                    self.display_message("Ripperdoc", block.text)
+                elif hasattr(block, "type") and block.type == "tool_use":
+                    tool_name = getattr(block, "name", "unknown tool")
+                    tool_args = getattr(block, "input", {})
+                    tool_use_id = getattr(block, "tool_use_id", None) or getattr(block, "id", None)
+
+                    if tool_use_id:
+                        tool_registry[tool_use_id] = {
+                            "name": tool_name,
+                            "args": tool_args,
+                            "printed": False,
+                        }
+
+                    if tool_name == "Task":
+                        self.display_message(
+                            tool_name, "", is_tool=True, tool_type="call", tool_args=tool_args
+                        )
+                        if tool_use_id:
+                            tool_registry[tool_use_id]["printed"] = True
+
+                    last_tool_name = tool_name
+
+        return last_tool_name
+
+    def _handle_tool_result_message(
+        self,
+        message: UserMessage,
+        tool_registry: Dict[str, Dict[str, Any]],
+        last_tool_name: Optional[str],
+    ) -> None:
+        """Handle a user message containing tool results."""
+        if not isinstance(message.message.content, list):
+            return
+
+        for block in message.message.content:
+            if not (hasattr(block, "type") and block.type == "tool_result" and block.text):
+                continue
+
+            tool_name = "Tool"
+            tool_data = getattr(message, "tool_use_result", None)
+            is_error = bool(getattr(block, "is_error", False))
+            tool_use_id = getattr(block, "tool_use_id", None)
+
+            entry = tool_registry.get(tool_use_id) if tool_use_id else None
+            if entry:
+                tool_name = entry.get("name", tool_name)
+                if not entry.get("printed"):
+                    self.display_message(
+                        tool_name,
+                        "",
+                        is_tool=True,
+                        tool_type="call",
+                        tool_args=entry.get("args", {}),
+                    )
+                    entry["printed"] = True
+            elif last_tool_name:
+                tool_name = last_tool_name
+
+            self.display_message(
+                tool_name,
+                block.text,
+                is_tool=True,
+                tool_type="result",
+                tool_data=tool_data,
+                tool_error=is_error,
+            )
+
+    def _handle_progress_message(
+        self,
+        message: ProgressMessage,
+        spinner: ThinkingSpinner,
+        output_token_est: int,
+    ) -> int:
+        """Handle a progress message and update spinner.
+
+        Returns:
+            Updated output token estimate.
+        """
+        if self.verbose:
+            self.display_message("System", f"Progress: {message.content}", is_tool=True)
+        elif message.content and isinstance(message.content, str):
+            if message.content.startswith("Subagent: "):
+                self.display_message(
+                    "Subagent", message.content[len("Subagent: ") :], is_tool=True
+                )
+            elif message.content.startswith("Subagent"):
+                self.display_message("Subagent", message.content, is_tool=True)
+
+        if message.tool_use_id == "stream":
+            delta_tokens = estimate_tokens(message.content)
+            output_token_est += delta_tokens
+            spinner.update_tokens(output_token_est)
+        else:
+            spinner.update_tokens(output_token_est, suffix=f"Working... {message.content}")
+
+        return output_token_est
+
     async def process_query(self, user_input: str) -> None:
         """Process a user query and display the response."""
+        # Initialize or reset query context
         if not self.query_context:
             self.query_context = QueryContext(
                 tools=self.get_default_tools(), safe_mode=self.safe_mode, verbose=self.verbose
             )
         else:
-            # Clear any prior abort so new queries aren't immediately interrupted.
             abort_controller = getattr(self.query_context, "abort_controller", None)
             if abort_controller is not None:
                 abort_controller.clear()
@@ -739,42 +898,16 @@ class RichUI:
         )
 
         try:
-            context: Dict[str, str] = {}
-            servers = await load_mcp_servers_async(self.project_path)
-            dynamic_tools = await load_dynamic_mcp_tools_async(self.project_path)
-            if dynamic_tools:
-                self.query_context.tools = merge_tools_with_dynamic(
-                    self.query_context.tools, dynamic_tools
-                )
-            logger.debug(
-                "[ui] Prepared tools and MCP servers",
-                extra={
-                    "session_id": self.session_id,
-                    "tool_count": len(self.query_context.tools),
-                    "mcp_servers": len(servers),
-                    "dynamic_tools": len(dynamic_tools),
-                },
-            )
-            mcp_instructions = format_mcp_instructions(servers)
-            base_system_prompt = build_system_prompt(
-                self.query_context.tools,
-                user_input,
-                context,
-                mcp_instructions=mcp_instructions,
-            )
-            memory_instructions = build_memory_instructions()
-            system_prompt = (
-                f"{base_system_prompt}\n\n{memory_instructions}"
-                if memory_instructions
-                else base_system_prompt
-            )
+            # Prepare context and system prompt
+            system_prompt, context = await self._prepare_query_context(user_input)
 
-            # Create user message
+            # Create and log user message
             user_message = create_user_message(user_input)
-            messages = self.conversation_messages + [user_message]
+            messages: List[ConversationMessage] = self.conversation_messages + [user_message]
             self._log_message(user_message)
             self._append_prompt_history(user_input)
 
+            # Get model configuration
             config = get_global_config()
             model_profile = get_profile_for_pointer("main")
             max_context_tokens = get_remaining_context_tokens(
@@ -783,74 +916,59 @@ class RichUI:
             auto_compact_enabled = resolve_auto_compact_enabled(config)
             protocol = provider_protocol(model_profile.provider) if model_profile else "openai"
 
-            used_tokens = estimate_used_tokens(messages, protocol=protocol)  # type: ignore[arg-type]
-            usage_status = get_context_usage_status(
-                used_tokens, max_context_tokens, auto_compact_enabled
-            )
-            logger.debug(
-                "[ui] Context usage snapshot",
-                extra={
-                    "session_id": self.session_id,
-                    "used_tokens": used_tokens,
-                    "max_context_tokens": max_context_tokens,
-                    "percent_used": round(usage_status.percent_used, 2),
-                    "auto_compact_enabled": auto_compact_enabled,
-                },
+            # Check and potentially compact messages
+            messages = self._check_and_compact_messages(
+                messages, max_context_tokens, auto_compact_enabled, protocol
             )
 
-            if usage_status.is_above_warning:
-                console.print(
-                    f"[yellow]Context usage is {usage_status.percent_used:.1f}% "
-                    f"({usage_status.total_tokens}/{usage_status.max_context_tokens} tokens).[/yellow]"
-                )
-                if not auto_compact_enabled:
-                    console.print(
-                        "[dim]Auto-compaction is disabled; run /compact to trim history.[/dim]"
-                    )
-
-            if usage_status.should_auto_compact:
-                original_messages = list(messages)
-                compaction = compact_messages(messages, protocol=protocol)  # type: ignore[arg-type]
-                if compaction.was_compacted:
-                    if self._saved_conversation is None:
-                        self._saved_conversation = original_messages  # type: ignore[assignment]
-                    messages = compaction.messages  # type: ignore[assignment]
-                    console.print(
-                        f"[yellow]Auto-compacted conversation (saved ~{compaction.tokens_saved} tokens). "
-                        f"Estimated usage: {compaction.tokens_after}/{max_context_tokens} tokens.[/yellow]"
-                    )
-                    logger.info(
-                        "[ui] Auto-compacted conversation",
-                        extra={
-                            "session_id": self.session_id,
-                            "tokens_before": compaction.tokens_before,
-                            "tokens_after": compaction.tokens_after,
-                            "tokens_saved": compaction.tokens_saved,
-                            "cleared_tool_ids": list(compaction.cleared_tool_ids),
-                        },
-                    )
-
+            # Setup spinner and callbacks
             prompt_tokens_est = estimate_conversation_tokens(messages, protocol=protocol)
             spinner = ThinkingSpinner(console, prompt_tokens_est)
-            # Wrap permission checker to pause the spinner while waiting for user input.
+
+            def pause_ui() -> None:
+                spinner.stop()
+
+            def resume_ui() -> None:
+                spinner.start()
+                spinner.update("Thinking...")
+
+            self.query_context.pause_ui = pause_ui
+            self.query_context.resume_ui = resume_ui
+
+            # Create permission checker with spinner control
             base_permission_checker = self._permission_checker
 
             async def permission_checker(tool: Any, parsed_input: Any) -> bool:
-                if spinner:
-                    spinner.stop()
+                spinner.stop()
                 try:
                     if base_permission_checker is not None:
                         result = await base_permission_checker(tool, parsed_input)
-                        return result.result if hasattr(result, "result") else True
+                        allowed = result.result if hasattr(result, "result") else True
+                        logger.debug(
+                            "[ui] Permission check result",
+                            extra={
+                                "tool": getattr(tool, "name", None),
+                                "allowed": allowed,
+                                "session_id": self.session_id,
+                            },
+                        )
+                        return allowed
                     return True
                 finally:
-                    if spinner:
+                    # Wrap spinner restart in try-except to prevent exceptions
+                    # from discarding the permission result
+                    try:
                         spinner.start()
                         spinner.update("Thinking...")
+                    except (RuntimeError, ValueError, OSError) as exc:
+                        logger.debug(
+                            "[ui] Failed to restart spinner after permission check: %s: %s",
+                            type(exc).__name__, exc,
+                        )
 
-            # Track tool uses by ID so results align even when multiple tools fire.
+            # Process query stream
             tool_registry: Dict[str, Dict[str, Any]] = {}
-            last_tool_name = None
+            last_tool_name: Optional[str] = None
             output_token_est = 0
 
             try:
@@ -863,117 +981,41 @@ class RichUI:
                     permission_checker,  # type: ignore[arg-type]
                 ):
                     if message.type == "assistant" and isinstance(message, AssistantMessage):
-                        # Extract text content from assistant message
-                        if isinstance(message.message.content, str):
-                            self.display_message("Ripperdoc", message.message.content)
-                        elif isinstance(message.message.content, list):
-                            for block in message.message.content:
-                                if hasattr(block, "type") and block.type == "text" and block.text:
-                                    self.display_message("Ripperdoc", block.text)
-                                elif hasattr(block, "type") and block.type == "tool_use":
-                                    # Show tool usage in the new format
-                                    tool_name = getattr(block, "name", "unknown tool")
-                                    tool_args = getattr(block, "input", {})
-
-                                    tool_use_id = getattr(block, "tool_use_id", None) or getattr(
-                                        block, "id", None
-                                    )
-                                    if tool_use_id:
-                                        tool_registry[tool_use_id] = {
-                                            "name": tool_name,
-                                            "args": tool_args,
-                                            "printed": False,
-                                        }
-                                    if tool_name == "Task":
-                                        self.display_message(
-                                            tool_name,
-                                            "",
-                                            is_tool=True,
-                                            tool_type="call",
-                                            tool_args=tool_args,
-                                        )
-                                        if tool_use_id:
-                                            tool_registry[tool_use_id]["printed"] = True
-                                    last_tool_name = tool_name
+                        result = self._handle_assistant_message(message, tool_registry)
+                        if result:
+                            last_tool_name = result
 
                     elif message.type == "user" and isinstance(message, UserMessage):
-                        # Handle tool results - show summary instead of full content
-                        if isinstance(message.message.content, list):
-                            for block in message.message.content:
-                                if (
-                                    hasattr(block, "type")
-                                    and block.type == "tool_result"
-                                    and block.text
-                                ):
-                                    tool_name = "Tool"
-                                    tool_data = getattr(message, "tool_use_result", None)
-                                    is_error = bool(getattr(block, "is_error", False))
-
-                                    tool_use_id = getattr(block, "tool_use_id", None)
-                                    entry = tool_registry.get(tool_use_id) if tool_use_id else None
-                                    if entry:
-                                        tool_name = entry.get("name", tool_name)
-                                        if not entry.get("printed"):
-                                            self.display_message(
-                                                tool_name,
-                                                "",
-                                                is_tool=True,
-                                                tool_type="call",
-                                                tool_args=entry.get("args", {}),
-                                            )
-                                            entry["printed"] = True
-                                    elif last_tool_name:
-                                        tool_name = last_tool_name
-
-                                    self.display_message(
-                                        tool_name,
-                                        block.text,
-                                        is_tool=True,
-                                        tool_type="result",
-                                        tool_data=tool_data,
-                                        tool_error=is_error,
-                                    )
+                        self._handle_tool_result_message(message, tool_registry, last_tool_name)
 
                     elif message.type == "progress" and isinstance(message, ProgressMessage):
-                        if self.verbose:
-                            self.display_message(
-                                "System", f"Progress: {message.content}", is_tool=True
-                            )
-                        elif message.content and isinstance(message.content, str):
-                            if message.content.startswith("Subagent: "):
-                                self.display_message(
-                                    "Subagent", message.content[len("Subagent: ") :], is_tool=True
-                                )
-                            elif message.content.startswith("Subagent"):
-                                self.display_message("Subagent", message.content, is_tool=True)
-                        if message.tool_use_id == "stream":
-                            delta_tokens = estimate_tokens_from_text(message.content)
-                            output_token_est += delta_tokens
-                            spinner.update_tokens(output_token_est)
-                        else:
-                            spinner.update_tokens(
-                                output_token_est, suffix=f"Working... {message.content}"
-                            )
+                        output_token_est = self._handle_progress_message(
+                            message, spinner, output_token_est
+                        )
 
-                    # Add message to history
                     self._log_message(message)
                     messages.append(message)  # type: ignore[arg-type]
-            except Exception as e:
-                logger.exception(
-                    "[ui] Unhandled error while processing streamed query response",
+
+            except asyncio.CancelledError:
+                # Re-raise cancellation to allow proper cleanup
+                raise
+            except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as e:
+                logger.warning(
+                    "[ui] Error while processing streamed query response: %s: %s",
+                    type(e).__name__, e,
                     extra={"session_id": self.session_id},
                 )
                 self.display_message("System", f"Error: {str(e)}", is_tool=True)
             finally:
-                # Ensure spinner stops even on exceptions
                 try:
                     spinner.stop()
-                except Exception:
-                    logger.exception(
-                        "[ui] Failed to stop spinner", extra={"session_id": self.session_id}
+                except (RuntimeError, ValueError, OSError) as exc:
+                    logger.warning(
+                        "[ui] Failed to stop spinner: %s: %s",
+                        type(exc).__name__, exc,
+                        extra={"session_id": self.session_id},
                     )
 
-                # Update conversation history
                 self.conversation_messages = messages
                 logger.info(
                     "[ui] Query processing completed",
@@ -983,9 +1025,28 @@ class RichUI:
                         "project_path": str(self.project_path),
                     },
                 )
-        finally:
-            await shutdown_mcp_runtime()
-            await shutdown_mcp_runtime()
+
+        except asyncio.CancelledError:
+            # Re-raise cancellation to allow proper cleanup
+            raise
+        except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as exc:
+            logger.warning(
+                "[ui] Error during query processing: %s: %s",
+                type(exc).__name__, exc,
+                extra={"session_id": self.session_id},
+            )
+            self.display_message("System", f"Error: {str(exc)}", is_tool=True)
+
+    def _run_async(self, coro: Any) -> Any:
+        """Run a coroutine on the persistent event loop."""
+        if self._loop.is_closed():
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+        return self._loop.run_until_complete(coro)
+
+    def run_async(self, coro: Any) -> Any:
+        """Public wrapper for running coroutines on the UI event loop."""
+        return self._run_async(coro)
 
     def handle_slash_command(self, user_input: str) -> bool:
         """Handle slash commands. Returns True if the input was handled."""
@@ -1058,60 +1119,124 @@ class RichUI:
             extra={"session_id": self.session_id, "log_file": str(self.log_file_path)},
         )
 
-        while not self._should_exit:
-            try:
-                # Get user input
-                user_input = session.prompt("> ")
+        try:
+            while not self._should_exit:
+                try:
+                    # Get user input
+                    user_input = session.prompt("> ")
 
-                if not user_input.strip():
-                    continue
+                    if not user_input.strip():
+                        continue
 
-                if user_input.strip() == "?":
-                    self._print_shortcuts()
-                    console.print()
-                    continue
+                    if user_input.strip() == "?":
+                        self._print_shortcuts()
+                        console.print()
+                        continue
 
-                # Handle slash commands locally
-                if user_input.startswith("/"):
-                    logger.debug(
-                        "[ui] Received slash command",
-                        extra={"session_id": self.session_id, "command": user_input},
+                    # Handle slash commands locally
+                    if user_input.startswith("/"):
+                        logger.debug(
+                            "[ui] Received slash command",
+                            extra={"session_id": self.session_id, "command": user_input},
+                        )
+                        handled = self.handle_slash_command(user_input)
+                        if self._should_exit:
+                            break
+                        if handled:
+                            console.print()  # spacing
+                            continue
+
+                    # Process the query
+                    logger.info(
+                        "[ui] Processing interactive prompt",
+                        extra={
+                            "session_id": self.session_id,
+                            "prompt_length": len(user_input),
+                            "prompt_preview": user_input[:200],
+                        },
                     )
-                    handled = self.handle_slash_command(user_input)
-                    if self._should_exit:
-                        break
-                    if handled:
-                        console.print()  # spacing
-                        continue
+                    self._run_async(self.process_query(user_input))
+
+                    console.print()  # Add spacing between interactions
+
+                except KeyboardInterrupt:
+                    # Signal abort to cancel running queries
+                    if self.query_context:
+                        abort_controller = getattr(self.query_context, "abort_controller", None)
+                        if abort_controller is not None:
+                            abort_controller.set()
+                    console.print("\n[yellow]Goodbye![/yellow]")
+                    break
+                except EOFError:
+                    console.print("\n[yellow]Goodbye![/yellow]")
+                    break
+                except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as e:
+                    console.print(f"[red]Error: {escape(str(e))}[/]")
+                    logger.warning(
+                        "[ui] Error in interactive loop: %s: %s",
+                        type(e).__name__, e,
+                        extra={"session_id": self.session_id},
+                    )
+                    if self.verbose:
+                        import traceback
 
-                # Process the query
-                logger.info(
-                    "[ui] Processing interactive prompt",
-                    extra={
-                        "session_id": self.session_id,
-                        "prompt_length": len(user_input),
-                        "prompt_preview": user_input[:200],
-                    },
-                )
-                asyncio.run(self.process_query(user_input))
+                        console.print(traceback.format_exc())
+        finally:
+            # Cancel any running tasks before shutdown
+            if self.query_context:
+                abort_controller = getattr(self.query_context, "abort_controller", None)
+                if abort_controller is not None:
+                    abort_controller.set()
 
-                console.print()  # Add spacing between interactions
+            # Suppress async generator cleanup errors during shutdown
+            original_hook = sys.unraisablehook
 
-            except KeyboardInterrupt:
-                console.print("\n[yellow]Goodbye![/yellow]")
-                break
-            except EOFError:
-                console.print("\n[yellow]Goodbye![/yellow]")
-                break
-            except Exception as e:
-                console.print(f"[red]Error: {escape(str(e))}[/]")
-                logger.exception(
-                    "[ui] Error in interactive loop", extra={"session_id": self.session_id}
-                )
-                if self.verbose:
-                    import traceback
+            def _quiet_unraisable_hook(unraisable: Any) -> None:
+                # Suppress "asynchronous generator is already running" errors during shutdown
+                if isinstance(unraisable.exc_value, RuntimeError):
+                    if "asynchronous generator is already running" in str(unraisable.exc_value):
+                        return
+                # Call original hook for other errors
+                original_hook(unraisable)
+
+            sys.unraisablehook = _quiet_unraisable_hook
+
+            try:
+                try:
+                    self._run_async(shutdown_mcp_runtime())
+                except (OSError, RuntimeError, ConnectionError, asyncio.CancelledError) as exc:
+                    # pragma: no cover - defensive shutdown
+                    logger.warning(
+                        "[ui] Failed to shut down MCP runtime cleanly: %s: %s",
+                        type(exc).__name__, exc,
+                        extra={"session_id": self.session_id},
+                    )
+            finally:
+                if not self._loop.is_closed():
+                    # Cancel all pending tasks
+                    pending = asyncio.all_tasks(self._loop)
+                    for task in pending:
+                        task.cancel()
+
+                    # Allow cancelled tasks to clean up
+                    if pending:
+                        try:
+                            self._loop.run_until_complete(
+                                asyncio.gather(*pending, return_exceptions=True)
+                            )
+                        except (RuntimeError, asyncio.CancelledError):
+                            pass  # Ignore errors during task cancellation
 
-                    console.print(traceback.format_exc())
+                    # Shutdown async generators (suppress expected errors)
+                    try:
+                        self._loop.run_until_complete(self._loop.shutdown_asyncgens())
+                    except (RuntimeError, asyncio.CancelledError):
+                        # Expected during forced shutdown - async generators may already be running
+                        pass
+
+                    self._loop.close()
+                asyncio.set_event_loop(None)
+                sys.unraisablehook = original_hook
 
     async def _run_manual_compact(self, custom_instructions: str) -> None:
         """Manual compaction: clear bulky tool output and summarize conversation."""
@@ -1135,10 +1260,12 @@ class RichUI:
             summary_text = await self._summarize_conversation(
                 messages_for_summary, custom_instructions
             )
-        except Exception as e:
+        except (OSError, RuntimeError, ConnectionError, ValueError, KeyError) as e:
             console.print(f"[red]Error during compaction: {escape(str(e))}[/red]")
-            logger.exception(
-                "[ui] Error during manual compaction", extra={"session_id": self.session_id}
+            logger.warning(
+                "[ui] Error during manual compaction: %s: %s",
+                type(e).__name__, e,
+                extra={"session_id": self.session_id},
             )
             return
         finally: