shotgun-sh 0.2.11.dev7__py3-none-any.whl → 0.2.23.dev1__py3-none-any.whl

shotgun/tui/screens/chat/chat_screen.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+import time
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import cast
@@ -11,6 +12,7 @@ from pydantic_ai.messages import (
     ModelRequest,
     ModelResponse,
     TextPart,
+    ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
 )
@@ -42,12 +44,17 @@ from shotgun.agents.models import (
     AgentType,
     FileOperationTracker,
 )
+from shotgun.agents.runner import AgentRunner
 from shotgun.codebase.core.manager import (
     CodebaseAlreadyIndexedError,
     CodebaseGraphManager,
 )
 from shotgun.codebase.models import IndexProgress, ProgressPhase
-from shotgun.exceptions import ContextSizeLimitExceeded
+from shotgun.exceptions import (
+    SHOTGUN_CONTACT_EMAIL,
+    ErrorNotPickedUpBySentry,
+    ShotgunAccountException,
+)
 from shotgun.posthog_telemetry import track_event
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
@@ -57,6 +64,8 @@ from shotgun.tui.components.mode_indicator import ModeIndicator
 from shotgun.tui.components.prompt_input import PromptInput
 from shotgun.tui.components.spinner import Spinner
 from shotgun.tui.components.status_bar import StatusBar
+
+# TUIErrorHandler removed - exceptions now caught directly
 from shotgun.tui.screens.chat.codebase_index_prompt_screen import (
     CodebaseIndexPromptScreen,
 )
@@ -102,7 +111,6 @@ class ChatScreen(Screen[None]):
     history: PromptHistory = PromptHistory()
     messages = reactive(list[ModelMessage | HintMessage]())
     indexing_job: reactive[CodebaseIndexSelection | None] = reactive(None)
-    partial_message: reactive[ModelMessage | None] = reactive(None)
 
     # Q&A mode state (for structured output clarifying questions)
     qa_mode = reactive(False)
@@ -113,6 +121,10 @@ class ChatScreen(Screen[None]):
     # Working state - keep reactive for Textual watchers
     working = reactive(False)
 
+    # Throttle context indicator updates (in seconds)
+    _last_context_update: float = 0.0
+    _context_update_throttle: float = 5.0  # 5 seconds
+
     def __init__(
         self,
         agent_manager: AgentManager,
@@ -279,10 +291,8 @@ class ChatScreen(Screen[None]):
     def action_toggle_mode(self) -> None:
         # Prevent mode switching during Q&A
         if self.qa_mode:
-            self.notify(
-                "Cannot switch modes while answering questions",
-                severity="warning",
-                timeout=3,
+            self.agent_manager.add_hint_message(
+                HintMessage(message="⚠️ Cannot switch modes while answering questions")
             )
             return
 
@@ -298,20 +308,90 @@ class ChatScreen(Screen[None]):
         # Re-focus input after mode change
         self.call_later(lambda: self.widget_coordinator.update_prompt_input(focus=True))
 
-    def action_show_usage(self) -> None:
+    async def action_show_usage(self) -> None:
         usage_hint = self.agent_manager.get_usage_hint()
         logger.info(f"Usage hint: {usage_hint}")
+
+        # Add budget info for Shotgun Account users
+        if self.deps.llm_model.is_shotgun_account:
+            try:
+                from shotgun.llm_proxy import LiteLLMProxyClient
+
+                logger.debug("Fetching budget info for Shotgun Account")
+                client = LiteLLMProxyClient(self.deps.llm_model.api_key)
+                budget_info = await client.get_budget_info()
+
+                # Format budget section
+                source_label = "Key" if budget_info.source == "key" else "Team"
+                budget_section = f"""## Shotgun Account Budget
+
+* Max Budget:     ${budget_info.max_budget:.2f}
+* Current Spend:  ${budget_info.spend:.2f}
+* Remaining:      ${budget_info.remaining:.2f} ({100 - budget_info.percentage_used:.1f}%)
+* Budget Source:  {source_label}-level
+
+**Questions or need help?**"""
+
+                # Build markdown_before (usage + budget info before email)
+                if usage_hint:
+                    markdown_before = f"{usage_hint}\n\n{budget_section}"
+                else:
+                    markdown_before = budget_section
+
+                markdown_after = (
+                    "\n\n_Reach out anytime for billing questions "
+                    "or to increase your budget._"
+                )
+
+                # Mount with email copy button
+                self.mount_hint_with_email(
+                    markdown_before=markdown_before,
+                    email="contact@shotgun.sh",
+                    markdown_after=markdown_after,
+                )
+                logger.debug("Successfully added budget info to usage hint")
+                return  # Exit early since we've already mounted
+
+            except Exception as e:
+                logger.warning(f"Failed to fetch budget info: {e}")
+                # For Shotgun Account, show budget fetch error
+                # If we have usage data, still show it
+                if usage_hint:
+                    # Show usage even though budget fetch failed
+                    self.mount_hint(usage_hint)
+                else:
+                    # No usage and budget fetch failed - show specific error with email
+                    markdown_before = (
+                        "⚠️ **Unable to fetch budget information**\n\n"
+                        "There was an error retrieving your budget data."
+                    )
+                    markdown_after = (
+                        "\n\n_Try the command again in a moment. "
+                        "If the issue persists, reach out for help._"
+                    )
+                    self.mount_hint_with_email(
+                        markdown_before=markdown_before,
+                        email="contact@shotgun.sh",
+                        markdown_after=markdown_after,
+                    )
+                return  # Exit early
+
+        # Fallback for non-Shotgun Account users
         if usage_hint:
             self.mount_hint(usage_hint)
         else:
-            self.notify("No usage hint available", severity="error")
+            self.agent_manager.add_hint_message(
+                HintMessage(message="⚠️ No usage hint available")
+            )
 
     async def action_show_context(self) -> None:
         context_hint = await self.agent_manager.get_context_hint()
         if context_hint:
             self.mount_hint(context_hint)
         else:
-            self.notify("No context analysis available", severity="error")
+            self.agent_manager.add_hint_message(
+                HintMessage(message="⚠️ No context analysis available")
+            )
 
     def action_view_onboarding(self) -> None:
         """Show the onboarding modal."""
@@ -436,7 +516,9 @@ class ChatScreen(Screen[None]):
 
         except Exception as e:
             logger.error(f"Failed to compact conversation: {e}", exc_info=True)
-            self.notify(f"Failed to compact: {e}", severity="error")
+            self.agent_manager.add_hint_message(
+                HintMessage(message=f"❌ Failed to compact: {e}")
+            )
         finally:
             # Hide spinner
             self.processing_state.stop_processing()
@@ -484,7 +566,9 @@ class ChatScreen(Screen[None]):
 
         except Exception as e:
             logger.error(f"Failed to clear conversation: {e}", exc_info=True)
-            self.notify(f"Failed to clear: {e}", severity="error")
+            self.agent_manager.add_hint_message(
+                HintMessage(message=f"❌ Failed to clear: {e}")
+            )
 
     @work(exclusive=False)
     async def update_context_indicator(self) -> None:
@@ -571,10 +655,23 @@ class ChatScreen(Screen[None]):
         hint = HintMessage(message=markdown)
         self.agent_manager.add_hint_message(hint)
 
+    def mount_hint_with_email(
+        self, markdown_before: str, email: str, markdown_after: str = ""
+    ) -> None:
+        """Mount a hint with inline email copy button.
+
+        Args:
+            markdown_before: Markdown content to display before the email line
+            email: Email address to display with copy button
+            markdown_after: Optional markdown content to display after the email line
+        """
+        hint = HintMessage(
+            message=markdown_before, email=email, markdown_after=markdown_after
+        )
+        self.agent_manager.add_hint_message(hint)
+
     @on(PartialResponseMessage)
     def handle_partial_response(self, event: PartialResponseMessage) -> None:
-        self.partial_message = event.message
-
         # Filter event.messages to exclude ModelRequest with only ToolReturnPart
         # These are intermediate tool results that would render as empty (UserQuestionWidget
         # filters out ToolReturnPart in format_prompt_parts), causing user messages to disappear
@@ -598,16 +695,33 @@ class ChatScreen(Screen[None]):
         )
 
         # Use widget coordinator to set partial response
-        self.widget_coordinator.set_partial_response(
-            self.partial_message, new_message_list
+        self.widget_coordinator.set_partial_response(event.message, new_message_list)
+
+        # Skip context updates for file write operations (they don't add to input context)
+        has_file_write = any(
+            isinstance(msg, ModelResponse)
+            and any(
+                isinstance(part, ToolCallPart)
+                and part.tool_name in ("write_file", "append_file")
+                for part in msg.parts
+            )
+            for msg in event.messages
         )
 
-        # Update context indicator with full message history including streaming messages
-        # Combine existing agent history with new streaming messages for accurate token count
-        combined_agent_history = self.agent_manager.message_history + event.messages
-        self.update_context_indicator_with_messages(
-            combined_agent_history, new_message_list
-        )
+        if has_file_write:
+            return  # Skip context update for file writes
+
+        # Throttle context indicator updates to improve performance during streaming
+        # Only update at most once per 5 seconds to avoid excessive token calculations
+        current_time = time.time()
+        if current_time - self._last_context_update >= self._context_update_throttle:
+            self._last_context_update = current_time
+            # Update context indicator with full message history including streaming messages
+            # Combine existing agent history with new streaming messages for accurate token count
+            combined_agent_history = self.agent_manager.message_history + event.messages
+            self.update_context_indicator_with_messages(
+                combined_agent_history, new_message_list
+            )
 
     def _clear_partial_response(self) -> None:
         # Use widget coordinator to clear partial response
@@ -742,6 +856,19 @@ class ChatScreen(Screen[None]):
             # Update the agent manager's model configuration
             self.agent_manager.deps.llm_model = result.model_config
 
+            # Reset agents so they get recreated with new model
+            self.agent_manager._agents_initialized = False
+            self.agent_manager._research_agent = None
+            self.agent_manager._plan_agent = None
+            self.agent_manager._tasks_agent = None
+            self.agent_manager._specify_agent = None
+            self.agent_manager._export_agent = None
+            self.agent_manager._research_deps = None
+            self.agent_manager._plan_deps = None
+            self.agent_manager._tasks_deps = None
+            self.agent_manager._specify_deps = None
+            self.agent_manager._export_deps = None
+
             # Get current analysis and update context indicator via coordinator
             analysis = await self.agent_manager.get_context_analysis()
             self.widget_coordinator.update_context_indicator(analysis, result.new_model)
@@ -919,11 +1046,15 @@ class ChatScreen(Screen[None]):
     async def delete_codebase(self, graph_id: str) -> None:
         try:
             await self.codebase_sdk.delete_codebase(graph_id)
-            self.notify(f"Deleted codebase: {graph_id}", severity="information")
+            self.agent_manager.add_hint_message(
+                HintMessage(message=f"✓ Deleted codebase: {graph_id}")
+            )
         except CodebaseNotFoundError as exc:
-            self.notify(str(exc), severity="error")
+            self.agent_manager.add_hint_message(HintMessage(message=f"❌ {exc}"))
         except Exception as exc:  # pragma: no cover - defensive UI path
-            self.notify(f"Failed to delete codebase: {exc}", severity="error")
+            self.agent_manager.add_hint_message(
+                HintMessage(message=f"❌ Failed to delete codebase: {exc}")
+            )
 
     def _is_kuzu_corruption_error(self, exception: Exception) -> bool:
         """Check if error is related to kuzu database corruption.
@@ -1030,9 +1161,10 @@ class ChatScreen(Screen[None]):
                     )
                     cleaned = await manager.cleanup_corrupted_databases()
                     logger.info(f"Cleaned up {len(cleaned)} corrupted database(s)")
-                    self.notify(
-                        f"Retrying indexing after cleanup (attempt {attempt + 1}/{max_retries})...",
-                        severity="information",
+                    self.agent_manager.add_hint_message(
+                        HintMessage(
+                            message=f"🔄 Retrying indexing after cleanup (attempt {attempt + 1}/{max_retries})..."
+                        )
                     )
 
                 # Pass the current working directory as the indexed_from_cwd
@@ -1060,22 +1192,22 @@ class ChatScreen(Screen[None]):
                 logger.info(
                     f"Successfully indexed codebase '{result.name}' (ID: {result.graph_id})"
                 )
-                self.notify(
-                    f"Indexed codebase '{result.name}' (ID: {result.graph_id})",
-                    severity="information",
-                    timeout=8,
+                self.agent_manager.add_hint_message(
+                    HintMessage(
+                        message=f"✓ Indexed codebase '{result.name}' (ID: {result.graph_id})"
+                    )
                 )
                 break  # Success - exit retry loop
 
             except CodebaseAlreadyIndexedError as exc:
                 progress_timer.stop()
                 logger.warning(f"Codebase already indexed: {exc}")
-                self.notify(str(exc), severity="warning")
+                self.agent_manager.add_hint_message(HintMessage(message=f"⚠️ {exc}"))
                 return
             except InvalidPathError as exc:
                 progress_timer.stop()
                 logger.error(f"Invalid path error: {exc}")
-                self.notify(str(exc), severity="error")
+                self.agent_manager.add_hint_message(HintMessage(message=f"❌ {exc}"))
                 return
 
             except Exception as exc:  # pragma: no cover - defensive UI path
@@ -1094,10 +1226,10 @@ class ChatScreen(Screen[None]):
                     f"Failed to index codebase after {attempt + 1} attempts - "
                     f"repo_path: {selection.repo_path}, name: {selection.name}, error: {exc}"
                 )
-                self.notify(
-                    f"Failed to index codebase after {attempt + 1} attempts: {exc}",
-                    severity="error",
-                    timeout=30,  # Keep error visible for 30 seconds
+                self.agent_manager.add_hint_message(
+                    HintMessage(
+                        message=f"❌ Failed to index codebase after {attempt + 1} attempts: {exc}"
+                    )
                 )
                 break
 
@@ -1108,8 +1240,6 @@ class ChatScreen(Screen[None]):
 
     @work
     async def run_agent(self, message: str) -> None:
-        prompt = None
-
         # Start processing with spinner
         from textual.worker import get_current_worker
 
@@ -1119,60 +1249,31 @@ class ChatScreen(Screen[None]):
         # Start context indicator animation immediately
         self.widget_coordinator.set_context_streaming(True)
 
-        prompt = message
-
         try:
-            await self.agent_manager.run(
-                prompt=prompt,
-            )
-        except asyncio.CancelledError:
-            # Handle cancellation gracefully - DO NOT re-raise
-            self.mount_hint("⚠️ Operation cancelled by user")
-        except ContextSizeLimitExceeded as e:
-            # User-friendly error with actionable options
-            hint = (
-                f"⚠️ **Context too large for {e.model_name}**\n\n"
-                f"Your conversation history exceeds this model's limit ({e.max_tokens:,} tokens).\n\n"
-                f"**Choose an action:**\n\n"
-                f"1. Switch to a larger model (`Ctrl+P` → Change Model)\n"
-                f"2. Switch to a larger model, compact (`/compact`), then switch back to {e.model_name}\n"
-                f"3. Clear conversation (`/clear`)\n"
-            )
-
-            self.mount_hint(hint)
-
-            # Log for debugging (won't send to Sentry due to ErrorNotPickedUpBySentry)
-            logger.info(
-                "Context size limit exceeded",
-                extra={
-                    "max_tokens": e.max_tokens,
-                    "model_name": e.model_name,
-                },
-            )
-        except Exception as e:
-            # Log with full stack trace to shotgun.log
-            logger.exception(
-                "Agent run failed",
-                extra={
-                    "agent_mode": self.mode.value,
-                    "error_type": type(e).__name__,
-                },
-            )
-
-            # Determine user-friendly message based on error type
-            error_name = type(e).__name__
-            error_message = str(e)
-
-            if "APIStatusError" in error_name and "overload" in error_message.lower():
-                hint = "⚠️ The AI service is temporarily overloaded. Please wait a moment and try again."
-            elif "APIStatusError" in error_name and "rate" in error_message.lower():
-                hint = "⚠️ Rate limit reached. Please wait before trying again."
-            elif "APIStatusError" in error_name:
-                hint = f"⚠️ AI service error: {error_message}"
+            # Use unified agent runner - exceptions propagate for handling
+            runner = AgentRunner(self.agent_manager)
+            await runner.run(message)
+        except ShotgunAccountException as e:
+            # Shotgun Account errors show contact email UI
+            message_parts = e.to_markdown().split("**Need help?**")
+            if len(message_parts) == 2:
+                markdown_before = message_parts[0] + "**Need help?**"
+                markdown_after = message_parts[1].strip()
+                self.mount_hint_with_email(
+                    markdown_before=markdown_before,
+                    email=SHOTGUN_CONTACT_EMAIL,
+                    markdown_after=markdown_after,
+                )
             else:
-                hint = f"⚠️ An error occurred: {error_message}\n\nCheck logs at ~/.shotgun-sh/logs/shotgun.log"
-
-            self.mount_hint(hint)
+                # Fallback if message format is unexpected
+                self.mount_hint(e.to_markdown())
+        except ErrorNotPickedUpBySentry as e:
+            # All other user-actionable errors - display with markdown
+            self.mount_hint(e.to_markdown())
+        except Exception as e:
+            # Unexpected errors that weren't wrapped (shouldn't happen)
+            logger.exception("Unexpected error in run_agent")
+            self.mount_hint(f"⚠️ An unexpected error occurred: {str(e)}")
         finally:
             self.processing_state.stop_processing()
             # Stop context indicator animation

shotgun/tui/screens/chat/codebase_index_prompt_screen.py

@@ -4,9 +4,11 @@ from pathlib import Path
 
 from textual import on
 from textual.app import ComposeResult
-from textual.containers import Container
+from textual.containers import Container, VerticalScroll
 from textual.screen import ModalScreen
-from textual.widgets import Button, Label, Static
+from textual.widgets import Button, Label, Markdown
+
+from shotgun.utils.file_system_utils import get_shotgun_home
 
 
 class CodebaseIndexPromptScreen(ModalScreen[bool]):
@@ -19,39 +21,88 @@ class CodebaseIndexPromptScreen(ModalScreen[bool]):
         }
 
         CodebaseIndexPromptScreen > #index-prompt-dialog {
-            width: 60%;
-            max-width: 60;
+            width: 80%;
+            max-width: 90;
             height: auto;
+            max-height: 85%;
             border: wide $primary;
             padding: 1 2;
             layout: vertical;
             background: $surface;
+        }
+
+        #index-prompt-title {
+            text-style: bold;
+            color: $text-accent;
+            text-align: center;
+            padding-bottom: 1;
+        }
+
+        #index-prompt-content {
             height: auto;
+            max-height: 1fr;
+        }
+
+        #index-prompt-info {
+            padding: 0 1;
         }
 
         #index-prompt-buttons {
             layout: horizontal;
             align-horizontal: right;
             height: auto;
+            padding-top: 1;
+        }
+
+        #index-prompt-buttons Button {
+            margin: 0 1;
+            min-width: 12;
         }
     """
 
     def compose(self) -> ComposeResult:
+        storage_path = get_shotgun_home() / "codebases"
+        cwd = Path.cwd()
+
+        # Build the markdown content with privacy-first messaging
+        content = f"""
+## 🔒 Your code never leaves your computer
+
+Shotgun will index the codebase at:
+**`{cwd}`**
+_(This is the current working directory where you started Shotgun)_
+
+### What happens during indexing:
+
+- **Stays on your computer**: Index is stored locally at `{storage_path}` - it will not be stored on a server
+- **Zero cost**: Indexing runs entirely on your machine
+- **Runs in the background**: Usually takes 1-3 minutes, and you can continue using Shotgun while it indexes
+- **Enable code understanding**: Allows Shotgun to answer questions about your codebase
+
+---
+
+If you're curious, you can review how Shotgun indexes/queries code by taking a look at the [source code](https://github.com/shotgun-sh/shotgun).
+
+We take your privacy seriously. You can read our full [privacy policy](https://app.shotgun.sh/privacy) for more details.
+"""
+
         with Container(id="index-prompt-dialog"):
-            yield Label("Index this codebase?", id="index-prompt-title")
-            yield Static(
-                f"Would you like to index the codebase at:\n{Path.cwd()}\n\n"
-                "This is required for the agent to understand your code and answer "
-                "questions about it. Without indexing, the agent cannot analyze "
-                "your codebase."
+            yield Label(
+                "Want to index your codebase so Shotgun can understand it?",
+                id="index-prompt-title",
             )
+            with VerticalScroll(id="index-prompt-content"):
+                yield Markdown(content, id="index-prompt-info")
             with Container(id="index-prompt-buttons"):
+                yield Button(
+                    "Not now",
+                    id="index-prompt-cancel",
+                )
                 yield Button(
                     "Index now",
                     id="index-prompt-confirm",
                     variant="primary",
                 )
-                yield Button("Not now", id="index-prompt-cancel")
 
     @on(Button.Pressed, "#index-prompt-cancel")
     def handle_cancel(self, event: Button.Pressed) -> None:

shotgun/tui/screens/chat_screen/command_providers.py

@@ -5,6 +5,7 @@ from textual.command import DiscoveryHit, Hit, Provider
 
 from shotgun.agents.models import AgentType
 from shotgun.codebase.models import CodebaseGraph
+from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.tui.screens.model_picker import ModelPickerScreen
 from shotgun.tui.screens.provider_config import ProviderConfigScreen
 
@@ -271,8 +272,8 @@ class DeleteCodebasePaletteProvider(Provider):
         try:
             result = await self.chat_screen.codebase_sdk.list_codebases()
         except Exception as exc:  # pragma: no cover - defensive UI path
-            self.chat_screen.notify(
-                f"Unable to load codebases: {exc}", severity="error"
+            self.chat_screen.agent_manager.add_hint_message(
+                HintMessage(message=f"❌ Unable to load codebases: {exc}")
             )
             return []
         return result.graphs

shotgun/tui/screens/chat_screen/hint_message.py

@@ -1,14 +1,23 @@
 from typing import Literal
 
 from pydantic import BaseModel
+from textual import on
 from textual.app import ComposeResult
+from textual.containers import Horizontal
 from textual.widget import Widget
-from textual.widgets import Markdown
+from textual.widgets import Button, Label, Markdown, Static
+
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
 
 
 class HintMessage(BaseModel):
     message: str
     kind: Literal["hint"] = "hint"
+    # Optional email copy functionality
+    email: str | None = None
+    markdown_after: str | None = None
 
 
 class HintMessageWidget(Widget):
@@ -30,6 +39,30 @@ class HintMessageWidget(Widget):
           }
         }
 
+        HintMessageWidget .email-copy-row {
+            width: auto;
+            height: auto;
+            margin: 1 0;
+        }
+
+        HintMessageWidget .email-text {
+            width: auto;
+            margin-right: 1;
+            content-align: left middle;
+        }
+
+        HintMessageWidget .copy-btn {
+            width: auto;
+            min-width: 12;
+        }
+
+        HintMessageWidget #copy-status {
+            height: 1;
+            width: 100%;
+            margin-top: 1;
+            content-align: left middle;
+        }
+
     """
 
     def __init__(self, message: HintMessage) -> None:
@@ -37,4 +70,46 @@ class HintMessageWidget(Widget):
         self.message = message
 
     def compose(self) -> ComposeResult:
+        # Main message markdown
         yield Markdown(markdown=f"{self.message.message}")
+
+        # Optional email copy section
+        if self.message.email:
+            # Email + copy button on same line
+            with Horizontal(classes="email-copy-row"):
+                yield Static(f"Contact: {self.message.email}", classes="email-text")
+                yield Button("Copy email", id="copy-email-btn", classes="copy-btn")
+
+            # Status feedback label
+            yield Label("", id="copy-status")
+
+            # Optional markdown after email
+            if self.message.markdown_after:
+                yield Markdown(self.message.markdown_after)
+
+    @on(Button.Pressed, "#copy-email-btn")
+    def _copy_email(self) -> None:
+        """Copy email address to clipboard when button is pressed."""
+        if not self.message.email:
+            return
+
+        status_label = self.query_one("#copy-status", Label)
+
+        try:
+            import pyperclip  # type: ignore[import-untyped]  # noqa: PGH003
+
+            pyperclip.copy(self.message.email)
+            status_label.update("✓ Copied to clipboard!")
+            logger.debug(
+                f"Successfully copied email to clipboard: {self.message.email}"
+            )
+
+        except ImportError:
+            status_label.update(
+                f"⚠️ Clipboard unavailable. Please manually copy: {self.message.email}"
+            )
+            logger.warning("pyperclip not available for clipboard operations")
+
+        except Exception as e:
+            status_label.update(f"⚠️ Copy failed: {e}")
+            logger.error(f"Failed to copy email to clipboard: {e}", exc_info=True)