ripperdoc 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

ripperdoc/cli/ui/rich_ui.py

@@ -6,6 +6,7 @@ This module provides a clean, minimal terminal UI using Rich for the Ripperdoc a
 import asyncio
 import json
 import sys
+import time
 import uuid
 from typing import List, Dict, Any, Optional, Union, Iterable
 from pathlib import Path
@@ -25,6 +26,7 @@ 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.core.hooks.manager import hook_manager
+from ripperdoc.core.hooks.llm_callback import build_hook_llm_callback
 from ripperdoc.cli.commands import (
     get_slash_command,
     get_custom_command,
@@ -64,6 +66,8 @@ from ripperdoc.utils.mcp import (
     load_mcp_servers_async,
     shutdown_mcp_runtime,
 )
+from ripperdoc.utils.lsp import shutdown_lsp_manager
+from ripperdoc.tools.background_shell import shutdown_background_shell
 from ripperdoc.tools.mcp_tools import load_dynamic_mcp_tools_async, merge_tools_with_dynamic
 from ripperdoc.utils.session_history import SessionHistory
 from ripperdoc.utils.memory import build_memory_instructions
@@ -86,31 +90,37 @@ console = Console()
 logger = get_logger()
 
 
-# Legacy aliases for backward compatibility with tests
-_extract_tool_ids_from_message = extract_tool_ids_from_message
-_get_complete_tool_pairs_tail = get_complete_tool_pairs_tail
-
-
 class RichUI:
     """Rich-based UI for Ripperdoc."""
 
     def __init__(
         self,
-        safe_mode: bool = False,
+        yolo_mode: bool = False,
         verbose: bool = False,
+        show_full_thinking: Optional[bool] = None,
         session_id: Optional[str] = None,
         log_file_path: Optional[Path] = None,
+        allowed_tools: Optional[List[str]] = None,
+        custom_system_prompt: Optional[str] = None,
+        append_system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        resume_messages: Optional[List[Any]] = None,
     ):
         self._loop = asyncio.new_event_loop()
         asyncio.set_event_loop(self._loop)
         self.console = console
-        self.safe_mode = safe_mode
+        self.yolo_mode = yolo_mode
         self.verbose = verbose
+        self.allowed_tools = allowed_tools
+        self.custom_system_prompt = custom_system_prompt
+        self.append_system_prompt = append_system_prompt
+        self.model = model or "main"
         self.conversation_messages: List[ConversationMessage] = []
         self._saved_conversation: Optional[List[ConversationMessage]] = None
         self.query_context: Optional[QueryContext] = None
         self._current_tool: Optional[str] = None
         self._should_exit: bool = False
+        self._last_ctrl_c_time: float = 0.0  # Track Ctrl+C timing for double-press exit
         self.command_list = list_slash_commands()
         self._custom_command_list = list_custom_commands()
         self._prompt_session: Optional[PromptSession] = None
@@ -128,16 +138,22 @@ class RichUI:
                 "session_id": self.session_id,
                 "project_path": str(self.project_path),
                 "log_file": str(self.log_file_path),
-                "safe_mode": self.safe_mode,
+                "yolo_mode": self.yolo_mode,
                 "verbose": self.verbose,
             },
         )
         self._session_history = SessionHistory(self.project_path, self.session_id)
+        self._session_hook_contexts: List[str] = []
+        self._session_start_time = time.time()
+        self._session_end_sent = False
+        self._exit_reason: Optional[str] = None
+        hook_manager.set_transcript_path(str(self._session_history.path))
         self._permission_checker = (
-            make_permission_checker(self.project_path, safe_mode) if safe_mode else None
+            None if yolo_mode else make_permission_checker(self.project_path, yolo_mode=False)
         )
         # Build ignore filter for file completion
         from ripperdoc.utils.path_ignore import get_project_ignore_patterns
+
         project_patterns = get_project_ignore_patterns()
         self._ignore_filter = build_ignore_filter(
             self.project_path,
@@ -146,8 +162,17 @@ class RichUI:
             include_gitignore=True,
         )
 
+        # Get global config for display preferences
+        config = get_global_config()
+        if show_full_thinking is None:
+            self.show_full_thinking = config.show_full_thinking
+        else:
+            self.show_full_thinking = show_full_thinking
+
         # Initialize component handlers
-        self._message_display = MessageDisplay(self.console, self.verbose)
+        self._message_display = MessageDisplay(
+            self.console, self.verbose, self.show_full_thinking
+        )
         self._interrupt_handler = InterruptHandler()
         self._interrupt_handler.set_abort_callback(self._trigger_abort)
 
@@ -157,13 +182,15 @@ class RichUI:
         except (OSError, RuntimeError, ConnectionError) as exc:
             logger.warning(
                 "[ui] Failed to initialize MCP runtime at startup: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"session_id": self.session_id},
             )
 
         # Initialize hook manager with project context
         hook_manager.set_project_dir(self.project_path)
         hook_manager.set_session_id(self.session_id)
+        hook_manager.set_llm_callback(build_hook_llm_callback())
         logger.debug(
             "[ui] Initialized hook manager",
             extra={
@@ -171,6 +198,18 @@ class RichUI:
                 "project_path": str(self.project_path),
             },
         )
+        self._run_session_start("startup")
+
+        # Handle resume_messages if provided (for --continue)
+        if resume_messages:
+            self.conversation_messages = list(resume_messages)
+            logger.info(
+                "[ui] Resumed conversation with messages",
+                extra={
+                    "session_id": self.session_id,
+                    "message_count": len(resume_messages),
+                },
+            )
 
     # ─────────────────────────────────────────────────────────────────────────────
     # Properties for backward compatibility with interrupt handler
@@ -206,6 +245,69 @@ class RichUI:
             },
         )
         self._session_history = SessionHistory(self.project_path, session_id)
+        hook_manager.set_session_id(self.session_id)
+        hook_manager.set_transcript_path(str(self._session_history.path))
+
+    def _collect_hook_contexts(self, hook_result: Any) -> List[str]:
+        contexts: List[str] = []
+        system_message = getattr(hook_result, "system_message", None)
+        additional_context = getattr(hook_result, "additional_context", None)
+        if system_message:
+            contexts.append(str(system_message))
+        if additional_context:
+            contexts.append(str(additional_context))
+        return contexts
+
+    def _set_session_hook_contexts(self, hook_result: Any) -> None:
+        self._session_hook_contexts = self._collect_hook_contexts(hook_result)
+        self._session_start_time = time.time()
+        self._session_end_sent = False
+
+    def _run_session_start(self, source: str) -> None:
+        try:
+            result = self._run_async(hook_manager.run_session_start_async(source))
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionStart hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "source": source},
+            )
+            return
+        self._set_session_hook_contexts(result)
+
+    async def _run_session_start_async(self, source: str) -> None:
+        try:
+            result = await hook_manager.run_session_start_async(source)
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionStart hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "source": source},
+            )
+            return
+        self._set_session_hook_contexts(result)
+
+    def _run_session_end(self, reason: str) -> None:
+        if self._session_end_sent:
+            return
+        duration = max(time.time() - self._session_start_time, 0.0)
+        message_count = len(self.conversation_messages)
+        try:
+            self._run_async(
+                hook_manager.run_session_end_async(
+                    reason, duration_seconds=duration, message_count=message_count
+                )
+            )
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionEnd hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "reason": reason},
+            )
+        self._session_end_sent = True
 
     def _log_message(self, message: Any) -> None:
         """Best-effort persistence of a message to the session log."""
@@ -215,7 +317,8 @@ class RichUI:
             # Logging failures should never interrupt the UI flow
             logger.warning(
                 "[ui] Failed to append message to session history: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"session_id": self.session_id},
             )
 
@@ -229,7 +332,8 @@ class RichUI:
         except (AttributeError, TypeError, ValueError) as exc:
             logger.warning(
                 "[ui] Failed to append prompt history: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"session_id": self.session_id},
             )
 
@@ -264,8 +368,8 @@ class RichUI:
                 self.display_message("Ripperdoc", text)
 
     def get_default_tools(self) -> list:
-        """Get the default set of tools."""
-        return get_default_tools()
+        """Get the default set of tools, filtered by allowed_tools if specified."""
+        return get_default_tools(allowed_tools=self.allowed_tools)
 
     def display_message(
         self,
@@ -320,7 +424,9 @@ class RichUI:
     def _print_reasoning(self, reasoning: Any) -> None:
         self._message_display.print_reasoning(reasoning)
 
-    async def _prepare_query_context(self, user_input: str) -> tuple[str, Dict[str, str]]:
+    async def _prepare_query_context(
+        self, user_input: str, hook_instructions: Optional[List[str]] = None
+    ) -> tuple[str, Dict[str, str]]:
         """Load MCP servers, skills, and build system prompt.
 
         Returns:
@@ -366,14 +472,32 @@ class RichUI:
         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,
-        )
+        if self._session_hook_contexts:
+            additional_instructions.extend(self._session_hook_contexts)
+        if hook_instructions:
+            additional_instructions.extend([text for text in hook_instructions if text])
+
+        # Build system prompt based on options:
+        # - custom_system_prompt: replaces the default entirely
+        # - append_system_prompt: appends to the default system prompt
+        if self.custom_system_prompt:
+            # Complete replacement
+            system_prompt = self.custom_system_prompt
+            # Still append if both are provided
+            if self.append_system_prompt:
+                system_prompt = f"{system_prompt}\n\n{self.append_system_prompt}"
+        else:
+            # Build default with optional append
+            all_instructions = list(additional_instructions) if additional_instructions else []
+            if self.append_system_prompt:
+                all_instructions.append(self.append_system_prompt)
+            system_prompt = build_system_prompt(
+                self.query_context.tools if self.query_context else [],
+                user_input,
+                context,
+                additional_instructions=all_instructions or None,
+                mcp_instructions=mcp_instructions,
+            )
 
         return system_prompt, context
 
@@ -438,10 +562,33 @@ class RichUI:
         if usage_status.should_auto_compact:
             original_messages = list(messages)
             spinner = Spinner(self.console, "Summarizing conversation...", spinner="dots")
+            hook_instructions = ""
+            try:
+                hook_result = await hook_manager.run_pre_compact_async(
+                    trigger="auto", custom_instructions=""
+                )
+                if hook_result.should_block or not hook_result.should_continue:
+                    reason = (
+                        hook_result.block_reason
+                        or hook_result.stop_reason
+                        or "Compaction blocked by hook."
+                    )
+                    console.print(f"[yellow]{escape(str(reason))}[/yellow]")
+                    return messages
+                hook_contexts = self._collect_hook_contexts(hook_result)
+                if hook_contexts:
+                    hook_instructions = "\n\n".join(hook_contexts)
+            except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+                logger.warning(
+                    "[ui] PreCompact hook failed: %s: %s",
+                    type(exc).__name__,
+                    exc,
+                    extra={"session_id": self.session_id},
+                )
             try:
                 spinner.start()
                 result = await compact_conversation(
-                    messages, custom_instructions="", protocol=protocol
+                    messages, custom_instructions=hook_instructions, protocol=protocol
                 )
             finally:
                 spinner.stop()
@@ -462,6 +609,7 @@ class RichUI:
                         "tokens_saved": result.tokens_saved,
                     },
                 )
+                await self._run_session_start_async("compact")
                 return result.messages
             elif isinstance(result, CompactionError):
                 logger.warning(
@@ -476,29 +624,36 @@ class RichUI:
         self,
         message: AssistantMessage,
         tool_registry: Dict[str, Dict[str, Any]],
+        spinner: Optional[ThinkingSpinner] = None,
     ) -> Optional[str]:
         """Handle an assistant message from the query stream.
 
         Returns:
             The last tool name if a tool_use block was processed, None otherwise.
         """
+        # Factory to create pause context - spinner.paused() if spinner exists, else no-op
+        from contextlib import nullcontext
+
+        pause = lambda: spinner.paused() if spinner else nullcontext()  # noqa: E731
+
         meta = getattr(getattr(message, "message", None), "metadata", {}) or {}
         reasoning_payload = (
-            meta.get("reasoning_content")
-            or meta.get("reasoning")
-            or meta.get("reasoning_details")
+            meta.get("reasoning_content") or meta.get("reasoning") or meta.get("reasoning_details")
         )
         if reasoning_payload:
-            self._print_reasoning(reasoning_payload)
+            with pause():
+                self._print_reasoning(reasoning_payload)
 
         last_tool_name: Optional[str] = None
 
         if isinstance(message.message.content, str):
-            self.display_message("Ripperdoc", message.message.content)
+            with pause():
+                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)
+                    with pause():
+                        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", {})
@@ -512,9 +667,10 @@ class RichUI:
                         }
 
                     if tool_name == "Task":
-                        self.display_message(
-                            tool_name, "", is_tool=True, tool_type="call", tool_args=tool_args
-                        )
+                        with pause():
+                            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
 
@@ -527,11 +683,17 @@ class RichUI:
         message: UserMessage,
         tool_registry: Dict[str, Dict[str, Any]],
         last_tool_name: Optional[str],
+        spinner: Optional[ThinkingSpinner] = None,
     ) -> None:
         """Handle a user message containing tool results."""
         if not isinstance(message.message.content, list):
             return
 
+        # Factory to create pause context - spinner.paused() if spinner exists, else no-op
+        from contextlib import nullcontext
+
+        pause = lambda: spinner.paused() if spinner else nullcontext()  # noqa: E731
+
         for block in message.message.content:
             if not (hasattr(block, "type") and block.type == "tool_result" and block.text):
                 continue
@@ -545,25 +707,27 @@ class RichUI:
             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", {}),
-                    )
+                    with pause():
+                        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,
-            )
+            with pause():
+                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,
@@ -577,14 +741,17 @@ class RichUI:
             Updated output token estimate.
         """
         if self.verbose:
-            self.display_message("System", f"Progress: {message.content}", is_tool=True)
+            with spinner.paused():
+                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
-                )
+                with spinner.paused():
+                    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)
+                with spinner.paused():
+                    self.display_message("Subagent", message.content, is_tool=True)
 
         if message.tool_use_id == "stream":
             delta_tokens = estimate_tokens(message.content)
@@ -600,12 +767,16 @@ class RichUI:
         # 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
+                tools=self.get_default_tools(),
+                yolo_mode=self.yolo_mode,
+                verbose=self.verbose,
+                model=self.model,
             )
         else:
             abort_controller = getattr(self.query_context, "abort_controller", None)
             if abort_controller is not None:
                 abort_controller.clear()
+        self.query_context.stop_hook_active = False
 
         logger.info(
             "[ui] Starting query processing",
@@ -617,8 +788,21 @@ class RichUI:
         )
 
         try:
+            hook_result = await hook_manager.run_user_prompt_submit_async(user_input)
+            if hook_result.should_block or not hook_result.should_continue:
+                reason = (
+                    hook_result.block_reason
+                    or hook_result.stop_reason
+                    or "Prompt blocked by hook."
+                )
+                self.console.print(f"[red]{escape(str(reason))}[/red]")
+                return
+            hook_instructions = self._collect_hook_contexts(hook_result)
+
             # Prepare context and system prompt
-            system_prompt, context = await self._prepare_query_context(user_input)
+            system_prompt, context = await self._prepare_query_context(
+                user_input, hook_instructions
+            )
 
             # Create and log user message
             user_message = create_user_message(user_input)
@@ -684,7 +868,8 @@ class RichUI:
                     except (RuntimeError, ValueError, OSError) as exc:
                         logger.debug(
                             "[ui] Failed to restart spinner after permission check: %s: %s",
-                            type(exc).__name__, exc,
+                            type(exc).__name__,
+                            exc,
                         )
 
             # Process query stream
@@ -702,12 +887,14 @@ class RichUI:
                     permission_checker,  # type: ignore[arg-type]
                 ):
                     if message.type == "assistant" and isinstance(message, AssistantMessage):
-                        result = self._handle_assistant_message(message, tool_registry)
+                        result = self._handle_assistant_message(message, tool_registry, spinner)
                         if result:
                             last_tool_name = result
 
                     elif message.type == "user" and isinstance(message, UserMessage):
-                        self._handle_tool_result_message(message, tool_registry, last_tool_name)
+                        self._handle_tool_result_message(
+                            message, tool_registry, last_tool_name, spinner
+                        )
 
                     elif message.type == "progress" and isinstance(message, ProgressMessage):
                         output_token_est = self._handle_progress_message(
@@ -723,7 +910,8 @@ class RichUI:
             except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as e:
                 logger.warning(
                     "[ui] Error while processing streamed query response: %s: %s",
-                    type(e).__name__, e,
+                    type(e).__name__,
+                    e,
                     extra={"session_id": self.session_id},
                 )
                 self.display_message("System", f"Error: {str(e)}", is_tool=True)
@@ -733,7 +921,8 @@ class RichUI:
                 except (RuntimeError, ValueError, OSError) as exc:
                     logger.warning(
                         "[ui] Failed to stop spinner: %s: %s",
-                        type(exc).__name__, exc,
+                        type(exc).__name__,
+                        exc,
                         extra={"session_id": self.session_id},
                     )
 
@@ -753,7 +942,8 @@ class RichUI:
         except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as exc:
             logger.warning(
                 "[ui] Error during query processing: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"session_id": self.session_id},
             )
             self.display_message("System", f"Error: {str(exc)}", is_tool=True)
@@ -823,14 +1013,10 @@ class RichUI:
         custom_cmd = get_custom_command(command_name, self.project_path)
         if custom_cmd is not None:
             # Expand the custom command content
-            expanded_content = expand_command_content(
-                custom_cmd, trimmed_arg, self.project_path
-            )
+            expanded_content = expand_command_content(custom_cmd, trimmed_arg, self.project_path)
 
             # Show a hint that this is from a custom command
-            self.console.print(
-                f"[dim]Running custom command: /{command_name}[/dim]"
-            )
+            self.console.print(f"[dim]Running custom command: /{command_name}[/dim]")
             if custom_cmd.argument_hint and trimmed_arg:
                 self.console.print(f"[dim]Arguments: {trimmed_arg}[/dim]")
 
@@ -851,7 +1037,7 @@ class RichUI:
             def __init__(self, project_path: Path):
                 self.project_path = project_path
 
-            def get_completions(self, document: Any, complete_event: Any) -> Iterable[Completion]:
+            def get_completions(self, document: Any, _complete_event: Any) -> Iterable[Completion]:
                 text = document.text_before_cursor
                 if not text.startswith("/"):
                     return
@@ -902,12 +1088,57 @@ class RichUI:
             else:
                 buf.start_completion(select_first=True)
 
+        @key_bindings.add("escape", "enter")
+        def _(event: Any) -> None:
+            """Insert newline on Alt+Enter."""
+            event.current_buffer.insert_text("\n")
+
+        # Capture self for use in Ctrl+C handler closure
+        ui_instance = self
+
+        @key_bindings.add("c-c")
+        def _(event: Any) -> None:
+            """Handle Ctrl+C: first press clears input, second press exits."""
+            import time as time_module
+
+            buf = event.current_buffer
+            current_text = buf.text
+            current_time = time_module.time()
+
+            # Check if this is a double Ctrl+C (within 1.5 seconds)
+            if current_time - ui_instance._last_ctrl_c_time < 1.5:
+                # Double Ctrl+C - exit
+                buf.reset()
+                raise KeyboardInterrupt()
+
+            # First Ctrl+C - save to history and clear
+            ui_instance._last_ctrl_c_time = current_time
+
+            if current_text.strip():
+                # Save current input to history before clearing
+                try:
+                    event.app.current_buffer.history.append_string(current_text)
+                except (AttributeError, TypeError, ValueError):
+                    pass
+
+            # Print hint message in clean terminal context, then clear buffer
+            from prompt_toolkit.application import run_in_terminal
+
+            def _print_hint() -> None:
+                print("\n\033[2mPress Ctrl+C again to exit, or continue typing.\033[0m")
+
+            run_in_terminal(_print_hint)
+
+            # Clear the buffer after printing
+            buf.reset()
+
         self._prompt_session = PromptSession(
             completer=combined_completer,
             complete_style=CompleteStyle.COLUMN,
             complete_while_typing=True,
             history=InMemoryHistory(),
             key_bindings=key_bindings,
+            multiline=True,
         )
         return self._prompt_session
 
@@ -921,7 +1152,10 @@ class RichUI:
         # Display status
         console.print(create_status_bar())
         console.print()
-        console.print("[dim]Tip: type '/' then press Tab to see available commands. Type '@' to mention files. Press ESC to interrupt a running query.[/dim]\n")
+        console.print(
+            "[dim]Tip: type '/' then press Tab to see available commands. Type '@' to mention files. "
+            "Press Alt+Enter for newline. Press ESC to interrupt. Press Ctrl+C twice to exit.[/dim]\n"
+        )
 
         session = self.get_prompt_session()
         logger.info(
@@ -929,6 +1163,7 @@ class RichUI:
             extra={"session_id": self.session_id, "log_file": str(self.log_file_path)},
         )
 
+        exit_reason = "other"
         try:
             while not self._should_exit:
                 try:
@@ -951,6 +1186,7 @@ class RichUI:
                         )
                         handled = self.handle_slash_command(user_input)
                         if self._should_exit:
+                            exit_reason = self._exit_reason or "other"
                             break
                         # If handled is a string, it's expanded custom command content
                         if isinstance(handled, str):
@@ -972,7 +1208,9 @@ class RichUI:
                     interrupted = self._run_async_with_esc_interrupt(self.process_query(user_input))
 
                     if interrupted:
-                        console.print("\n[red]■ Conversation interrupted[/red] · [dim]Tell the model what to do differently.[/dim]")
+                        console.print(
+                            "\n[red]■ Conversation interrupted[/red] · [dim]Tell the model what to do differently.[/dim]"
+                        )
                         logger.info(
                             "[ui] Query interrupted by ESC key",
                             extra={"session_id": self.session_id},
@@ -981,21 +1219,45 @@ class RichUI:
                     console.print()  # Add spacing between interactions
 
                 except KeyboardInterrupt:
+                    # Handle Ctrl+C: first press during query aborts it,
+                    # double press exits the CLI
+                    current_time = time.time()
+
                     # 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
+
+                    # Check if this is a double Ctrl+C (within 1.5 seconds)
+                    if current_time - self._last_ctrl_c_time < 1.5:
+                        console.print("\n[yellow]Goodbye![/yellow]")
+                        exit_reason = "prompt_input_exit"
+                        break
+
+                    # First Ctrl+C - just abort the query and continue
+                    self._last_ctrl_c_time = current_time
+                    console.print(
+                        "\n[dim]Query interrupted. Press Ctrl+C again to exit.[/dim]"
+                    )
+                    continue
                 except EOFError:
                     console.print("\n[yellow]Goodbye![/yellow]")
+                    exit_reason = "prompt_input_exit"
                     break
-                except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as e:
+                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,
+                        type(e).__name__,
+                        e,
                         extra={"session_id": self.session_id},
                     )
                     if self.verbose:
@@ -1009,6 +1271,8 @@ class RichUI:
                 if abort_controller is not None:
                     abort_controller.set()
 
+            self._run_session_end(exit_reason)
+
             # Suppress async generator cleanup errors during shutdown
             original_hook = sys.unraisablehook
 
@@ -1025,11 +1289,24 @@ class RichUI:
             try:
                 try:
                     self._run_async(shutdown_mcp_runtime())
+                    self._run_async(shutdown_lsp_manager())
                 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,
+                        type(exc).__name__,
+                        exc,
+                        extra={"session_id": self.session_id},
+                    )
+
+                # Shutdown background shell manager to clean up any background tasks
+                try:
+                    shutdown_background_shell(force=True)
+                except (OSError, RuntimeError) as exc:
+                    logger.debug(
+                        "[ui] Failed to shut down background shell cleanly: %s: %s",
+                        type(exc).__name__,
+                        exc,
                         extra={"session_id": self.session_id},
                     )
             finally:
@@ -1073,15 +1350,47 @@ class RichUI:
         original_messages = list(self.conversation_messages)
         spinner = Spinner(self.console, "Summarizing conversation...", spinner="dots")
 
+        hook_instructions = ""
+        try:
+            hook_result = await hook_manager.run_pre_compact_async(
+                trigger="manual", custom_instructions=custom_instructions
+            )
+            if hook_result.should_block or not hook_result.should_continue:
+                reason = (
+                    hook_result.block_reason
+                    or hook_result.stop_reason
+                    or "Compaction blocked by hook."
+                )
+                self.console.print(f"[yellow]{escape(str(reason))}[/yellow]")
+                return
+            hook_contexts = self._collect_hook_contexts(hook_result)
+            if hook_contexts:
+                hook_instructions = "\n\n".join(hook_contexts)
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] PreCompact hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id},
+            )
+
+        merged_instructions = custom_instructions.strip()
+        if hook_instructions:
+            merged_instructions = (
+                f"{merged_instructions}\n\n{hook_instructions}".strip()
+                if merged_instructions
+                else hook_instructions
+            )
         try:
             spinner.start()
             result = await compact_conversation(
                 self.conversation_messages,
-                custom_instructions,
+                merged_instructions,
                 protocol=protocol,
             )
         except Exception as exc:
             import traceback
+
             self.console.print(f"[red]Error during compaction: {escape(str(exc))}[/red]")
             self.console.print(f"[dim red]{traceback.format_exc()}[/dim red]")
             return
@@ -1095,6 +1404,7 @@ class RichUI:
                 f"[green]✓ Conversation compacted[/green] "
                 f"(saved ~{result.tokens_saved} tokens). Use /resume to restore full history."
             )
+            await self._run_session_start_async("compact")
         elif isinstance(result, CompactionError):
             self.console.print(f"[red]{escape(result.message)}[/red]")
 
@@ -1110,17 +1420,23 @@ def check_onboarding_rich() -> bool:
     if config.has_completed_onboarding:
         return True
 
-    # Use simple console onboarding
-    from ripperdoc.cli.cli import check_onboarding
+    # Use the wizard onboarding
+    from ripperdoc.cli.ui.wizard import check_onboarding
 
     return check_onboarding()
 
 
 def main_rich(
-    safe_mode: bool = False,
+    yolo_mode: bool = False,
     verbose: bool = False,
+    show_full_thinking: Optional[bool] = None,
     session_id: Optional[str] = None,
     log_file_path: Optional[Path] = None,
+    allowed_tools: Optional[List[str]] = None,
+    custom_system_prompt: Optional[str] = None,
+    append_system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    resume_messages: Optional[List[Any]] = None,
 ) -> None:
     """Main entry point for Rich interface."""
 
@@ -1130,10 +1446,16 @@ def main_rich(
 
     # Run the Rich UI
     ui = RichUI(
-        safe_mode=safe_mode,
+        yolo_mode=yolo_mode,
         verbose=verbose,
+        show_full_thinking=show_full_thinking,
         session_id=session_id,
         log_file_path=log_file_path,
+        allowed_tools=allowed_tools,
+        custom_system_prompt=custom_system_prompt,
+        append_system_prompt=append_system_prompt,
+        model=model,
+        resume_messages=resume_messages,
     )
     ui.run()