copex 0.7.1__tar.gz → 0.8.0__tar.gz

{copex-0.7.1 → copex-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: copex
-Version: 0.7.1
+Version: 0.8.0
 Summary: Copilot Extended - Resilient wrapper for GitHub Copilot SDK with auto-retry, Ralph Wiggum loops, and more
 Project-URL: Homepage, https://github.com/Arthur742Ramos/copex
 Project-URL: Repository, https://github.com/Arthur742Ramos/copex

{copex-0.7.1 → copex-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "copex"
-version = "0.7.1"
+version = "0.8.0"
 description = "Copilot Extended - Resilient wrapper for GitHub Copilot SDK with auto-retry, Ralph Wiggum loops, and more"
 readme = "README.md"
 requires-python = ">=3.10"

{copex-0.7.1 → copex-0.8.0}/src/copex/__init__.py

@@ -10,7 +10,7 @@ from copex.mcp import MCPClient, MCPManager, MCPServerConfig, MCPTool, load_mcp_
 
 # Metrics
 from copex.metrics import MetricsCollector, RequestMetrics, SessionMetrics, get_collector
-from copex.models import Model, ReasoningEffort
+from copex.models import Model, ReasoningEffort, supports_reasoning
 
 # Persistence
 from copex.persistence import Message, PersistentSession, SessionData, SessionStore
@@ -27,6 +27,7 @@ __all__ = [
     "CopexConfig",
     "Model",
     "ReasoningEffort",
+    "supports_reasoning",
     "find_copilot_cli",
     # Ralph
     "RalphWiggum",

{copex-0.7.1 → copex-0.8.0}/src/copex/cli.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import sys
+import time
 from pathlib import Path
 from typing import Annotated, Optional
 
@@ -19,7 +20,7 @@ from rich.panel import Panel
 
 from copex.client import Copex, StreamChunk
 from copex.config import CopexConfig, load_last_model, save_last_model
-from copex.models import Model, ReasoningEffort
+from copex.models import Model, ReasoningEffort, supports_reasoning
 
 # Effective default: last used model or claude-opus-4.5
 _DEFAULT_MODEL = load_last_model() or Model.CLAUDE_OPUS_4_5
@@ -99,11 +100,11 @@ class SlashCompleter(Completer):
                 yield Completion(cmd, start_position=-len(text))
 
 
-def _build_prompt_session() -> PromptSession:
+def _build_prompt_session(model: str = "") -> PromptSession:
     history_path = Path.home() / ".copex" / "history"
     history_path.parent.mkdir(parents=True, exist_ok=True)
     bindings = KeyBindings()
-    commands = ["/model", "/reasoning", "/models", "/new", "/status", "/tools", "/help"]
+    commands = ["/model", "/reasoning", "/thinking", "/models", "/new", "/status", "/tools", "/copy", "/export", "/bell", "/help"]
     completer = SlashCompleter(commands)
 
     @bindings.add("enter")
@@ -118,14 +119,18 @@ def _build_prompt_session() -> PromptSession:
     def _(event) -> None:
         event.app.current_buffer.insert_text("\n")
 
+    # Model indicator in prompt
+    prompt_msg = f"[{model}] > " if model else "copilot> "
+    
     return PromptSession(
-        message="copilot> ",
+        message=prompt_msg,
         history=FileHistory(str(history_path)),
         key_bindings=bindings,
         completer=completer,
         complete_while_typing=True,
         multiline=True,
         prompt_continuation=lambda width, line_number, is_soft_wrap: "... ",
+        enable_history_search=True,  # Ctrl+R for history search
     )
 
 
@@ -265,8 +270,8 @@ def chat(
         bool, typer.Option("--no-stream", help="Disable streaming output")
     ] = False,
     show_reasoning: Annotated[
-        bool, typer.Option("--show-reasoning/--no-reasoning", help="Show model reasoning")
-    ] = True,
+        bool, typer.Option("--show-reasoning/--no-reasoning", help="Show model reasoning (GPT models only)")
+    ] = False,
     config_file: Annotated[
         Optional[Path], typer.Option("--config", "-c", help="Config file path")
     ] = None,
@@ -325,18 +330,20 @@ async def _run_chat(
 ) -> None:
     """Run the chat command."""
     client = Copex(config)
+    # Only show reasoning for GPT models
+    effective_show_reasoning = show_reasoning and supports_reasoning(config.model)
 
     try:
         await client.start()
 
         if config.streaming and not raw:
-            await _stream_response(client, prompt, show_reasoning)
+            await _stream_response(client, prompt, effective_show_reasoning)
         else:
             response = await client.send(prompt)
             if raw:
                 print(response.content)
             else:
-                if show_reasoning and response.reasoning:
+                if effective_show_reasoning and response.reasoning:
                     console.print(Panel(
                         Markdown(response.reasoning),
                         title="[dim]Reasoning[/dim]",
@@ -517,6 +524,9 @@ def interactive(
     reasoning: Annotated[
         str, typer.Option("--reasoning", "-r", help="Reasoning effort level")
     ] = ReasoningEffort.XHIGH.value,
+    show_reasoning: Annotated[
+        bool, typer.Option("--show-reasoning/--no-reasoning", help="Show model reasoning (GPT models only)")
+    ] = False,
     ui_theme: Annotated[
         Optional[str], typer.Option("--ui-theme", help="UI theme (default, midnight, mono, sunset)")
     ] = None,
@@ -542,14 +552,14 @@ def interactive(
         theme=config.ui_theme,
         density=config.ui_density,
     )
-    asyncio.run(_interactive_loop(config))
+    asyncio.run(_interactive_loop(config, show_reasoning))
 
 
-async def _interactive_loop(config: CopexConfig) -> None:
+async def _interactive_loop(config: CopexConfig, show_reasoning: bool = False) -> None:
     """Run interactive chat loop."""
     client = Copex(config)
     await client.start()
-    session = _build_prompt_session()
+    session = _build_prompt_session(config.model.value)
     show_all_tools = False
     
     # Create persistent UI for conversation history
@@ -560,21 +570,38 @@ async def _interactive_loop(config: CopexConfig) -> None:
         show_all_tools=show_all_tools,
     )
 
+    def rebuild_session() -> None:
+        """Rebuild prompt session with updated model."""
+        nonlocal session
+        session = _build_prompt_session(client.config.model.value)
+
     def show_help() -> None:
         console.print(f"\n[{Theme.MUTED}]Commands:[/{Theme.MUTED}]")
         console.print(f"  [{Theme.PRIMARY}]/model <name>[/{Theme.PRIMARY}]     - Change model (e.g., /model gpt-5.1-codex)")
-        console.print(f"  [{Theme.PRIMARY}]/reasoning <level>[/{Theme.PRIMARY}] - Change reasoning (low, medium, high, xhigh)")
+        if supports_reasoning(client.config.model):
+            console.print(f"  [{Theme.PRIMARY}]/reasoning <level>[/{Theme.PRIMARY}] - Change reasoning (low, medium, high, xhigh)")
+            console.print(f"  [{Theme.PRIMARY}]/thinking[/{Theme.PRIMARY}]           - Toggle reasoning display")
         console.print(f"  [{Theme.PRIMARY}]/models[/{Theme.PRIMARY}]            - List available models")
-        console.print(f"  [{Theme.PRIMARY}]/new[/{Theme.PRIMARY}]               - Start new session")
+        console.print(f"  [{Theme.PRIMARY}]/new[/{Theme.PRIMARY}]               - Start new session (or Ctrl+N)")
         console.print(f"  [{Theme.PRIMARY}]/status[/{Theme.PRIMARY}]            - Show current settings")
         console.print(f"  [{Theme.PRIMARY}]/tools[/{Theme.PRIMARY}]             - Toggle full tool call list")
+        console.print(f"  [{Theme.PRIMARY}]/copy[/{Theme.PRIMARY}]              - Copy last response to clipboard")
+        console.print(f"  [{Theme.PRIMARY}]/export[/{Theme.PRIMARY}]            - Export conversation as markdown")
+        console.print(f"  [{Theme.PRIMARY}]/bell[/{Theme.PRIMARY}]              - Toggle sound on completion")
         console.print(f"  [{Theme.PRIMARY}]/help[/{Theme.PRIMARY}]              - Show this help")
-        console.print(f"  [{Theme.PRIMARY}]exit[/{Theme.PRIMARY}]               - Exit\n")
+        console.print(f"  [{Theme.PRIMARY}]exit[/{Theme.PRIMARY}]               - Exit")
+        console.print(f"\n[{Theme.MUTED}]Shortcuts: Ctrl+R (history search), Shift+Enter (newline)[/{Theme.MUTED}]\n")
 
     def show_status() -> None:
         console.print(f"\n[{Theme.MUTED}]Current settings:[/{Theme.MUTED}]")
         console.print(f"  Model:     [{Theme.PRIMARY}]{client.config.model.value}[/{Theme.PRIMARY}]")
-        console.print(f"  Reasoning: [{Theme.PRIMARY}]{client.config.reasoning_effort.value}[/{Theme.PRIMARY}]\n")
+        if supports_reasoning(client.config.model):
+            console.print(f"  Reasoning: [{Theme.PRIMARY}]{client.config.reasoning_effort.value}[/{Theme.PRIMARY}]")
+            console.print(f"  Thinking:  [{Theme.PRIMARY}]{'on' if show_reasoning else 'off'}[/{Theme.PRIMARY}]")
+        console.print(f"  Bell:      [{Theme.PRIMARY}]{'on' if ui._bell_on_complete else 'off'}[/{Theme.PRIMARY}]")
+        if ui.state.total_tokens > 0:
+            console.print(f"  Tokens:    [{Theme.PRIMARY}]{ui.state.total_tokens:,}[/{Theme.PRIMARY}] (~${ui.state.estimated_cost:.4f})")
+        console.print()
 
     try:
         while True:
@@ -614,14 +641,15 @@ async def _interactive_loop(config: CopexConfig) -> None:
                 if selected and selected != client.config.model:
                     client.config.model = selected
                     save_last_model(selected)  # Persist for next run
-                    # Prompt for reasoning effort if GPT model
-                    if selected.value.startswith("gpt-"):
+                    # Prompt for reasoning effort only for GPT models
+                    if supports_reasoning(selected):
                         new_reasoning = await _reasoning_picker(client.config.reasoning_effort)
                         if new_reasoning:
                             client.config.reasoning_effort = new_reasoning
                     client.new_session()
                     # Clear UI history for new session
                     ui.state.history = []
+                    rebuild_session()  # Update prompt with new model
                     console.print(f"\n[{Theme.SUCCESS}]{Icons.DONE} Switched to {selected.value} (new session started)[/{Theme.SUCCESS}]\n")
                 continue
  
@@ -645,6 +673,7 @@ async def _interactive_loop(config: CopexConfig) -> None:
                     client.new_session()  # Need new session for model change
                     # Clear UI history for new session
                     ui.state.history = []
+                    rebuild_session()  # Update prompt with new model
                     console.print(f"\n[{Theme.SUCCESS}]{Icons.DONE} Switched to {new_model.value} (new session started)[/{Theme.SUCCESS}]\n")
                 except ValueError:
                     console.print(f"[{Theme.ERROR}]Unknown model: {model_name}[/{Theme.ERROR}]")
@@ -652,6 +681,9 @@ async def _interactive_loop(config: CopexConfig) -> None:
                 continue
 
             if command.startswith("/reasoning ") or command.startswith("reasoning "):
+                if not supports_reasoning(client.config.model):
+                    console.print(f"[{Theme.MUTED}]Reasoning effort is only supported for GPT models[/{Theme.MUTED}]")
+                    continue
                 parts = prompt.split(maxsplit=1)
                 if len(parts) < 2:
                     console.print(f"[{Theme.ERROR}]Usage: /reasoning <level>[/{Theme.ERROR}]")
@@ -669,9 +701,56 @@ async def _interactive_loop(config: CopexConfig) -> None:
                     console.print(f"[{Theme.ERROR}]Invalid reasoning level. Valid: {valid}[/{Theme.ERROR}]")
                 continue
 
+            if command in {"thinking", "/thinking"}:
+                if not supports_reasoning(client.config.model):
+                    console.print(f"[{Theme.MUTED}]Thinking display is only available for GPT models[/{Theme.MUTED}]")
+                    continue
+                show_reasoning = not show_reasoning
+                mode = "on" if show_reasoning else "off"
+                console.print(f"\n[{Theme.SUCCESS}]{Icons.DONE} Thinking display {mode}[/{Theme.SUCCESS}]\n")
+                continue
+
+            if command in {"copy", "/copy"}:
+                last_response = ui.get_last_response()
+                if last_response:
+                    try:
+                        import subprocess
+                        # Try pbcopy (macOS), xclip (Linux), or clip (Windows)
+                        if sys.platform == "darwin":
+                            subprocess.run(["pbcopy"], input=last_response.encode(), check=True)
+                        elif sys.platform == "win32":
+                            subprocess.run(["clip"], input=last_response.encode(), check=True)
+                        else:
+                            subprocess.run(["xclip", "-selection", "clipboard"], input=last_response.encode(), check=True)
+                        console.print(f"\n[{Theme.SUCCESS}]{Icons.DONE} Copied to clipboard ({len(last_response)} chars)[/{Theme.SUCCESS}]\n")
+                    except Exception as e:
+                        console.print(f"[{Theme.ERROR}]Failed to copy: {e}[/{Theme.ERROR}]")
+                else:
+                    console.print(f"[{Theme.MUTED}]No response to copy[/{Theme.MUTED}]")
+                continue
+
+            if command in {"export", "/export"}:
+                markdown = ui.export_conversation()
+                if markdown and len(ui.state.history) > 0:
+                    export_path = Path.home() / ".copex" / "exports"
+                    export_path.mkdir(parents=True, exist_ok=True)
+                    filename = f"conversation_{time.strftime('%Y%m%d_%H%M%S')}.md"
+                    filepath = export_path / filename
+                    filepath.write_text(markdown)
+                    console.print(f"\n[{Theme.SUCCESS}]{Icons.DONE} Exported to {filepath}[/{Theme.SUCCESS}]\n")
+                else:
+                    console.print(f"[{Theme.MUTED}]No conversation to export[/{Theme.MUTED}]")
+                continue
+
+            if command in {"bell", "/bell"}:
+                is_on = ui.toggle_bell()
+                mode = "on" if is_on else "off"
+                console.print(f"\n[{Theme.SUCCESS}]{Icons.DONE} Bell on completion {mode}[/{Theme.SUCCESS}]\n")
+                continue
+
             try:
                 print_user_prompt(console, prompt)
-                await _stream_response_interactive(client, prompt, ui)
+                await _stream_response_interactive(client, prompt, ui, show_reasoning)
             except Exception as e:
                 print_error(console, str(e))
 
@@ -685,6 +764,7 @@ async def _stream_response_interactive(
     client: Copex,
     prompt: str,
     ui: CopexUI,
+    show_reasoning: bool = False,
 ) -> None:
     """Stream response with beautiful UI in interactive mode."""
     # Add user message to history
@@ -693,6 +773,9 @@ async def _stream_response_interactive(
     # Reset for new turn but preserve history
     ui.reset(model=client.config.model.value, preserve_history=True)
     ui.set_activity(ActivityType.THINKING)
+    
+    # Only show reasoning for GPT models when enabled
+    effective_show_reasoning = show_reasoning and supports_reasoning(client.config.model)
 
     live_display: Live | None = None
     refresh_stop = asyncio.Event()
@@ -700,14 +783,15 @@ async def _stream_response_interactive(
     def on_chunk(chunk: StreamChunk) -> None:
         if chunk.type == "message":
             if chunk.is_final:
-                ui.set_final_content(chunk.content or ui.state.message, ui.state.reasoning)
+                ui.set_final_content(chunk.content or ui.state.message, ui.state.reasoning if effective_show_reasoning else None)
             else:
                 ui.add_message(chunk.delta)
         elif chunk.type == "reasoning":
-            if chunk.is_final:
-                pass
-            else:
-                ui.add_reasoning(chunk.delta)
+            if effective_show_reasoning:
+                if chunk.is_final:
+                    pass
+                else:
+                    ui.add_reasoning(chunk.delta)
         elif chunk.type == "tool_call":
             tool = ToolCallInfo(
                 name=chunk.tool_name or "unknown",
@@ -743,7 +827,7 @@ async def _stream_response_interactive(
             response = await client.send(prompt, on_chunk=on_chunk)
             # Prefer streamed content over response object (which may have stale fallback)
             final_message = ui.state.message if ui.state.message else response.content
-            final_reasoning = ui.state.reasoning if ui.state.reasoning else response.reasoning
+            final_reasoning = (ui.state.reasoning if ui.state.reasoning else response.reasoning) if effective_show_reasoning else None
             ui.set_final_content(final_message, final_reasoning)
             ui.state.retries = response.retries
         finally:
@@ -957,7 +1041,7 @@ def status() -> None:
         console.print("Install: [bold]https://cli.github.com/[/bold]")
 
 
-__version__ = "0.7.1"
+__version__ = "0.8.0"
 
 
 if __name__ == "__main__":

{copex-0.7.1 → copex-0.8.0}/src/copex/config.py

@@ -269,12 +269,17 @@ class CopexConfig(BaseModel):
 
     def to_session_options(self) -> dict[str, Any]:
         """Convert to create_session options."""
+        from copex.models import supports_reasoning
+
         opts: dict[str, Any] = {
             "model": self.model.value,
-            "model_reasoning_effort": self.reasoning_effort.value,
             "streaming": self.streaming,
         }
 
+        # Only include reasoning_effort for GPT models
+        if supports_reasoning(self.model):
+            opts["model_reasoning_effort"] = self.reasoning_effort.value
+
         # Skills
         if self.skills:
             opts["skills"] = self.skills

{copex-0.7.1 → copex-0.8.0}/src/copex/models.py

@@ -21,6 +21,16 @@ class Model(str, Enum):
     CLAUDE_OPUS_4_5 = "claude-opus-4.5"
     GEMINI_3_PRO = "gemini-3-pro-preview"
 
+    def supports_reasoning(self) -> bool:
+        """Check if this model supports reasoning effort."""
+        return self.value.startswith("gpt-")
+
+
+def supports_reasoning(model: Model | str) -> bool:
+    """Check if a model supports reasoning effort."""
+    model_str = model.value if isinstance(model, Model) else model
+    return model_str.startswith("gpt-")
+
 
 class ReasoningEffort(str, Enum):
     """Reasoning effort levels for supported models."""

{copex-0.7.1 → copex-0.8.0}/src/copex/ui.py

@@ -226,9 +226,16 @@ class UIState:
     retries: int = 0
     last_update: float = field(default_factory=time.time)
     history: list[HistoryEntry] = field(default_factory=list)
+    # Token tracking
+    input_tokens: int = 0
+    output_tokens: int = 0
+    # Completion time
+    completed_at: float | None = None
 
     @property
     def elapsed(self) -> float:
+        if self.completed_at:
+            return self.completed_at - self.start_time
         return time.time() - self.start_time
 
     @property
@@ -253,6 +260,16 @@ class UIState:
         seconds = idle % 60
         return f"{minutes}m {seconds:.0f}s"
 
+    @property
+    def total_tokens(self) -> int:
+        return self.input_tokens + self.output_tokens
+
+    @property
+    def estimated_cost(self) -> float:
+        """Rough cost estimate (varies by model)."""
+        # Approximate pricing: $0.01 per 1K tokens average
+        return self.total_tokens * 0.00001
+
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # UI Components
@@ -261,6 +278,15 @@ class UIState:
 class CopexUI:
     """Beautiful UI for Copex CLI."""
 
+    # Different spinners for different activities
+    SPINNERS = {
+        "thinking": ["🤔", "💭", "🧠", "💡"],
+        "reasoning": ["🔍", "📊", "🔬", "📈"],
+        "tools": ["⚙️", "🔧", "🛠️", "⚡"],
+        "responding": ["✍️", "📝", "💬", "📢"],
+        "default": ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+    }
+
     def __init__(
         self,
         console: Console | None = None,
@@ -274,17 +300,29 @@ class CopexUI:
         self.density = density
         self.state = UIState()
         self._live: Live | None = None
-        self._spinners = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        self._spinners = self.SPINNERS["default"]
         self._spinner_idx = 0
         self._last_frame_at = 0.0
         self._dot_frames = [".", "..", "..."]
         self.show_all_tools = show_all_tools
         self._max_live_message_chars = 2000 if density == "extended" else 900
         self._max_live_reasoning_chars = 800 if density == "extended" else 320
+        self._bell_on_complete = False  # Can be toggled
 
     def _get_spinner(self) -> str:
-        """Get current spinner frame."""
-        return self._spinners[self._spinner_idx]
+        """Get current spinner frame based on current activity."""
+        activity = self.state.activity
+        if activity == ActivityType.THINKING:
+            spinners = self.SPINNERS["thinking"]
+        elif activity == ActivityType.REASONING:
+            spinners = self.SPINNERS["reasoning"]
+        elif activity == ActivityType.TOOL_CALL:
+            spinners = self.SPINNERS["tools"]
+        elif activity == ActivityType.RESPONDING:
+            spinners = self.SPINNERS["responding"]
+        else:
+            spinners = self.SPINNERS["default"]
+        return spinners[self._spinner_idx % len(spinners)]
 
     def _get_dots(self) -> str:
         """Get current dot animation frame."""
@@ -293,10 +331,10 @@ class CopexUI:
     def _advance_frame(self) -> None:
         """Advance animation frame."""
         now = time.time()
-        if now - self._last_frame_at < 0.08:
+        if now - self._last_frame_at < 0.15:  # Slower for emoji spinners
             return
         self._last_frame_at = now
-        self._spinner_idx = (self._spinner_idx + 1) % len(self._spinners)
+        self._spinner_idx = (self._spinner_idx + 1) % 10  # Common denominator
 
     def _build_header(self) -> Text:
         """Build the header with model and status."""
@@ -423,12 +461,22 @@ class CopexUI:
 
             branch = tree.add(tool_text)
 
-            # Add result preview if available
+            # Add result preview if available (truncated but useful)
             if tool.result and tool.status != "running":
-                result_preview = tool.result[:100]
-                if len(tool.result) > 100:
-                    result_preview += "..."
-                branch.add(Text(result_preview, style=Theme.MUTED))
+                lines = tool.result.strip().split("\n")
+                max_preview_lines = 3 if self.density == "extended" else 1
+                preview_lines = lines[:max_preview_lines]
+                
+                for line in preview_lines:
+                    # Truncate long lines
+                    if len(line) > 80:
+                        line = line[:77] + "..."
+                    if line.strip():
+                        branch.add(Text(f"  {line}", style=Theme.MUTED))
+                
+                remaining = len(lines) - max_preview_lines
+                if remaining > 0:
+                    branch.add(Text(f"  ... +{remaining} more lines", style=Theme.MUTED))
 
         if len(self.state.tool_calls) > max_tools:
             if self.show_all_tools:
@@ -524,11 +572,18 @@ class CopexUI:
 
         elapsed_text = Text()
         elapsed_text.append(f"{Icons.CLOCK} ", style=Theme.MUTED)
-        elapsed_text.append(f"{self.state.elapsed_str} elapsed", style=Theme.MUTED)
-
-        updated_text = Text()
-        updated_text.append(f"{Icons.SPARKLE} ", style=Theme.MUTED)
-        updated_text.append(f"updated {self.state.idle_str} ago", style=Theme.MUTED)
+        elapsed_text.append(f"{self.state.elapsed_str}", style=Theme.MUTED)
+
+        # Token/cost display
+        tokens_text = Text()
+        if self.state.total_tokens > 0:
+            tokens_text.append("💰 ", style=Theme.SUCCESS)
+            tokens_text.append(f"{self.state.total_tokens:,} tokens", style=Theme.SUCCESS)
+            if self.state.estimated_cost > 0:
+                tokens_text.append(f" (~${self.state.estimated_cost:.4f})", style=Theme.MUTED)
+        else:
+            tokens_text.append("💰 ", style=Theme.MUTED)
+            tokens_text.append("0 tokens", style=Theme.MUTED)
 
         model_text = Text()
         if self.state.model:
@@ -549,7 +604,7 @@ class CopexUI:
         if self.density == "extended":
             grid.add_column(justify="center")
             grid.add_column(justify="right")
-            grid.add_row(activity, elapsed_text, updated_text)
+            grid.add_row(activity, elapsed_text, tokens_text)
             grid.add_row(message_text, reasoning_text, tools_text)
             grid.add_row(model_text, Text(), retry_text)
         else:
@@ -747,6 +802,18 @@ class CopexUI:
         self.state.retries += 1
         self._touch()
 
+    def set_tokens(self, input_tokens: int = 0, output_tokens: int = 0) -> None:
+        """Set token counts."""
+        self.state.input_tokens = input_tokens
+        self.state.output_tokens = output_tokens
+        self._touch()
+
+    def add_tokens(self, input_tokens: int = 0, output_tokens: int = 0) -> None:
+        """Add to token counts."""
+        self.state.input_tokens += input_tokens
+        self.state.output_tokens += output_tokens
+        self._touch()
+
     def set_final_content(self, message: str, reasoning: str | None = None) -> None:
         """Set final content."""
         if message:
@@ -754,8 +821,51 @@ class CopexUI:
         if reasoning:
             self.state.reasoning = reasoning
         self.state.activity = ActivityType.DONE
+        self.state.completed_at = time.time()
+        # Ring bell if enabled
+        if self._bell_on_complete:
+            print("\a", end="", flush=True)
         self._touch()
 
+    def toggle_bell(self) -> bool:
+        """Toggle bell on completion. Returns new state."""
+        self._bell_on_complete = not self._bell_on_complete
+        return self._bell_on_complete
+
+    def get_last_response(self) -> str | None:
+        """Get the last assistant response for clipboard."""
+        return self.state.message if self.state.message else None
+
+    def export_conversation(self) -> str:
+        """Export conversation as markdown."""
+        lines = ["# Copex Conversation\n"]
+        lines.append(f"**Model:** {self.state.model}\n")
+        lines.append(f"**Date:** {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+        lines.append("---\n")
+        
+        for entry in self.state.history:
+            if entry.role == "user":
+                lines.append(f"## 👤 User\n\n{entry.content}\n")
+            else:
+                lines.append(f"## 🤖 Assistant\n\n{entry.content}\n")
+                if entry.reasoning:
+                    lines.append(f"\n<details>\n<summary>Reasoning</summary>\n\n{entry.reasoning}\n</details>\n")
+                if entry.tool_calls:
+                    lines.append("\n**Tool Calls:**\n")
+                    for tool in entry.tool_calls:
+                        status = "✅" if tool.status == "success" else "❌" if tool.status == "error" else "🔄"
+                        lines.append(f"- {status} `{tool.name}`")
+                        if tool.duration:
+                            lines.append(f" ({tool.duration:.2f}s)")
+                        lines.append("\n")
+            lines.append("\n---\n")
+        
+        # Add current response if not in history
+        if self.state.message and (not self.state.history or self.state.history[-1].content != self.state.message):
+            lines.append(f"## 🤖 Assistant\n\n{self.state.message}\n")
+        
+        return "".join(lines)
+
     def add_user_message(self, content: str) -> None:
         """Add a user message to history."""
         self.state.history.append(HistoryEntry(role="user", content=content))
@@ -783,17 +893,26 @@ class CopexUI:
         summary.add_column(justify="right")
 
         elapsed_text = Text()
-        elapsed_text.append(f"{Icons.CLOCK} ", style=Theme.MUTED)
-        elapsed_text.append(f"{self.state.elapsed_str} elapsed", style=Theme.MUTED)
+        elapsed_text.append(f"{Icons.CLOCK} ", style=Theme.SUCCESS)
+        elapsed_text.append(f"{self.state.elapsed_str}", style=Theme.SUCCESS)
+
+        # Token/cost summary
+        tokens_text = Text()
+        if self.state.total_tokens > 0:
+            tokens_text.append("💰 ", style=Theme.SUCCESS)
+            tokens_text.append(f"{self.state.total_tokens:,} tokens", style=Theme.SUCCESS)
+            if self.state.estimated_cost > 0.0001:
+                tokens_text.append(f" (~${self.state.estimated_cost:.4f})", style=Theme.MUTED)
+        else:
+            tokens_text.append("", style=Theme.MUTED)
+
+        summary.add_row(elapsed_text, tokens_text)
 
         retry_text = Text()
         if self.state.retries:
             retry_text.append(f"{Icons.WARNING} ", style=Theme.WARNING)
             retry_text.append(f"{self.state.retries} retries", style=Theme.WARNING)
-        else:
-            retry_text.append(f"{Icons.DONE} no retries", style=Theme.MUTED)
-
-        summary.add_row(elapsed_text, retry_text)
+            summary.add_row(retry_text, Text())
 
         if self.state.tool_calls:
             successful = sum(1 for t in self.state.tool_calls if t.status == "success")
@@ -813,9 +932,9 @@ class CopexUI:
 
         return Panel(
             summary,
-            title=f"[{Theme.SUCCESS}]{Icons.DONE} Summary[/{Theme.SUCCESS}]",
+            title=f"[{Theme.SUCCESS}]{Icons.DONE} Complete[/{Theme.SUCCESS}]",
             title_align="left",
-            border_style=Theme.BORDER_ACTIVE,
+            border_style=Theme.SUCCESS,
             padding=(0, 1),
             box=ROUNDED,
         )
@@ -882,8 +1001,8 @@ def print_welcome(
             f"[{Theme.MUTED}]- Copilot Extended[/{Theme.MUTED}]\n\n"
             f"[{Theme.MUTED}]Model:[/{Theme.MUTED}] [{Theme.PRIMARY}]{model}[/{Theme.PRIMARY}]\n"
             f"[{Theme.MUTED}]Reasoning:[/{Theme.MUTED}] [{Theme.PRIMARY}]{reasoning}[/{Theme.PRIMARY}]\n\n"
-            f"[{Theme.MUTED}]Type [bold]exit[/bold] to quit, [bold]new[/bold] for fresh session[/{Theme.MUTED}]\n"
-            f"[{Theme.MUTED}]Press [bold]Shift+Enter[/bold] for newline[/{Theme.MUTED}]"
+            f"[{Theme.MUTED}]Type [bold]/help[/bold] for commands, [bold]exit[/bold] to quit[/{Theme.MUTED}]\n"
+            f"[{Theme.MUTED}][bold]Ctrl+R[/bold] history search, [bold]Shift+Enter[/bold] newline[/{Theme.MUTED}]"
         ),
         border_style=Theme.BORDER_ACTIVE,
         box=ROUNDED,