code-puppy 0.0.323__py3-none-any.whl → 0.0.335__py3-none-any.whl

code_puppy/agents/base_agent.py

@@ -4,7 +4,6 @@ import asyncio
 import json
 import math
 import signal
-import sys
 import threading
 import uuid
 from abc import ABC, abstractmethod
@@ -1340,15 +1339,19 @@ class BaseAgent(ABC):
     ) -> None:
         """Handle streaming events from the agent run.
 
-        This method processes streaming events and emits TextPart and ThinkingPart
-        content with styled banners as they stream in.
+        This method processes streaming events and emits TextPart, ThinkingPart,
+        and ToolCallPart content with styled banners/tokens as they stream in.
 
         Args:
             ctx: The run context.
             events: Async iterable of streaming events (PartStartEvent, PartDeltaEvent, etc.).
         """
         from pydantic_ai import PartDeltaEvent, PartStartEvent
-        from pydantic_ai.messages import TextPartDelta, ThinkingPartDelta
+        from pydantic_ai.messages import (
+            TextPartDelta,
+            ThinkingPartDelta,
+            ToolCallPartDelta,
+        )
         from rich.console import Console
         from rich.markdown import Markdown
         from rich.markup import escape
@@ -1364,29 +1367,29 @@ class BaseAgent(ABC):
             # Fallback if console not set (shouldn't happen in normal use)
             console = Console()
 
-        # Track which part indices we're currently streaming (for Text/Thinking parts)
+        # Track which part indices we're currently streaming (for Text/Thinking/Tool parts)
         streaming_parts: set[int] = set()
         thinking_parts: set[int] = (
             set()
         )  # Track which parts are thinking (for dim style)
         text_parts: set[int] = set()  # Track which parts are text
+        tool_parts: set[int] = set()  # Track which parts are tool calls
         banner_printed: set[int] = set()  # Track if banner was already printed
         text_buffer: dict[int, list[str]] = {}  # Buffer text for final markdown render
-        token_count: dict[int, int] = {}  # Track token count per text part
+        token_count: dict[int, int] = {}  # Track token count per text/tool part
         did_stream_anything = False  # Track if we streamed any content
 
         def _print_thinking_banner() -> None:
             """Print the THINKING banner with spinner pause and line clear."""
             nonlocal did_stream_anything
-            import sys
             import time
 
             from code_puppy.config import get_banner_color
 
             pause_all_spinners()
             time.sleep(0.1)  # Delay to let spinner fully clear
-            sys.stdout.write("\r\x1b[K")  # Clear line
-            sys.stdout.flush()
+            # Clear line and print newline before banner
+            console.print(" " * 50, end="\r")
             console.print()  # Newline before banner
             # Bold banner with configurable color and lightning bolt
             thinking_color = get_banner_color("thinking")
@@ -1396,21 +1399,19 @@ class BaseAgent(ABC):
                 ),
                 end="",
             )
-            sys.stdout.flush()
             did_stream_anything = True
 
         def _print_response_banner() -> None:
             """Print the AGENT RESPONSE banner with spinner pause and line clear."""
             nonlocal did_stream_anything
-            import sys
             import time
 
             from code_puppy.config import get_banner_color
 
             pause_all_spinners()
             time.sleep(0.1)  # Delay to let spinner fully clear
-            sys.stdout.write("\r\x1b[K")  # Clear line
-            sys.stdout.flush()
+            # Clear line and print newline before banner
+            console.print(" " * 50, end="\r")
             console.print()  # Newline before banner
             response_color = get_banner_color("agent_response")
             console.print(
@@ -1418,7 +1419,6 @@ class BaseAgent(ABC):
                     f"[bold white on {response_color}] AGENT RESPONSE [/bold white on {response_color}]"
                 )
             )
-            sys.stdout.flush()
             did_stream_anything = True
 
         async for event in events:
@@ -1442,7 +1442,16 @@ class BaseAgent(ABC):
                     # Buffer initial content if present
                     if part.content and part.content.strip():
                         text_buffer[event.index].append(part.content)
+                        # Count chunks (each part counts as 1)
                         token_count[event.index] += 1
+                elif isinstance(part, ToolCallPart):
+                    streaming_parts.add(event.index)
+                    tool_parts.add(event.index)
+                    token_count[event.index] = 0  # Initialize token counter
+                    # Track tool name for display
+                    banner_printed.add(
+                        event.index
+                    )  # Use banner_printed to track if we've shown tool info
 
             # PartDeltaEvent - stream the content as it arrives
             elif isinstance(event, PartDeltaEvent):
@@ -1452,21 +1461,20 @@ class BaseAgent(ABC):
                         if delta.content_delta:
                             # For text parts, show token counter then render at end
                             if event.index in text_parts:
-                                import sys
-
                                 # Print banner on first content
                                 if event.index not in banner_printed:
                                     _print_response_banner()
                                     banner_printed.add(event.index)
                                 # Accumulate text for final markdown render
                                 text_buffer[event.index].append(delta.content_delta)
+                                # Count chunks received
                                 token_count[event.index] += 1
-                                # Update token counter in place (single line)
+                                # Update chunk counter in place (single line)
                                 count = token_count[event.index]
-                                sys.stdout.write(
-                                    f"\r\x1b[K  ⏳ Receiving... {count} tokens"
+                                console.print(
+                                    f"  ⏳ Receiving... {count} chunks   ",
+                                    end="\r",
                                 )
-                                sys.stdout.flush()
                             else:
                                 # For thinking parts, stream immediately (dim)
                                 if event.index not in banner_printed:
@@ -1474,17 +1482,31 @@ class BaseAgent(ABC):
                                     banner_printed.add(event.index)
                                 escaped = escape(delta.content_delta)
                                 console.print(f"[dim]{escaped}[/dim]", end="")
+                    elif isinstance(delta, ToolCallPartDelta):
+                        # For tool calls, count chunks received
+                        token_count[event.index] += 1
+                        # Get tool name if available
+                        tool_name = getattr(delta, "tool_name_delta", "")
+                        count = token_count[event.index]
+                        # Display with tool wrench icon and tool name
+                        if tool_name:
+                            console.print(
+                                f"  🔧 Calling {tool_name}... {count} chunks   ",
+                                end="\r",
+                            )
+                        else:
+                            console.print(
+                                f"  🔧 Calling tool... {count} chunks   ",
+                                end="\r",
+                            )
 
             # PartEndEvent - finish the streaming with a newline
             elif isinstance(event, PartEndEvent):
                 if event.index in streaming_parts:
                     # For text parts, clear counter line and render markdown
                     if event.index in text_parts:
-                        import sys
-
-                        # Clear the token counter line
-                        sys.stdout.write("\r\x1b[K")
-                        sys.stdout.flush()
+                        # Clear the chunk counter line by printing spaces and returning
+                        console.print(" " * 50, end="\r")
                         # Render the final markdown nicely
                         if event.index in text_buffer:
                             try:
@@ -1494,24 +1516,30 @@ class BaseAgent(ABC):
                             except Exception:
                                 pass
                             del text_buffer[event.index]
-                        # Clean up token count
-                        token_count.pop(event.index, None)
+                    # For tool parts, clear the chunk counter line
+                    elif event.index in tool_parts:
+                        # Clear the chunk counter line by printing spaces and returning
+                        console.print(" " * 50, end="\r")
                     # For thinking parts, just print newline
                     elif event.index in banner_printed:
                         console.print()  # Final newline after streaming
+
+                    # Clean up token count
+                    token_count.pop(event.index, None)
                     # Clean up all tracking sets
                     streaming_parts.discard(event.index)
                     thinking_parts.discard(event.index)
                     text_parts.discard(event.index)
+                    tool_parts.discard(event.index)
                     banner_printed.discard(event.index)
 
-                    # Resume spinner if next part is NOT text/thinking (avoid race condition)
-                    # If next part is a tool call or None, it's safe to resume
+                    # Resume spinner if next part is NOT text/thinking/tool (avoid race condition)
+                    # If next part is None or handled differently, it's safe to resume
                     # Note: spinner itself handles blank line before appearing
                     from code_puppy.messaging.spinner import resume_all_spinners
 
                     next_kind = getattr(event, "next_part_kind", None)
-                    if next_kind not in ("text", "thinking"):
+                    if next_kind not in ("text", "thinking", "tool-call"):
                         resume_all_spinners()
 
         # Spinner is resumed in PartEndEvent when appropriate (based on next_part_kind)
@@ -1910,73 +1938,35 @@ class BaseAgent(ABC):
         def graceful_sigint_handler(_sig, _frame):
             # When using keyboard-based cancel, SIGINT should be a no-op
             # (just show a hint to user about the configured cancel key)
+            # Also reset terminal to prevent bricking on Windows+uvx
             from code_puppy.keymap import get_cancel_agent_display_name
-            import sys
+            from code_puppy.terminal_utils import reset_windows_terminal_full
+
+            # Reset terminal state first to prevent bricking
+            reset_windows_terminal_full()
 
             cancel_key = get_cancel_agent_display_name()
-            if sys.platform == "win32":
-                # On Windows, we use keyboard listener, so SIGINT might still fire
-                # but we handle cancellation via the key listener
-                pass  # Silent on Windows - the key listener handles it
-            else:
-                emit_info(f"Use {cancel_key} to cancel the agent task.")
+            emit_info(f"Use {cancel_key} to cancel the agent task.")
 
         original_handler = None
         key_listener_stop_event = None
         _key_listener_thread = None
-        _windows_ctrl_handler = None  # Store reference to prevent garbage collection
 
         try:
-            if sys.platform == "win32":
-                # Windows: Use SetConsoleCtrlHandler for reliable Ctrl+C handling
-                import ctypes
-
-                # Define the handler function type
-                HANDLER_ROUTINE = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_ulong)
-
-                def windows_ctrl_handler(ctrl_type):
-                    """Handle Windows console control events."""
-                    CTRL_C_EVENT = 0
-                    CTRL_BREAK_EVENT = 1
-
-                    if ctrl_type in (CTRL_C_EVENT, CTRL_BREAK_EVENT):
-                        # Check if we're awaiting user input
-                        if is_awaiting_user_input():
-                            return False  # Let default handler run
-
-                        # Schedule agent cancellation
-                        schedule_agent_cancel()
-                        return True  # We handled it, don't terminate
-
-                    return False  # Let other handlers process it
-
-                # Create the callback - must keep reference alive!
-                _windows_ctrl_handler = HANDLER_ROUTINE(windows_ctrl_handler)
-
-                # Register the handler
-                kernel32 = ctypes.windll.kernel32
-                if not kernel32.SetConsoleCtrlHandler(_windows_ctrl_handler, True):
-                    emit_warning("Failed to set Windows Ctrl+C handler")
-
-                # Also spawn keyboard listener for Ctrl+X (shell cancel) and other keys
-                key_listener_stop_event = threading.Event()
-                _key_listener_thread = self._spawn_ctrl_x_key_listener(
-                    key_listener_stop_event,
-                    on_escape=lambda: None,  # Ctrl+X handled by command_runner
-                    on_cancel_agent=None,  # Ctrl+C handled by SetConsoleCtrlHandler above
-                )
-            elif cancel_agent_uses_signal():
-                # Unix with Ctrl+C: Use SIGINT-based cancellation
+            if cancel_agent_uses_signal():
+                # Use SIGINT-based cancellation (default Ctrl+C behavior)
                 original_handler = signal.signal(
                     signal.SIGINT, keyboard_interrupt_handler
                 )
             else:
-                # Unix with different cancel key: Use keyboard listener
+                # Use keyboard listener for agent cancellation
+                # Set a graceful SIGINT handler that shows a hint
                 original_handler = signal.signal(signal.SIGINT, graceful_sigint_handler)
+                # Spawn keyboard listener with the cancel agent callback
                 key_listener_stop_event = threading.Event()
                 _key_listener_thread = self._spawn_ctrl_x_key_listener(
                     key_listener_stop_event,
-                    on_escape=lambda: None,
+                    on_escape=lambda: None,  # Ctrl+X handled by command_runner
                     on_cancel_agent=schedule_agent_cancel,
                 )
 
@@ -2001,17 +1991,8 @@ class BaseAgent(ABC):
             # Stop keyboard listener if it was started
             if key_listener_stop_event is not None:
                 key_listener_stop_event.set()
-
-            # Unregister Windows Ctrl handler
-            if sys.platform == "win32" and _windows_ctrl_handler is not None:
-                try:
-                    import ctypes
-
-                    kernel32 = ctypes.windll.kernel32
-                    kernel32.SetConsoleCtrlHandler(_windows_ctrl_handler, False)
-                except Exception:
-                    pass  # Best effort cleanup
-
-            # Restore original signal handler (Unix)
-            if original_handler is not None:
+            # Restore original signal handler
+            if (
+                original_handler is not None
+            ):  # Explicit None check - SIG_DFL can be 0/falsy!
                 signal.signal(signal.SIGINT, original_handler)

code_puppy/cli_runner.py

@@ -171,6 +171,45 @@ async def main():
         emit_error(str(e))
         sys.exit(1)
 
+    # Show uvx detection notice if we're on Windows + uvx
+    # Also disable Ctrl+C at the console level to prevent terminal bricking
+    try:
+        from code_puppy.uvx_detection import should_use_alternate_cancel_key
+
+        if should_use_alternate_cancel_key():
+            from code_puppy.terminal_utils import (
+                disable_windows_ctrl_c,
+                set_keep_ctrl_c_disabled,
+            )
+
+            # Disable Ctrl+C at the console input level
+            # This prevents Ctrl+C from being processed as a signal at all
+            disable_windows_ctrl_c()
+
+            # Set flag to keep it disabled (prompt_toolkit may re-enable it)
+            set_keep_ctrl_c_disabled(True)
+
+            # Use print directly - emit_system_message can get cleared by ANSI codes
+            print(
+                "🔧 Detected uvx launch on Windows - using Ctrl+K for cancellation "
+                "(Ctrl+C is disabled to prevent terminal issues)"
+            )
+
+            # Also install a SIGINT handler as backup
+            import signal
+
+            from code_puppy.terminal_utils import reset_windows_terminal_full
+
+            def _uvx_protective_sigint_handler(_sig, _frame):
+                """Protective SIGINT handler for Windows+uvx."""
+                reset_windows_terminal_full()
+                # Re-disable Ctrl+C in case something re-enabled it
+                disable_windows_ctrl_c()
+
+            signal.signal(signal.SIGINT, _uvx_protective_sigint_handler)
+    except ImportError:
+        pass  # uvx_detection module not available, ignore
+
     # Load API keys from puppy.cfg into environment variables
     from code_puppy.config import load_api_keys_to_environment
 
@@ -325,6 +364,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
     emit_system_message(
         "Use /diff to configure diff highlighting colors for file changes."
     )
+    emit_system_message("To re-run the tutorial, use /tutorial.")
     try:
         from code_puppy.command_line.motd import print_motd
 
@@ -417,6 +457,45 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
     # Autosave loading is now manual - use /autosave_load command
 
+    # Auto-run tutorial on first startup
+    try:
+        from code_puppy.command_line.onboarding_wizard import should_show_onboarding
+
+        if should_show_onboarding():
+            import asyncio
+            import concurrent.futures
+
+            from code_puppy.command_line.onboarding_wizard import run_onboarding_wizard
+            from code_puppy.config import set_model_name
+            from code_puppy.messaging import emit_info
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(lambda: asyncio.run(run_onboarding_wizard()))
+                result = future.result(timeout=300)
+
+            if result == "chatgpt":
+                emit_info("🔐 Starting ChatGPT OAuth flow...")
+                from code_puppy.plugins.chatgpt_oauth.oauth_flow import run_oauth_flow
+
+                run_oauth_flow()
+                set_model_name("chatgpt-gpt-5.2-codex")
+            elif result == "claude":
+                emit_info("🔐 Starting Claude Code OAuth flow...")
+                from code_puppy.plugins.claude_code_oauth.register_callbacks import (
+                    _perform_authentication,
+                )
+
+                _perform_authentication()
+                set_model_name("claude-code-claude-opus-4-5-20251101")
+            elif result == "completed":
+                emit_info("🎉 Tutorial complete! Happy coding!")
+            elif result == "skipped":
+                emit_info("⏭️ Tutorial skipped. Run /tutorial anytime!")
+    except Exception as e:
+        from code_puppy.messaging import emit_warning
+
+        emit_warning(f"Tutorial auto-start failed: {e}")
+
     # Track the current agent task for cancellation on quit
     current_agent_task = None
 
@@ -440,6 +519,15 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 task = await get_input_with_combined_completion(
                     get_prompt_with_active_model(), history_file=COMMAND_HISTORY_FILE
                 )
+
+                # Windows+uvx: Re-disable Ctrl+C after prompt_toolkit
+                # (prompt_toolkit restores console mode which re-enables Ctrl+C)
+                try:
+                    from code_puppy.terminal_utils import ensure_ctrl_c_disabled
+
+                    ensure_ctrl_c_disabled()
+                except ImportError:
+                    pass
             except ImportError:
                 # Fall back to basic input if prompt_toolkit is not available
                 task = input(">>> ")
@@ -605,6 +693,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 if result is None:
                     # Windows-specific: Reset terminal state after cancellation
                     reset_windows_terminal_ansi()
+                    # Re-disable Ctrl+C if needed (uvx mode)
+                    try:
+                        from code_puppy.terminal_utils import ensure_ctrl_c_disabled
+
+                        ensure_ctrl_c_disabled()
+                    except ImportError:
+                        pass
                     continue
                 # Get the structured response
                 agent_response = result.output
@@ -645,6 +740,15 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
             auto_save_session_if_enabled()
 
+            # Re-disable Ctrl+C if needed (uvx mode) - must be done after
+            # each iteration as various operations may restore console mode
+            try:
+                from code_puppy.terminal_utils import ensure_ctrl_c_disabled
+
+                ensure_ctrl_c_disabled()
+            except ImportError:
+                pass
+
 
 def prettier_code_blocks():
     """Configure Rich to use prettier code block rendering."""
@@ -790,6 +894,5 @@ def main_entry():
             DBOS.destroy()
         return 0
     finally:
-        # Reset terminal on all platforms for clean state
-        reset_windows_terminal_full()  # Safe no-op on non-Windows
+        # Reset terminal on Unix-like systems (not Windows)
         reset_unix_terminal()

code_puppy/command_line/add_model_menu.py

@@ -571,6 +571,7 @@ class AddModelMenu:
             "cerebras": "cerebras",
             "cohere": "custom_openai",
             "perplexity": "custom_openai",
+            "minimax": "custom_anthropic",
         }
 
         # Determine the model type
@@ -600,6 +601,16 @@ class AddModelMenu:
                 api_key_env = f"${provider.env[0]}" if provider.env else "$API_KEY"
                 config["custom_endpoint"] = {"url": api_url, "api_key": api_key_env}
 
+        # Special handling for minimax: uses custom_anthropic but needs custom_endpoint
+        # and the URL needs /v1 stripped (comes as https://api.minimax.io/anthropic/v1)
+        if provider.id == "minimax" and provider.api:
+            api_url = provider.api
+            # Strip /v1 suffix if present
+            if api_url.endswith("/v1"):
+                api_url = api_url[:-3]
+            api_key_env = f"${provider.env[0]}" if provider.env else "$API_KEY"
+            config["custom_endpoint"] = {"url": api_url, "api_key": api_key_env}
+
         # Add context length if available
         if model.context_length and model.context_length > 0:
             config["context_length"] = model.context_length
@@ -984,6 +995,10 @@ class AddModelMenu:
             # Reset awaiting input flag
             set_awaiting_user_input(False)
 
+        # Clear exit message (unless we're about to prompt for more input)
+        if self.result not in ("pending_credentials", "pending_custom_model"):
+            emit_info("✓ Exited model browser")
+
         # Handle unsupported provider
         if self.result == "unsupported" and self.current_provider:
             reason = UNSUPPORTED_PROVIDERS.get(

code_puppy/command_line/autosave_menu.py

@@ -603,4 +603,9 @@ async def interactive_autosave_picker() -> Optional[str]:
         # Reset awaiting input flag
         set_awaiting_user_input(False)
 
+    # Clear exit message
+    from code_puppy.messaging import emit_info
+
+    emit_info("✓ Exited session browser")
+
     return result[0]

code_puppy/command_line/colors_menu.py

@@ -230,6 +230,11 @@ async def interactive_colors_picker() -> Optional[dict]:
         sys.stdout.write("\033[?1049l")  # Exit alternate buffer
         sys.stdout.flush()
 
+    # Clear exit message
+    from code_puppy.messaging import emit_info
+
+    emit_info("✓ Exited banner color configuration")
+
     # Return changes if any
     if config.has_changes():
         return config.current_colors

code_puppy/command_line/config_commands.py

@@ -46,6 +46,7 @@ def handle_show_command(command: str) -> bool:
         get_use_dbos,
         get_yolo_mode,
     )
+    from code_puppy.keymap import get_cancel_agent_display_name
     from code_puppy.messaging import emit_info
 
     puppy_name = get_puppy_name()
@@ -79,6 +80,7 @@ def handle_show_command(command: str) -> bool:
 [bold]reasoning_effort:[/bold]      [cyan]{get_openai_reasoning_effort()}[/cyan]
 [bold]verbosity:[/bold]             [cyan]{get_openai_verbosity()}[/cyan]
 [bold]temperature:[/bold]           [cyan]{effective_temperature if effective_temperature is not None else "(model default)"}[/cyan]{" (per-model)" if effective_temperature != global_temperature and effective_temperature is not None else ""}
+[bold]cancel_agent_key:[/bold]      [cyan]{get_cancel_agent_display_name()}[/cyan] (options: ctrl+c, ctrl+k, ctrl+q)
 
 """
     emit_info(Text.from_markup(status_msg))
@@ -200,9 +202,13 @@ def handle_set_command(command: str) -> bool:
             "\n[yellow]Session Management[/yellow]"
             "\n  [cyan]auto_save_session[/cyan]    Auto-save chat after every response (true/false)"
         )
+        keymap_help = (
+            "\n[yellow]Keyboard Shortcuts[/yellow]"
+            "\n  [cyan]cancel_agent_key[/cyan]     Key to cancel agent tasks (ctrl+c, ctrl+k, or ctrl+q)"
+        )
         emit_warning(
             Text.from_markup(
-                f"Usage: /set KEY=VALUE or /set KEY VALUE\nConfig keys: {', '.join(config_keys)}\n[dim]Note: compaction_strategy can be 'summarization' or 'truncation'[/dim]{session_help}"
+                f"Usage: /set KEY=VALUE or /set KEY VALUE\nConfig keys: {', '.join(config_keys)}\n[dim]Note: compaction_strategy can be 'summarization' or 'truncation'[/dim]{session_help}{keymap_help}"
             )
         )
         return True
@@ -215,6 +221,23 @@ def handle_set_command(command: str) -> bool:
                 )
             )
 
+        # Validate cancel_agent_key before setting
+        if key == "cancel_agent_key":
+            from code_puppy.keymap import VALID_CANCEL_KEYS
+
+            normalized_value = value.strip().lower()
+            if normalized_value not in VALID_CANCEL_KEYS:
+                emit_error(
+                    f"Invalid cancel_agent_key '{value}'. Valid options: {', '.join(sorted(VALID_CANCEL_KEYS))}"
+                )
+                return True
+            value = normalized_value  # Use normalized value
+            emit_info(
+                Text.from_markup(
+                    "[yellow]⚠️ cancel_agent_key changed. Please restart Code Puppy for this change to take effect.[/yellow]"
+                )
+            )
+
         set_config_value(key, value)
         emit_success(f'Set {key} = "{value}" in puppy.cfg!')
 

code_puppy/command_line/core_commands.py

@@ -115,6 +115,57 @@ def handle_motd_command(command: str) -> bool:
     return True
 
 
+@register_command(
+    name="tutorial",
+    description="Run the interactive tutorial wizard",
+    usage="/tutorial",
+    category="core",
+)
+def handle_tutorial_command(command: str) -> bool:
+    """Run the interactive tutorial wizard.
+
+    Usage:
+        /tutorial  - Run the tutorial (can be run anytime)
+    """
+    import asyncio
+    import concurrent.futures
+
+    from code_puppy.command_line.onboarding_wizard import (
+        reset_onboarding,
+        run_onboarding_wizard,
+    )
+    from code_puppy.config import set_model_name
+
+    # Always reset so user can re-run the tutorial anytime
+    reset_onboarding()
+
+    # Run the async wizard in a thread pool (same pattern as agent picker)
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        future = executor.submit(lambda: asyncio.run(run_onboarding_wizard()))
+        result = future.result(timeout=300)  # 5 min timeout
+
+    if result == "chatgpt":
+        emit_info("🔐 Starting ChatGPT OAuth flow...")
+        from code_puppy.plugins.chatgpt_oauth.oauth_flow import run_oauth_flow
+
+        run_oauth_flow()
+        set_model_name("chatgpt-gpt-5.2-codex")
+    elif result == "claude":
+        emit_info("🔐 Starting Claude Code OAuth flow...")
+        from code_puppy.plugins.claude_code_oauth.register_callbacks import (
+            _perform_authentication,
+        )
+
+        _perform_authentication()
+        set_model_name("claude-code-claude-opus-4-5-20251101")
+    elif result == "completed":
+        emit_info("🎉 Tutorial complete! Happy coding!")
+    elif result == "skipped":
+        emit_info("⏭️ Tutorial skipped. Run /tutorial anytime!")
+
+    return True
+
+
 @register_command(
     name="exit",
     description="Exit interactive mode",

code_puppy/command_line/diff_menu.py

@@ -456,6 +456,11 @@ async def interactive_diff_picker() -> Optional[dict]:
         sys.stdout.write("\033[?1049l")  # Exit alternate buffer
         sys.stdout.flush()
 
+    # Clear exit message
+    from code_puppy.messaging import emit_info
+
+    emit_info("✓ Exited diff color configuration")
+
     # Return changes if any
     if config.has_changes():
         return {

code_puppy/command_line/mcp/custom_server_form.py

@@ -604,6 +604,10 @@ class CustomServerForm:
             sys.stdout.flush()
             set_awaiting_user_input(False)
 
+        # Clear exit message if not installing
+        if self.result != "installed":
+            emit_info("✓ Exited custom server form")
+
         # Handle result
         if self.result == "installed":
             if self.edit_mode: