event_loop.rs

//! Main event loop for Cortex TUI.
//!
//! This module provides the heart of the application - the main event loop that
//! coordinates the 120 FPS render loop with cortex-core backend events using
//! `tokio::select!`.
//!
//! ## Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────────────────┐
//! │                         EventLoop                                    │
//! │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌────────────┐  │
//! │  │ FrameEngine │  │SessionBridge│  │StreamControl│  │ActionMapper│  │
//! │  │  (120 FPS)  │  │  (Backend)  │  │  (State)    │  │ (Bindings) │  │
//! │  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘  └──────┬─────┘  │
//! │         │                │                │                │        │
//! │         │    tokio::select!              │                │        │
//! │         ▼                ▼                ▼                ▼        │
//! │  ┌──────────────────────────────────────────────────────────────┐   │
//! │  │                    Main Event Loop                           │   │
//! │  │  • Engine events (ticks, keys, mouse, resize)                │   │
//! │  │  • Backend events (streaming, tools, errors)                 │   │
//! │  │  • Action dispatch and state updates                         │   │
//! │  │  • View rendering                                            │   │
//! │  └──────────────────────────────────────────────────────────────┘   │
//! └─────────────────────────────────────────────────────────────────────┘
//! ```
//!
//! ## Example
//!
//! ```rust,ignore
//! use cortex_tui::app::AppState;
//! use cortex_tui::runner::{CortexTerminal, EventLoop};
//!
//! #[tokio::main]
//! async fn main() -> anyhow::Result<()> {
//!     let mut terminal = CortexTerminal::new()?;
//!     let app_state = AppState::new();
//!     
//!     let mut event_loop = EventLoop::new(app_state);
//!     event_loop.run(&mut terminal).await?;
//!     
//!     Ok(())
//! }
//! ```

use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant};

use anyhow::Result;
use ratatui::prelude::*;
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use tokio_stream::StreamExt;

use crate::actions::{ActionContext, ActionMapper, KeyAction};
use crate::app::{
    AppState, AppView, ApprovalMode, ApprovalState, AutocompleteItem, AutocompleteTrigger,
    FocusTarget, PendingToolResult, SubagentDisplayStatus, SubagentTaskDisplay,
};
use crate::bridge::{SessionBridge, StreamController, adapt_event};
use crate::commands::{
    CommandExecutor, CommandParser, CommandResult, FormRegistry, ModalType, ViewType,
};
use crate::events::{AppEvent, SubagentEvent, ToolEvent};
use crate::input::{ClickZoneId, ClickZoneRegistry, MouseAction, MouseButton, MouseHandler};
use crate::modal::{Modal, ModalAction, ModalResult, ModalStack};
use crate::permissions::PermissionManager;
use crate::providers::ProviderManager;
use crate::question::{QuestionRequest, QuestionState};
use crate::runner::card_handler::CardHandler;
use crate::runner::terminal::CortexTerminal;
use crate::session::{
    CortexSession, ExportFormat, StoredToolCall, default_export_filename, export_session,
    export_to_file,
};
use crate::views::tool_call::{ToolStatus, format_result_summary};
use crate::views::{ApprovalView, QuestionClickZones, QuestionHit, QuestionPromptView};
use cortex_engine::AgentRegistry;
use cortex_engine::client::{
    Message, ResponseEvent, TokenUsage, ToolDefinition as ClientToolDefinition,
};
use cortex_engine::streaming::StreamEvent;
use cortex_engine::tools::handlers::subagent::{
    ProgressEvent, SubagentConfig, SubagentExecutor, SubagentType,
};
use cortex_engine::tools::{ExecutorConfig, ToolRegistry, ToolResult, UnifiedToolExecutor};

use crate::agent::build_system_prompt;
use crate::capture::TuiCapture;

use cortex_core::{EngineEvent, frame_engine::FrameEngine};

// ============================================================================
// ERROR MESSAGE HELPERS
// ============================================================================

/// Returns the error message as-is for debugging.
/// Previously simplified errors, but this hid useful information.
fn simplify_error_message(error: &str) -> String {
    // Return the full error message for better debugging
    // Log a debug hint based on error type
    let lower = error.to_lowercase();

    if lower.contains("401") || lower.contains("unauthorized") {
        tracing::debug!("Auth error hint: Run 'cortex login' to re-authenticate");
    } else if lower.contains("403") || lower.contains("forbidden") {
        tracing::debug!("Permission error hint: Check API key or subscription");
    }

    error.to_string()
}

// ============================================================================
// EVENT LOOP STRUCT
// ============================================================================

/// Main event loop for the Cortex TUI application.
///
/// This struct coordinates the 120 FPS render loop with backend events,
/// handling user input, streaming responses, tool executions, and UI updates.
pub struct EventLoop {
    /// Application state containing all UI state.
    pub app_state: AppState,

    /// Frame engine for 120 FPS rendering.
    frame_engine: Option<FrameEngine>,

    /// Session bridge for backend communication.
    session_bridge: Option<SessionBridge>,

    /// Stream controller for managing streaming state.
    stream_controller: StreamController,

    /// Action mapper for keybindings.
    action_mapper: ActionMapper,

    /// Click zone registry for mouse interaction.
    click_zones: ClickZoneRegistry,

    /// Mouse handler for click/drag/scroll.
    mouse_handler: MouseHandler,

    /// Modal stack for overlay dialogs.
    modal_stack: ModalStack,

    /// Command executor for slash commands.
    command_executor: CommandExecutor,

    /// Form registry for command forms.
    form_registry: FormRegistry,

    /// Permission manager for tool approvals.
    permission_manager: PermissionManager,

    /// Provider manager for AI providers.
    provider_manager: Option<Arc<tokio::sync::RwLock<ProviderManager>>>,

    /// Tool executor for running tools.
    tool_executor: Option<Arc<UnifiedToolExecutor>>,

    /// Subagent executor for running subagents.
    subagent_executor: Option<Arc<SubagentExecutor>>,

    /// Whether the event loop is running.
    running: Arc<AtomicBool>,

    /// Background task handles.
    background_tasks: Vec<JoinHandle<()>>,

    /// Last render timestamp for frame timing.
    last_render: Instant,

    /// Minimum frame time for 120 FPS.
    min_frame_time: Duration,

    /// Current Cortex session.
    cortex_session: Option<CortexSession>,

    /// Tool registry for available tools.
    tool_registry: Option<Arc<ToolRegistry>>,

    /// Whether streaming was cancelled.
    streaming_cancelled: Arc<AtomicBool>,

    /// Whether stream done was received.
    stream_done_received: bool,

    /// Receiver for streaming events.
    streaming_rx: Option<mpsc::Receiver<StreamEvent>>,

    /// Handle to the streaming task.
    streaming_task: Option<JoinHandle<()>>,

    /// Card handler for card-based UI.
    card_handler: CardHandler,

    /// Unified tool executor.
    unified_executor: Option<Arc<UnifiedToolExecutor>>,

    /// Pending assistant tool calls.
    pending_assistant_tool_calls: Vec<PendingToolCall>,

    /// Running tool tasks.
    running_tool_tasks: std::collections::HashMap<String, JoinHandle<()>>,

    /// Running subagents.
    running_subagents: std::collections::HashMap<String, JoinHandle<()>>,

    /// Tool execution started flag.
    tool_execution_started: bool,

    /// Channel for receiving tool execution events.
    tool_event_tx: mpsc::Sender<ToolEvent>,
    tool_event_rx: Option<mpsc::Receiver<ToolEvent>>,

    /// Whether the current streaming is a continuation after tool results.
    /// When true, tool calls should NOT be cleared on StreamEvent::Done.
    is_continuation: bool,

    /// Undo stack for session message exchanges.
    /// Each entry is a pair of (user_message, assistant_message).
    undo_stack: Vec<Vec<cortex_core::widgets::Message>>,

    /// TUI capture manager for debugging (enabled via CORTEX_TUI_CAPTURE=1).
    tui_capture: TuiCapture,
}

/// Pending tool call information.
#[derive(Debug, Clone)]
pub struct PendingToolCall {
    /// Tool call ID.
    pub id: String,
    /// Tool name.
    pub name: String,
    /// Tool arguments.
    pub arguments: serde_json::Value,
}

impl EventLoop {
    /// Creates a new EventLoop with the given application state.
    pub fn new(app_state: AppState) -> Self {
        // Create channel for tool execution events
        let (tool_event_tx, tool_event_rx) = mpsc::channel::<ToolEvent>(100);

        // Initialize TUI capture with terminal size from app state
        let (width, height) = app_state.terminal_size;
        let tui_capture = TuiCapture::new(width, height);

        Self {
            app_state,
            frame_engine: None,
            session_bridge: None,
            stream_controller: StreamController::new(),
            action_mapper: ActionMapper::default(),
            click_zones: ClickZoneRegistry::new(),
            mouse_handler: MouseHandler::new(),
            modal_stack: ModalStack::new(),
            command_executor: CommandExecutor::new(),
            form_registry: FormRegistry::new(),
            permission_manager: PermissionManager::new(),
            provider_manager: None,
            tool_executor: None,
            subagent_executor: None,
            running: Arc::new(AtomicBool::new(false)),
            background_tasks: Vec::new(),
            last_render: Instant::now(),
            min_frame_time: Duration::from_micros(8333), // ~120 FPS
            cortex_session: None,
            tool_registry: None,
            streaming_cancelled: Arc::new(AtomicBool::new(false)),
            stream_done_received: false,
            streaming_rx: None,
            streaming_task: None,
            card_handler: CardHandler::new(),
            unified_executor: None,
            pending_assistant_tool_calls: Vec::new(),
            running_tool_tasks: std::collections::HashMap::new(),
            running_subagents: std::collections::HashMap::new(),
            tool_execution_started: false,
            tool_event_tx,
            tool_event_rx: Some(tool_event_rx),
            is_continuation: false,
            undo_stack: Vec::new(),
            tui_capture,
        }
    }

    /// Sets the provider manager.
    pub fn with_provider_manager(mut self, manager: ProviderManager) -> Self {
        self.provider_manager = Some(Arc::new(tokio::sync::RwLock::new(manager)));
        self
    }

    /// Sets the unified executor.
    pub fn with_unified_executor(mut self, executor: Arc<UnifiedToolExecutor>) -> Self {
        self.unified_executor = Some(executor);
        self
    }

    /// Sets the session bridge.
    pub fn with_session(mut self, bridge: SessionBridge) -> Self {
        self.session_bridge = Some(bridge);
        self
    }

    /// Sets the cortex session.
    pub fn with_cortex_session(mut self, session: CortexSession) -> Self {
        self.cortex_session = Some(session);
        self
    }

    /// Sets the tool registry for executing tools.
    pub fn with_tool_registry(mut self, registry: Arc<ToolRegistry>) -> Self {
        self.tool_registry = Some(registry);
        self
    }

    /// Runs the main event loop.
    ///
    /// This method initializes the FrameEngine to poll keyboard, mouse, and
    /// terminal events, then dispatches them to `handle_engine_event()` for
    /// processing. It also polls streaming events from the LLM backend.
    pub async fn run(&mut self, terminal: &mut CortexTerminal) -> Result<()> {
        self.running.store(true, Ordering::SeqCst);

        // Create channel for receiving events from FrameEngine
        let (action_tx, mut action_rx) = tokio::sync::mpsc::channel::<EngineEvent>(256);

        // Create and spawn the FrameEngine
        let running = self.running.clone();
        let mut frame_engine = FrameEngine::new(action_tx, running);

        let engine_handle = tokio::spawn(async move {
            if let Err(e) = frame_engine.run().await {
                tracing::error!("FrameEngine error: {}", e);
            }
        });

        // Initial render
        self.render(terminal)?;

        // Check token expiration and handle accordingly
        let session_expired = if let Ok(Some(auth)) = cortex_login::load_from_keyring() {
            if auth.is_expired() {
                // Session is already expired
                true
            } else if auth.expires_soon(86400) {
                // Session expires within 24 hours but is still valid
                if let Some(remaining) = auth.time_until_expiry() {
                    if remaining > 0 {
                        let hours = remaining / 3600;
                        let minutes = (remaining % 3600) / 60;
                        if hours > 0 {
                            self.app_state.toasts.warning(&format!(
                                "Session expires in {} hours. Run /login to refresh.",
                                hours
                            ));
                        } else if minutes > 0 {
                            self.app_state.toasts.warning(&format!(
                                "Session expires in {} minutes. Run /login to refresh.",
                                minutes
                            ));
                        }
                        false // Session still valid
                    } else {
                        // remaining <= 0 means expired
                        true
                    }
                } else {
                    false
                }
            } else {
                false
            }
        } else {
            false
        };

        // If session is expired, automatically redirect to login page
        if session_expired {
            self.app_state
                .toasts
                .warning("Session expired. Redirecting to login...");
            self.start_login_flow().await;
        }

        // Main event loop: poll BOTH FrameEngine events AND streaming events
        loop {
            // Check exit conditions
            if !self.running.load(Ordering::SeqCst) || self.app_state.should_quit() {
                break;
            }

            // Use tokio::select! to poll multiple event sources concurrently
            tokio::select! {
                // Branch 1: FrameEngine events (keyboard, mouse, ticks, resize)
                Some(event) = action_rx.recv() => {
                    // Handle quit event
                    if matches!(event, EngineEvent::Quit) {
                        self.app_state.set_quit();
                        break;
                    }

                    // Dispatch event to handler
                    if let Err(e) = self.handle_engine_event(event, terminal).await {
                        tracing::error!("Error handling engine event: {}", e);
                    }
                }

                // Branch 2: Streaming events from LLM (Delta, Done, Error, ToolCall)
                Some(stream_event) = async {
                    match self.streaming_rx.as_mut() {
                        Some(rx) => rx.recv().await,
                        None => std::future::pending().await,
                    }
                } => {
                    self.handle_stream_event(stream_event).await;
                    // Re-render after streaming update to show new content
                    if let Err(e) = self.render(terminal) {
                        tracing::error!("Error rendering after stream event: {}", e);
                    }
                }

                // Branch 3: Tool execution events (Started, Output, Completed, Failed)
                Some(tool_event) = async {
                    match self.tool_event_rx.as_mut() {
                        Some(rx) => rx.recv().await,
                        None => std::future::pending().await,
                    }
                } => {
                    self.handle_tool_event(tool_event).await;
                    // Re-render after tool event to show status update
                    if let Err(e) = self.render(terminal) {
                        tracing::error!("Error rendering after tool event: {}", e);
                    }
                }
            }
        }

        // Cleanup: signal engine to stop and wait for it
        self.running.store(false, Ordering::SeqCst);
        let _ = engine_handle.await;

        // Export TUI captures if enabled
        if self.tui_capture.is_enabled() {
            // Take ownership of capture manager for export
            let capture = std::mem::take(&mut self.tui_capture);
            if let Err(e) = capture.export().await {
                tracing::warn!("Failed to export TUI capture: {}", e);
            }
        }

        Ok(())
    }

    /// Spawns a subagent task (for Task tool).
    /// Based on OpenCode's task.ts implementation.
    ///
    /// Supports two parameter formats:
    /// 1. API format (documented): { "agent": "name", "task": "instructions", "context": "..." }
    /// 2. Internal format: { "description": "...", "prompt": "...", "subagent_type": "..." }
    fn spawn_subagent(&mut self, tool_call_id: String, args: serde_json::Value) {
        tracing::info!("Spawning subagent for tool call: {}", tool_call_id);

        // Support both API format (agent, task, context) and internal format (description, prompt, subagent_type)
        // API format takes precedence if present
        let agent = args.get("agent").and_then(|v| v.as_str());
        let task = args.get("task").and_then(|v| v.as_str());
        let context = args.get("context").and_then(|v| v.as_str());

        // Map API format to internal format, with fallbacks for backward compatibility
        let description = args
            .get("description")
            .and_then(|v| v.as_str())
            .or(agent) // Use agent name as description if API format
            .unwrap_or("Subagent task")
            .to_string();

        let prompt = args
            .get("prompt")
            .and_then(|v| v.as_str())
            .or(task) // Use task as prompt if API format
            .map(|p| {
                // Append context to prompt if provided via API format
                if let Some(ctx) = context {
                    format!("{}\n\nContext: {}", p, ctx)
                } else {
                    p.to_string()
                }
            })
            .unwrap_or_default();

        let subagent_type = args
            .get("subagent_type")
            .and_then(|v| v.as_str())
            .or(agent) // Use agent name as subagent type if API format
            .unwrap_or("code") // Default to "code" type instead of "default"
            .to_string();

        if prompt.is_empty() {
            self.app_state.add_pending_tool_result(
                tool_call_id,
                "Task".to_string(),
                "Task tool requires a 'task' or 'prompt' parameter with instructions for the subagent.".to_string(),
                false,
            );
            return;
        }

        // Get dependencies for the spawned task
        let Some(registry) = self.tool_registry.clone() else {
            self.app_state.add_pending_tool_result(
                tool_call_id,
                "Task".to_string(),
                "Tool registry not available for subagent.".to_string(),
                false,
            );
            return;
        };

        let Some(provider_manager) = self.provider_manager.clone() else {
            self.app_state.add_pending_tool_result(
                tool_call_id,
                "Task".to_string(),
                "Provider not configured for subagent.".to_string(),
                false,
            );
            return;
        };

        let tool_tx = self.tool_event_tx.clone();
        let id = tool_call_id.clone();

        // Add to UI display (session_id, tool_call_id, description, agent_type)
        self.app_state.add_subagent_task(SubagentTaskDisplay::new(
            format!("subagent_{}", id), // session_id
            id.clone(),                 // tool_call_id
            description.clone(),
            subagent_type.clone(),
        ));

        // Spawn background task with full agentic loop (like OpenCode)
        let task = tokio::spawn(async move {
            let started_at = Instant::now();

            // Send started event
            let _ = tool_tx
                .send(ToolEvent::Started {
                    id: id.clone(),
                    name: "Task".to_string(),
                    started_at,
                })
                .await;

            // Build subagent system prompt (like OpenCode)
            let system_prompt = format!(
                "You are a specialized {} subagent working on: {}\n\n\
                 You have access to tools like Read, Edit, Grep, Glob, LS, Execute, Batch, etc.\n\
                 Note: You cannot use Task, TodoWrite, or TodoRead tools (they are disabled for subagents).\n\
                 Use Batch to execute multiple tools in parallel for efficiency.\n\
                 If a tool fails, try an alternative approach instead of giving up.\n\
                 Complete the task and provide a clear summary when done.",
                subagent_type, description
            );

            // Build initial messages for subagent
            let mut messages = vec![Message::system(system_prompt), Message::user(&prompt)];

            // Get tool definitions - filter based on subagent permissions (like OpenCode)
            let tools: Vec<ClientToolDefinition> = registry
                .get_definitions()
                .into_iter()
                .filter(|t| {
                    let name_lower = t.name.to_lowercase();
                    name_lower != "task" && name_lower != "todowrite" && name_lower != "todoread"
                })
                .map(|t| ClientToolDefinition::function(t.name, t.description, t.parameters))
                .collect();

            // Get model info
            let model = {
                let pm = provider_manager.read().await;
                pm.current_model().to_string()
            };

            let mut final_content = String::new();
            let mut tool_calls_executed: Vec<String> = Vec::new();
            let max_iterations = 10; // Prevent infinite loops

            // Agentic loop - continues until no more tool calls
            for iteration in 0..max_iterations {
                tracing::info!("Subagent iteration {}", iteration + 1);

                // Get fresh client for each iteration
                let client = {
                    let mut pm = provider_manager.write().await;
                    if let Err(e) = pm.ensure_client() {
                        let _ = tool_tx
                            .send(ToolEvent::Failed {
                                id: id.clone(),
                                name: "Task".to_string(),
                                error: format!("Failed to initialize provider: {}", e),
                                duration: started_at.elapsed(),
                            })
                            .await;
                        return;
                    }
                    pm.take_client()
                };

                let Some(client) = client else {
                    let _ = tool_tx
                        .send(ToolEvent::Failed {
                            id: id.clone(),
                            name: "Task".to_string(),
                            error: "No client available".to_string(),
                            duration: started_at.elapsed(),
                        })
                        .await;
                    return;
                };

                // Make LLM request
                let request = cortex_engine::client::CompletionRequest {
                    messages: messages.clone(),
                    model: model.clone(),
                    max_tokens: Some(8192),
                    temperature: Some(0.7),
                    tools: tools.clone(),
                    stream: true,
                };

                let stream_result =
                    tokio::time::timeout(Duration::from_secs(120), client.complete(request)).await;

                let mut stream = match stream_result {
                    Ok(Ok(s)) => s,
                    Ok(Err(e)) => {
                        let _ = tool_tx
                            .send(ToolEvent::Failed {
                                id: id.clone(),
                                name: "Task".to_string(),
                                error: simplify_error_message(&e.to_string()),
                                duration: started_at.elapsed(),
                            })
                            .await;
                        return;
                    }
                    Err(_) => {
                        let _ = tool_tx
                            .send(ToolEvent::Failed {
                                id: id.clone(),
                                name: "Task".to_string(),
                                error: "Connection timeout".to_string(),
                                duration: started_at.elapsed(),
                            })
                            .await;
                        return;
                    }
                };

                // Collect response from this iteration
                let mut iteration_content = String::new();
                let mut iteration_tool_calls: Vec<(String, String, serde_json::Value)> = Vec::new(); // (id, name, args)

                loop {
                    let event = tokio::time::timeout(Duration::from_secs(60), stream.next()).await;

                    match event {
                        Ok(Some(Ok(ResponseEvent::Delta(delta)))) => {
                            iteration_content.push_str(&delta);
                        }
                        Ok(Some(Ok(ResponseEvent::Done(_)))) => {
                            break;
                        }
                        Ok(Some(Ok(ResponseEvent::ToolCall(tc)))) => {
                            let args: serde_json::Value = serde_json::from_str(&tc.arguments)
                                .unwrap_or(serde_json::json!({}));
                            iteration_tool_calls.push((tc.id, tc.name, args));
                        }
                        Ok(Some(Ok(ResponseEvent::Error(e)))) => {
                            let _ = tool_tx
                                .send(ToolEvent::Failed {
                                    id: id.clone(),
                                    name: "Task".to_string(),
                                    error: e,
                                    duration: started_at.elapsed(),
                                })
                                .await;
                            return;
                        }
                        Ok(Some(Err(e))) => {
                            let _ = tool_tx
                                .send(ToolEvent::Failed {
                                    id: id.clone(),
                                    name: "Task".to_string(),
                                    error: e.to_string(),
                                    duration: started_at.elapsed(),
                                })
                                .await;
                            return;
                        }
                        Ok(None) => break,
                        Err(_) => {
                            let _ = tool_tx
                                .send(ToolEvent::Failed {
                                    id: id.clone(),
                                    name: "Task".to_string(),
                                    error: "Response timeout".to_string(),
                                    duration: started_at.elapsed(),
                                })
                                .await;
                            return;
                        }
                        _ => {}
                    }
                }

                // If no tool calls, we're done
                if iteration_tool_calls.is_empty() {
                    final_content = iteration_content;
                    break;
                }

                // Execute tool calls and collect results
                let mut tool_results: Vec<(String, String)> = Vec::new(); // (tool_call_id, output)

                // Build tool_calls for the assistant message
                let tool_calls_for_msg: Vec<cortex_engine::client::ToolCall> = iteration_tool_calls
                    .iter()
                    .map(
                        |(tc_id, tc_name, tc_args)| cortex_engine::client::ToolCall {
                            id: tc_id.clone(),
                            call_type: "function".to_string(),
                            function: cortex_engine::client::FunctionCall {
                                name: tc_name.clone(),
                                arguments: tc_args.to_string(),
                            },
                        },
                    )
                    .collect();

                for (tc_id, tc_name, tc_args) in &iteration_tool_calls {
                    tracing::info!("Subagent executing tool: {} ({})", tc_name, tc_id);

                    let result = registry.execute(tc_name, tc_args.clone()).await;
                    match result {
                        Ok(tool_result) => {
                            let status = if tool_result.success {
                                "success"
                            } else {
                                "failed"
                            };
                            tool_calls_executed.push(format!("{}: {}", tc_name, status));
                            tool_results.push((tc_id.clone(), tool_result.output));
                        }
                        Err(e) => {
                            let error_msg = format!("Error executing {}: {}", tc_name, e);
                            tool_calls_executed.push(format!("{}: error", tc_name));
                            tool_results.push((tc_id.clone(), error_msg));
                        }
                    }
                }

                // Add assistant message with tool calls to conversation
                let assistant_msg = Message {
                    role: cortex_engine::client::MessageRole::Assistant,
                    content: cortex_engine::client::MessageContent::Text(iteration_content.clone()),
                    tool_call_id: None,
                    tool_calls: Some(tool_calls_for_msg),
                };
                messages.push(assistant_msg);

                // Add tool results to conversation
                for (tc_id, output) in tool_results {
                    messages.push(Message::tool_result(&tc_id, &output));
                }

                // Store content for final output
                if !iteration_content.is_empty() {
                    final_content = iteration_content;
                }
            }

            // Build output with metadata
            let tools_summary = if tool_calls_executed.is_empty() {
                "No tools executed".to_string()
            } else {
                tool_calls_executed.join("\n")
            };

            let output = format!(
                "{}\n\n\
                 Tools executed:\n{}\n\n\
                 <task_metadata>\n\
                 session_id: subagent_{}\n\
                 agent_type: {}\n\
                 description: {}\n\
                 </task_metadata>",
                final_content, tools_summary, id, subagent_type, description
            );

            let duration = started_at.elapsed();

            let _ = tool_tx
                .send(ToolEvent::Completed {
                    id,
                    name: "Task".to_string(),
                    output,
                    success: true,
                    duration,
                })
                .await;
        });

        self.running_tool_tasks.insert(tool_call_id, task);
    }

    /// Spawns a tool execution task in the background.
    fn spawn_tool_execution(
        &mut self,
        tool_call_id: String,
        tool_name: String,
        args: serde_json::Value,
    ) {
        tracing::info!("Spawning tool execution: {} ({})", tool_name, tool_call_id);

        // Get tool registry
        let Some(registry) = self.tool_registry.clone() else {
            tracing::warn!(
                "Tool registry not initialized, cannot execute: {}",
                tool_name
            );
            self.app_state.add_pending_tool_result(
                tool_call_id,
                tool_name,
                "Tool registry not initialized. This is a configuration error.".to_string(),
                false,
            );
            return;
        };

        let tool_tx = self.tool_event_tx.clone();
        let id = tool_call_id.clone();
        let name = tool_name.clone();

        // Spawn background task for tool execution
        let task = tokio::spawn(async move {
            let started_at = Instant::now();

            // Send started event
            let _ = tool_tx
                .send(ToolEvent::Started {
                    id: id.clone(),
                    name: name.clone(),
                    started_at,
                })
                .await;

            // Execute the tool
            let result = registry.execute(&name, args).await;
            let duration = started_at.elapsed();

            match result {
                Ok(tool_result) => {
                    let _ = tool_tx
                        .send(ToolEvent::Completed {
                            id,
                            name,
                            output: tool_result.output,
                            success: tool_result.success,
                            duration,
                        })
                        .await;
                }
                Err(e) => {
                    let _ = tool_tx
                        .send(ToolEvent::Failed {
                            id,
                            name,
                            error: e.to_string(),
                            duration,
                        })
                        .await;
                }
            }
        });

        self.running_tool_tasks.insert(tool_call_id, task);
    }

    /// Syncs the permission mode between app state and permission manager.
    fn sync_permission_mode(&mut self) {
        self.permission_manager.mode = match self.app_state.permission_mode {
            crate::permissions::PermissionMode::Yolo => crate::permissions::PermissionMode::Yolo,
            crate::permissions::PermissionMode::Low => crate::permissions::PermissionMode::Low,
            crate::permissions::PermissionMode::Medium => {
                crate::permissions::PermissionMode::Medium
            }
            crate::permissions::PermissionMode::High => crate::permissions::PermissionMode::High,
        };
    }

    /// Updates the session's model metadata and persists it.
    /// This ensures the model is saved with the session for /load to display correctly.
    fn update_session_model(&mut self, model_id: &str) {
        if let Some(ref mut session) = self.cortex_session {
            session.meta.model = model_id.to_string();
            if let Err(e) = session.save() {
                tracing::error!("Failed to save session model: {}", e);
            }
        }
    }

    /// Continues with tool results after execution - sends results back to LLM.
    async fn continue_with_tool_results(&mut self) -> Result<()> {
        // Check if there are pending tool results
        if !self.app_state.has_pending_tool_results() {
            return Ok(());
        }

        tracing::info!(
            "Continuing with {} pending tool results",
            self.app_state.pending_tool_results.len()
        );

        // Take pending results
        let pending_results = std::mem::take(&mut self.app_state.pending_tool_results);

        // Save tool results to session
        if let Some(ref mut session) = self.cortex_session {
            for result in &pending_results {
                let stored_msg = crate::session::StoredMessage::tool_result(
                    &result.tool_call_id,
                    &result.output,
                );
                session.add_message_raw(stored_msg);
            }
        }

        // Send tool results back to LLM to continue the conversation
        // This triggers a new streaming request with the tool results
        tracing::info!("About to call send_tool_results_to_llm");
        self.send_tool_results_to_llm(pending_results).await?;
        tracing::info!("send_tool_results_to_llm completed, streaming_rx is now set");

        Ok(())
    }

    /// Sends tool results to the LLM to continue the agentic loop.
    /// This triggers a new streaming request with the tool results already in the session.
    async fn send_tool_results_to_llm(&mut self, results: Vec<PendingToolResult>) -> Result<()> {
        if results.is_empty() {
            return Ok(());
        }

        tracing::info!(
            "Sending {} tool results to LLM for continuation",
            results.len()
        );

        // Mark as continuation - tool calls should NOT be cleared
        self.is_continuation = true;

        // Check provider exists
        let provider_manager = match &self.provider_manager {
            Some(pm) => pm.clone(),
            None => {
                tracing::warn!("No provider manager for tool result continuation");
                return Ok(());
            }
        };

        // Build system prompt
        let system_prompt = build_system_prompt();
        let system_message = Message::system(system_prompt);

        // Build messages for API (includes tool results that were just added to session)
        let session_messages: Vec<Message> = if let Some(ref session) = self.cortex_session {
            session.messages_for_api()
        } else {
            tracing::warn!("No session for tool result continuation");
            return Ok(());
        };

        // Prepend system prompt to messages
        let mut messages: Vec<Message> = vec![system_message];
        messages.extend(session_messages);

        // Get tool definitions from registry
        let tools: Vec<ClientToolDefinition> = self
            .tool_registry
            .as_ref()
            .map(|r| r.get_definitions())
            .unwrap_or_default()
            .into_iter()
            .map(|t| ClientToolDefinition::function(t.name, t.description, t.parameters))
            .collect();

        // Start streaming UI state
        self.stream_controller.start_processing();
        self.app_state.start_streaming(None);

        // Reset cancellation flag and stream_done flag
        self.streaming_cancelled.store(false, Ordering::SeqCst);
        self.stream_done_received = false;

        // Get completion request parameters
        let (model, max_tokens, temperature, client) = {
            let mut pm = provider_manager.write().await;

            if let Err(e) = pm.ensure_client() {
                self.stream_controller.set_error(e.to_string());
                self.app_state.stop_streaming();
                return Ok(());
            }

            let model = pm.current_model().to_string();
            let max_tokens = pm.config().max_tokens;
            let temperature = pm.config().temperature;
            let client = pm.take_client();

            (model, max_tokens, temperature, client)
        };

        if client.is_none() {
            self.app_state.stop_streaming();
            return Ok(());
        }

        // Create channel for streaming events
        let (tx, rx) = mpsc::channel::<StreamEvent>(100);
        self.streaming_rx = Some(rx);

        let cancelled = self.streaming_cancelled.clone();

        // Spawn background streaming task
        let task = tokio::spawn(async move {
            let client = client.unwrap();

            let request = cortex_engine::client::CompletionRequest {
                messages,
                model,
                max_tokens: Some(max_tokens),
                temperature: Some(temperature),
                tools,
                stream: true,
            };

            let stream_result =
                tokio::time::timeout(Duration::from_secs(60), client.complete(request)).await;

            let mut stream = match stream_result {
                Ok(Ok(s)) => s,
                Ok(Err(e)) => {
                    let _ = tx
                        .send(StreamEvent::Error(simplify_error_message(&e.to_string())))
                        .await;
                    return;
                }
                Err(_) => {
                    let _ = tx
                        .send(StreamEvent::Error(
                            "Connection timed out. Please try again.".to_string(),
                        ))
                        .await;
                    return;
                }
            };

            let mut content = String::new();
            let mut reasoning = String::new();
            let mut tokens: Option<cortex_engine::streaming::StreamTokenUsage> = None;

            loop {
                if cancelled.load(Ordering::SeqCst) {
                    let _ = tx
                        .send(StreamEvent::Error("Cancelled by user".to_string()))
                        .await;
                    break;
                }

                let event = tokio::time::timeout(Duration::from_secs(30), stream.next()).await;

                match event {
                    Ok(Some(Ok(ResponseEvent::Delta(delta)))) => {
                        content.push_str(&delta);
                        if tx.send(StreamEvent::Delta(delta)).await.is_err() {
                            break;
                        }
                    }
                    Ok(Some(Ok(ResponseEvent::Reasoning(r)))) => {
                        reasoning.push_str(&r);
                        if tx.send(StreamEvent::Reasoning(r)).await.is_err() {
                            break;
                        }
                    }
                    Ok(Some(Ok(ResponseEvent::Done(response)))) => {
                        tokens = Some(cortex_engine::streaming::StreamTokenUsage::from(
                            response.usage,
                        ));
                        let _ = tx
                            .send(StreamEvent::Done {
                                content,
                                reasoning,
                                tokens,
                            })
                            .await;
                        break;
                    }
                    Ok(Some(Ok(ResponseEvent::Error(e)))) => {
                        let _ = tx.send(StreamEvent::Error(e)).await;
                        break;
                    }
                    Ok(Some(Ok(ResponseEvent::ToolCall(tool_call)))) => {
                        let arguments = serde_json::from_str(&tool_call.arguments)
                            .unwrap_or_else(|_| serde_json::json!({"raw": tool_call.arguments}));
                        if tx
                            .send(StreamEvent::ToolCall {
                                id: tool_call.id.clone(),
                                name: tool_call.name.clone(),
                                arguments,
                            })
                            .await
                            .is_err()
                        {
                            break;
                        }
                    }
                    Ok(Some(Err(e))) => {
                        let _ = tx.send(StreamEvent::Error(e.to_string())).await;
                        break;
                    }
                    Ok(None) => {
                        let _ = tx
                            .send(StreamEvent::Done {
                                content,
                                reasoning,
                                tokens,
                            })
                            .await;
                        break;
                    }
                    Err(_) => {
                        let _ = tx
                            .send(StreamEvent::Error("Response timeout".to_string()))
                            .await;
                        break;
                    }
                }
            }
        });

        self.streaming_task = Some(task);

        Ok(())
    }

    /// Processes the message queue (queued user messages).
    async fn process_message_queue(&mut self) -> Result<()> {
        // Take first message from queue
        if let Some(message) = self.app_state.message_queue.pop_front() {
            tracing::debug!(
                "Processing queued message: {}",
                &message[..message.len().min(50)]
            );
            self.handle_submit_with_provider(message).await?;
        }
        Ok(())
    }

    /// Spawns a unified tool execution (for Task/Batch tools).
    /// Routes Task to spawn_subagent, Batch to parallel execution.
    fn spawn_unified_tool_execution(
        &mut self,
        tool_call_id: String,
        tool_name: String,
        args: serde_json::Value,
    ) {
        tracing::info!(
            "Spawning unified tool execution: {} ({})",
            tool_name,
            tool_call_id
        );

        // Route Task tool to spawn_subagent
        if tool_name == "Task" || tool_name == "task" {
            self.spawn_subagent(tool_call_id, args);
            return;
        }

        // Parse args for Batch: { tool_calls: [{ tool, parameters }, ...] }
        let tool_calls = match args.get("tool_calls").and_then(|v| v.as_array()) {
            Some(calls) => calls.clone(),
            None => {
                self.app_state.add_pending_tool_result(
                    tool_call_id,
                    tool_name,
                    "Batch tool requires 'tool_calls' array parameter.".to_string(),
                    false,
                );
                return;
            }
        };

        // Validate: max 10 tools
        if tool_calls.len() > 10 {
            self.app_state.add_pending_tool_result(
                tool_call_id,
                tool_name,
                format!("Batch tool allows max 10 tools, got {}.", tool_calls.len()),
                false,
            );
            return;
        }

        // Get tool registry
        let Some(registry) = self.tool_registry.clone() else {
            self.app_state.add_pending_tool_result(
                tool_call_id,
                tool_name,
                "Tool registry not available for batch execution.".to_string(),
                false,
            );
            return;
        };

        let tool_tx = self.tool_event_tx.clone();
        let id = tool_call_id.clone();

        // Spawn background task for parallel execution
        let task = tokio::spawn(async move {
            let started_at = Instant::now();

            // Send started event
            let _ = tool_tx
                .send(ToolEvent::Started {
                    id: id.clone(),
                    name: "Batch".to_string(),
                    started_at,
                })
                .await;

            // Execute tools in parallel
            let mut handles = Vec::new();

            for call in tool_calls {
                let tool_name_inner = call
                    .get("tool")
                    .and_then(|v| v.as_str())
                    .unwrap_or("unknown")
                    .to_string();
                let params = call
                    .get("parameters")
                    .cloned()
                    .unwrap_or(serde_json::json!({}));

                // Skip batch in batch (prevent recursion)
                if tool_name_inner.to_lowercase() == "batch" {
                    continue;
                }

                let reg = registry.clone();
                let handle = tokio::spawn(async move {
                    let result = reg.execute(&tool_name_inner, params).await;
                    (tool_name_inner, result)
                });
                handles.push(handle);
            }

            // Wait for all to complete
            let mut results = Vec::new();
            for handle in handles {
                results.push(handle.await);
            }

            let mut successful = 0;
            let mut failed = 0;
            let mut details = Vec::new();

            for result in results {
                match result {
                    Ok((name, Ok(tool_result))) => {
                        if tool_result.success {
                            successful += 1;
                        } else {
                            failed += 1;
                        }
                        details.push(format!(
                            "- {}: {}",
                            name,
                            if tool_result.success {
                                "success"
                            } else {
                                "failed"
                            }
                        ));
                    }
                    Ok((name, Err(e))) => {
                        failed += 1;
                        details.push(format!("- {}: error - {}", name, e));
                    }
                    Err(e) => {
                        failed += 1;
                        details.push(format!("- <task error>: {}", e));
                    }
                }
            }

            let total = successful + failed;
            let output = format!(
                "Batch execution completed: {}/{} successful\n\n{}\n\n\
                 <batch_metadata>\n\
                 total_calls: {}\n\
                 successful: {}\n\
                 failed: {}\n\
                 </batch_metadata>",
                successful,
                total,
                details.join("\n"),
                total,
                successful,
                failed
            );

            let duration = started_at.elapsed();

            let _ = tool_tx
                .send(ToolEvent::Completed {
                    id,
                    name: "Batch".to_string(),
                    output,
                    success: failed == 0,
                    duration,
                })
                .await;
        });

        self.running_tool_tasks.insert(tool_call_id, task);
    }

    /// Handle events from the frame engine.
    ///
    /// This processes low-level events from the terminal: frame ticks (for
    /// animations), keyboard events (mapped to actions), mouse events,
    /// resize events, and quit signals.
    async fn handle_engine_event(
        &mut self,
        event: EngineEvent,
        terminal: &mut CortexTerminal,
    ) -> Result<()> {
        match event {
            EngineEvent::Tick(_frame) => {
                // Update animations
                self.app_state.tick();
                self.stream_controller.tick();

                // Update tool call spinners (for animated ◐◑◒◓ indicator)
                self.app_state.tick_tool_spinners();

                // Update subagent spinners (for animated ◐◑◒◓ indicator)
                self.app_state.tick_subagent_spinners();

                // Update scrollbar visibility (for auto-hide with fade)
                self.app_state.tick_scrollbar();

                // Update toast notifications (for auto-dismiss with fade)
                self.app_state.toasts.tick();

                // Render frame (respecting frame time to avoid over-rendering)
                if self.last_render.elapsed() >= self.min_frame_time {
                    self.render(terminal)?;
                    self.last_render = Instant::now();
                }
            }

            EngineEvent::Key(key_event) => {
                use crossterm::event::KeyCode;

                // Check modal stack first (new unified modal system)
                if self.modal_stack.is_active() {
                    let result = self.modal_stack.handle_key(key_event.clone());
                    match result {
                        ModalResult::Action(action) => {
                            self.process_modal_action(action).await;
                        }
                        _ => {}
                    }
                    self.render(terminal)?;
                    return Ok(());
                }

                // Check if in interactive mode and handle its input first
                if self.app_state.is_interactive_mode() {
                    if let Some(state) = self.app_state.get_interactive_state_mut() {
                        let result =
                            crate::interactive::handle_interactive_key(state, key_event.clone());
                        match result {
                            crate::interactive::InteractiveResult::Selected {
                                action,
                                item_id,
                                item_ids,
                            } => {
                                let keep_open = self
                                    .handle_interactive_selection(action, item_id, item_ids)
                                    .await;
                                if !keep_open {
                                    self.app_state.exit_interactive_mode();
                                }
                            }
                            crate::interactive::InteractiveResult::FormSubmitted {
                                action_id,
                                values,
                            } => {
                                // Handle inline form submission
                                // Returns true if we should stay in interactive mode
                                let stay_open =
                                    self.handle_inline_form_submission(&action_id, values);
                                if !stay_open {
                                    self.app_state.exit_interactive_mode();
                                }
                            }
                            crate::interactive::InteractiveResult::Cancelled => {
                                self.app_state.exit_interactive_mode();
                            }
                            crate::interactive::InteractiveResult::Continue => {
                                // Just re-render
                            }
                        }
                    }
                    self.render(terminal)?;
                    return Ok(());
                }

                // Check if a card is active and handle its input first
                if self.card_handler.is_active() {
                    if self.card_handler.handle_key(key_event.clone()) {
                        // Process any pending card actions
                        self.process_card_actions();
                        self.render(terminal)?;
                        return Ok(());
                    }
                }

                // Check if a modal is open and handle its input first
                if self.app_state.has_modal() {
                    if self.handle_modal_key(key_event.clone()).await? {
                        self.render(terminal)?;
                        return Ok(());
                    }
                }

                // Handle Questions view input
                if self.app_state.view == AppView::Questions {
                    if self.handle_question_key(key_event.clone()).await? {
                        self.render(terminal)?;
                        return Ok(());
                    }
                }

                // Handle Ctrl+C with contextual behavior
                if key_event.code == KeyCode::Char('c')
                    && key_event
                        .modifiers
                        .contains(crossterm::event::KeyModifiers::CONTROL)
                {
                    // Priority 1: If in interactive mode, exit it
                    if self.app_state.is_interactive_mode() {
                        self.app_state.exit_interactive_mode();
                        self.app_state.reset_ctrl_c();
                        self.app_state.reset_esc();
                        self.render(terminal)?;
                        return Ok(());
                    }

                    // Priority 2: If text is selected, copy it
                    if self.app_state.text_selection.has_selection() {
                        self.copy_selection_to_clipboard(terminal)?;
                        self.app_state.text_selection.clear();
                        self.app_state.reset_ctrl_c();
                        self.app_state.reset_esc();
                        self.render(terminal)?;
                        return Ok(());
                    }

                    // Priority 3: If input has text, clear it
                    if !self.app_state.input.is_empty() {
                        self.app_state.input.clear();
                        self.app_state.autocomplete.hide();
                        self.app_state.reset_ctrl_c();
                        self.app_state.reset_esc();
                        self.render(terminal)?;
                        return Ok(());
                    }

                    // Priority 4: Double Ctrl+C to quit
                    if self.app_state.handle_ctrl_c() {
                        self.app_state.set_quit();
                        return Ok(());
                    } else {
                        self.app_state.toasts.info("Press Ctrl+C again to quit");
                        self.render(terminal)?;
                        return Ok(());
                    }
                }

                // Handle ESC with double-tap to quit when idle
                if key_event.code == KeyCode::Esc {
                    // Check if app is idle (nothing active that ESC should cancel)
                    let is_idle = !self.app_state.streaming.is_streaming
                        && self.app_state.pending_approval.is_none()
                        && !self.app_state.has_queued_messages()
                        && !self.app_state.autocomplete.visible;

                    if is_idle {
                        if self.app_state.handle_esc() {
                            self.app_state.set_quit();
                            return Ok(());
                        } else {
                            self.app_state.toasts.info("Press ESC again to quit");
                            self.render(terminal)?;
                            return Ok(());
                        }
                    }
                }

                // Reset Ctrl+C and ESC timers on other key presses
                if key_event.code != KeyCode::Esc {
                    self.app_state.reset_esc();
                }
                self.app_state.reset_ctrl_c();

                let context = self.get_action_context();
                let action = self.action_mapper.get_action(key_event.clone(), context);

                // Check if autocomplete is visible and handle its navigation
                if self.app_state.autocomplete.visible {
                    match key_event.code {
                        KeyCode::Up => {
                            self.app_state.autocomplete.select_prev();
                            self.render(terminal)?;
                            return Ok(());
                        }
                        KeyCode::Down => {
                            self.app_state.autocomplete.select_next();
                            self.render(terminal)?;
                            return Ok(());
                        }
                        KeyCode::Tab => {
                            // Accept completion with Tab only
                            if let Some(completion_text) =
                                self.app_state.autocomplete.completion_text()
                            {
                                let pos = self.app_state.autocomplete.trigger_position;
                                let current = self.app_state.input.text();

                                // Find the end of the current query (next whitespace or end of string)
                                let query_end = current[pos..]
                                    .find(char::is_whitespace)
                                    .map(|i| pos + i)
                                    .unwrap_or(current.len());

                                // Get trigger char (/ or @)
                                let trigger = if pos < current.len() {
                                    &current[pos..pos + 1]
                                } else {
                                    ""
                                };

                                // Build new text: before trigger + trigger + completion + rest of input (or space)
                                let rest = if query_end < current.len() {
                                    &current[query_end..]
                                } else {
                                    " "
                                };
                                let new_text = format!(
                                    "{}{}{}{}",
                                    &current[..pos],
                                    trigger,
                                    completion_text,
                                    rest
                                );
                                self.app_state.input.set_text(&new_text);
                            }
                            self.app_state.autocomplete.hide();
                            self.render(terminal)?;
                            return Ok(());
                        }
                        KeyCode::Enter => {
                            // Enter completes and immediately executes the command
                            if let Some(completion_text) =
                                self.app_state.autocomplete.completion_text()
                            {
                                let current = self.app_state.input.text().to_string();
                                let pos = self.app_state.autocomplete.trigger_position;
                                if pos < current.len() {
                                    let query_end = current[pos..]
                                        .find(char::is_whitespace)
                                        .map(|i| pos + i)
                                        .unwrap_or(current.len());
                                    let trigger = if pos < current.len() {
                                        &current[pos..pos + 1]
                                    } else {
                                        ""
                                    };
                                    let rest = if query_end < current.len() {
                                        &current[query_end..]
                                    } else {
                                        ""
                                    };
                                    let new_text = format!(
                                        "{}{}{}{}",
                                        &current[..pos],
                                        trigger,
                                        completion_text,
                                        rest
                                    );
                                    self.app_state.input.set_text(&new_text);
                                }
                            }
                            self.app_state.autocomplete.hide();
                            // Don't return - fall through to execute the command
                        }
                        KeyCode::Esc => {
                            self.app_state.autocomplete.hide();
                            self.render(terminal)?;
                            return Ok(());
                        }
                        _ => {
                            // Continue to normal handling, which will update autocomplete
                        }
                    }
                }

                // Forward key events to input widget when focused and no action mapped
                // This allows character input, backspace, delete, etc. to work
                if context == ActionContext::Input && action == KeyAction::None {
                    // Clear selection when typing
                    self.app_state.text_selection.clear();

                    self.app_state.input.handle_key(key_event);
                    // Update autocomplete based on new input
                    self.update_autocomplete();
                }

                self.handle_action(action).await?;

                // Always render after key input for responsiveness
                self.render(terminal)?;
            }

            EngineEvent::Mouse(mouse_event) => {
                if let Some(action) = self.mouse_handler.handle(mouse_event) {
                    self.handle_mouse_action(action, terminal).await?;
                }
            }

            EngineEvent::Resize(width, height) => {
                self.app_state.terminal_size = (width, height);
                terminal.clear()?;
                self.render(terminal)?;
            }

            EngineEvent::Quit => {
                self.app_state.set_quit();
            }

            EngineEvent::Error(msg) => {
                tracing::error!("Engine error: {}", msg);
            }

            EngineEvent::Paste(text) => {
                // Check if a form modal is active and route paste to it
                if let Some(crate::app::ActiveModal::Form(ref mut form_state)) =
                    self.app_state.active_modal
                {
                    form_state.handle_paste(&text);
                } else {
                    // Otherwise insert pasted text into the main input widget
                    self.app_state.input.insert_str(&text);
                }
                self.render(terminal)?;
            }
        }

        Ok(())
    }

    // ========================================================================
    // BACKEND EVENT HANDLING
    // ========================================================================

    /// Handles an event from the cortex-core backend.
    ///
    /// Converts the protocol event to an application event and dispatches it.
    fn handle_backend_event(&mut self, event: cortex_protocol::Event) -> Result<()> {
        // Convert to AppEvent
        if let Some(app_event) = adapt_event(event) {
            self.handle_app_event(app_event)?;
        }
        Ok(())
    }

    /// Handles an application-level event.
    ///
    /// This method processes streaming events, tool events, message events,
    /// and other high-level application events converted from backend events.
    fn handle_app_event(&mut self, event: AppEvent) -> Result<()> {
        match event {
            AppEvent::StreamingStarted => {
                self.stream_controller.start_processing();
                self.app_state.start_streaming(None);
            }

            AppEvent::StreamingChunk(chunk) => {
                self.stream_controller.append_text(&chunk);
            }

            AppEvent::StreamingCompleted => {
                self.stream_controller.complete();
                self.app_state.stop_streaming();

                // Create message from accumulated content
                let content = self.stream_controller.committed_text().to_string();
                if !content.is_empty() {
                    let message = cortex_core::widgets::Message::assistant(content);
                    self.app_state.add_message(message);
                }
                self.stream_controller.reset();
            }

            AppEvent::StreamingError(err) => {
                self.stream_controller.set_error(err.clone());
                self.app_state.stop_streaming();
                tracing::error!("Streaming error: {}", err);
            }

            AppEvent::MessageReceived(msg) => {
                self.app_state.add_message(msg);
            }

            AppEvent::ToolStarted { name, args: _ } => {
                self.stream_controller.start_tool(name.clone());
                self.app_state.streaming.current_tool = Some(name);
            }

            AppEvent::ToolCompleted { name: _, result: _ } => {
                self.app_state.streaming.current_tool = None;
            }

            AppEvent::ToolApprovalRequired { name, args, diff } => {
                self.stream_controller.wait_approval(name.clone());
                let args_str = serde_json::to_string_pretty(&args).unwrap_or_default();
                self.app_state.request_approval(name, args_str, diff);
            }

            AppEvent::ToolError { name, error } => {
                tracing::error!("Tool '{}' error: {}", name, error);
                self.app_state.streaming.current_tool = None;
            }

            AppEvent::ToolProgress { name: _, status: _ } => {
                // Tool progress updates are handled by stream controller
            }

            AppEvent::ToolApproved(_) | AppEvent::ToolRejected(_) => {
                // These are outgoing events, not incoming
            }

            AppEvent::Error(err) => {
                tracing::error!("Backend error: {}", err);
                // Could show error notification in UI
            }

            AppEvent::Warning(warning) => {
                tracing::warn!("Backend warning: {}", warning);
            }

            AppEvent::Info(info) => {
                tracing::info!("Backend info: {}", info);
            }

            AppEvent::SessionCreated(id) => {
                self.app_state.session_id = Some(id);
            }

            AppEvent::SessionLoaded(id) => {
                self.app_state.session_id = Some(id);
                self.app_state.set_view(AppView::Session);
            }

            AppEvent::Quit => {
                self.app_state.set_quit();
            }

            // Handle other events as needed
            _ => {
                tracing::debug!("Unhandled app event: {:?}", event);
            }
        }

        Ok(())
    }

    // ========================================================================
    // ACTION HANDLING
    // ========================================================================

    /// Handles a mapped action from user input.
    ///
    /// This method translates high-level actions into state changes and
    /// backend communication.
    async fn handle_action(&mut self, action: KeyAction) -> Result<()> {
        match action {
            KeyAction::Quit => {
                self.app_state.set_quit();
            }

            KeyAction::Submit => {
                let text = self.app_state.input.submit();
                if !text.is_empty() {
                    // Check for slash commands first
                    if text.starts_with('/') {
                        // Check if command exists before executing
                        let cmd_name = text[1..].split_whitespace().next().unwrap_or("");
                        if self.command_executor.registry().exists(cmd_name) {
                            // Valid command - record and execute
                            self.app_state.add_to_history(cmd_name);
                            let result = self.command_executor.execute_str(&text);
                            self.handle_command_result(result).await?;
                        } else {
                            // Unknown command - send as regular message
                            self.send_text_message(text).await?;
                        }
                    } else {
                        // Regular text message
                        self.send_text_message(text).await?;
                    }
                }
            }

            KeyAction::Cancel => {
                // Priority order: queued messages > pending approval > streaming
                if self.app_state.has_queued_messages() {
                    // Cancel queued messages first
                    let count = self.app_state.queued_count();
                    self.app_state.clear_message_queue();
                    self.add_system_message(&format!("Cancelled {} queued message(s)", count));
                } else if self.app_state.pending_approval.is_some() {
                    self.app_state.reject();
                } else if self.app_state.streaming.is_streaming {
                    // Cancel streaming - try new system first, then legacy
                    if self.streaming_task.is_some() {
                        self.cancel_streaming();
                    } else if let Some(ref bridge) = self.session_bridge {
                        bridge.interrupt().await?;
                    }
                }
            }

            KeyAction::Approve => {
                if let Some(approval) = self.app_state.approve() {
                    // New provider system: execute the tool in background
                    if self.provider_manager.is_some() {
                        let tool_call_id = approval.tool_call_id.clone();
                        let tool_name = approval.tool_name.clone();

                        // Get arguments from the stored JSON
                        let arguments = approval
                            .tool_args_json
                            .clone()
                            .unwrap_or_else(|| serde_json::json!({}));

                        // Update tool status
                        self.app_state
                            .update_tool_status(&tool_call_id, ToolStatus::Running);

                        // Route Task tool to subagent spawner
                        if tool_name == "Task" || tool_name == "task" {
                            self.spawn_subagent(tool_call_id, arguments);
                        } else {
                            // Spawn tool execution in background (non-blocking!)
                            // The result will come back via tool_rx channel
                            self.spawn_tool_execution(tool_call_id, tool_name, arguments);
                        }
                    } else if let Some(ref bridge) = self.session_bridge {
                        // Legacy: send approval to session bridge
                        let call_id =
                            serde_json::from_str::<serde_json::Value>(&approval.tool_args)
                                .ok()
                                .and_then(|v| {
                                    v.get("call_id")
                                        .and_then(|id| id.as_str())
                                        .map(String::from)
                                })
                                .unwrap_or_default();
                        bridge
                            .send_approval(call_id, cortex_protocol::ReviewDecision::Approved)
                            .await?;
                    }
                }
            }

            KeyAction::Reject => {
                if let Some(approval) = self.app_state.reject() {
                    // Update tool status to failed
                    self.app_state.update_tool_result(
                        &approval.tool_call_id,
                        "Tool execution rejected by user".to_string(),
                        false,
                        "Rejected".to_string(),
                    );

                    if let Some(ref bridge) = self.session_bridge {
                        // Legacy: send rejection to session bridge
                        let call_id =
                            serde_json::from_str::<serde_json::Value>(&approval.tool_args)
                                .ok()
                                .and_then(|v| {
                                    v.get("call_id")
                                        .and_then(|id| id.as_str())
                                        .map(String::from)
                                })
                                .unwrap_or_default();
                        bridge
                            .send_approval(call_id, cortex_protocol::ReviewDecision::Denied)
                            .await?;
                    }
                }
            }

            KeyAction::ApproveSession => {
                // Approve and allow this tool for the rest of the session
                if let Some(approval) = self.app_state.approve() {
                    let tool_name = approval.tool_name.clone();

                    // Add to session-allowed tools
                    self.permission_manager.allow_for_session(&tool_name);

                    if self.provider_manager.is_some() {
                        let tool_call_id = approval.tool_call_id.clone();
                        let arguments = approval
                            .tool_args_json
                            .clone()
                            .unwrap_or_else(|| serde_json::json!({}));

                        self.app_state
                            .update_tool_status(&tool_call_id, ToolStatus::Running);

                        self.add_system_message(&format!(
                            "'{}' will be auto-approved for this session",
                            tool_name
                        ));

                        // Route Task tool to subagent spawner
                        if tool_name == "Task" || tool_name == "task" {
                            self.spawn_subagent(tool_call_id, arguments);
                        } else {
                            // Spawn tool execution in background (non-blocking!)
                            self.spawn_tool_execution(tool_call_id, tool_name, arguments);
                        }
                    }
                }
            }

            KeyAction::ApproveAlways => {
                // Approve and always allow this tool
                if let Some(approval) = self.app_state.approve() {
                    let tool_name = approval.tool_name.clone();

                    // Add to always-allowed tools
                    self.permission_manager.allow_always(&tool_name);

                    if self.provider_manager.is_some() {
                        let tool_call_id = approval.tool_call_id.clone();
                        let arguments = approval
                            .tool_args_json
                            .clone()
                            .unwrap_or_else(|| serde_json::json!({}));

                        self.app_state
                            .update_tool_status(&tool_call_id, ToolStatus::Running);

                        self.add_system_message(&format!(
                            "'{}' will always be auto-approved",
                            tool_name
                        ));

                        // Route Task tool to subagent spawner
                        if tool_name == "Task" || tool_name == "task" {
                            self.spawn_subagent(tool_call_id, arguments);
                        } else {
                            // Spawn tool execution in background (non-blocking!)
                            self.spawn_tool_execution(tool_call_id, tool_name, arguments);
                        }
                    }
                }
            }

            // Focus actions
            KeyAction::FocusNext => self.app_state.focus_next(),
            KeyAction::FocusPrev => self.app_state.focus_prev(),
            KeyAction::FocusInput => self.app_state.set_focus(FocusTarget::Input),
            KeyAction::FocusChat => self.app_state.set_focus(FocusTarget::Chat),
            KeyAction::FocusSidebar => self.app_state.set_focus(FocusTarget::Sidebar),

            // Scroll actions
            KeyAction::ScrollUp => self.app_state.scroll_chat(-1),
            KeyAction::ScrollDown => self.app_state.scroll_chat(1),
            KeyAction::ScrollPageUp => self.app_state.scroll_chat(-10),
            KeyAction::ScrollPageDown => self.app_state.scroll_chat(10),
            KeyAction::ScrollToTop => self.app_state.scroll_chat_to_top(),
            KeyAction::ScrollToBottom => self.app_state.scroll_chat_to_bottom(),

            // View actions
            KeyAction::ToggleSidebar => self.app_state.toggle_sidebar(),
            KeyAction::Help => {
                // Open the new help modal
                use crate::modal::HelpModal;
                self.modal_stack.push(Box::new(HelpModal::new()));
            }

            // Model/Provider switching - open modals
            KeyAction::SwitchModel => {
                self.open_models_modal();
            }
            // SwitchProvider removed: provider is now always "cortex"

            // Modal shortcuts (new unified modal system)
            KeyAction::OpenCommandPalette => {
                use crate::modal::CommandsModal;
                self.modal_stack.push(Box::new(CommandsModal::new()));
            }
            KeyAction::OpenSessions => {
                self.open_sessions_modal();
            }
            KeyAction::OpenMcp => {
                // Open MCP manager using interactive mode (like settings panel)
                use crate::interactive::builders::build_mcp_selector;
                let servers = self.app_state.mcp_servers.clone();
                let interactive = build_mcp_selector(&servers);
                self.app_state.enter_interactive_mode(interactive);
            }

            // Transcript
            KeyAction::ViewTranscript => {
                self.handle_transcript();
            }

            // Permission and tool actions
            KeyAction::CyclePermissionMode => {
                self.app_state.cycle_permission_mode();
                self.sync_permission_mode();
            }
            KeyAction::ToggleToolDetails => {
                // Toggle all tool calls collapsed state
                for call in &mut self.app_state.tool_calls {
                    call.toggle_collapsed();
                }
            }

            // Input history navigation
            KeyAction::HistoryPrev => {
                self.app_state.input.history_prev();
            }
            KeyAction::HistoryNext => {
                self.app_state.input.history_next();
            }

            // No action
            KeyAction::None => {}

            // Handle other actions
            _ => {
                tracing::debug!("Unhandled action: {:?}", action);
            }
        }

        Ok(())
    }

    // ========================================================================
    // RENDERING
    // ========================================================================

    /// Renders the current view to the terminal.
    ///
    /// This method selects the appropriate view based on the current application
    /// state and renders it to the terminal frame.
    fn render(&mut self, terminal: &mut CortexTerminal) -> Result<()> {
        // Sync streaming content from stream controller to app state
        // The SessionView reads from app_state.typewriter for streaming display
        if self.app_state.streaming.is_streaming {
            let display_text = self.stream_controller.display_text();
            // Update app_state typewriter with current streaming content
            if let Some(ref mut typewriter) = self.app_state.typewriter {
                if typewriter.visible_text() != display_text {
                    typewriter.set_text(display_text.to_string());
                    typewriter.skip_to_end();
                }
            }
        }

        terminal.draw(|frame| {
            let area = frame.area();

            match self.app_state.view {
                AppView::Session => {
                    // Use the new minimalist session view
                    let view = crate::views::MinimalSessionView::new(&self.app_state);
                    frame.render_widget(view, area);
                }

                AppView::Approval => {
                    // Render minimal session view as background
                    let session_view = crate::views::MinimalSessionView::new(&self.app_state);
                    frame.render_widget(session_view, area);

                    // Render approval overlay
                    let approval_view = ApprovalView::new(&self.app_state);
                    frame.render_widget(approval_view, area);
                }

                AppView::Questions => {
                    // Render minimal session view as background
                    let session_view = crate::views::MinimalSessionView::new(&self.app_state);
                    frame.render_widget(session_view, area);

                    // Render question prompt overlay
                    if let Some(q_state) = self.app_state.get_question_state() {
                        let question_view = QuestionPromptView::new(q_state)
                            .with_hovered_option(self.app_state.question_hovered_option)
                            .with_hovered_tab(self.app_state.question_hovered_tab);
                        frame.render_widget(question_view, area);
                    }
                }

                AppView::Settings => {
                    // Settings view - use minimal session as background
                    let view = crate::views::MinimalSessionView::new(&self.app_state);
                    frame.render_widget(view, area);
                }

                AppView::Help => {
                    // Help view - use minimal session as background, help card will overlay
                    let view = crate::views::MinimalSessionView::new(&self.app_state);
                    frame.render_widget(view, area);
                }
            }

            // Render modal overlays (legacy)
            if let Some(modal) = self.app_state.active_modal.as_ref() {
                use crate::app::ActiveModal;
                use crate::widgets::ModelPicker;

                match modal {
                    // ProviderPicker removed: provider is now always "cortex"
                    ActiveModal::ModelPicker => {
                        let picker = ModelPicker::new(&self.app_state.model_picker);
                        frame.render_widget(picker, area);
                    }
                    ActiveModal::Form(form_state) => {
                        let widget = crate::widgets::FormModal::new(form_state);
                        frame.render_widget(widget, area);
                    }
                    _ => {
                        // Other modals not yet implemented
                    }
                }
            }

            // Render modal stack (new unified modal system)
            if self.modal_stack.is_active() {
                use ratatui::widgets::Clear;
                let modal_width = (area.width as f32 * 0.6).max(40.0).min(area.width as f32) as u16;
                if let Some(modal) = self.modal_stack.current() {
                    let modal_height = modal.desired_height(area.height - 4, modal_width);
                    let modal_x = (area.width.saturating_sub(modal_width)) / 2;
                    let modal_y = (area.height.saturating_sub(modal_height)) / 2;
                    let modal_area = Rect::new(modal_x, modal_y, modal_width, modal_height);

                    // Clear background
                    Clear.render(modal_area, frame.buffer_mut());
                    modal.render(modal_area, frame.buffer_mut());
                }
            }

            // Render new card system overlays (takes priority over legacy modals)
            if self.card_handler.is_active() {
                // Calculate centered modal area (60% width, 80% height)
                let modal_width = (area.width as f32 * 0.6).max(40.0).min(area.width as f32) as u16;
                let modal_height =
                    (area.height as f32 * 0.8).max(10.0).min(area.height as f32) as u16;
                let modal_x = (area.width.saturating_sub(modal_width)) / 2;
                let modal_y = (area.height.saturating_sub(modal_height)) / 2;
                let modal_area = Rect::new(modal_x, modal_y, modal_width, modal_height);

                self.card_handler.render(modal_area, frame.buffer_mut());
            }

            // Apply selection highlight over the entire screen (absolute coords)
            self.apply_selection_highlight(frame.buffer_mut());

            // Render toast notifications (top-right corner, always on top)
            if !self.app_state.toasts.is_empty() {
                let toast_widget = crate::widgets::ToastWidget::new(&self.app_state.toasts)
                    .terminal_size(area.width, area.height);
                toast_widget.render(area, frame.buffer_mut());
            }
        })?;

        // Capture frame for TUI debugging (if enabled via CORTEX_TUI_CAPTURE=1)
        if self.tui_capture.is_enabled() {
            // Track autocomplete state changes
            let autocomplete_visible = self.app_state.autocomplete.visible;
            let autocomplete_query = self.app_state.autocomplete.query.clone();
            self.tui_capture
                .record_autocomplete(autocomplete_visible, &autocomplete_query);

            // Track modal state changes
            let modal_open = self.app_state.has_modal() || self.modal_stack.is_active();
            let modal_name = if self.modal_stack.is_active() {
                "modal_stack"
            } else if self.app_state.has_modal() {
                "legacy_modal"
            } else {
                ""
            };
            self.tui_capture.record_modal(modal_open, modal_name);

            // Track view changes
            let current_view = format!("{:?}", self.app_state.view);
            if current_view != self.tui_capture.current_view {
                let old_view =
                    std::mem::replace(&mut self.tui_capture.current_view, current_view.clone());
                self.tui_capture
                    .record_view_change(&old_view, &current_view);
            }

            // Capture the frame buffer using the terminal's current buffer
            // Note: We access the backend's buffer for capture purposes
            let buffer = terminal.terminal.current_buffer_mut();
            self.tui_capture.capture_auto(buffer);
        }

        // Register click zones for mouse interaction after rendering
        // This must happen after draw() since we need to know the actual areas
        self.register_click_zones();

        Ok(())
    }

    /// Registers click zones for mouse interaction.
    /// Called after each render to update zone positions.
    fn register_click_zones(&mut self) {
        use crate::input::ClickZoneId;

        // Clear previous zones
        self.click_zones.clear();

        let (width, height) = self.app_state.terminal_size;
        let area = Rect::new(0, 0, width, height);

        // Calculate layout based on current view
        match self.app_state.view {
            AppView::Session
            | AppView::Approval
            | AppView::Questions
            | AppView::Settings
            | AppView::Help => {
                // MinimalSessionView layout:
                // - Chat history: most of the screen
                // - Status indicator: 1 line (when streaming)
                // - Input: 1 line
                // - Key hints: 1 line
                let input_height: u16 = 1;
                let hints_height: u16 = 1;
                let status_height: u16 = if self.app_state.streaming.is_streaming {
                    1
                } else {
                    0
                };

                let total_bottom = status_height + input_height + hints_height;
                let chat_height = area.height.saturating_sub(total_bottom);

                // Register chat area (for scroll)
                let chat_area = Rect::new(area.x, area.y, area.width, chat_height);
                self.click_zones.register(ClickZoneId::ChatArea, chat_area);

                // Register input area
                let input_y = area.y + chat_height + status_height;
                let input_area = Rect::new(area.x, input_y, area.width, input_height);
                self.click_zones
                    .register(ClickZoneId::InputField, input_area);

                // Calculate click zones for interactive mode (if active)
                if self.app_state.is_interactive_mode() {
                    if let Some(state) = self.app_state.get_interactive_state_mut() {
                        // Calculate interactive widget area (same logic as MinimalSessionView)
                        let items_count = state.filtered_indices.len().min(state.max_visible);
                        let required_height = (items_count as u16) + 4; // items + border(2) + hints(1) + title(1)
                        let max_height = (area.height * 85 / 100).max(12);
                        let widget_height = required_height.min(max_height);
                        let extra_height = widget_height.saturating_sub(input_height);
                        let interactive_area = Rect::new(
                            input_area.x,
                            input_area.y.saturating_sub(extra_height),
                            input_area.width,
                            widget_height,
                        );
                        // Calculate and store click zones for the interactive widget
                        crate::interactive::InteractiveWidget::calculate_click_zones(
                            state,
                            interactive_area,
                        );
                    }
                }
            }
        }
    }

    // ========================================================================
    // HELPER METHODS
    // ========================================================================

    /// Updates the autocomplete state based on current input.
    ///
    /// Detects `/` for commands and `@` for mentions and populates
    /// the autocomplete popup accordingly.
    fn update_autocomplete(&mut self) {
        use crate::commands::{CommandRegistry, CompletionEngine};
        use crate::widgets::filter_mentions;

        let text = self.app_state.input.text();

        // Find trigger character position
        let mut trigger_pos: Option<(usize, AutocompleteTrigger)> = None;

        // Look for the last trigger character that starts a word
        for (i, ch) in text.char_indices().rev() {
            match ch {
                '/' => {
                    // Check if at start or after whitespace
                    if i == 0
                        || text
                            .chars()
                            .nth(i - 1)
                            .map(|c| c.is_whitespace())
                            .unwrap_or(true)
                    {
                        trigger_pos = Some((i, AutocompleteTrigger::Command));
                        break;
                    }
                }
                '@' => {
                    // Check if at start or after whitespace
                    if i == 0
                        || text
                            .chars()
                            .nth(i - 1)
                            .map(|c| c.is_whitespace())
                            .unwrap_or(true)
                    {
                        trigger_pos = Some((i, AutocompleteTrigger::Mention));
                        break;
                    }
                }
                ' ' | '\n' | '\t' => {
                    // Stop looking if we hit whitespace without finding a trigger
                    break;
                }
                _ => continue,
            }
        }

        match trigger_pos {
            Some((pos, AutocompleteTrigger::Command)) => {
                // Show command completions
                let query = &text[pos + 1..]; // Text after /
                self.app_state
                    .autocomplete
                    .show(AutocompleteTrigger::Command, pos);
                self.app_state.autocomplete.set_query(query);

                // Get command completions
                let registry = CommandRegistry::default();
                let engine = CompletionEngine::new(&registry);
                let completions = engine.complete(&format!("/{}", query));

                let items: Vec<AutocompleteItem> = completions
                    .into_iter()
                    .take(10)
                    .map(|c| {
                        AutocompleteItem::new(&c.command, &c.display, &c.description)
                            .with_category(format!("{:?}", c.category))
                    })
                    .collect();

                self.app_state.autocomplete.set_items(items);
            }
            Some((pos, AutocompleteTrigger::Mention)) => {
                // Show mention completions
                let query = &text[pos + 1..]; // Text after @
                self.app_state
                    .autocomplete
                    .show(AutocompleteTrigger::Mention, pos);
                self.app_state.autocomplete.set_query(query);

                // Get mention completions
                let items = filter_mentions(query);
                self.app_state.autocomplete.set_items(items);
            }
            None => {
                // No trigger found, hide autocomplete
                if self.app_state.autocomplete.visible {
                    self.app_state.autocomplete.hide();
                }
            }
        }
    }

    /// Sends a text message to the AI provider.
    ///
    /// Handles busy state (queuing) and routes to the appropriate provider system.
    async fn send_text_message(&mut self, text: String) -> Result<()> {
        if self.app_state.is_busy() {
            // System is busy - queue the message
            self.app_state.queue_message(text);
            let count = self.app_state.queued_count();
            tracing::debug!("{} message(s) queued", count);
        } else {
            // System is free - send immediately
            self.app_state.scroll_chat_to_bottom();

            if self.provider_manager.is_some() {
                self.handle_submit_with_provider(text).await?;
            } else if let Some(ref bridge) = self.session_bridge {
                let message = cortex_core::widgets::Message::user(&text);
                self.app_state.add_message(message);
                bridge.send_message(text).await?;
                self.app_state.set_view(AppView::Session);
            }
        }
        Ok(())
    }

    /// Handles message submission using the new provider system.
    ///
    /// This method is NON-BLOCKING. It:
    /// 1. Validates that a provider is available
    /// 2. Adds the user message to the session
    /// 3. Spawns a background task for streaming
    /// 4. Returns immediately so the UI stays responsive
    ///
    /// The streaming events are received in the main loop via `streaming_rx`.
    async fn handle_submit_with_provider(&mut self, text: String) -> Result<()> {
        // ====================================================================
        // STEP 1: Validate provider is available
        // ====================================================================

        // Check provider exists
        if self.provider_manager.is_none() {
            // Switch to session view and show user message + error
            self.app_state.set_view(AppView::Session);
            let ui_message = cortex_core::widgets::Message::user(&text);
            self.app_state.add_message(ui_message);
            self.add_system_message(
                "No provider configured. Use /provider <name> to select one.\n\
                 Run /providers to list available providers.",
            );
            return Ok(());
        }

        // Check if Cortex authentication is configured
        // Use provider_manager.is_available() which checks: auth_token, env vars, AND keyring
        let is_authenticated = if let Some(ref pm) = self.provider_manager {
            pm.read().await.is_available()
        } else {
            cortex_login::has_valid_auth()
        };

        if !is_authenticated {
            // Switch to session view and show user message
            self.app_state.set_view(AppView::Session);
            let ui_message = cortex_core::widgets::Message::user(&text);
            self.app_state.add_message(ui_message);

            // Queue the message so it can be auto-sent after API key configuration
            self.app_state.queue_message(text);
            tracing::info!(
                "Queued message for auto-send after authentication (queue size: {})",
                self.app_state.queued_count()
            );

            // Open the authentication alert modal
            use crate::modal::AuthAlertModal;
            let alert = AuthAlertModal::new();
            self.modal_stack.push(Box::new(alert));
            return Ok(());
        }

        // ====================================================================
        // STEP 2: Add user message to UI and session
        // ====================================================================

        // Clear previous tool calls from display (new conversation turn)
        self.app_state.clear_tool_calls();

        let ui_message = cortex_core::widgets::Message::user(&text);
        self.app_state.add_message(ui_message);

        if let Some(ref mut session) = self.cortex_session {
            session.add_user_message(&text);
        }

        // Switch to session view
        self.app_state.set_view(AppView::Session);

        // ====================================================================
        // STEP 3: Prepare for streaming
        // ====================================================================

        // Build system prompt
        let system_prompt = build_system_prompt();
        let system_message = Message::system(system_prompt);

        // Build messages for API
        let session_messages: Vec<Message> = if let Some(ref session) = self.cortex_session {
            session.messages_for_api()
        } else {
            vec![Message::user(&text)]
        };

        // Prepend system prompt to messages
        let mut messages: Vec<Message> = vec![system_message];
        messages.extend(session_messages);

        // Get tool definitions from registry and convert to client format
        let tools: Vec<ClientToolDefinition> = self
            .tool_registry
            .as_ref()
            .map(|r| r.get_definitions())
            .unwrap_or_default()
            .into_iter()
            .map(|t| ClientToolDefinition::function(t.name, t.description, t.parameters))
            .collect();

        // Start streaming UI state
        self.stream_controller.start_processing();
        self.app_state.start_streaming(None);

        // Reset cancellation flag and stream_done flag for new request
        self.streaming_cancelled.store(false, Ordering::SeqCst);
        self.stream_done_received = false;

        // ====================================================================
        // STEP 4: Create client and spawn background streaming task
        // ====================================================================

        // Get provider manager for client operations
        let provider_manager = match &self.provider_manager {
            Some(pm) => pm.clone(),
            None => {
                self.add_system_message("No provider manager configured.");
                self.app_state.stop_streaming();
                return Ok(());
            }
        };

        // Get completion request parameters using read lock
        let (model, max_tokens, temperature, client) = {
            let mut pm = provider_manager.write().await;

            // Ensure client is created
            if let Err(e) = pm.ensure_client() {
                self.stream_controller.set_error(e.to_string());
                self.app_state.stop_streaming();
                self.add_system_message(&format!("Failed to initialize provider: {}", e));
                return Ok(());
            }

            let model = pm.current_model().to_string();
            let max_tokens = pm.config().max_tokens;
            let temperature = pm.config().temperature;
            let client = pm.take_client();

            (model, max_tokens, temperature, client)
        };

        if client.is_none() {
            self.add_system_message("Failed to get provider client. Try again.");
            self.app_state.stop_streaming();
            return Ok(());
        }

        // Create channel for streaming events
        let (tx, rx) = mpsc::channel::<StreamEvent>(100);
        self.streaming_rx = Some(rx);

        // Clone what we need for the background task
        let cancelled = self.streaming_cancelled.clone();

        // Spawn background streaming task
        let task = tokio::spawn(async move {
            let client = client.unwrap();

            let request = cortex_engine::client::CompletionRequest {
                messages,
                model,
                max_tokens: Some(max_tokens),
                temperature: Some(temperature),
                tools,
                stream: true,
            };

            // Start the completion request with timeout
            let stream_result = tokio::time::timeout(
                Duration::from_secs(60), // 60 second timeout for initial connection
                client.complete(request),
            )
            .await;

            let mut stream = match stream_result {
                Ok(Ok(s)) => s,
                Ok(Err(e)) => {
                    let _ = tx
                        .send(StreamEvent::Error(simplify_error_message(&e.to_string())))
                        .await;
                    return;
                }
                Err(_) => {
                    let _ = tx
                        .send(StreamEvent::Error(
                            "Connection timed out. Please try again.".to_string(),
                        ))
                        .await;
                    return;
                }
            };

            let mut content = String::new();
            let mut reasoning = String::new();
            let mut tokens: Option<cortex_engine::streaming::StreamTokenUsage> = None;

            // Process stream events
            loop {
                // Check for cancellation
                if cancelled.load(Ordering::SeqCst) {
                    let _ = tx
                        .send(StreamEvent::Error("Cancelled by user".to_string()))
                        .await;
                    break;
                }

                // Wait for next event with timeout
                let event = tokio::time::timeout(
                    Duration::from_secs(30), // 30 second timeout between chunks
                    stream.next(),
                )
                .await;

                match event {
                    Ok(Some(Ok(ResponseEvent::Delta(delta)))) => {
                        content.push_str(&delta);
                        if tx.send(StreamEvent::Delta(delta)).await.is_err() {
                            break; // Receiver dropped
                        }
                    }
                    Ok(Some(Ok(ResponseEvent::Reasoning(r)))) => {
                        reasoning.push_str(&r);
                        if tx.send(StreamEvent::Reasoning(r)).await.is_err() {
                            break;
                        }
                    }
                    Ok(Some(Ok(ResponseEvent::Done(response)))) => {
                        tokens = Some(cortex_engine::streaming::StreamTokenUsage::from(
                            response.usage,
                        ));
                        let _ = tx
                            .send(StreamEvent::Done {
                                content,
                                reasoning,
                                tokens,
                            })
                            .await;
                        break;
                    }
                    Ok(Some(Ok(ResponseEvent::Error(e)))) => {
                        let _ = tx.send(StreamEvent::Error(e)).await;
                        break;
                    }
                    Ok(Some(Ok(ResponseEvent::ToolCall(tool_call)))) => {
                        // Parse arguments from JSON string
                        let arguments = serde_json::from_str(&tool_call.arguments)
                            .unwrap_or_else(|_| serde_json::json!({"raw": tool_call.arguments}));
                        // Send tool call to main event loop for processing
                        if tx
                            .send(StreamEvent::ToolCall {
                                id: tool_call.id.clone(),
                                name: tool_call.name.clone(),
                                arguments,
                            })
                            .await
                            .is_err()
                        {
                            break; // Receiver dropped
                        }
                    }
                    Ok(Some(Err(e))) => {
                        let _ = tx.send(StreamEvent::Error(e.to_string())).await;
                        break;
                    }
                    Ok(None) => {
                        // Stream ended without Done event
                        let _ = tx
                            .send(StreamEvent::Done {
                                content,
                                reasoning,
                                tokens,
                            })
                            .await;
                        break;
                    }
                    Err(_) => {
                        // Timeout
                        let _ = tx
                            .send(StreamEvent::Error("Response timeout".to_string()))
                            .await;
                        break;
                    }
                }
            }
        });

        self.streaming_task = Some(task);

        Ok(())
    }

    /// Handles a streaming event from the background task.
    async fn handle_stream_event(&mut self, event: StreamEvent) {
        match event {
            StreamEvent::Delta(delta) => {
                self.stream_controller.append_text(&delta);
                // Track text for interleaved display
                self.app_state.append_streaming_text(&delta);
                // Keep scroll at bottom if pinned (user hasn't scrolled up)
                if self.app_state.chat_scroll_pinned_bottom {
                    self.app_state.chat_scroll = 0;
                }
            }
            StreamEvent::Reasoning(r) => {
                // Could display reasoning in a separate area if desired
                tracing::debug!("Reasoning: {}", r);
            }
            StreamEvent::Done {
                content,
                reasoning,
                tokens,
            } => {
                self.stream_controller.complete();
                self.app_state.stop_streaming();

                // Flush any remaining text as a final segment
                self.app_state.flush_pending_text();

                // Take pending tool calls from this streaming response
                let tool_calls_for_message = std::mem::take(&mut self.pending_assistant_tool_calls);
                let has_tool_calls = !tool_calls_for_message.is_empty();

                // Add assistant message to UI (if there's content)
                if !content.is_empty() {
                    let ui_message = cortex_core::widgets::Message::assistant(&content);
                    self.app_state.add_message(ui_message);
                }

                // Add assistant message to session (always, if there's content OR tool calls)
                // IMPORTANT: This must happen BEFORE continue_with_tool_results() so the LLM
                // sees its own tool_calls in the conversation history.
                if !content.is_empty() || has_tool_calls {
                    if let Some(ref mut session) = self.cortex_session {
                        // Create assistant message with tool calls
                        let mut stored_msg = crate::session::StoredMessage::assistant(&content);

                        // Add tool calls to the message
                        for tc in &tool_calls_for_message {
                            let tool_call =
                                StoredToolCall::new(&tc.id, &tc.name, tc.arguments.clone());
                            stored_msg = stored_msg.with_tool_call(tool_call);
                        }

                        // Add reasoning if present
                        if !reasoning.is_empty() {
                            stored_msg = stored_msg.with_reasoning(&reasoning);
                        }

                        // Add tokens
                        if let Some(ref t) = tokens {
                            stored_msg = stored_msg
                                .with_tokens(t.prompt_tokens as i64, t.completion_tokens as i64);
                        }

                        // Add to session via internal method
                        session.add_message_raw(stored_msg);

                        // Update token counts in metadata
                        if let Some(ref t) = tokens {
                            session.add_tokens(t.prompt_tokens as i64, t.completion_tokens as i64);
                        }

                        // Auto-generate title from first message
                        if session.message_count() <= 2 {
                            session.auto_title();
                        }
                    }
                }

                self.stream_controller.reset();
                self.streaming_rx = None;
                self.streaming_task = None;

                // Mark stream as done - this is used by tool/subagent handlers to know
                // when it's safe to call continue_with_tool_results()
                self.stream_done_received = true;

                // Reset continuation flag after stream completes
                // This ensures next user message will clear tool calls normally
                let was_continuation = self.is_continuation;
                self.is_continuation = false;

                // Now check if we need to continue the agentic loop.
                // Tool results may already be ready (if tools finished before stream Done).
                tracing::info!(
                    running_tools = self.running_tool_tasks.len(),
                    running_subagents = self.running_subagents.len(),
                    has_pending_results = self.app_state.has_pending_tool_results(),
                    pending_tool_calls = self.pending_assistant_tool_calls.len(),
                    "StreamEvent::Done - checking continuation state"
                );

                if self.running_tool_tasks.is_empty() && self.running_subagents.is_empty() {
                    if self.app_state.has_pending_tool_results() {
                        tracing::info!("Calling continue_with_tool_results from StreamEvent::Done");
                        self.continue_with_tool_results().await;
                    } else {
                        tracing::info!("No pending results, processing message queue");
                        // No tool results pending - check for queued messages
                        self.process_message_queue().await;
                    }
                } else {
                    tracing::info!("Tools still running, will continue when they complete");
                }
                // If tools are still running, they will call continue_with_tool_results()
                // when they complete (now that stream_done_received is true).
            }
            StreamEvent::Error(e) => {
                self.stream_controller.set_error(e.clone());
                self.app_state.stop_streaming();

                // Check if this is an authentication error - trigger login flow
                let error_lower = e.to_lowercase();
                if error_lower.contains("401")
                    || error_lower.contains("unauthorized")
                    || error_lower.contains("auth_required")
                    || error_lower.contains("authentication required")
                    || error_lower.contains("authentication failed")
                {
                    self.add_system_message(
                        "🔐 Session expired or authentication required.\n\n\
                         Opening login screen to re-authenticate...",
                    );
                    self.app_state
                        .toasts
                        .warning("Session expired. Please re-authenticate.");

                    // Reset streaming state before starting login
                    self.stream_controller.reset();
                    self.streaming_rx = None;
                    self.streaming_task = None;

                    // Trigger the login flow
                    self.start_login_flow().await;
                    return;
                }

                // Check if this is a rate limit / usage limit error and provide helpful guidance
                if error_lower.contains("rate limit")
                    || error_lower.contains("usage limit")
                    || error_lower.contains("quota exceeded")
                    || error_lower.contains("limit exceeded")
                    || error_lower.contains("too many requests")
                    || error_lower.contains("429")
                {
                    self.add_system_message(&format!(
                        "Warning: Usage limit reached: {}\n\n\
                         If you've added a payment method or upgraded your plan:\n\
                         -> Run /refresh to update your billing status\n\n\
                         To manage your billing, visit: https://cortex.foundation/billing",
                        e
                    ));
                    self.app_state
                        .toasts
                        .warning("Usage limit reached. Run /refresh after adding payment.");
                } else {
                    // Display simplified, user-friendly error message
                    self.add_system_message(&e);
                }

                self.stream_controller.reset();
                self.streaming_rx = None;
                self.streaming_task = None;

                // Even on error, check for queued messages
                self.process_message_queue().await;
            }
            StreamEvent::ToolCall {
                id,
                name,
                arguments,
            } => {
                // Store tool call for assistant message (to be added on StreamEvent::Done)
                self.pending_assistant_tool_calls.push(PendingToolCall {
                    id: id.clone(),
                    name: name.clone(),
                    arguments: arguments.clone(),
                });

                // Add tool call to display - but NOT for Task tools
                // Task tools use SubagentTaskDisplay for better visualization
                if name != "Task" && name != "task" {
                    self.app_state
                        .add_tool_call(id.clone(), name.clone(), arguments.clone());
                }

                // Special handling for Questions tool - show interactive TUI
                if name == "Questions" || name == "question" {
                    if let Some(request) = QuestionRequest::from_tool_args(&id, &arguments) {
                        let state = QuestionState::new(request);
                        self.app_state.start_question_prompt(state);
                        self.app_state.update_tool_status(&id, ToolStatus::Running);
                        // Don't execute the tool yet - wait for user answers
                        return;
                    }
                }

                // Special handling for Task and Batch tools - use UnifiedToolExecutor
                if name == "Task" || name == "task" || name == "Batch" || name == "batch" {
                    // Note: Task tools don't need update_tool_status here because
                    // they use SubagentTaskDisplay which has its own status tracking
                    if name == "Batch" || name == "batch" {
                        self.app_state.update_tool_status(&id, ToolStatus::Running);
                    }

                    // Use UnifiedToolExecutor if available, otherwise fall back to old behavior
                    if self.unified_executor.is_some() {
                        self.spawn_unified_tool_execution(id, name, arguments);
                    } else if name == "Task" || name == "task" {
                        // Fall back to spawn_subagent for Task
                        self.spawn_subagent(id, arguments);
                    } else {
                        // Batch without unified executor - return error
                        self.app_state.add_pending_tool_result(
                            id,
                            name,
                            "Batch tool requires UnifiedToolExecutor to be configured. \
                             This enables parallel tool execution."
                                .to_string(),
                            false,
                        );
                    }
                    return;
                }

                // Check if we need to ask for permission
                if self.permission_manager.should_ask(&name) {
                    // Generate diff preview for Edit/Write tools
                    let diff_preview = if name == "Edit" || name == "Write" || name == "ApplyPatch"
                    {
                        self.generate_diff_preview(&name, &arguments)
                    } else {
                        None
                    };

                    // Request approval with full tool call details
                    self.app_state.request_tool_approval(
                        id.clone(),
                        name.clone(),
                        arguments.clone(),
                        diff_preview,
                    );
                    // The approval handler will execute the tool when approved
                } else {
                    // Auto-approved - execute in background (non-blocking!)
                    self.app_state.update_tool_status(&id, ToolStatus::Running);
                    self.spawn_tool_execution(id, name, arguments);
                }
            }
            // Handle other variants that we don't specifically process
            _ => {
                // Start, TextDelta, ToolCallStart, ToolCallDelta, ToolCallComplete,
                // TokenUsage, Complete, ErrorInfo are not specifically handled
                // They may be processed by stream_controller.push_event() elsewhere
            }
        }
    }

    /// Handles events from background tool execution tasks.
    ///
    /// This is called when a tool completes execution in the background,
    /// allowing the UI to remain responsive during long-running commands.
    async fn handle_tool_event(&mut self, event: ToolEvent) {
        match event {
            ToolEvent::Started {
                id,
                name,
                started_at: _,
            } => {
                tracing::debug!("Tool execution started: {} ({})", name, id);
                // Status already set to Running in spawn_tool_execution
                // Update stream controller to show tool is executing
                self.stream_controller
                    .set_executing_tool(Some(name.clone()));

                // If this is a Task tool, update the subagent to "Thinking" status
                if name == "Task" || name == "task" {
                    let session_id = format!("subagent_{}", id);
                    self.app_state.update_subagent(&session_id, |task| {
                        task.status = SubagentDisplayStatus::Thinking;
                        task.current_activity = "Processing request...".to_string();
                    });
                }
            }

            ToolEvent::Output { id, chunk } => {
                // Append output to the tool call's live output buffer (keeps last 3 lines)
                for line in chunk.lines() {
                    if !line.is_empty() {
                        self.app_state.append_tool_output(&id, line.to_string());
                    }
                }
            }

            ToolEvent::Completed {
                id,
                name,
                output,
                success,
                duration,
            } => {
                // Handle login events specially
                if name == "login" {
                    if id == "login_init" && success {
                        // Device code received - update widget and start polling
                        if let Ok(data) = serde_json::from_str::<serde_json::Value>(&output) {
                            let device_code =
                                data["device_code"].as_str().unwrap_or_default().to_string();
                            let user_code =
                                data["user_code"].as_str().unwrap_or_default().to_string();
                            let verification_uri = data["verification_uri"]
                                .as_str()
                                .unwrap_or_default()
                                .to_string();

                            if let Some(ref mut flow) = self.app_state.login_flow {
                                flow.set_device_code(
                                    device_code.clone(),
                                    user_code,
                                    verification_uri,
                                );
                            }

                            // Refresh widget
                            if let Some(ref flow) = self.app_state.login_flow {
                                let interactive =
                                    crate::interactive::builders::build_login_selector(flow);
                                self.app_state.enter_interactive_mode(interactive);
                            }

                            // Start polling
                            self.start_login_polling(device_code);
                        }
                        return;
                    } else if id == "login_poll" && success && output == "login:success" {
                        // Login successful
                        self.app_state.login_flow = None;
                        self.app_state.exit_interactive_mode();

                        // CRITICAL: Reload fresh auth token into provider_manager
                        // Without this, the provider_manager still has the old/expired token
                        // and subsequent API calls will fail with "session invalid"
                        if let Some(ref pm) = self.provider_manager {
                            if let Some(token) = cortex_login::get_auth_token() {
                                tracing::info!(
                                    "Reloading fresh auth token into provider_manager after login"
                                );
                                pm.write().await.set_auth_token(token);
                            } else {
                                tracing::warn!(
                                    "Login succeeded but could not load fresh token from keyring"
                                );
                            }
                        }

                        self.app_state.toasts.success("Logged in!");
                        return;
                    } else if id == "login" && success {
                        // Legacy login flow (from handle_auth_login) - also reload the token
                        // CRITICAL: Reload fresh auth token into provider_manager
                        // Without this, the provider_manager still has the old/expired token
                        if let Some(ref pm) = self.provider_manager {
                            if let Some(token) = cortex_login::get_auth_token() {
                                tracing::info!(
                                    "Reloading fresh auth token into provider_manager after legacy login"
                                );
                                pm.write().await.set_auth_token(token);
                            } else {
                                tracing::warn!(
                                    "Login succeeded but could not load fresh token from keyring"
                                );
                            }
                        }
                        self.add_system_message(&output);
                        self.app_state.toasts.success("Logged in!");
                        return;
                    }
                }

                tracing::debug!(
                    "Tool execution completed: {} ({}) in {:?}",
                    name,
                    id,
                    duration
                );

                // Clear tool execution state
                self.tool_execution_started = false;
                self.stream_controller.set_executing_tool(None);
                self.app_state.streaming.stop_tool_execution();

                // Update tool result in UI
                let summary = format_result_summary(&name, &output, success);
                self.app_state
                    .update_tool_result(&id, output.clone(), success, summary.clone());

                // If this is a Task tool, remove the subagent from display
                // The tool result will be shown in the normal tool call display
                if name == "Task" || name == "task" {
                    let session_id = format!("subagent_{}", id);
                    // Remove from active subagents - the task result is in the tool output
                    self.app_state.remove_subagent(&session_id);
                }

                // Store for agentic continuation
                self.app_state
                    .add_pending_tool_result(id.clone(), name.clone(), output, success);

                // Remove from running tasks
                self.running_tool_tasks.remove(&id);

                // IMPORTANT: Before calling continue_with_tool_results(), we need to ensure
                // the assistant message with tool_calls is saved. If stream is not done yet,
                // force-save the pending tool calls now.
                if !self.stream_done_received && !self.pending_assistant_tool_calls.is_empty() {
                    // Save the assistant message with pending tool calls NOW
                    // This ensures the LLM sees its own tool_call in the conversation history
                    if let Some(ref mut session) = self.cortex_session {
                        let tool_calls_for_message =
                            std::mem::take(&mut self.pending_assistant_tool_calls);
                        // Use full_text() to get ALL text (committed + pending)
                        // display_text() may be empty if no newline received yet
                        let content = self.stream_controller.full_text();

                        let mut stored_msg = crate::session::StoredMessage::assistant(&content);
                        for tc in &tool_calls_for_message {
                            let tool_call =
                                StoredToolCall::new(&tc.id, &tc.name, tc.arguments.clone());
                            stored_msg = stored_msg.with_tool_call(tool_call);
                        }
                        session.add_message_raw(stored_msg);
                        tracing::debug!(
                            "Force-saved assistant message with {} tool calls before stream done",
                            tool_calls_for_message.len()
                        );
                    }
                    // Mark as done so StreamEvent::Done doesn't try to save again
                    self.stream_done_received = true;
                }

                // Continue agentic loop if no more tools are running
                tracing::info!(
                    running_tools = self.running_tool_tasks.len(),
                    running_subagents = self.running_subagents.len(),
                    has_pending_results = self.app_state.has_pending_tool_results(),
                    stream_done = self.stream_done_received,
                    "ToolEvent::Completed - checking continuation state"
                );

                if self.running_tool_tasks.is_empty() && self.running_subagents.is_empty() {
                    if self.app_state.has_pending_tool_results() {
                        tracing::info!(
                            "Calling continue_with_tool_results from ToolEvent::Completed"
                        );
                        self.continue_with_tool_results().await;
                    } else {
                        tracing::info!("No pending results after tool completion");
                        self.process_message_queue().await;
                    }
                } else {
                    tracing::info!("More tools still running after this completion");
                }
            }

            ToolEvent::Failed {
                id,
                name,
                error,
                duration,
            } => {
                // Handle login errors specially
                if name == "login" && (id == "login_init" || id == "login_poll") {
                    let error_msg = if let Some(msg) = error.strip_prefix("login:error:") {
                        msg.to_string()
                    } else if error == "login:expired" {
                        "Code expired. Please try again.".to_string()
                    } else if error == "login:denied" {
                        "Access denied".to_string()
                    } else if error == "login:timeout" {
                        "Login timed out".to_string()
                    } else {
                        error.clone()
                    };
                    self.app_state.login_flow = None;
                    self.app_state.exit_interactive_mode();
                    self.app_state.toasts.error(&error_msg);
                    return;
                }

                tracing::error!(
                    "Tool execution failed: {} ({}) after {:?} - {}",
                    name,
                    id,
                    duration,
                    error
                );

                // Clear tool execution state
                self.tool_execution_started = false;
                self.stream_controller.set_executing_tool(None);
                self.app_state.streaming.stop_tool_execution();

                self.app_state.update_tool_result(
                    &id,
                    error.clone(),
                    false,
                    format!("Error: {}", error),
                );

                // If this is a Task tool, remove the subagent from display
                if name == "Task" || name == "task" {
                    let session_id = format!("subagent_{}", id);
                    self.app_state.remove_subagent(&session_id);
                }

                self.app_state
                    .add_pending_tool_result(id.clone(), name, error, false);

                self.running_tool_tasks.remove(&id);

                // Same as Completed: force-save assistant message if stream not done
                if !self.stream_done_received && !self.pending_assistant_tool_calls.is_empty() {
                    if let Some(ref mut session) = self.cortex_session {
                        let tool_calls_for_message =
                            std::mem::take(&mut self.pending_assistant_tool_calls);
                        // Use full_text() to get ALL text (committed + pending)
                        let content = self.stream_controller.full_text();

                        let mut stored_msg = crate::session::StoredMessage::assistant(&content);
                        for tc in &tool_calls_for_message {
                            let tool_call =
                                StoredToolCall::new(&tc.id, &tc.name, tc.arguments.clone());
                            stored_msg = stored_msg.with_tool_call(tool_call);
                        }
                        session.add_message_raw(stored_msg);
                    }
                    self.stream_done_received = true;
                }

                // Continue agentic loop if no more tools are running
                if self.running_tool_tasks.is_empty() && self.running_subagents.is_empty() {
                    if self.app_state.has_pending_tool_results() {
                        self.continue_with_tool_results().await;
                    } else {
                        self.process_message_queue().await;
                    }
                }
            }
        }
    }

    // ========================================================================
    // SUBAGENT EVENT HANDLING
    // ========================================================================

    /// Handles events from background subagent execution tasks.
    ///
    /// This is called when a subagent reports progress or completes execution,
    /// allowing the UI to show real-time updates from subagents.
    async fn handle_subagent_event(&mut self, event: SubagentEvent) {
        use crate::app::SubagentDisplayStatus;

        match event {
            SubagentEvent::Progress(progress) => {
                let session_id = progress.session_id().to_string();

                match &progress {
                    ProgressEvent::Started {
                        agent_type,
                        description,
                        ..
                    } => {
                        tracing::debug!(
                            "Subagent started: {} ({}) - {}",
                            session_id,
                            agent_type,
                            description
                        );
                        self.app_state.update_subagent(&session_id, |task| {
                            task.status = SubagentDisplayStatus::Starting;
                            task.current_activity = format!("Starting {} agent", agent_type);
                        });
                    }

                    ProgressEvent::Thinking { turn_number, .. } => {
                        tracing::trace!("Subagent thinking: {} turn {}", session_id, turn_number);
                        self.app_state.update_subagent(&session_id, |task| {
                            task.status = SubagentDisplayStatus::Thinking;
                            task.current_activity = format!("Thinking (turn {})", turn_number);
                        });
                    }

                    ProgressEvent::ToolCallStarted { tool_name, .. } => {
                        tracing::debug!("Subagent calling tool: {} - {}", session_id, tool_name);
                        self.app_state.update_subagent(&session_id, |task| {
                            task.status = SubagentDisplayStatus::ExecutingTool(tool_name.clone());
                            task.current_activity = format!("Running {}", tool_name);
                        });
                    }

                    ProgressEvent::ToolCallCompleted {
                        tool_name, success, ..
                    } => {
                        tracing::debug!(
                            "Subagent tool completed: {} - {} (success: {})",
                            session_id,
                            tool_name,
                            success
                        );
                        self.app_state.update_subagent(&session_id, |task| {
                            task.tool_calls.push((tool_name.clone(), *success));
                            task.status = SubagentDisplayStatus::Thinking;
                            task.current_activity = "Thinking...".to_string();
                        });
                    }

                    ProgressEvent::TextOutput { content, .. } => {
                        self.app_state.update_subagent(&session_id, |task| {
                            task.output_preview = content.chars().take(200).collect();
                        });
                    }

                    ProgressEvent::TurnCompleted {
                        turn_number,
                        tool_calls_count,
                        ..
                    } => {
                        tracing::debug!(
                            "Subagent turn completed: {} - turn {} ({} tool calls)",
                            session_id,
                            turn_number,
                            tool_calls_count
                        );
                    }

                    ProgressEvent::Warning { message, .. } => {
                        tracing::warn!("Subagent warning: {} - {}", session_id, message);
                        self.app_state.update_subagent(&session_id, |task| {
                            task.current_activity = format!("Warning: {}", message);
                        });
                    }

                    ProgressEvent::TodoUpdated { todos, .. } => {
                        use crate::app::{SubagentTodoItem, SubagentTodoStatus};
                        tracing::debug!(
                            "Subagent todos updated: {} - {} items",
                            session_id,
                            todos.len()
                        );
                        self.app_state.update_subagent(&session_id, |task| {
                            task.todos = todos
                                .iter()
                                .map(|(content, status)| {
                                    let todo_status = match status.as_str() {
                                        "completed" => SubagentTodoStatus::Completed,
                                        "in_progress" => SubagentTodoStatus::InProgress,
                                        _ => SubagentTodoStatus::Pending,
                                    };
                                    SubagentTodoItem::new(content.clone(), todo_status)
                                })
                                .collect();
                        });
                    }

                    _ => {}
                }
            }

            SubagentEvent::Completed {
                session_id,
                output,
                tool_call_id,
            } => {
                tracing::info!("Subagent completed: {}", session_id);

                // Update status before removing
                self.app_state.update_subagent(&session_id, |task| {
                    task.status = SubagentDisplayStatus::Completed;
                    task.current_activity = "Completed".to_string();
                });

                // Remove from active subagents and get task info
                if let Some(task) = self.app_state.remove_subagent(&session_id) {
                    // Remove from running tasks
                    self.running_subagents.remove(&session_id);

                    // Format result for the LLM
                    let result_output = format!(
                        "## Subagent Completed\n\n\
                        **Type:** {}\n\
                        **Description:** {}\n\
                        **Duration:** {:.1}s\n\
                        **Tool Calls:** {}\n\n\
                        ## Output\n\n{}",
                        task.agent_type,
                        task.description,
                        task.elapsed().as_secs_f64(),
                        task.tool_calls.len(),
                        output
                    );

                    // Add as pending tool result for continuation
                    self.app_state.add_pending_tool_result(
                        tool_call_id,
                        "Task".to_string(),
                        result_output,
                        true,
                    );

                    // Force-save assistant message if stream not done
                    if !self.stream_done_received && !self.pending_assistant_tool_calls.is_empty() {
                        if let Some(ref mut session) = self.cortex_session {
                            let tool_calls_for_message =
                                std::mem::take(&mut self.pending_assistant_tool_calls);
                            // Use full_text() to get ALL text (committed + pending)
                            let content = self.stream_controller.full_text();

                            let mut stored_msg = crate::session::StoredMessage::assistant(&content);
                            for tc in &tool_calls_for_message {
                                let tool_call =
                                    StoredToolCall::new(&tc.id, &tc.name, tc.arguments.clone());
                                stored_msg = stored_msg.with_tool_call(tool_call);
                            }
                            session.add_message_raw(stored_msg);
                        }
                        self.stream_done_received = true;
                    }

                    // Continue agentic loop if no more subagents or tools running
                    if self.running_subagents.is_empty() && self.running_tool_tasks.is_empty() {
                        if self.app_state.has_pending_tool_results() {
                            self.continue_with_tool_results().await;
                        } else {
                            self.process_message_queue().await;
                        }
                    }
                }
            }

            SubagentEvent::Failed {
                session_id,
                error,
                tool_call_id,
            } => {
                tracing::error!("Subagent failed: {} - {}", session_id, error);

                // Update status before removing
                self.app_state.update_subagent(&session_id, |task| {
                    task.status = SubagentDisplayStatus::Failed;
                    task.current_activity = format!("Failed: {}", error);
                });

                // Remove from active subagents and get task info
                if let Some(task) = self.app_state.remove_subagent(&session_id) {
                    // Remove from running tasks
                    self.running_subagents.remove(&session_id);

                    // Format error for the LLM
                    let error_output = format!(
                        "## Subagent Failed\n\n\
                        **Type:** {}\n\
                        **Description:** {}\n\
                        **Duration:** {:.1}s\n\n\
                        ## Error\n\n{}",
                        task.agent_type,
                        task.description,
                        task.elapsed().as_secs_f64(),
                        error
                    );

                    // Add as pending tool result
                    self.app_state.add_pending_tool_result(
                        tool_call_id,
                        "Task".to_string(),
                        error_output,
                        false,
                    );

                    // Force-save assistant message if stream not done
                    if !self.stream_done_received && !self.pending_assistant_tool_calls.is_empty() {
                        if let Some(ref mut session) = self.cortex_session {
                            let tool_calls_for_message =
                                std::mem::take(&mut self.pending_assistant_tool_calls);
                            // Use full_text() to get ALL text (committed + pending)
                            let content = self.stream_controller.full_text();

                            let mut stored_msg = crate::session::StoredMessage::assistant(&content);
                            for tc in &tool_calls_for_message {
                                let tool_call =
                                    StoredToolCall::new(&tc.id, &tc.name, tc.arguments.clone());
                                stored_msg = stored_msg.with_tool_call(tool_call);
                            }
                            session.add_message_raw(stored_msg);
                        }
                        self.stream_done_received = true;
                    }

                    // Continue agentic loop if no more subagents or tools running
                    if self.running_subagents.is_empty() && self.running_tool_tasks.is_empty() {
                        if self.app_state.has_pending_tool_results() {
                            self.continue_with_tool_results().await;
                        } else {
                            self.process_message_queue().await;
                        }
                    }
                }
            }
        }
    }

    /// Handles keyboard input for question prompts.
    /// Returns true if the key was handled.
    async fn handle_question_key(&mut self, key_event: crossterm::event::KeyEvent) -> Result<bool> {
        use crossterm::event::KeyCode;

        let Some(q_state) = self.app_state.get_question_state_mut() else {
            return Ok(false);
        };

        // If editing custom input, handle text input
        if q_state.editing_custom {
            match key_event.code {
                KeyCode::Esc => {
                    q_state.cancel_custom_input();
                    return Ok(true);
                }
                KeyCode::Enter => {
                    q_state.confirm_custom_input();
                    // Check if single question single choice - auto submit
                    if q_state.is_single_question() && !q_state.answers[0].is_empty() {
                        self.submit_question_answers().await?;
                    }
                    return Ok(true);
                }
                KeyCode::Backspace => {
                    q_state.current_custom_text.pop();
                    return Ok(true);
                }
                KeyCode::Char(c) => {
                    q_state.current_custom_text.push(c);
                    return Ok(true);
                }
                _ => return Ok(true),
            }
        }

        // On confirm tab
        if q_state.on_confirm_tab {
            match key_event.code {
                KeyCode::Esc => {
                    self.cancel_question_prompt().await?;
                    return Ok(true);
                }
                KeyCode::Enter => {
                    self.submit_question_answers().await?;
                    return Ok(true);
                }
                KeyCode::Left | KeyCode::Char('h') => {
                    q_state.prev_tab();
                    return Ok(true);
                }
                KeyCode::Right | KeyCode::Char('l') => {
                    q_state.next_tab();
                    return Ok(true);
                }
                _ => return Ok(true),
            }
        }

        // Normal question navigation
        match key_event.code {
            KeyCode::Esc => {
                self.cancel_question_prompt().await?;
                return Ok(true);
            }
            KeyCode::Up | KeyCode::Char('k') => {
                q_state.move_up();
                return Ok(true);
            }
            KeyCode::Down | KeyCode::Char('j') => {
                q_state.move_down();
                return Ok(true);
            }
            KeyCode::Left | KeyCode::Char('h') => {
                q_state.prev_tab();
                return Ok(true);
            }
            KeyCode::Right | KeyCode::Char('l') => {
                q_state.next_tab();
                return Ok(true);
            }
            KeyCode::Enter => {
                q_state.toggle_current();
                // Check if single question single choice - auto submit
                if q_state.is_single_question()
                    && !q_state.answers[0].is_empty()
                    && !q_state.editing_custom
                {
                    self.submit_question_answers().await?;
                }
                return Ok(true);
            }
            KeyCode::Char(c) if c.is_ascii_digit() => {
                // Quick select by number (1-9)
                let digit = c.to_digit(10).unwrap_or(0) as usize;
                if digit >= 1 && digit <= q_state.option_count() {
                    q_state.move_to(digit - 1);
                    q_state.toggle_current();
                    // Check if single question single choice - auto submit
                    if q_state.is_single_question()
                        && !q_state.answers[0].is_empty()
                        && !q_state.editing_custom
                    {
                        self.submit_question_answers().await?;
                    }
                }
                return Ok(true);
            }
            _ => return Ok(true),
        }
    }

    /// Submit question answers and complete the tool call
    async fn submit_question_answers(&mut self) -> Result<()> {
        let Some(q_state) = self.app_state.get_question_state() else {
            return Ok(());
        };

        let tool_call_id = q_state.request.id.clone();
        let answers = q_state.get_formatted_answers();

        // Format answers for the LLM
        let formatted_answers = serde_json::to_string_pretty(&answers).unwrap_or_default();
        let output = format!("User answered the questions:\n{}", formatted_answers);

        // Update tool result
        self.app_state.update_tool_result(
            &tool_call_id,
            output.clone(),
            true,
            "Questions answered".to_string(),
        );

        // Complete the question prompt
        self.app_state.complete_question_prompt();

        // Store for agentic continuation
        self.app_state
            .add_pending_tool_result(tool_call_id, "Questions".to_string(), output, true);

        // Continue with tool results if streaming is done
        if !self.app_state.streaming.is_streaming && self.app_state.has_pending_tool_results() {
            self.continue_with_tool_results().await;
        }

        Ok(())
    }

    /// Cancel question prompt and return an error result
    async fn cancel_question_prompt(&mut self) -> Result<()> {
        let Some(tool_call_id) = self.app_state.cancel_question_prompt() else {
            return Ok(());
        };

        let output = "User dismissed the questions without answering.".to_string();

        // Update tool result as failed/cancelled
        self.app_state.update_tool_result(
            &tool_call_id,
            output.clone(),
            false,
            "Questions dismissed".to_string(),
        );

        // Store for agentic continuation
        self.app_state.add_pending_tool_result(
            tool_call_id,
            "Questions".to_string(),
            output,
            false,
        );

        // Continue with tool results if streaming is done
        if !self.app_state.streaming.is_streaming && self.app_state.has_pending_tool_results() {
            self.continue_with_tool_results().await;
        }

        Ok(())
    }

    /// Handles keyboard input for modal dialogs.
    /// Returns true if the key was handled by the modal.
    async fn handle_modal_key(&mut self, key_event: crossterm::event::KeyEvent) -> Result<bool> {
        use crate::app::ActiveModal;
        // PickerFocus import removed: ProviderPicker is no longer used
        use crossterm::event::KeyCode;

        let Some(modal) = self.app_state.active_modal.as_mut() else {
            return Ok(false);
        };

        match modal {
            // ProviderPicker removed: provider is now always "cortex"
            ActiveModal::ModelPicker => {
                match key_event.code {
                    KeyCode::Esc => {
                        self.app_state.close_modal();
                    }
                    KeyCode::Up => {
                        self.app_state.model_picker.select_prev();
                    }
                    KeyCode::Down => {
                        self.app_state.model_picker.select_next();
                    }
                    KeyCode::Enter => {
                        // Select model
                        if let Some(model) = self.app_state.model_picker.selected_model() {
                            let model_id = model.id.clone();
                            self.app_state.model = model_id.clone();

                            // Update provider manager
                            if let Some(pm) = &self.provider_manager {
                                if let Ok(mut manager) = pm.try_write() {
                                    let _ = manager.set_model(&model_id);
                                }
                            }

                            // Save last used model to config
                            if let Ok(mut config) = crate::providers::config::CortexConfig::load() {
                                let _ = config.save_last_model(&self.app_state.provider, &model_id);
                            }

                            // Update session model metadata
                            self.update_session_model(&model_id);

                            self.app_state.close_modal();
                        }
                    }
                    KeyCode::Char(c)
                        if key_event
                            .modifiers
                            .contains(crossterm::event::KeyModifiers::CONTROL)
                            && c == 'l' =>
                    {
                        self.app_state.model_picker.clear_search();
                    }
                    KeyCode::Char(c) => {
                        self.app_state.model_picker.handle_char(c);
                    }
                    KeyCode::Backspace => {
                        self.app_state.model_picker.handle_backspace();
                    }
                    _ => {}
                }
                Ok(true)
            }
            ActiveModal::Form(form_state) => {
                match key_event.code {
                    KeyCode::Esc => {
                        self.app_state.close_modal();
                    }
                    KeyCode::Tab | KeyCode::Down => {
                        form_state.focus_next();
                    }
                    KeyCode::BackTab | KeyCode::Up => {
                        form_state.focus_prev();
                    }
                    KeyCode::Char(c) => {
                        form_state.handle_char(c);
                    }
                    KeyCode::Backspace => {
                        form_state.handle_backspace();
                    }
                    KeyCode::Enter => {
                        // Determine if we should submit the form:
                        // 1. Always submit if focus is on the Submit button
                        // 2. Submit if all required fields are filled AND current field is text/number/secret
                        // 3. Otherwise toggle current field (for select/toggle types)
                        let on_submit_button = form_state.focus_index == form_state.fields.len();
                        let current_field_is_input = form_state.focus_index
                            < form_state.fields.len()
                            && matches!(
                                form_state.fields[form_state.focus_index].kind,
                                crate::widgets::form::FieldKind::Text
                                    | crate::widgets::form::FieldKind::Number
                                    | crate::widgets::form::FieldKind::Secret
                            );

                        if on_submit_button || (current_field_is_input && form_state.can_submit()) {
                            // Submit the form - clone values before closing modal
                            let command = form_state.command.clone();
                            let values: std::collections::HashMap<String, String> = form_state
                                .fields
                                .iter()
                                .map(|f| (f.key.clone(), f.value.clone()))
                                .collect();
                            self.app_state.close_modal();
                            self.handle_form_submission(&command, values);
                        } else {
                            // Toggle current field (for select/toggle types)
                            form_state.toggle_current();
                        }
                    }
                    KeyCode::Left | KeyCode::Right => {
                        // Toggle for select fields
                        form_state.toggle_current();
                    }
                    _ => {}
                }
                Ok(true)
            }
            _ => Ok(false),
        }
    }

    /// Handles form submission by reconstructing and executing the slash command.
    fn handle_form_submission(
        &mut self,
        command: &str,
        values: std::collections::HashMap<String, String>,
    ) {
        // Helper to get a value or empty string
        let get = |key: &str| -> &str { values.get(key).map(|s| s.as_str()).unwrap_or("") };

        // Build the command string based on the command name
        let cmd_str = match command {
            "rename" => {
                // /rename {name}
                let name = get("name");
                if !name.is_empty() {
                    format!("/rename {}", name)
                } else {
                    return;
                }
            }
            "export" => {
                // /export {format}
                let format = get("format");
                if !format.is_empty() {
                    format!("/export {}", format)
                } else {
                    "/export markdown".to_string()
                }
            }
            "mcp" => {
                // /mcp {action} {server} {args}
                let action = get("action");
                let server = get("server_name");
                let args = get("command_args");

                if action.is_empty() {
                    "/mcp list".to_string()
                } else if server.is_empty() {
                    format!("/mcp {}", action)
                } else if args.is_empty() {
                    format!("/mcp {} {}", action, server)
                } else {
                    format!("/mcp {} {} {}", action, server, args)
                }
            }
            "temperature" => {
                // /temperature {value}
                let value = get("value");
                if !value.is_empty() {
                    format!("/temperature {}", value)
                } else {
                    return;
                }
            }
            "model" => {
                // /model {name}
                let name = get("model");
                if !name.is_empty() {
                    format!("/model {}", name)
                } else {
                    return;
                }
            }
            "provider" => {
                // /provider {name}
                let name = get("provider");
                if !name.is_empty() {
                    format!("/provider {}", name)
                } else {
                    return;
                }
            }
            "context" => {
                // /context {action} {path}
                let action = get("action");
                let path = get("path");
                let action = if action.is_empty() { "add" } else { action };

                if path.is_empty() {
                    format!("/context {}", action)
                } else {
                    format!("/context {} {}", action, path)
                }
            }
            // Delete session
            "delete" => {
                let session_id = get("session_id");
                format!("/delete {}", session_id)
            }
            // Go to message
            "goto" => {
                let message_number = get("message_number");
                format!("/goto {}", message_number)
            }
            // Remove files from context
            "remove" => {
                let files = get("files");
                format!("/remove {}", files)
            }
            // Search in session
            "search" => {
                let pattern = get("pattern");
                format!("/search {}", pattern)
            }
            // Mention file/symbol
            "mention" => {
                let target = get("target");
                format!("/mention {}", target)
            }
            // Set max tokens
            "tokens" => {
                let max_tokens = get("max_tokens");
                format!("/tokens {}", max_tokens)
            }
            // MCP add server
            "mcp-add" => {
                let server_name = get("server_name");
                let command = get("command");
                let args = get("args");
                if args.is_empty() {
                    format!("/mcp add {} {}", server_name, command)
                } else {
                    format!("/mcp add {} {} {}", server_name, command, args)
                }
            }
            // MCP remove server
            "mcp-remove" => {
                let server_name = get("server_name");
                format!("/mcp remove {}", server_name)
            }
            // MCP auth
            "mcp-auth" => {
                let server_name = get("server_name");
                let api_key = get("api_key");
                format!("/mcp-auth {} {}", server_name, api_key)
            }
            // Eval expression
            "eval" => {
                let expression = get("expression");
                format!("/eval {}", expression)
            }
            _ => {
                // Generic handling: /command arg1 arg2 ...
                let args: Vec<&str> = values
                    .values()
                    .map(|s| s.as_str())
                    .filter(|v| !v.is_empty())
                    .collect();

                if args.is_empty() {
                    format!("/{}", command)
                } else {
                    format!("/{} {}", command, args.join(" "))
                }
            }
        };

        // Record command in history (strip leading slash for clean display)
        let cmd_name = cmd_str.trim_start_matches('/');
        self.app_state.add_to_history(cmd_name);

        // Execute the command
        let result = self.command_executor.execute_str(&cmd_str);

        // Handle the result synchronously for now
        // For async commands, we need to spawn a task
        match result {
            CommandResult::Success => {}
            CommandResult::Message(msg) => {
                self.add_system_message(&msg);
            }
            CommandResult::Error(err) => {
                self.add_system_message(&format!("Error: {}", err));
            }
            CommandResult::SetValue(key, value) => {
                self.handle_set_value(&key, &value);
            }
            CommandResult::Clear => {
                self.app_state.clear_messages();
            }
            CommandResult::Quit => {
                self.app_state.set_quit();
            }
            CommandResult::NotFound(cmd) => {
                self.add_system_message(&format!("Unknown command: {}", cmd));
            }
            CommandResult::NeedsArgs(msg) => {
                self.add_system_message(&msg);
            }
            _ => {
                // Other results handled elsewhere or not applicable
            }
        }
    }

    /// Cancels the current streaming operation.
    fn cancel_streaming(&mut self) {
        if self.streaming_task.is_some() {
            self.streaming_cancelled.store(true, Ordering::SeqCst);
            self.stream_controller.set_error("Cancelled".to_string());
            self.app_state.stop_streaming();
            self.add_system_message("Streaming cancelled.");

            // Clean up
            self.streaming_rx = None;
            if let Some(task) = self.streaming_task.take() {
                task.abort();
            }
            self.stream_controller.reset();
        }
    }

    /// Handles a command result from the CommandExecutor.
    ///
    /// This method processes the result of a slash command execution and
    /// performs the appropriate action based on the result type.
    async fn handle_command_result(&mut self, result: CommandResult) -> Result<()> {
        match result {
            CommandResult::Success => {
                // Command executed successfully, nothing more to do
            }

            CommandResult::Message(msg) => {
                // Display message as system notification
                self.add_system_message(&msg);
            }

            CommandResult::Error(err) => {
                self.add_system_message(&format!("Error: {}", err));
            }

            CommandResult::Quit => {
                self.app_state.set_quit();
            }

            CommandResult::Clear => {
                self.app_state.clear_messages();
            }

            CommandResult::NewSession => {
                self.app_state.new_session();
            }

            CommandResult::ResumeSession(id) => {
                // Load session by ID
                if let Ok(session) = CortexSession::load(&id) {
                    self.cortex_session = Some(session);
                    self.app_state.set_view(AppView::Session);
                    self.add_system_message(&format!("Resumed session: {}", id));
                } else {
                    self.add_system_message(&format!("Failed to load session: {}", id));
                }
            }

            CommandResult::Toggle(feature) => match feature.as_str() {
                "sidebar" => {
                    self.app_state.toggle_sidebar();
                    let state = if self.app_state.sidebar_visible {
                        "shown"
                    } else {
                        "hidden"
                    };
                    self.app_state.toasts.info(&format!("Sidebar {}", state));
                }
                "compact" => {
                    self.app_state.toggle_compact();
                    let state = if self.app_state.compact_mode {
                        "on"
                    } else {
                        "off"
                    };
                    self.app_state
                        .toasts
                        .info(&format!("Compact mode: {}", state));
                }
                "favorite" => {
                    if self.cortex_session.is_some() {
                        // Toggle favorite in settings (session doesn't have this yet)
                        let key = "session_favorite".to_string();
                        let is_fav = self
                            .app_state
                            .settings
                            .get(&key)
                            .map(|v| v == "true")
                            .unwrap_or(false);
                        self.app_state.settings.insert(key, (!is_fav).to_string());
                        if !is_fav {
                            self.app_state.toasts.success("Marked as favorite");
                        } else {
                            self.app_state.toasts.info("Favorite removed");
                        }
                    } else {
                        self.app_state.toasts.error("No active session");
                    }
                }
                "debug" => {
                    self.app_state.toggle_debug();
                    let state = if self.app_state.debug_mode {
                        "on"
                    } else {
                        "off"
                    };
                    self.app_state
                        .toasts
                        .info(&format!("Debug mode: {}", state));
                }
                "sandbox" => {
                    self.app_state.toggle_sandbox();
                    let state = if self.app_state.sandbox_mode {
                        "on"
                    } else {
                        "off"
                    };
                    self.app_state
                        .toasts
                        .info(&format!("Sandbox mode: {}", state));
                }
                "auto" => {
                    // Toggle auto-approve mode
                    let is_yolo = matches!(
                        self.app_state.permission_mode,
                        crate::permissions::PermissionMode::Yolo
                    );
                    if is_yolo {
                        self.app_state.permission_mode = crate::permissions::PermissionMode::High;
                        self.app_state.toasts.info("Auto-approve: OFF");
                    } else {
                        self.app_state.permission_mode = crate::permissions::PermissionMode::Yolo;
                        self.app_state.toasts.success("Auto-approve: ON");
                    }
                }
                _ => {
                    self.app_state
                        .toasts
                        .error(&format!("Unknown toggle: {}", feature));
                }
            },

            CommandResult::SetValue(key, value) => {
                self.handle_set_value(&key, &value);
            }

            CommandResult::OpenModal(modal_type) => {
                // Handle modal opening - use new unified modal system
                match modal_type {
                    ModalType::Help(topic) => {
                        use crate::modal::HelpModal;
                        self.modal_stack
                            .push(Box::new(HelpModal::with_topic(topic)));
                    }
                    ModalType::Settings => {
                        // Use interactive mode for settings
                        use crate::interactive::builders::{
                            SettingsSnapshot, build_settings_selector,
                        };
                        let snapshot = SettingsSnapshot {
                            // Display
                            compact_mode: self.app_state.compact_mode,
                            timestamps: self.app_state.timestamps_enabled,
                            line_numbers: self.app_state.line_numbers_enabled,
                            word_wrap: self.app_state.word_wrap_enabled,
                            syntax_highlight: self.app_state.syntax_highlight_enabled,
                            // Behavior
                            auto_approve: matches!(
                                self.app_state.permission_mode,
                                crate::permissions::PermissionMode::Yolo
                            ),
                            sandbox_mode: self.app_state.sandbox_mode,
                            streaming_enabled: true,
                            auto_scroll: self.app_state.auto_scroll_enabled,
                            sound: self.app_state.sound_enabled,
                            // AI
                            thinking_enabled: self.app_state.thinking_budget.is_some(),
                            debug_mode: self.app_state.debug_mode,
                            context_aware: self.app_state.context_aware_enabled,
                            // Git
                            co_author: self.app_state.co_author_enabled,
                            auto_commit: self.app_state.auto_commit_enabled,
                            sign_commits: self.app_state.sign_commits_enabled,
                            // Cloud
                            cloud_sync: self.app_state.cloud_sync_enabled,
                            auto_save: self.app_state.auto_save_enabled,
                            session_history: self.app_state.session_history_enabled,
                            // Privacy
                            telemetry: self.app_state.telemetry_enabled,
                            analytics: self.app_state.analytics_enabled,
                        };
                        let terminal_height = self.app_state.terminal_size.1;
                        let interactive = build_settings_selector(snapshot, Some(terminal_height));
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    // ModalType::ProviderPicker removed: provider is now always "cortex"
                    ModalType::ModelPicker => {
                        // Get models from ProviderManager (fetched from API)
                        let (models, current_model) = if let Some(ref pm) = self.provider_manager {
                            if let Ok(manager) = pm.try_read() {
                                let models = manager.available_models();
                                let current = manager.current_model().to_string();

                                if models.is_empty() {
                                    tracing::warn!(
                                        "No models available. Auth token present: {}, cached_models: {}",
                                        manager.is_authenticated(),
                                        manager.available_models().len()
                                    );
                                }

                                (models, Some(current))
                            } else {
                                (Vec::new(), None)
                            }
                        } else {
                            (Vec::new(), None)
                        };

                        if models.is_empty() {
                            // Show helpful message to user
                            self.add_system_message(
                                "No models available. Run /login to authenticate or check your connection."
                            );
                        }

                        let interactive = crate::interactive::builders::build_model_selector(
                            models,
                            current_model.as_deref(),
                        );
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    ModalType::CommandPalette => {
                        use crate::modal::CommandsModal;
                        self.modal_stack.push(Box::new(CommandsModal::new()));
                    }
                    ModalType::Sessions => {
                        self.open_sessions_modal();
                    }
                    ModalType::McpManager => {
                        // Use interactive mode for MCP servers (like settings panel)
                        use crate::interactive::builders::build_mcp_selector;
                        let servers = self.app_state.mcp_servers.clone();
                        let interactive = build_mcp_selector(&servers);
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    ModalType::Form(cmd_name) => {
                        // Some commands use interactive mode instead of forms
                        match cmd_name.as_str() {
                            "temperature" => {
                                let interactive =
                                    crate::interactive::builders::build_temperature_selector(
                                        self.app_state.temperature,
                                    );
                                self.app_state.enter_interactive_mode(interactive);
                            }
                            "scroll" => {
                                let interactive =
                                    crate::interactive::builders::build_scroll_selector();
                                self.app_state.enter_interactive_mode(interactive);
                            }
                            _ => {
                                // Open form modal for other commands
                                let registry = FormRegistry::new();
                                if let Some(form_state) = registry.get_form(&cmd_name) {
                                    self.app_state.active_modal =
                                        Some(crate::app::ActiveModal::Form(form_state));
                                } else {
                                    // Show usage hint instead of silently failing
                                    let usage = match cmd_name.as_str() {
                                        "rename" => "/rename <new name>",
                                        "remove" => "/remove <file>...",
                                        "search" => "/search <pattern>",
                                        "mention" => "/mention <file|symbol>",
                                        "tokens" => "/tokens <number>",
                                        "goto" => "/goto <message number>",
                                        "delete" => "/delete <session-id>",
                                        "eval" => "/eval <expression>",
                                        _ => &cmd_name,
                                    };
                                    self.app_state.toasts.info(&format!("Usage: {}", usage));
                                }
                            }
                        }
                    }
                    ModalType::ApprovalPicker => {
                        // Use interactive mode instead of modal
                        let current = self.app_state.approval_mode_string();
                        let interactive =
                            crate::interactive::builders::build_approval_selector(Some(&current));
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    ModalType::LogLevelPicker => {
                        // Use interactive mode instead of modal
                        let current = self.app_state.log_level.clone();
                        let interactive =
                            crate::interactive::builders::build_log_level_selector(Some(&current));
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    ModalType::Timeline => {
                        // Timeline view showing message history with timestamps
                        self.app_state
                            .toasts
                            .info("Timeline: Use scroll to navigate messages");
                    }
                    ModalType::ThemePicker => {
                        // Use interactive mode for theme selection
                        let current = self.app_state.settings.get("theme").map(|s| s.as_str());
                        let interactive =
                            crate::interactive::builders::build_theme_selector(current);
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    ModalType::Fork => {
                        // Fork current session
                        if let Some(ref session) = self.cortex_session {
                            let fork_name = format!("{} (fork)", session.title());
                            self.app_state
                                .toasts
                                .success(&format!("Forked: {}", fork_name));
                            // TODO: Actually create forked session
                        } else {
                            self.app_state.toasts.error("No active session to fork");
                        }
                    }
                    ModalType::FilePicker => {
                        // Use interactive file browser
                        let cwd = std::env::current_dir().unwrap_or_default();
                        let interactive = crate::interactive::builders::build_file_browser(&cwd);
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    ModalType::Export(format) => {
                        // Handle export with format or show selector
                        if let Some(fmt) = format {
                            match fmt.as_str() {
                                "md" | "markdown" => {
                                    let _ = self.handle_export(ExportFormat::Markdown);
                                }
                                "json" => {
                                    let _ = self.handle_export(ExportFormat::Json);
                                }
                                "txt" | "text" => {
                                    let _ = self.handle_export(ExportFormat::Text);
                                }
                                _ => {
                                    self.app_state
                                        .toasts
                                        .error(&format!("Unknown format: {}", fmt));
                                }
                            }
                        } else {
                            // Use interactive mode for format selection
                            let interactive = crate::interactive::builders::build_export_selector();
                            self.app_state.enter_interactive_mode(interactive);
                        }
                    }
                    ModalType::Confirm(msg) => {
                        // Show confirmation toast
                        self.app_state.toasts.info(&msg);
                    }
                    ModalType::Login => {
                        // Start the login flow and show the modal
                        self.start_login_flow().await;
                    }
                    ModalType::Upgrade => {
                        // Start the upgrade flow
                        self.app_state.toasts.info("Checking for updates...");
                        // TODO: Implement upgrade modal
                    }
                    ModalType::Agents => {
                        // Use interactive mode for agents management
                        let cwd = std::env::current_dir().ok();
                        let terminal_height = self.app_state.terminal_size.1;
                        let interactive = crate::interactive::builders::build_agents_selector(
                            cwd.as_deref(),
                            Some(terminal_height),
                        );
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    _ => {
                        self.app_state
                            .toasts
                            .error(&format!("Not implemented: {:?}", modal_type));
                    }
                }
            }

            CommandResult::SwitchView(view_type) => match view_type {
                ViewType::Session => self.app_state.set_view(AppView::Session),
                ViewType::Settings => self.app_state.set_view(AppView::Settings),
                ViewType::Help => self.app_state.set_view(AppView::Help),
            },

            CommandResult::Async(cmd_string) => {
                // Handle async commands
                self.handle_async_command(&cmd_string).await?;
            }

            CommandResult::NotFound(cmd) => {
                self.add_system_message(&format!("Unknown command: {}", cmd));
            }

            CommandResult::NeedsArgs(msg) => {
                self.add_system_message(&msg);
            }
        }

        Ok(())
    }

    /// Handles async command execution.
    ///
    /// These commands require access to the provider_manager or cortex_session
    /// and may involve async operations.
    async fn handle_async_command(&mut self, cmd: &str) -> Result<()> {
        match cmd {
            // === PROVIDER COMMANDS ===
            "providers:list" => {
                self.handle_providers_list();
            }
            "models:list" => {
                self.handle_models_list().await;
            }
            "models:fetch-and-pick" => {
                self.handle_models_fetch_and_pick().await;
            }

            // === AUTH COMMANDS ===
            "auth:login" => {
                self.handle_auth_login().await;
            }
            "auth:logout" => {
                self.handle_auth_logout();
            }
            "auth:account" => {
                self.handle_auth_account().await;
            }

            // === BILLING COMMANDS ===
            "billing:status" => {
                self.handle_billing_status().await;
            }
            "billing:refresh" => {
                self.handle_billing_refresh().await;
            }

            // === SESSION COMMANDS ===
            "session:info" => {
                self.handle_session_info();
            }
            "sessions:list" => {
                self.handle_sessions_list();
            }
            "undo" => {
                self.handle_undo().await;
            }
            "redo" => {
                self.handle_redo().await;
            }
            "transcript" => {
                self.handle_transcript();
            }
            "history" => {
                self.handle_history();
            }

            // === EXPORT COMMANDS ===
            "export:markdown" => {
                self.handle_export(ExportFormat::Markdown)?;
            }
            "export:json" => {
                self.handle_export(ExportFormat::Json)?;
            }
            "export:text" => {
                self.handle_export(ExportFormat::Text)?;
            }

            // === FILE/CONTEXT COMMANDS ===
            "context" => {
                // Use interactive mode for context list
                let interactive =
                    crate::interactive::builders::build_context_list(&self.app_state.context_files);
                self.app_state.enter_interactive_mode(interactive);
            }
            "images:list" => {
                self.handle_images_list();
            }

            // === MCP COMMANDS ===
            "mcp-tools" => {
                self.handle_mcp_tools();
            }
            "mcp-reload" => {
                self.handle_mcp_reload().await;
            }
            "mcp:status" => {
                // Use interactive mode for MCP status
                let interactive =
                    crate::interactive::builders::build_mcp_selector(&self.app_state.mcp_servers);
                self.app_state.enter_interactive_mode(interactive);
            }

            // === DEBUG COMMANDS ===
            "status" => {
                self.handle_system_status();
            }
            "metrics" => {
                self.handle_metrics();
            }
            "config:list" => {
                self.handle_config_list();
            }

            // === CUSTOM COMMANDS ===
            "commands:list" => {
                self.handle_commands_list();
            }
            "agents:list" => {
                self.handle_agents_list();
            }
            "init" => {
                self.handle_init(false);
            }
            "init:force" => {
                self.handle_init(true);
            }
            "share" => {
                self.handle_share(None).await;
            }

            // === PATTERN-MATCHED COMMANDS ===
            _ => {
                // Handle commands with parameters
                if cmd.starts_with("billing:usage") {
                    self.handle_billing_usage(cmd).await;
                } else if let Some(files) = cmd.strip_prefix("add:") {
                    self.handle_add_files(files);
                } else if let Some(files) = cmd.strip_prefix("remove:") {
                    self.handle_remove_files(files);
                } else if let Some(pattern) = cmd.strip_prefix("search:") {
                    self.handle_search(pattern).await;
                } else if let Some(path) = cmd.strip_prefix("ls:") {
                    self.handle_ls(path);
                } else if let Some(path) = cmd.strip_prefix("tree:") {
                    self.handle_tree(path);
                } else if let Some(item) = cmd.strip_prefix("mention:") {
                    self.handle_mention(item);
                } else if let Some(paths) = cmd.strip_prefix("images:add:") {
                    self.handle_images_add(paths);
                } else if cmd == "diff" || cmd.starts_with("diff:") {
                    let file = cmd.strip_prefix("diff:").unwrap_or("");
                    self.handle_diff(file);
                } else if let Some(sub) = cmd.strip_prefix("mcp:add:") {
                    self.handle_mcp_add(sub).await;
                } else if let Some(sub) = cmd.strip_prefix("mcp:remove:") {
                    self.handle_mcp_remove(sub).await;
                } else if let Some(server) = cmd.strip_prefix("mcp:auth:") {
                    self.handle_mcp_auth(server);
                } else if let Some(server) = cmd.strip_prefix("mcp:logs:") {
                    self.handle_mcp_logs(server);
                } else if let Some(key) = cmd.strip_prefix("config:get:") {
                    self.handle_config_get(key);
                } else if let Some(level) = cmd.strip_prefix("logs:") {
                    self.handle_set_log_level(level);
                } else if let Some(file) = cmd.strip_prefix("dump:") {
                    self.handle_dump(file)?;
                } else if let Some(expr) = cmd.strip_prefix("eval:") {
                    self.handle_eval(expr);
                } else if let Some(duration) = cmd.strip_prefix("share:") {
                    self.handle_share(Some(duration)).await;
                } else {
                    tracing::debug!("Unhandled async command: {}", cmd);
                    // Show as warning toast (orange, no emoji)
                    self.app_state
                        .toasts
                        .warning(&format!("Command not yet implemented: {}", cmd));
                }
            }
        }

        Ok(())
    }

    /// Lists all providers with their configuration status.
    fn handle_providers_list(&mut self) {
        let mut output = String::from("Provider:\n\n");

        // Check Cortex authentication via cortex_login
        let is_authenticated = cortex_login::has_valid_auth();

        if is_authenticated {
            output.push_str("  [x] Cortex - Authenticated\n\n");
        } else {
            output.push_str("  [ ] Cortex - Not authenticated\n\n");
            output.push_str("Run /login to authenticate.");
        }

        self.add_system_message(&output);
    }

    /// Lists available models for the current provider.
    async fn handle_models_list(&mut self) {
        // Clone the Arc to avoid borrow issues
        let pm_opt = self.provider_manager.clone();

        let output = if let Some(pm) = pm_opt {
            // First, try to fetch models if not yet loaded
            {
                let mut manager = match pm.try_write() {
                    Ok(m) => m,
                    Err(_) => {
                        self.add_system_message("Unable to access provider manager.");
                        return;
                    }
                };

                // If no models cached, try to fetch them now
                if manager.available_models().is_empty() && manager.is_available() {
                    tracing::info!("No cached models, fetching from API...");
                    match manager.fetch_models().await {
                        Ok(fetched) => {
                            tracing::info!("Fetched {} models from API", fetched.len());
                        }
                        Err(e) => {
                            tracing::warn!("Failed to fetch models: {}", e);
                        }
                    }
                }
            }

            // Now read the models
            let manager = match pm.try_read() {
                Ok(m) => m,
                Err(_) => {
                    self.add_system_message("Unable to access provider manager.");
                    return;
                }
            };
            let models = manager.available_models();
            if models.is_empty() {
                if !manager.is_available() {
                    "No models available. Run /login to authenticate.".to_string()
                } else {
                    "No models available from the API.".to_string()
                }
            } else {
                let current_model = manager.current_model();
                let mut out = format!(
                    "Models for {} ({} total):\n",
                    manager.current_provider_name(),
                    models.len()
                );

                // Show first 20 models to avoid overwhelming output
                for model in models.iter().take(20) {
                    let current = if model.id == current_model {
                        " (current)"
                    } else {
                        ""
                    };
                    out.push_str(&format!("  - {}{}\n", model.name, current));
                }

                if models.len() > 20 {
                    out.push_str(&format!("  ... and {} more\n", models.len() - 20));
                }

                out
            }
        } else {
            "Provider manager not initialized.".to_string()
        };

        self.add_system_message(&output);
    }

    /// Fetches models from API if not cached, then opens the model picker.
    async fn handle_models_fetch_and_pick(&mut self) {
        // Clone the Arc to avoid borrow issues with self
        let pm_opt = self.provider_manager.clone();

        if let Some(pm) = pm_opt {
            // Check if we need to fetch
            let needs_fetch = {
                let manager = match pm.try_read() {
                    Ok(m) => m,
                    Err(_) => {
                        self.add_system_message("Unable to access provider manager.");
                        return;
                    }
                };
                manager.available_models().is_empty() && manager.is_available()
            };

            // Fetch if needed
            if needs_fetch {
                tracing::info!("No cached models, fetching from API before opening picker...");
                let fetch_result = {
                    let mut manager = match pm.try_write() {
                        Ok(m) => m,
                        Err(_) => {
                            self.add_system_message("Unable to access provider manager.");
                            return;
                        }
                    };
                    manager.fetch_models().await
                };

                match fetch_result {
                    Ok(fetched) => {
                        tracing::info!("Fetched {} models from API", fetched.len());
                    }
                    Err(e) => {
                        tracing::warn!("Failed to fetch models: {}", e);
                        self.add_system_message(&format!(
                            "Failed to load models: {}. Try /login to authenticate.",
                            e
                        ));
                    }
                }
            }

            // Now open the model picker with whatever models we have
            let (models, current_model) = {
                let manager = match pm.try_read() {
                    Ok(m) => m,
                    Err(_) => {
                        self.add_system_message("Unable to access provider manager.");
                        return;
                    }
                };
                (
                    manager.available_models(),
                    Some(manager.current_model().to_string()),
                )
            };

            if models.is_empty() {
                self.add_system_message(
                    "No models available. Run /login to authenticate or check your connection.",
                );
            }

            let interactive = crate::interactive::builders::build_model_selector(
                models,
                current_model.as_deref(),
            );
            self.app_state.enter_interactive_mode(interactive);
        } else {
            self.add_system_message("Provider manager not initialized.");
        }
    }

    // ========================================================================
    // AUTH HANDLERS
    // ========================================================================

    /// Starts the login flow with the interactive widget (same style as /settings).
    /// Non-blocking: shows widget immediately, does HTTP requests in background.
    async fn start_login_flow(&mut self) {
        use crate::interactive::builders::{
            LoginFlowState, build_already_logged_in_selector, build_login_selector,
        };
        use cortex_login::{CredentialsStoreMode, load_auth, logout_with_fallback};

        // Get cortex home directory
        let cortex_home = match dirs::home_dir() {
            Some(home) => home.join(".cortex"),
            None => {
                self.app_state.toasts.error("Could not find home directory");
                return;
            }
        };

        // Check if already logged in -> show confirmation widget
        if let Ok(Some(auth)) = load_auth(&cortex_home, CredentialsStoreMode::default()) {
            if !auth.is_expired() {
                let interactive = build_already_logged_in_selector();
                self.app_state.enter_interactive_mode(interactive);
                return;
            } else {
                // Session is expired - delete the expired token so user won't appear as "logged in"
                tracing::info!("Detected expired session, removing stale credentials");
                if let Err(e) = logout_with_fallback(&cortex_home) {
                    tracing::warn!("Failed to remove expired credentials: {}", e);
                }
            }
        }

        // Show loading widget immediately (non-blocking)
        let flow_state = LoginFlowState::loading();
        self.app_state.login_flow = Some(flow_state);
        let interactive = build_login_selector(self.app_state.login_flow.as_ref().unwrap());
        self.app_state.enter_interactive_mode(interactive);

        // Launch background task for device code request
        let tx = self.tool_event_tx.clone();
        tokio::spawn(async move {
            const API_BASE_URL: &str = "https://api.cortex.foundation";
            const AUTH_BASE_URL: &str = "https://auth.cortex.foundation";

            let client = match cortex_engine::create_client_builder()
                .connect_timeout(std::time::Duration::from_secs(5))
                .build()
            {
                Ok(c) => c,
                Err(e) => {
                    let _ = tx
                        .send(crate::events::ToolEvent::Failed {
                            id: "login_init".to_string(),
                            name: "login".to_string(),
                            error: format!("login:error:{}", e),
                            duration: std::time::Duration::from_secs(0),
                        })
                        .await;
                    return;
                }
            };

            let device_name = hostname::get()
                .map(|h| h.to_string_lossy().to_string())
                .unwrap_or_else(|_| "Cortex CLI".to_string());

            let response = match client
                .post(format!("{}/auth/device/code", API_BASE_URL))
                .json(&serde_json::json!({
                    "device_name": device_name,
                    "scopes": ["chat", "models"]
                }))
                .send()
                .await
            {
                Ok(r) => r,
                Err(e) => {
                    let _ = tx
                        .send(crate::events::ToolEvent::Failed {
                            id: "login_init".to_string(),
                            name: "login".to_string(),
                            error: format!("login:error:Network error: {}", e),
                            duration: std::time::Duration::from_secs(0),
                        })
                        .await;
                    return;
                }
            };

            if !response.status().is_success() {
                let status = response.status();
                let error_msg = match status.as_u16() {
                    403 => "Cannot connect to Cortex API".to_string(),
                    429 => "Too many attempts. Please wait.".to_string(),
                    _ => format!("API error ({})", status),
                };
                let _ = tx
                    .send(crate::events::ToolEvent::Failed {
                        id: "login_init".to_string(),
                        name: "login".to_string(),
                        error: format!("login:error:{}", error_msg),
                        duration: std::time::Duration::from_secs(0),
                    })
                    .await;
                return;
            }

            #[derive(serde::Deserialize)]
            struct DeviceCodeResponse {
                user_code: String,
                device_code: String,
                #[allow(dead_code)]
                verification_uri: String,
            }

            let device_code_data: DeviceCodeResponse = match response.json().await {
                Ok(d) => d,
                Err(e) => {
                    let _ = tx
                        .send(crate::events::ToolEvent::Failed {
                            id: "login_init".to_string(),
                            name: "login".to_string(),
                            error: format!("login:error:Parse error: {}", e),
                            duration: std::time::Duration::from_secs(0),
                        })
                        .await;
                    return;
                }
            };

            let verification_url = format!("{}/device", AUTH_BASE_URL);

            // Send device code data via event channel
            let _ = tx
                .send(crate::events::ToolEvent::Completed {
                    id: "login_init".to_string(),
                    name: "login".to_string(),
                    output: serde_json::json!({
                        "device_code": device_code_data.device_code,
                        "user_code": device_code_data.user_code,
                        "verification_uri": verification_url,
                    })
                    .to_string(),
                    success: true,
                    duration: std::time::Duration::from_secs(0),
                })
                .await;
        });
    }

    /// Starts polling for login token after device code is received.
    fn start_login_polling(&mut self, device_code: String) {
        use cortex_login::{SecureAuthData, save_auth_with_fallback};

        const API_BASE_URL: &str = "https://api.cortex.foundation";

        let cortex_home = match dirs::home_dir() {
            Some(home) => home.join(".cortex"),
            None => return,
        };

        let tx = self.tool_event_tx.clone();

        tokio::spawn(async move {
            let poll_client = match cortex_engine::create_default_client() {
                Ok(c) => c,
                Err(e) => {
                    tracing::error!("Login polling failed: {}", e);
                    let _ = tx
                        .send(crate::events::ToolEvent::Failed {
                            id: "login_poll".to_string(),
                            name: "login".to_string(),
                            error: format!("login:error:{}", e),
                            duration: std::time::Duration::from_secs(0),
                        })
                        .await;
                    return;
                }
            };

            let interval = std::time::Duration::from_secs(5);
            let max_attempts = 180;

            for _ in 0..max_attempts {
                tokio::time::sleep(interval).await;

                let poll_response = match poll_client
                    .post(format!("{}/auth/device/token", API_BASE_URL))
                    .json(&serde_json::json!({ "device_code": device_code }))
                    .send()
                    .await
                {
                    Ok(r) => r,
                    Err(_) => continue,
                };

                let status = poll_response.status();
                let body = poll_response.text().await.unwrap_or_default();

                if status.is_success() {
                    #[derive(serde::Deserialize)]
                    struct TokenResponse {
                        access_token: String,
                        refresh_token: String,
                    }

                    if let Ok(token) = serde_json::from_str::<TokenResponse>(&body) {
                        let expires_at = chrono::Utc::now().timestamp() + 3600;
                        let auth_data = SecureAuthData::with_oauth(
                            token.access_token,
                            Some(token.refresh_token),
                            Some(expires_at),
                        );

                        // Use save_auth_with_fallback for automatic keyring -> encrypted file fallback
                        // This handles Windows Credential Manager limitations gracefully
                        match save_auth_with_fallback(&cortex_home, &auth_data) {
                            Ok(mode) => {
                                tracing::info!("Auth credentials saved using {:?} storage", mode);
                                let _ = tx
                                    .send(crate::events::ToolEvent::Completed {
                                        id: "login_poll".to_string(),
                                        name: "login".to_string(),
                                        output: "login:success".to_string(),
                                        success: true,
                                        duration: std::time::Duration::from_secs(0),
                                    })
                                    .await;
                                return;
                            }
                            Err(e) => {
                                tracing::error!("Failed to save auth credentials: {}", e);
                                let _ = tx
                                    .send(crate::events::ToolEvent::Failed {
                                        id: "login_poll".to_string(),
                                        name: "login".to_string(),
                                        error: format!("Failed to save credentials: {}", e),
                                        duration: std::time::Duration::from_secs(0),
                                    })
                                    .await;
                                return;
                            }
                        }
                    }
                    continue;
                }

                if let Ok(error) = serde_json::from_str::<serde_json::Value>(&body) {
                    if let Some(err) = error.get("error").and_then(|e| e.as_str()) {
                        match err {
                            "authorization_pending" | "slow_down" => continue,
                            "expired_token" => {
                                let _ = tx
                                    .send(crate::events::ToolEvent::Failed {
                                        id: "login_poll".to_string(),
                                        name: "login".to_string(),
                                        error: "login:expired".to_string(),
                                        duration: std::time::Duration::from_secs(0),
                                    })
                                    .await;
                                return;
                            }
                            "access_denied" => {
                                let _ = tx
                                    .send(crate::events::ToolEvent::Failed {
                                        id: "login_poll".to_string(),
                                        name: "login".to_string(),
                                        error: "login:denied".to_string(),
                                        duration: std::time::Duration::from_secs(0),
                                    })
                                    .await;
                                return;
                            }
                            _ => {}
                        }
                    }
                }
            }

            let _ = tx
                .send(crate::events::ToolEvent::Failed {
                    id: "login_poll".to_string(),
                    name: "login".to_string(),
                    error: "login:timeout".to_string(),
                    duration: std::time::Duration::from_secs(0),
                })
                .await;
        });
    }

    /// Handles the /login command - triggers device code OAuth flow (legacy, uses chat messages).
    ///
    /// This displays the verification URL and user code in the chat BEFORE attempting
    /// to open a browser, providing a fallback for environments where browser opening fails.
    async fn handle_auth_login(&mut self) {
        use cortex_login::{
            CredentialsStoreMode, SecureAuthData, load_auth, save_auth_with_fallback,
        };

        const API_BASE_URL: &str = "https://api.cortex.foundation";
        const AUTH_BASE_URL: &str = "https://auth.cortex.foundation";

        // Get cortex home directory
        let cortex_home = match dirs::home_dir() {
            Some(home) => home.join(".cortex"),
            None => {
                self.add_system_message("Error: Could not determine home directory.");
                return;
            }
        };

        // Check if already logged in
        if let Ok(Some(auth)) = load_auth(&cortex_home, CredentialsStoreMode::default()) {
            if !auth.is_expired() {
                self.add_system_message(
                    "Already logged in. Use /logout to sign out first, or /account to see your account info."
                );
                return;
            }
        }

        self.add_system_message("Starting login...");

        // Step 1: Request device code from API
        let client = match cortex_engine::create_default_client() {
            Ok(c) => c,
            Err(e) => {
                self.add_system_message(&format!(
                    "Login failed: Could not create HTTP client: {}",
                    e
                ));
                return;
            }
        };

        let device_name = hostname::get()
            .map(|h| h.to_string_lossy().to_string())
            .unwrap_or_else(|_| "Cortex CLI".to_string());

        let response = match client
            .post(format!("{}/auth/device/code", API_BASE_URL))
            .json(&serde_json::json!({
                "device_name": device_name,
                "scopes": ["chat", "models"]
            }))
            .send()
            .await
        {
            Ok(r) => r,
            Err(e) => {
                self.add_system_message(&format!("Login failed: Network error: {}", e));
                return;
            }
        };

        // Handle non-success status codes
        if !response.status().is_success() {
            let status = response.status();
            let body = response.text().await.unwrap_or_default();

            let error_msg = if status.as_u16() == 403 {
                "Cannot connect to Cortex API. Service may be unavailable.".to_string()
            } else if status.as_u16() == 429 {
                "Too many login attempts. Please wait.".to_string()
            } else {
                format!("API error ({}): {}", status, body)
            };

            self.add_system_message(&format!("Login failed: {}", error_msg));
            return;
        }

        // Step 2: Parse device code response
        #[derive(serde::Deserialize)]
        struct DeviceCodeResponse {
            user_code: String,
            device_code: String,
            verification_uri: String,
        }

        let device_code_data: DeviceCodeResponse = match response.json().await {
            Ok(d) => d,
            Err(e) => {
                self.add_system_message(&format!("Login failed: Could not parse response: {}", e));
                return;
            }
        };

        // Step 3: Display URL and code in chat FIRST (visible fallback)
        let user_code = device_code_data.user_code.clone();
        let verification_url = format!("{}/device", AUTH_BASE_URL);
        let msg = format!(
            "Starting login...\n\n\
             **Visit:** {}\n\n\
             **Enter code:** {}\n\n\
             _If browser doesn't open automatically, copy the URL above._",
            verification_url, user_code
        );
        self.add_system_message(&msg);

        // Step 4: Try to open browser (may fail silently in some environments)
        let browser_url = format!("{}?code={}", verification_url, user_code);
        let _ = open_browser_url(&browser_url);

        // Step 5: Start polling for token in background
        let device_code = device_code_data.device_code;
        let cortex_home_clone = cortex_home.clone();
        let tx = self.tool_event_tx.clone();

        tokio::spawn(async move {
            let poll_client = match cortex_engine::create_default_client() {
                Ok(c) => c,
                Err(e) => {
                    tracing::error!("Login polling failed: Could not create HTTP client: {}", e);
                    let _ = tx
                        .send(crate::events::ToolEvent::Failed {
                            id: "login".to_string(),
                            name: "login".to_string(),
                            error: format!("Login failed: {}", e),
                            duration: std::time::Duration::from_secs(0),
                        })
                        .await;
                    return;
                }
            };

            let interval = std::time::Duration::from_secs(5);
            let max_attempts = 180; // 15 minutes total

            for _ in 0..max_attempts {
                tokio::time::sleep(interval).await;

                let poll_response = match poll_client
                    .post(format!("{}/auth/device/token", API_BASE_URL))
                    .json(&serde_json::json!({ "device_code": device_code }))
                    .send()
                    .await
                {
                    Ok(r) => r,
                    Err(_) => continue, // Network error, retry
                };

                let status = poll_response.status();
                let body = poll_response.text().await.unwrap_or_default();

                if status.is_success() {
                    #[derive(serde::Deserialize)]
                    struct TokenResponse {
                        access_token: String,
                        refresh_token: String,
                    }

                    if let Ok(token) = serde_json::from_str::<TokenResponse>(&body) {
                        let expires_at = chrono::Utc::now().timestamp() + 3600;
                        let auth_data = SecureAuthData::with_oauth(
                            token.access_token,
                            Some(token.refresh_token),
                            Some(expires_at),
                        );

                        // Use save_auth_with_fallback for automatic keyring -> encrypted file fallback
                        // This handles Windows Credential Manager limitations gracefully
                        match save_auth_with_fallback(&cortex_home_clone, &auth_data) {
                            Ok(mode) => {
                                tracing::info!(
                                    "Login successful, credentials saved using {:?} storage",
                                    mode
                                );
                                let _ = tx
                                    .send(crate::events::ToolEvent::Completed {
                                        id: "login".to_string(),
                                        name: "login".to_string(),
                                        output: "Login successful! You are now authenticated."
                                            .to_string(),
                                        success: true,
                                        duration: std::time::Duration::from_secs(0),
                                    })
                                    .await;
                                return;
                            }
                            Err(e) => {
                                tracing::error!("Login failed: Could not save credentials: {}", e);
                                let _ = tx
                                    .send(crate::events::ToolEvent::Failed {
                                        id: "login".to_string(),
                                        name: "login".to_string(),
                                        error: format!(
                                            "Login failed: Could not save credentials: {}",
                                            e
                                        ),
                                        duration: std::time::Duration::from_secs(0),
                                    })
                                    .await;
                                return;
                            }
                        }
                    }
                    continue;
                }

                // Handle error responses
                if let Ok(error) = serde_json::from_str::<serde_json::Value>(&body) {
                    if let Some(err) = error.get("error").and_then(|e| e.as_str()) {
                        match err {
                            "authorization_pending" | "slow_down" => continue,
                            "expired_token" => {
                                tracing::error!("Login failed: Device code expired");
                                let _ = tx
                                    .send(crate::events::ToolEvent::Failed {
                                        id: "login".to_string(),
                                        name: "login".to_string(),
                                        error:
                                            "Login failed: Device code expired. Please try again."
                                                .to_string(),
                                        duration: std::time::Duration::from_secs(0),
                                    })
                                    .await;
                                return;
                            }
                            "access_denied" => {
                                tracing::error!("Login failed: Access denied");
                                let _ = tx
                                    .send(crate::events::ToolEvent::Failed {
                                        id: "login".to_string(),
                                        name: "login".to_string(),
                                        error: "Login failed: Access denied.".to_string(),
                                        duration: std::time::Duration::from_secs(0),
                                    })
                                    .await;
                                return;
                            }
                            _ => {}
                        }
                    }
                }
            }

            // Max attempts reached
            tracing::error!("Login failed: Authentication timed out");
            let _ = tx
                .send(crate::events::ToolEvent::Failed {
                    id: "login".to_string(),
                    name: "login".to_string(),
                    error: "Login failed: Authentication timed out. Please try again.".to_string(),
                    duration: std::time::Duration::from_secs(0),
                })
                .await;
        });

        self.app_state
            .toasts
            .info("Check your browser to complete login");
    }

    /// Handles the /logout command - clears stored credentials.
    fn handle_auth_logout(&mut self) {
        use cortex_login::logout_with_fallback;

        // Get cortex home directory
        let cortex_home = match dirs::home_dir() {
            Some(home) => home.join(".cortex"),
            None => {
                self.add_system_message("Error: Could not determine home directory.");
                return;
            }
        };

        // Use logout_with_fallback to clear credentials from all storage locations
        // (keyring, encrypted file, and legacy file) since save_auth_with_fallback
        // may have stored them in encrypted file when keyring was unavailable
        match logout_with_fallback(&cortex_home) {
            Ok(true) => {
                self.add_system_message("Successfully logged out. Credentials have been removed.");
                self.app_state.toasts.success("Logged out successfully");
            }
            Ok(false) => {
                self.add_system_message("No credentials found. You are not logged in.");
            }
            Err(e) => {
                self.add_system_message(&format!("Error logging out: {}", e));
                self.app_state.toasts.error("Logout failed");
            }
        }
    }

    /// Handles the /account command - displays account information.
    async fn handle_auth_account(&mut self) {
        use cortex_login::{AuthMode, CredentialsStoreMode, load_auth};

        // Get cortex home directory
        let cortex_home = match dirs::home_dir() {
            Some(home) => home.join(".cortex"),
            None => {
                self.add_system_message("Error: Could not determine home directory.");
                return;
            }
        };

        // Load auth data
        let auth = match load_auth(&cortex_home, CredentialsStoreMode::default()) {
            Ok(Some(auth)) => auth,
            Ok(None) => {
                self.add_system_message(
                    "Not logged in.\n\n\
                     Use /login to authenticate with your Cortex account.",
                );
                return;
            }
            Err(e) => {
                self.add_system_message(&format!("Error loading credentials: {}", e));
                return;
            }
        };

        // Check if expired
        if auth.is_expired() {
            self.add_system_message(
                "Session expired.\n\n\
                 Use /login to re-authenticate.",
            );
            return;
        }

        // Build account info display
        let mut output = String::from("Account Information:\n\n");

        // Auth mode
        let mode_str = match auth.mode {
            AuthMode::ApiKey => "API Key",
            AuthMode::OAuth => "OAuth",
        };
        output.push_str(&format!("  Auth Method: {}\n", mode_str));

        // Expiration
        if let Some(expires_at) = auth.expires_at {
            let expires = chrono::DateTime::from_timestamp(expires_at, 0)
                .map(|dt| dt.format("%Y-%m-%d %H:%M UTC").to_string())
                .unwrap_or_else(|| "unknown".to_string());
            output.push_str(&format!("  Expires: {}\n", expires));
        } else {
            output.push_str("  Expires: never\n");
        }

        // Account ID if available
        if let Some(ref account_id) = auth.account_id {
            output.push_str(&format!("  Account ID: {}\n", account_id));
        }

        // Status
        output.push_str("  Status: Active\n");

        output.push_str("\nUse /logout to sign out.");

        self.add_system_message(&output);
    }

    // ========================================================================
    // BILLING HANDLERS
    // ========================================================================

    /// Handles the /billing command - displays billing status, plan, and credits.
    async fn handle_billing_status(&mut self) {
        use cortex_engine::billing_client::{BillingClient, format_billing_status};

        // Create billing client
        let client = match BillingClient::new() {
            Ok(c) => c,
            Err(e) => {
                self.add_system_message(&format!("Error initializing billing client: {}", e));
                return;
            }
        };

        // Fetch subscription info
        let subscription = match client.get_subscription().await {
            Ok(sub) => sub,
            Err(e) => {
                let error_msg = if e.to_string().contains("Not authenticated")
                    || e.to_string().contains("Authentication failed")
                {
                    "Not authenticated. Use /login to sign in first.".to_string()
                } else if e.to_string().contains("not found") {
                    "No subscription found. You may be on a free plan.".to_string()
                } else {
                    format!("Error fetching subscription: {}", e)
                };
                self.add_system_message(&error_msg);
                return;
            }
        };

        // Fetch usage summary
        let usage = match client.get_usage(None).await {
            Ok(u) => u,
            Err(e) => {
                // Show subscription info even if usage fails
                let mut output = format_billing_status(
                    &subscription,
                    &cortex_engine::billing_client::UsageSummary {
                        org_id: uuid::Uuid::nil(),
                        period_start: subscription.current_period_start,
                        period_end: subscription.current_period_end,
                        total_tokens: 0,
                        input_tokens: 0,
                        output_tokens: 0,
                        total_requests: 0,
                        successful_requests: 0,
                        total_cost_usd: 0.0,
                        by_model: vec![],
                        quota: None,
                    },
                );
                output.push_str(&format!("\n\nWarning: Could not fetch usage: {}", e));
                self.add_system_message(&output);
                return;
            }
        };

        // Format and display
        let output = format_billing_status(&subscription, &usage);
        self.add_system_message(&output);
    }

    /// Handles the /usage command - displays detailed usage breakdown by model.
    ///
    /// Parses date range parameters from the command string:
    /// - billing:usage - current period
    /// - billing:usage:from=YYYY-MM-DD:to=YYYY-MM-DD - specific range
    async fn handle_billing_usage(&mut self, cmd: &str) {
        use cortex_engine::billing_client::{BillingClient, UsageQuery, format_usage_breakdown};

        // Parse date parameters from command string
        let mut query = UsageQuery::default();

        if let Some(params) = cmd.strip_prefix("billing:usage") {
            // Parse :from=YYYY-MM-DD:to=YYYY-MM-DD
            for part in params.split(':') {
                if let Some(from) = part.strip_prefix("from=") {
                    query.start_date = Some(from.to_string());
                } else if let Some(to) = part.strip_prefix("to=") {
                    query.end_date = Some(to.to_string());
                }
            }
        }

        // Create billing client
        let client = match BillingClient::new() {
            Ok(c) => c,
            Err(e) => {
                self.add_system_message(&format!("Error initializing billing client: {}", e));
                return;
            }
        };

        // Fetch model usage breakdown
        let models = match client.get_usage_by_model(Some(query.clone())).await {
            Ok(m) => m,
            Err(e) => {
                let error_msg = if e.to_string().contains("Not authenticated")
                    || e.to_string().contains("Authentication failed")
                {
                    "Not authenticated. Use /login to sign in first.".to_string()
                } else {
                    format!("Error fetching usage: {}", e)
                };
                self.add_system_message(&error_msg);
                return;
            }
        };

        // Format and display
        let output = format_usage_breakdown(&models, &Some(query));
        self.add_system_message(&output);
    }

    /// Handles the /refresh command - refreshes billing status after payment method added.
    ///
    /// This allows users to resume using the agent after hitting usage limits and
    /// adding a payment method externally, without needing to restart the application.
    async fn handle_billing_refresh(&mut self) {
        use cortex_engine::billing_client::BillingClient;

        self.add_system_message("Refreshing billing status...");

        // Create billing client
        let client = match BillingClient::new() {
            Ok(c) => c,
            Err(e) => {
                self.add_system_message(&format!(
                    "Error initializing billing client: {}\n\n\
                     Please ensure you are logged in with /login.",
                    e
                ));
                return;
            }
        };

        // Fetch current subscription to verify billing is active
        match client.get_subscription().await {
            Ok(subscription) => {
                // Check subscription status
                let status = subscription.status.as_str();
                match status {
                    "active" | "trialing" => {
                        // Check if payment method is now configured
                        let has_payment = subscription.payment_method.is_some();
                        let plan_name = &subscription.plan.name;

                        if has_payment {
                            self.app_state.toasts.success("Billing refreshed!");
                            self.add_system_message(&format!(
                                "Billing status refreshed successfully!\n\n\
                                 Plan: {}\n\
                                 Status: Active\n\
                                 Payment method: Configured\n\n\
                                 You can now continue using Cortex. Your messages will resume.",
                                plan_name
                            ));
                        } else {
                            self.app_state.toasts.success("Billing refreshed!");
                            self.add_system_message(&format!(
                                "Billing status refreshed!\n\n\
                                 Plan: {}\n\
                                 Status: Active (free tier)\n\n\
                                 To add a payment method, visit: https://cortex.foundation/billing\n\
                                 Then run /refresh again.",
                                plan_name
                            ));
                        }
                    }
                    "past_due" => {
                        self.app_state.toasts.warning("Payment past due");
                        self.add_system_message(
                            "Warning: Your subscription payment is past due.\n\n\
                             Please update your payment method at: https://cortex.foundation/billing\n\
                             Then run /refresh to resume."
                        );
                    }
                    "canceled" => {
                        self.app_state.toasts.error("Subscription canceled");
                        self.add_system_message(
                            "Error: Your subscription has been canceled.\n\n\
                             To resubscribe, visit: https://cortex.foundation/billing",
                        );
                    }
                    _ => {
                        self.app_state.toasts.info("Billing status updated");
                        self.add_system_message(&format!(
                            "Billing status: {}\n\n\
                             If you need to update your payment method, visit:\n\
                             https://cortex.foundation/billing",
                            status
                        ));
                    }
                }
            }
            Err(e) => {
                let error_str = e.to_string();
                if error_str.contains("Not authenticated")
                    || error_str.contains("Authentication failed")
                {
                    self.add_system_message(
                        "Error: Not authenticated.\n\n\
                         Please log in first with /login, then run /refresh.",
                    );
                } else if error_str.contains("not found") {
                    self.add_system_message(
                        "No subscription found. You may be on the free plan.\n\n\
                         To upgrade, visit: https://cortex.foundation/billing\n\
                         Then run /refresh to update your status.",
                    );
                } else {
                    self.add_system_message(&format!(
                        "Error refreshing billing status: {}\n\n\
                         Please try again or visit https://cortex.foundation/billing",
                        e
                    ));
                }
            }
        }
    }

    // ========================================================================
    // SESSION HANDLERS
    // ========================================================================

    /// Shows current session information.
    fn handle_session_info(&mut self) {
        if let Some(ref session) = self.cortex_session {
            let mut output = String::from("Session Info:\n");
            output.push_str(&format!("  ID: {}\n", session.id()));
            output.push_str(&format!("  Title: {}\n", session.title()));
            output.push_str(&format!("  Provider: {}\n", session.meta.provider));
            output.push_str(&format!("  Model: {}\n", session.meta.model));
            output.push_str(&format!("  Messages: {}\n", session.message_count()));
            output.push_str(&format!("  Tokens: {}\n", session.format_tokens()));
            output.push_str(&format!(
                "  Created: {}\n",
                session.meta.created_at.format("%Y-%m-%d %H:%M")
            ));
            self.add_system_message(&output);
        } else {
            self.add_system_message("No active session.");
        }
    }

    /// Lists recent sessions.
    fn handle_sessions_list(&mut self) {
        match CortexSession::list_recent(10) {
            Ok(sessions) => {
                if sessions.is_empty() {
                    self.add_system_message("No saved sessions found.");
                } else {
                    let current_id = self.cortex_session.as_ref().map(|s| s.id().to_string());
                    let mut output = format!("Recent Sessions ({}):\n", sessions.len());

                    for session in &sessions {
                        let current = if Some(&session.id) == current_id.as_ref() {
                            " (current)"
                        } else {
                            ""
                        };
                        let title = if session.title.is_empty() {
                            "Untitled"
                        } else {
                            &session.title
                        };
                        // Use short ID, handling potential short IDs
                        let short_id = if session.id.len() >= 8 {
                            &session.id[..8]
                        } else {
                            &session.id
                        };
                        output.push_str(&format!(
                            "  - {} [{}] - {} msgs{}\n",
                            title, short_id, session.message_count, current
                        ));
                    }

                    self.add_system_message(&output);
                }
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to list sessions: {}", e));
            }
        }
    }

    /// Exports the current session to the specified format.
    fn handle_export(&mut self, format: ExportFormat) -> Result<()> {
        if let Some(ref session) = self.cortex_session {
            let filename = default_export_filename(session, format);
            let export_dir = dirs::document_dir()
                .or_else(dirs::home_dir)
                .unwrap_or_else(|| std::path::PathBuf::from("."));
            let export_path = export_dir.join(&filename);

            match export_to_file(session, format, &export_path) {
                Ok(()) => {
                    tracing::info!(
                        path = %export_path.display(),
                        format = %format.name(),
                        "Session exported successfully"
                    );
                    self.add_system_message(&format!(
                        "Session exported as {} to:\n{}",
                        format.name(),
                        export_path.display()
                    ));
                }
                Err(e) => {
                    tracing::error!(error = %e, "Export failed");
                    self.add_system_message(&format!("Export failed: {}", e));
                }
            }
        } else {
            self.add_system_message("No active session to export.");
        }

        Ok(())
    }

    /// Handles setting a configuration value.
    fn handle_set_value(&mut self, key: &str, value: &str) {
        match key {
            "model" => {
                self.app_state.model = value.to_string();
                if let Some(pm) = &self.provider_manager {
                    if let Ok(mut manager) = pm.try_write() {
                        let _ = manager.set_model(value);
                    }
                }
                // Update session model metadata
                self.update_session_model(value);
                self.add_system_message(&format!("Model set to: {}", value));
            }
            "provider" => {
                self.app_state.provider = value.to_string();
                if let Some(pm) = &self.provider_manager {
                    if let Ok(mut manager) = pm.try_write() {
                        let _ = manager.set_provider(value);
                    }
                }
                self.add_system_message(&format!("Provider set to: {}", value));
            }
            "session_name" => {
                if let Some(ref mut session) = self.cortex_session {
                    session.set_title(value);
                }
                self.app_state
                    .toasts
                    .success(&format!("Renamed: {}", value));
            }
            "theme" => {
                // Currently only Ocean theme is supported
                self.app_state.toasts.info("Theme: Ocean (default)");
            }
            "favorite" => {
                let is_fav = value == "true";
                let key = "session_favorite".to_string();
                let was_favorited = self
                    .app_state
                    .settings
                    .get(&key)
                    .map(|v| v == "true")
                    .unwrap_or(false);
                self.app_state.settings.insert(key, is_fav.to_string());
                if is_fav {
                    self.app_state.toasts.success("Session marked as favorite");
                } else if was_favorited {
                    self.app_state.toasts.info("Favorite removed");
                } else {
                    self.app_state.toasts.info("Session is not favorited");
                }
            }
            "sandbox" => {
                let enabled = value == "on" || value == "true";
                self.app_state.sandbox_mode = enabled;
                self.app_state
                    .toasts
                    .info(&format!("Sandbox: {}", if enabled { "on" } else { "off" }));
            }
            "auto_approve" => {
                let enabled = value == "on" || value == "true";
                if enabled {
                    self.app_state.permission_mode = crate::permissions::PermissionMode::Yolo;
                    self.app_state.toasts.success("Auto-approve: ON");
                } else {
                    self.app_state.permission_mode = crate::permissions::PermissionMode::High;
                    self.app_state.toasts.info("Auto-approve: OFF");
                }
            }
            "temperature" => {
                if let Ok(temp) = value.parse::<f32>() {
                    let temp = temp.clamp(0.0, 2.0);
                    self.app_state.temperature = temp;
                    self.app_state
                        .toasts
                        .success(&format!("Temperature: {:.1}", temp));
                } else {
                    self.app_state.toasts.error("Invalid temperature value");
                }
            }
            "max_tokens" => {
                if let Ok(tokens) = value.parse::<u32>() {
                    // Update app state
                    self.app_state.max_tokens = Some(tokens);

                    // Persist to config file
                    match crate::providers::config::CortexConfig::load() {
                        Ok(mut config) => {
                            config.max_tokens = tokens;
                            if let Err(e) = config.save() {
                                tracing::error!(
                                    error = %e,
                                    tokens = tokens,
                                    "Failed to save max_tokens to config"
                                );
                                self.app_state
                                    .toasts
                                    .error("Max tokens set but failed to save");
                                return;
                            }
                        }
                        Err(e) => {
                            tracing::error!(
                                error = %e,
                                "Failed to load config for max_tokens update"
                            );
                            self.app_state
                                .toasts
                                .error("Max tokens set but failed to save");
                            return;
                        }
                    }

                    // Update provider manager config if available
                    if let Some(ref pm) = self.provider_manager {
                        if let Ok(mut manager) = pm.try_write() {
                            manager.config_mut().max_tokens = tokens;
                        }
                    }

                    self.app_state
                        .toasts
                        .success(&format!("Max tokens: {}", tokens));
                } else {
                    self.app_state.toasts.error("Invalid max_tokens value");
                }
            }
            "debug" => {
                let enabled = value == "on" || value == "true";
                self.app_state.debug_mode = enabled;
                self.app_state
                    .toasts
                    .info(&format!("Debug: {}", if enabled { "on" } else { "off" }));
            }
            "auto" => {
                // Alias for auto_approve
                let enabled = value == "on" || value == "true";
                if enabled {
                    self.app_state.permission_mode = crate::permissions::PermissionMode::Yolo;
                    self.app_state.toasts.success("Auto-approve: ON");
                } else {
                    self.app_state.permission_mode = crate::permissions::PermissionMode::High;
                    self.app_state.toasts.info("Auto-approve: OFF");
                }
            }
            "approval" => match value {
                "ask" => {
                    self.app_state.permission_mode = crate::permissions::PermissionMode::High;
                    self.app_state.toasts.info("Approval: ask");
                }
                "session" => {
                    self.app_state.permission_mode = crate::permissions::PermissionMode::Medium;
                    self.app_state.toasts.info("Approval: session");
                }
                "always" | "auto" => {
                    self.app_state.permission_mode = crate::permissions::PermissionMode::Yolo;
                    self.app_state.toasts.success("Approval: always");
                }
                "never" => {
                    self.app_state.permission_mode = crate::permissions::PermissionMode::High;
                    self.app_state.toasts.info("Approval: never (will reject)");
                }
                _ => {
                    self.app_state
                        .toasts
                        .error(&format!("Unknown approval mode: {}", value));
                }
            },
            "scroll" => match value {
                "top" => {
                    self.app_state.scroll_chat_to_top();
                    self.app_state.toasts.info("Scrolled to top");
                }
                "bottom" => {
                    self.app_state.scroll_chat_to_bottom();
                    self.app_state.toasts.info("Scrolled to bottom");
                }
                n => {
                    if let Ok(lines) = n.parse::<i32>() {
                        self.app_state.scroll_chat(lines);
                        self.app_state
                            .toasts
                            .info(&format!("Scrolled {} lines", lines));
                    } else {
                        self.app_state.toasts.error("Invalid scroll value");
                    }
                }
            },
            "goto" => {
                if let Ok(msg_num) = value.parse::<usize>() {
                    // Scroll to show message number (approximate)
                    let total = self.app_state.messages.len();
                    if msg_num > 0 && msg_num <= total {
                        // Calculate approximate scroll position
                        let scroll_pos = (total - msg_num) as i32;
                        self.app_state.chat_scroll = scroll_pos.max(0) as usize;
                        self.app_state.chat_scroll_pinned_bottom = false;
                        self.app_state
                            .toasts
                            .info(&format!("Jumped to message {}", msg_num));
                    } else {
                        self.app_state
                            .toasts
                            .error(&format!("Message {} not found (have {})", msg_num, total));
                    }
                } else {
                    self.app_state.toasts.error("Invalid message number");
                }
            }
            "rewind" => {
                if let Ok(steps) = value.parse::<usize>() {
                    // Rewind by removing last N exchanges
                    let mut rewound = 0;
                    for _ in 0..steps {
                        if let Some(ref mut session) = self.cortex_session {
                            if session.pop_last_exchange().is_some() {
                                rewound += 1;
                            }
                        }
                    }
                    if rewound > 0 {
                        // Rebuild display from session
                        self.app_state.clear_messages();
                        if let Some(ref session) = self.cortex_session {
                            for stored_msg in session.messages() {
                                let role = match stored_msg.role.as_str() {
                                    "user" => cortex_core::widgets::MessageRole::User,
                                    "assistant" => cortex_core::widgets::MessageRole::Assistant,
                                    _ => cortex_core::widgets::MessageRole::System,
                                };
                                let msg = cortex_core::widgets::Message {
                                    role,
                                    content: stored_msg.content.clone(),
                                    timestamp: None,
                                    is_streaming: false,
                                    tool_name: None,
                                };
                                self.app_state.add_message(msg);
                            }
                        }
                        self.app_state
                            .toasts
                            .success(&format!("Rewound {} step(s)", rewound));
                    } else {
                        self.app_state.toasts.info("Nothing to rewind");
                    }
                } else {
                    self.app_state.toasts.error("Invalid rewind steps");
                }
            }
            _ => {
                // Store in generic settings map
                self.app_state
                    .settings
                    .insert(key.to_string(), value.to_string());
            }
        }
    }

    /// Handles inline form submission from interactive mode (for MCP config, etc.).
    /// Returns `true` if we should stay in interactive mode (e.g., return to MCP panel).
    fn handle_inline_form_submission(
        &mut self,
        action_id: &str,
        values: std::collections::HashMap<String, String>,
    ) -> bool {
        match action_id {
            "mcp-add" | "mcp-add-stdio" => {
                // Add new stdio MCP server from inline form
                let name = values.get("name").cloned().unwrap_or_default();
                let command = values.get("command").cloned().unwrap_or_default();
                let args_str = values.get("args").cloned().unwrap_or_default();

                if name.is_empty() || command.is_empty() {
                    self.app_state.toasts.error("Name and command are required");
                    return false;
                }

                // Parse args
                let args: Vec<String> = if args_str.is_empty() {
                    Vec::new()
                } else {
                    args_str.split_whitespace().map(|s| s.to_string()).collect()
                };

                // Create new server info - MCP servers are enabled (Running) by default
                let server_info = crate::modal::mcp_manager::McpServerInfo {
                    name: name.clone(),
                    status: crate::modal::mcp_manager::McpStatus::Running,
                    tool_count: 0,
                    error: None,
                    requires_auth: false,
                };

                // Persist to storage
                let stored_server = crate::mcp_storage::StoredMcpServer::new_stdio(
                    name.clone(),
                    command.clone(),
                    args.clone(),
                );
                if let Err(e) = self.save_mcp_server(&stored_server) {
                    tracing::error!("Failed to save MCP server config: {}", e);
                    self.app_state
                        .toasts
                        .error(&format!("Failed to save MCP server: {}", e));
                    return false;
                }

                // Add to app state
                self.app_state.mcp_servers.push(server_info);
                self.app_state
                    .toasts
                    .success(&format!("Added stdio MCP server: {}", name));

                tracing::info!(
                    "Added stdio MCP server: {} (command: {}, args: {:?})",
                    name,
                    command,
                    args
                );

                // Return to MCP panel
                self.reopen_mcp_panel();
                true
            }
            "mcp-add-http" => {
                // Add new HTTP MCP server from inline form
                let name = values.get("name").cloned().unwrap_or_default();
                let url = values.get("url").cloned().unwrap_or_default();
                let api_key = values.get("api_key").cloned().unwrap_or_default();

                if name.is_empty() || url.is_empty() {
                    self.app_state.toasts.error("Name and URL are required");
                    return false;
                }

                // Create new server info - MCP servers are enabled (Running) by default
                let server_info = crate::modal::mcp_manager::McpServerInfo {
                    name: name.clone(),
                    status: crate::modal::mcp_manager::McpStatus::Running,
                    tool_count: 0,
                    error: None,
                    requires_auth: !api_key.is_empty(),
                };

                // Persist to storage
                let mut stored_server =
                    crate::mcp_storage::StoredMcpServer::new_http(name.clone(), url.clone());
                if !api_key.is_empty() {
                    // Store API key env var name (user should set the actual env var)
                    stored_server = stored_server.with_api_key_env_var(api_key.clone());
                }
                if let Err(e) = self.save_mcp_server(&stored_server) {
                    tracing::error!("Failed to save MCP server config: {}", e);
                    self.app_state
                        .toasts
                        .error(&format!("Failed to save MCP server: {}", e));
                    return false;
                }

                // Add to app state
                self.app_state.mcp_servers.push(server_info);
                self.app_state
                    .toasts
                    .success(&format!("Added HTTP MCP server: {}", name));

                tracing::info!(
                    "Added HTTP MCP server: {} (url: {}, has_api_key: {})",
                    name,
                    url,
                    !api_key.is_empty()
                );

                // Return to MCP panel
                self.reopen_mcp_panel();
                true
            }
            action if action.starts_with("agent-ai-create:") => {
                // AI-assisted agent creation from inline form
                let location_str = action.strip_prefix("agent-ai-create:").unwrap_or("project");
                let description = values.get("description").cloned().unwrap_or_default();

                if description.is_empty() {
                    self.app_state
                        .toasts
                        .error("Please describe what you want the agent to do");
                    return true; // Stay in form
                }

                // Determine location
                use crate::interactive::builders::AgentLocation;
                let location = match location_str {
                    "global" => AgentLocation::Global,
                    _ => AgentLocation::Project,
                };

                // Store location for later use
                self.app_state.agent_creation_location = Some(location);
                // Set mode to AI and store the description for processing
                self.app_state.agent_creation_mode = Some("ai".to_string());

                // Insert the description into the input box and trigger AI generation
                let prompt = format!("Create an agent with this description: {}", description);
                self.app_state.input.set_text(&prompt);

                self.app_state
                    .toasts
                    .info("Generating agent configuration...");

                // Exit interactive mode - the description will be processed
                false
            }
            _ => {
                tracing::warn!("Unhandled inline form submission: {}", action_id);
                false
            }
        }
    }

    /// Re-opens the MCP panel to show the list of servers after adding a new one.
    fn reopen_mcp_panel(&mut self) {
        use crate::interactive::builders::build_mcp_selector;
        let servers = self.app_state.mcp_servers.clone();
        let interactive = build_mcp_selector(&servers);
        self.app_state.enter_interactive_mode(interactive);
    }

    /// Re-opens the settings menu with current state (to stay in menu after toggle)
    fn reopen_settings_menu(&mut self) {
        use crate::interactive::builders::{SettingsSnapshot, build_settings_selector};

        // Preserve current selection position
        let current_selected = self
            .app_state
            .get_interactive_state()
            .map(|s| s.selected)
            .unwrap_or(0);

        let snapshot = SettingsSnapshot {
            compact_mode: self.app_state.compact_mode,
            timestamps: self.app_state.timestamps_enabled,
            line_numbers: self.app_state.line_numbers_enabled,
            word_wrap: self.app_state.word_wrap_enabled,
            syntax_highlight: self.app_state.syntax_highlight_enabled,
            auto_approve: matches!(
                self.app_state.permission_mode,
                crate::permissions::PermissionMode::Yolo
            ),
            sandbox_mode: self.app_state.sandbox_mode,
            streaming_enabled: true,
            auto_scroll: self.app_state.auto_scroll_enabled,
            sound: self.app_state.sound_enabled,
            thinking_enabled: self.app_state.thinking_budget.is_some(),
            debug_mode: self.app_state.debug_mode,
            context_aware: self.app_state.context_aware_enabled,
            co_author: self.app_state.co_author_enabled,
            auto_commit: self.app_state.auto_commit_enabled,
            sign_commits: self.app_state.sign_commits_enabled,
            cloud_sync: self.app_state.cloud_sync_enabled,
            auto_save: self.app_state.auto_save_enabled,
            session_history: self.app_state.session_history_enabled,
            telemetry: self.app_state.telemetry_enabled,
            analytics: self.app_state.analytics_enabled,
        };
        let terminal_height = self.app_state.terminal_size.1;
        let mut interactive = build_settings_selector(snapshot, Some(terminal_height));

        // Restore selection position
        if current_selected < interactive.items.len() {
            interactive.selected = current_selected;
        }

        self.app_state.enter_interactive_mode(interactive);
    }

    /// Handles actions from the interactive selection mode.
    /// Returns true if the interactive panel should stay open, false to close it.
    async fn handle_interactive_selection(
        &mut self,
        action: crate::interactive::InteractiveAction,
        item_id: String,
        _checked: Vec<String>,
    ) -> bool {
        use crate::interactive::InteractiveAction;

        match action {
            InteractiveAction::SetProvider => {
                if let Some(pm) = &self.provider_manager {
                    if let Ok(mut manager) = pm.try_write() {
                        let _ = manager.set_provider(&item_id);
                        self.app_state.provider = item_id.clone();
                    }
                }
                return false;
            }
            InteractiveAction::SetModel => {
                if let Some(pm) = &self.provider_manager {
                    if let Ok(mut manager) = pm.try_write() {
                        let _ = manager.set_model(&item_id);
                        self.app_state.model = item_id.clone();
                    }
                }
                self.update_session_model(&item_id);
                return false;
            }
            InteractiveAction::SetApprovalMode => {
                match item_id.as_str() {
                    "ask" => {
                        self.app_state.permission_mode = crate::permissions::PermissionMode::High
                    }
                    "session" => {
                        self.app_state.permission_mode = crate::permissions::PermissionMode::Medium
                    }
                    "always" => {
                        self.app_state.permission_mode = crate::permissions::PermissionMode::Yolo
                    }
                    "never" => {
                        self.app_state.permission_mode = crate::permissions::PermissionMode::High
                    }
                    _ => {}
                }
                return false;
            }
            InteractiveAction::SetLogLevel => {
                self.app_state.log_level = item_id.clone();
                return false;
            }
            InteractiveAction::SelectSession => {
                if item_id == "__new__" {
                    self.app_state.new_session();
                } else if let Ok(uuid) = uuid::Uuid::parse_str(&item_id) {
                    self.app_state.load_session(uuid);
                }
                return false;
            }
            InteractiveAction::ResumeSession => {
                if item_id == "__new__" || item_id.starts_with("__sep_") {
                    self.app_state.new_session();
                } else {
                    if let Ok(loaded) = crate::session::CortexSession::load(&item_id) {
                        self.app_state.messages.clear();
                        for msg in loaded.messages() {
                            let message = match msg.role.as_str() {
                                "user" => cortex_core::widgets::Message::user(&msg.content),
                                "assistant" => {
                                    cortex_core::widgets::Message::assistant(&msg.content)
                                }
                                _ => cortex_core::widgets::Message::system(&msg.content),
                            };
                            self.app_state.messages.push(message);
                        }
                        self.cortex_session = Some(loaded);
                    }
                }
                return false;
            }
            InteractiveAction::ForkSession => {
                if item_id != "__new__" && !item_id.starts_with("__sep_") {
                    if let Ok(forked) = crate::session::CortexSession::fork_from_id(&item_id) {
                        self.app_state.messages.clear();
                        for msg in forked.messages() {
                            let message = match msg.role.as_str() {
                                "user" => cortex_core::widgets::Message::user(&msg.content),
                                "assistant" => {
                                    cortex_core::widgets::Message::assistant(&msg.content)
                                }
                                _ => cortex_core::widgets::Message::system(&msg.content),
                            };
                            self.app_state.messages.push(message);
                        }
                        self.cortex_session = Some(forked);
                    }
                } else {
                    self.app_state.new_session();
                }
                return false;
            }
            InteractiveAction::McpServerAction => {
                // Handle MCP server selection
                match item_id.as_str() {
                    "__add__" => {
                        // Step 1: Show source selector (Custom vs Registry)
                        let source_selector =
                            crate::interactive::builders::mcp::build_mcp_source_selector();
                        self.app_state.enter_interactive_mode(source_selector);
                        return true; // Stay in interactive mode
                    }
                    "__tools__" => {
                        // Show all MCP tools
                        self.handle_mcp_tools();
                        return false;
                    }
                    "__reload__" => {
                        // Reload all servers
                        self.app_state.toasts.info("Reloading all MCP servers...");
                        // TODO: Actually reload via MCP integration
                        return false;
                    }
                    id if id.starts_with("__sep_") => {
                        // Skip separators - stay in interactive mode
                        return true;
                    }
                    _ => {
                        // Find the selected server and show its actions in the modal
                        let server = self
                            .app_state
                            .mcp_servers
                            .iter()
                            .find(|s| s.name == item_id)
                            .cloned();

                        if let Some(server) = server {
                            // Open server actions panel
                            let actions =
                                crate::interactive::builders::mcp::build_mcp_server_actions(
                                    &server,
                                );
                            self.app_state.enter_interactive_mode(actions);
                            return true; // Stay in interactive mode
                        } else {
                            self.app_state
                                .toasts
                                .error(&format!("Server not found: {}", item_id));
                        }
                    }
                }
                return false;
            }
            InteractiveAction::AddContextFiles => {
                for path in _checked.iter() {
                    let path_buf = std::path::PathBuf::from(path);
                    if !self.app_state.context_files.contains(&path_buf) {
                        self.app_state.context_files.push(path_buf);
                    }
                }
                return false;
            }
            InteractiveAction::RemoveContextFiles => {
                for path in _checked.iter() {
                    let path_buf = std::path::PathBuf::from(path);
                    self.app_state.context_files.retain(|p| p != &path_buf);
                }
                return false;
            }
            InteractiveAction::BrowseFiles { base_path } => {
                let selected_path = std::path::PathBuf::from(&item_id);
                if selected_path.is_dir() {
                    let interactive =
                        crate::interactive::builders::build_file_browser(&selected_path);
                    self.app_state.enter_interactive_mode(interactive);
                    return true; // Stay in interactive mode (navigating)
                } else {
                    let full_path = base_path.join(&item_id);
                    if !self.app_state.context_files.contains(&full_path) {
                        self.app_state.context_files.push(full_path);
                    }
                    return false;
                }
            }
            InteractiveAction::ToggleSetting => {
                // Skip category separators
                if item_id.starts_with("__cat_") {
                    self.reopen_settings_menu();
                    return true; // Stay open
                }
                // Toggle the selected setting
                match item_id.as_str() {
                    // Display
                    "compact" => {
                        self.app_state.compact_mode = !self.app_state.compact_mode;
                    }
                    "timestamps" => {
                        self.app_state.timestamps_enabled = !self.app_state.timestamps_enabled;
                    }
                    "line_numbers" => {
                        self.app_state.line_numbers_enabled = !self.app_state.line_numbers_enabled;
                    }
                    "word_wrap" => {
                        self.app_state.word_wrap_enabled = !self.app_state.word_wrap_enabled;
                    }
                    "syntax_highlight" => {
                        self.app_state.syntax_highlight_enabled =
                            !self.app_state.syntax_highlight_enabled;
                    }
                    // Behavior
                    "auto_approve" => {
                        let is_yolo = matches!(
                            self.app_state.permission_mode,
                            crate::permissions::PermissionMode::Yolo
                        );
                        if is_yolo {
                            self.app_state.permission_mode =
                                crate::permissions::PermissionMode::High;
                        } else {
                            self.app_state.permission_mode =
                                crate::permissions::PermissionMode::Yolo;
                        }
                    }
                    "sandbox" => {
                        self.app_state.sandbox_mode = !self.app_state.sandbox_mode;
                    }
                    "streaming" => {
                        // Streaming is always enabled, do nothing
                    }
                    "auto_scroll" => {
                        self.app_state.auto_scroll_enabled = !self.app_state.auto_scroll_enabled;
                    }
                    "sound" => {
                        self.app_state.sound_enabled = !self.app_state.sound_enabled;
                    }
                    // AI
                    "thinking" => {
                        if self.app_state.thinking_budget.is_some() {
                            self.app_state.thinking_budget = None;
                        } else {
                            self.app_state.thinking_budget = Some("medium".to_string());
                        }
                    }
                    "debug" => {
                        self.app_state.debug_mode = !self.app_state.debug_mode;
                    }
                    "context_aware" => {
                        self.app_state.context_aware_enabled =
                            !self.app_state.context_aware_enabled;
                    }
                    // Git
                    "co_author" => {
                        self.app_state.co_author_enabled = !self.app_state.co_author_enabled;
                    }
                    "auto_commit" => {
                        self.app_state.auto_commit_enabled = !self.app_state.auto_commit_enabled;
                    }
                    "sign_commits" => {
                        self.app_state.sign_commits_enabled = !self.app_state.sign_commits_enabled;
                    }
                    // Cloud
                    "cloud_sync" => {
                        self.app_state.cloud_sync_enabled = !self.app_state.cloud_sync_enabled;
                    }
                    "auto_save" => {
                        self.app_state.auto_save_enabled = !self.app_state.auto_save_enabled;
                    }
                    "session_history" => {
                        self.app_state.session_history_enabled =
                            !self.app_state.session_history_enabled;
                    }
                    // Privacy
                    "telemetry" => {
                        self.app_state.telemetry_enabled = !self.app_state.telemetry_enabled;
                    }
                    "analytics" => {
                        self.app_state.analytics_enabled = !self.app_state.analytics_enabled;
                    }
                    _ => {}
                };
                self.reopen_settings_menu();
                return true; // Stay open after toggling
            }
            InteractiveAction::Custom(custom_action) => {
                // Handle custom actions
                match custom_action.as_str() {
                    "temperature" => {
                        if let Ok(temp) = item_id.parse::<f32>() {
                            self.app_state.temperature = temp;
                        }
                    }
                    "export" => match item_id.as_str() {
                        "markdown" => {
                            let _ = self.handle_export(ExportFormat::Markdown);
                        }
                        "json" => {
                            let _ = self.handle_export(ExportFormat::Json);
                        }
                        "txt" => {
                            let _ = self.handle_export(ExportFormat::Text);
                        }
                        _ => {}
                    },
                    "theme" => {
                        self.app_state
                            .settings
                            .insert("theme".to_string(), item_id.clone());
                    }
                    "scroll" => match item_id.as_str() {
                        "top" => {
                            self.app_state.scroll_chat_to_top();
                        }
                        "bottom" => {
                            self.app_state.scroll_chat_to_bottom();
                        }
                        "up10" => {
                            self.app_state.scroll_chat(10);
                        }
                        "down10" => {
                            self.app_state.scroll_chat(-10);
                        }
                        "pageup" => {
                            self.app_state.scroll_chat(20);
                        }
                        "pagedown" => {
                            self.app_state.scroll_chat(-20);
                        }
                        _ => {}
                    },
                    "agents" => {
                        // Handle agents list actions
                        match item_id.as_str() {
                            "__create__" => {
                                // Open agent location selector
                                let interactive =
                                    crate::interactive::builders::build_agent_location_selector();
                                self.app_state.enter_interactive_mode(interactive);
                                return true; // Stay in interactive mode
                            }
                            id if id.starts_with("builtin:") => {
                                // Insert @agent mention into input
                                let agent_name = id.strip_prefix("builtin:").unwrap_or(id);
                                let mention = format!("@{} ", agent_name);
                                self.app_state.input.insert_str(&mention);
                                self.app_state
                                    .toasts
                                    .info(&format!("Agent @{} ready to use", agent_name));
                            }
                            id if id.starts_with("project:") || id.starts_with("global:") => {
                                // Insert @agent mention into input
                                let agent_name = id
                                    .strip_prefix("project:")
                                    .or_else(|| id.strip_prefix("global:"))
                                    .unwrap_or(id);
                                let mention = format!("@{} ", agent_name);
                                self.app_state.input.insert_str(&mention);
                                // Add event to chat for context
                                self.inject_agent_context_event(agent_name);
                            }
                            _ => {}
                        }
                    }
                    "agent_location" => {
                        // Handle location selection (project or global)
                        use crate::interactive::builders::{
                            AgentLocation, build_agent_method_selector,
                        };
                        let location = match item_id.as_str() {
                            "project" => AgentLocation::Project,
                            "global" => AgentLocation::Global,
                            _ => return false,
                        };
                        // Store location in app_state for later use
                        self.app_state.agent_creation_location = Some(location);
                        // Show method selector
                        let interactive = build_agent_method_selector(location);
                        self.app_state.enter_interactive_mode(interactive);
                        return true; // Stay in interactive mode
                    }
                    "agent_method" => {
                        // Handle method selection (AI or manual)
                        if item_id.starts_with("ai:") {
                            // AI-assisted creation - show inline form for description
                            use crate::interactive::builders::{
                                AgentLocation, build_agent_ai_description_form,
                            };
                            let location = self
                                .app_state
                                .agent_creation_location
                                .unwrap_or(AgentLocation::Project);
                            // Open inline form within the interactive panel
                            if let Some(state) = self.app_state.input_mode.interactive_mut() {
                                let form = build_agent_ai_description_form(location);
                                state.open_form(form);
                            }
                            return true; // Stay in interactive mode
                        } else if item_id.starts_with("manual:") {
                            // Manual creation - show permission selector
                            let interactive =
                                crate::interactive::builders::build_permission_selector(None);
                            self.app_state.enter_interactive_mode(interactive);
                            return true;
                        }
                    }
                    "agent_permissions" => {
                        use crate::interactive::builders::{
                            AgentLocation, NewAgentConfig, PermissionPreset,
                            build_agent_confirm_selector,
                        };
                        // Handle permission selection
                        let preset = match item_id.as_str() {
                            "readonly" => PermissionPreset::ReadOnly,
                            "standard" => PermissionPreset::Standard,
                            "full" => PermissionPreset::FullAccess,
                            "custom" => PermissionPreset::Custom,
                            _ => return false,
                        };
                        // Create a basic config and show confirmation
                        let location = self
                            .app_state
                            .agent_creation_location
                            .unwrap_or(AgentLocation::Project);
                        let mut config = NewAgentConfig::new("new-agent", location);
                        config.permission_preset = Some(preset);
                        config.description = "Custom agent".to_string();
                        // Store config for later
                        self.app_state.agent_creation_config = Some(config.clone());
                        // Show name input prompt
                        self.app_state.toasts.info("Enter agent name in input box");
                        self.app_state.agent_creation_mode = Some("manual_name".to_string());
                        return false;
                    }
                    "agent_confirm" => {
                        // Handle confirmation actions
                        match item_id.as_str() {
                            "confirm" => {
                                // Save the agent - clone config to avoid borrow issues
                                if let Some(config) = self.app_state.agent_creation_config.clone() {
                                    if let Err(e) = self.save_agent_config(&config) {
                                        self.app_state
                                            .toasts
                                            .error(&format!("Failed to save agent: {}", e));
                                    } else {
                                        let agent_name = config.name.clone();
                                        self.app_state
                                            .toasts
                                            .success(&format!("Agent @{} created!", agent_name));
                                        // Inject event into chat
                                        self.inject_agent_created_event(&agent_name);
                                    }
                                }
                                // Clear creation state
                                self.app_state.agent_creation_config = None;
                                self.app_state.agent_creation_location = None;
                                self.app_state.agent_creation_mode = None;
                            }
                            "edit_permissions" => {
                                // Go back to permission selector
                                let current_preset = self
                                    .app_state
                                    .agent_creation_config
                                    .as_ref()
                                    .and_then(|c| c.permission_preset);
                                let interactive =
                                    crate::interactive::builders::build_permission_selector(
                                        current_preset,
                                    );
                                self.app_state.enter_interactive_mode(interactive);
                                return true;
                            }
                            "cancel" => {
                                // Clear creation state
                                self.app_state.agent_creation_config = None;
                                self.app_state.agent_creation_location = None;
                                self.app_state.agent_creation_mode = None;
                            }
                            _ => {}
                        }
                    }
                    "mcp-source" => {
                        // Step 1 result: Custom vs Registry
                        match item_id.as_str() {
                            "custom" => {
                                // Step 2: Show transport selector (stdio vs HTTP)
                                let transport_selector =
                                    crate::interactive::builders::mcp::build_mcp_transport_selector(
                                    );
                                self.app_state.enter_interactive_mode(transport_selector);
                                return true;
                            }
                            "registry" => {
                                // Show registry browser (placeholder for now)
                                let registry_browser =
                                    crate::interactive::builders::mcp::build_mcp_registry_browser();
                                self.app_state.enter_interactive_mode(registry_browser);
                                return true;
                            }
                            _ => {}
                        }
                    }
                    "mcp-transport" => {
                        // Step 2 result: stdio vs HTTP
                        match item_id.as_str() {
                            "stdio" => {
                                // Show stdio form
                                if let Some(state) = self.app_state.input_mode.interactive_mut() {
                                    let form =
                                        crate::interactive::builders::mcp::build_mcp_stdio_form();
                                    state.open_form(form);
                                }
                                return true;
                            }
                            "http" => {
                                // Show HTTP form
                                if let Some(state) = self.app_state.input_mode.interactive_mut() {
                                    let form =
                                        crate::interactive::builders::mcp::build_mcp_http_form();
                                    state.open_form(form);
                                }
                                return true;
                            }
                            _ => {}
                        }
                    }
                    "mcp-registry" => {
                        // Registry browser - nothing selectable for now
                        self.app_state
                            .toasts
                            .info("Registry integration coming soon");
                    }
                    _ if custom_action.starts_with("mcp:") => {
                        // Handle MCP server actions - format: "mcp:<server_name>"
                        let server_name = custom_action.strip_prefix("mcp:").unwrap_or("");
                        match item_id.as_str() {
                            "start" => {
                                self.app_state
                                    .toasts
                                    .info(&format!("Starting {}...", server_name));
                                // TODO: Actually start the server via MCP integration
                            }
                            "stop" => {
                                self.app_state
                                    .toasts
                                    .info(&format!("Stopping {}...", server_name));
                                // TODO: Actually stop the server via MCP integration
                            }
                            "restart" => {
                                self.app_state
                                    .toasts
                                    .info(&format!("Restarting {}...", server_name));
                                // TODO: Actually restart the server via MCP integration
                            }
                            "auth" => {
                                // Open the MCP Manager modal in auth mode for this server
                                use crate::modal::McpManagerModal;
                                let servers = self.app_state.mcp_servers.clone();
                                let mut modal = McpManagerModal::new(servers);
                                // Trigger auth mode by sending 'k' key
                                modal.handle_key(crossterm::event::KeyEvent::new(
                                    crossterm::event::KeyCode::Char('k'),
                                    crossterm::event::KeyModifiers::empty(),
                                ));
                                self.modal_stack.push(Box::new(modal));
                            }
                            "logs" => {
                                self.handle_mcp_logs(server_name);
                            }
                            "remove" => {
                                // Find and remove the server
                                if let Some(pos) = self
                                    .app_state
                                    .mcp_servers
                                    .iter()
                                    .position(|s| s.name == server_name)
                                {
                                    // Remove from persistent storage
                                    if let Err(e) = self.remove_mcp_server(server_name) {
                                        tracing::error!(
                                            "Failed to remove MCP server from storage: {}",
                                            e
                                        );
                                    }

                                    self.app_state.mcp_servers.remove(pos);
                                    self.app_state
                                        .toasts
                                        .success(&format!("Removed MCP server: {}", server_name));
                                }
                            }
                            _ => {}
                        }
                    }
                    _ => {
                        tracing::debug!("Unhandled custom action: {}", custom_action);
                    }
                }
                return false;
            }
            InteractiveAction::DeviceLogin => {
                // Preserve cursor position
                let current_selected = self
                    .app_state
                    .get_interactive_state()
                    .map(|s| s.selected)
                    .unwrap_or(0);

                match item_id.as_str() {
                    "copy_code" => {
                        if let Some(ref flow) = self.app_state.login_flow {
                            #[cfg(feature = "clipboard")]
                            {
                                if let Ok(mut clipboard) = arboard::Clipboard::new() {
                                    let _ = clipboard.set_text(&flow.user_code);
                                    self.app_state.toasts.success("Code copied!");
                                }
                            }
                            #[cfg(not(feature = "clipboard"))]
                            {
                                self.app_state
                                    .toasts
                                    .info(&format!("Code: {}", flow.user_code));
                            }
                        }
                        if let Some(ref flow) = self.app_state.login_flow {
                            let mut interactive =
                                crate::interactive::builders::build_login_selector(flow);
                            if current_selected < interactive.items.len() {
                                interactive.selected = current_selected;
                            }
                            self.app_state.enter_interactive_mode(interactive);
                        }
                        return true;
                    }
                    "open_browser" => {
                        if let Some(ref flow) = self.app_state.login_flow {
                            let browser_url =
                                format!("{}?code={}", flow.verification_uri, flow.user_code);
                            let _ = open_browser_url(&browser_url);
                            self.app_state.toasts.info("Browser opened");
                        }
                        if let Some(ref flow) = self.app_state.login_flow {
                            let mut interactive =
                                crate::interactive::builders::build_login_selector(flow);
                            if current_selected < interactive.items.len() {
                                interactive.selected = current_selected;
                            }
                            self.app_state.enter_interactive_mode(interactive);
                        }
                        return true;
                    }
                    "cancel" => {
                        self.app_state.login_flow = None;
                        self.app_state.toasts.info("Login cancelled");
                        return false;
                    }
                    _ => {
                        // Separator clicked - stay open
                        if let Some(ref flow) = self.app_state.login_flow {
                            let mut interactive =
                                crate::interactive::builders::build_login_selector(flow);
                            if current_selected < interactive.items.len() {
                                interactive.selected = current_selected;
                            }
                            self.app_state.enter_interactive_mode(interactive);
                        }
                        return true;
                    }
                }
            }
            InteractiveAction::AlreadyLoggedIn => {
                match item_id.as_str() {
                    "switch_account" => {
                        self.handle_auth_logout();
                        self.start_login_flow().await;
                        return true; // New login flow takes over
                    }
                    "cancel" => {
                        self.app_state.toasts.info("Login cancelled");
                        return false;
                    }
                    _ => return true, // Separator, stay open
                }
            }
        }
        false // Default: close panel
    }

    // ========================================================================
    // SESSION COMMAND HANDLERS
    // ========================================================================

    /// Handles the /undo command - reverts the last message pair.
    async fn handle_undo(&mut self) {
        if let Some(ref mut session) = self.cortex_session {
            // Remove the last assistant message and the user message before it
            let msg_count = session.message_count();
            if msg_count >= 2 {
                // Store messages for potential redo
                if let Some(messages) = session.pop_last_exchange() {
                    self.undo_stack.push(messages);
                    self.app_state.clear_messages();
                    // Re-add remaining messages to display (convert StoredMessage to Message)
                    for stored_msg in session.messages() {
                        let role = match stored_msg.role.as_str() {
                            "user" => cortex_core::widgets::MessageRole::User,
                            "assistant" => cortex_core::widgets::MessageRole::Assistant,
                            _ => cortex_core::widgets::MessageRole::System,
                        };
                        let msg = cortex_core::widgets::Message {
                            role,
                            content: stored_msg.content.clone(),
                            timestamp: None,
                            is_streaming: false,
                            tool_name: None,
                        };
                        self.app_state.add_message(msg);
                    }
                    self.add_system_message("Undone last exchange.");
                } else {
                    self.add_system_message("Nothing to undo.");
                }
            } else {
                self.add_system_message("Nothing to undo.");
            }
        } else {
            self.add_system_message("No active session.");
        }
    }

    /// Handles the /redo command - restores the last undone message pair.
    async fn handle_redo(&mut self) {
        if let Some(ref mut session) = self.cortex_session {
            if let Some(messages) = self.undo_stack.pop() {
                for msg in &messages {
                    session.add_message(msg.clone());
                    self.app_state.add_message(msg.clone());
                }
                self.add_system_message("Redone last exchange.");
            } else {
                self.add_system_message("Nothing to redo.");
            }
        } else {
            self.add_system_message("No active session.");
        }
    }

    /// Handles the /transcript command - shows the full conversation.
    fn handle_transcript(&mut self) {
        if let Some(ref session) = self.cortex_session {
            let mut output = format!("=== Session Transcript ===\n");
            output.push_str(&format!("Title: {}\n", session.title()));
            output.push_str(&format!("Messages: {}\n\n", session.message_count()));

            for (i, msg) in session.messages().iter().enumerate() {
                let role = match msg.role.as_str() {
                    "user" => "User",
                    "assistant" => "Assistant",
                    "system" => "System",
                    _ => "Unknown",
                };
                output.push_str(&format!("[{}] {}:\n{}\n\n", i + 1, role, msg.content));
            }

            self.add_system_message(&output);
        } else {
            self.add_system_message("No active session.");
        }
    }

    /// Handles the /history command - shows command history.
    fn handle_history(&mut self) {
        if self.app_state.command_history.is_empty() {
            self.add_system_message("No command history yet. Try running some commands first!");
            return;
        }

        let mut output = String::from("📜 Command History\n");
        output.push_str(&"─".repeat(40));
        output.push('\n');

        for (i, cmd) in self
            .app_state
            .command_history
            .iter()
            .rev()
            .take(20)
            .enumerate()
        {
            output.push_str(&format!("{}. /{}\n", i + 1, cmd));
        }

        self.add_system_message(&output);
    }

    /// Handles the /diff command - shows file modifications in the session.
    fn handle_diff(&mut self, file: &str) {
        if let Some(ref session) = self.cortex_session {
            let mut output = String::from("=== File Modifications ===\n\n");
            let mut found_diffs = false;

            // Look for tool calls that modified files
            for msg in session.messages() {
                if msg.role == "assistant" {
                    // Check for file modification patterns in content
                    if msg.content.contains("```diff")
                        || msg.content.contains("Edit:")
                        || msg.content.contains("Create:")
                    {
                        if file.is_empty() || msg.content.contains(file) {
                            output.push_str(&msg.content);
                            output.push_str("\n---\n");
                            found_diffs = true;
                        }
                    }
                }
            }

            if !found_diffs {
                output.push_str("No file modifications found in this session.");
            }

            self.add_system_message(&output);
        } else {
            self.add_system_message("No active session.");
        }
    }

    // ========================================================================
    // FILE/CONTEXT COMMAND HANDLERS
    // ========================================================================

    /// Handles the /context command - lists files in the current context.
    fn handle_context_list(&mut self) {
        if self.app_state.context_files.is_empty() {
            self.add_system_message("No files in context. Use /add <file> to add files.");
        } else {
            let mut output = format!("Context Files ({}):\n", self.app_state.context_files.len());
            for (i, path) in self.app_state.context_files.iter().enumerate() {
                output.push_str(&format!("  {}. {}\n", i + 1, path.display()));
            }
            output.push_str("\nUse /remove <file> to remove files from context.");
            self.add_system_message(&output);
        }
    }

    /// Handles the /add command - adds files to the context.
    fn handle_add_files(&mut self, files: &str) {
        // Use quote-aware parsing to handle filenames with spaces
        // Supports: /add "my file.txt" or /add 'my file.txt' or /add file1.txt file2.txt
        let file_list = CommandParser::split_args(files);
        let mut added = Vec::new();
        let mut failed = Vec::new();

        for file in &file_list {
            let path = std::path::PathBuf::from(file);
            if path.exists() {
                if !self.app_state.context_files.contains(&path) {
                    self.app_state.context_files.push(path.clone());
                    added.push(file.clone());
                }
            } else {
                failed.push(file.clone());
            }
        }

        let mut output = String::new();
        if !added.is_empty() {
            output.push_str(&format!("Added to context: {}\n", added.join(", ")));
        }
        if !failed.is_empty() {
            output.push_str(&format!("Files not found: {}", failed.join(", ")));
        }
        if output.is_empty() {
            output = "No new files added.".to_string();
        }
        self.add_system_message(&output);
    }

    /// Handles the /remove command - removes files from the context.
    fn handle_remove_files(&mut self, files: &str) {
        // Use quote-aware parsing to handle filenames with spaces
        // Supports: /remove "my file.txt" or /remove 'my file.txt' or /remove file1.txt file2.txt
        let file_list = CommandParser::split_args(files);
        let mut removed = Vec::new();

        for file in &file_list {
            let path = std::path::PathBuf::from(file);
            if let Some(pos) = self.app_state.context_files.iter().position(|p| p == &path) {
                self.app_state.context_files.remove(pos);
                removed.push(file.clone());
            }
        }

        if removed.is_empty() {
            self.add_system_message("No matching files found in context.");
        } else {
            self.add_system_message(&format!("Removed from context: {}", removed.join(", ")));
        }
    }

    /// Handles the /search command - searches for a pattern in the working directory.
    async fn handle_search(&mut self, pattern: &str) {
        use std::process::Command;

        self.add_system_message(&format!("Searching for: {}", pattern));

        // Try ripgrep first, fall back to grep
        let result = Command::new("rg")
            .args(["--max-count", "20", "--line-number", pattern])
            .output()
            .or_else(|_| {
                Command::new("grep")
                    .args(["-rn", "--max-count=20", pattern, "."])
                    .output()
            });

        match result {
            Ok(output) => {
                if output.status.success() {
                    let stdout = String::from_utf8_lossy(&output.stdout);
                    if stdout.is_empty() {
                        self.add_system_message("No matches found.");
                    } else {
                        let lines: Vec<&str> = stdout.lines().take(20).collect();
                        let mut msg = format!("Search results for '{}':\n\n", pattern);
                        for line in lines {
                            msg.push_str(line);
                            msg.push('\n');
                        }
                        self.add_system_message(&msg);
                    }
                } else {
                    self.add_system_message("No matches found.");
                }
            }
            Err(_) => {
                self.add_system_message("Search failed. Neither 'rg' nor 'grep' available.");
            }
        }
    }

    /// Handles the /ls command - lists directory contents.
    fn handle_ls(&mut self, path: &str) {
        let target_path = if path.is_empty() || path == "." {
            std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."))
        } else {
            std::path::PathBuf::from(path)
        };

        match std::fs::read_dir(&target_path) {
            Ok(entries) => {
                let mut dirs = Vec::new();
                let mut files = Vec::new();

                for entry in entries.flatten() {
                    let name = entry.file_name().to_string_lossy().to_string();
                    if entry.file_type().map(|t| t.is_dir()).unwrap_or(false) {
                        dirs.push(format!("{}/", name));
                    } else {
                        files.push(name);
                    }
                }

                dirs.sort();
                files.sort();

                let mut output = format!("Contents of {}:\n\n", target_path.display());

                if !dirs.is_empty() {
                    output.push_str("Directories:\n");
                    for d in &dirs {
                        output.push_str(&format!("  {}\n", d));
                    }
                }

                if !files.is_empty() {
                    if !dirs.is_empty() {
                        output.push('\n');
                    }
                    output.push_str("Files:\n");
                    for f in files.iter().take(50) {
                        output.push_str(&format!("  {}\n", f));
                    }
                    if files.len() > 50 {
                        output.push_str(&format!("  ... and {} more files\n", files.len() - 50));
                    }
                }

                if dirs.is_empty() && files.is_empty() {
                    output.push_str("  (empty directory)");
                }

                self.add_system_message(&output);
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to list directory: {}", e));
            }
        }
    }

    /// Handles the /tree command - shows directory tree.
    fn handle_tree(&mut self, path: &str) {
        let target_path = if path.is_empty() || path == "." {
            std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."))
        } else {
            std::path::PathBuf::from(path)
        };

        fn build_tree(
            path: &std::path::Path,
            prefix: &str,
            depth: usize,
            max_depth: usize,
        ) -> String {
            if depth > max_depth {
                return String::new();
            }

            let mut result = String::new();

            if let Ok(entries) = std::fs::read_dir(path) {
                let mut items: Vec<_> = entries.flatten().collect();
                items.sort_by_key(|e| e.file_name());

                let count = items.len();
                for (i, entry) in items.into_iter().enumerate() {
                    let is_last = i == count - 1;
                    let connector = if is_last { "└── " } else { "├── " };
                    let name = entry.file_name().to_string_lossy().to_string();

                    let is_dir = entry.file_type().map(|t| t.is_dir()).unwrap_or(false);
                    let display_name = if is_dir { format!("{}/", name) } else { name };

                    result.push_str(&format!("{}{}{}\n", prefix, connector, display_name));

                    if is_dir && depth < max_depth {
                        let new_prefix =
                            format!("{}{}", prefix, if is_last { "    " } else { "│   " });
                        result.push_str(&build_tree(
                            &entry.path(),
                            &new_prefix,
                            depth + 1,
                            max_depth,
                        ));
                    }
                }
            }

            result
        }

        let mut output = format!("{}\n", target_path.display());
        output.push_str(&build_tree(&target_path, "", 0, 3));

        if output.lines().count() > 100 {
            let truncated: String = output.lines().take(100).collect::<Vec<_>>().join("\n");
            output = format!("{}\n... (truncated, showing first 100 entries)", truncated);
        }

        self.add_system_message(&output);
    }

    /// Handles the /mention command - adds a file or symbol reference.
    fn handle_mention(&mut self, item: &str) {
        let path = std::path::PathBuf::from(item);
        if path.exists() {
            if !self.app_state.context_files.contains(&path) {
                self.app_state.context_files.push(path);
            }
            self.add_system_message(&format!("Added mention: @{}", item));
        } else {
            self.add_system_message(&format!(
                "Referenced: @{} (file not found, treated as symbol)",
                item
            ));
        }
    }

    /// Handles listing images in the context.
    fn handle_images_list(&mut self) {
        let images: Vec<_> = self
            .app_state
            .context_files
            .iter()
            .filter(|p| {
                p.extension()
                    .map(|ext| {
                        matches!(ext.to_str(), Some("png" | "jpg" | "jpeg" | "gif" | "webp"))
                    })
                    .unwrap_or(false)
            })
            .collect();

        if images.is_empty() {
            self.add_system_message("No images in context. Use /images <path> to add images.");
        } else {
            let mut output = format!("Images in context ({}):\n", images.len());
            for path in images {
                output.push_str(&format!("  - {}\n", path.display()));
            }
            self.add_system_message(&output);
        }
    }

    /// Handles adding images to the context.
    fn handle_images_add(&mut self, paths: &str) {
        let file_list: Vec<&str> = paths.split(',').map(|s| s.trim()).collect();
        let mut added = Vec::new();
        let mut failed = Vec::new();

        for file in file_list {
            let path = std::path::PathBuf::from(file);
            if path.exists() {
                let is_image = path
                    .extension()
                    .map(|ext| {
                        matches!(ext.to_str(), Some("png" | "jpg" | "jpeg" | "gif" | "webp"))
                    })
                    .unwrap_or(false);

                if is_image && !self.app_state.context_files.contains(&path) {
                    self.app_state.context_files.push(path);
                    added.push(file.to_string());
                } else if !is_image {
                    failed.push(format!("{} (not an image)", file));
                }
            } else {
                failed.push(format!("{} (not found)", file));
            }
        }

        let mut output = String::new();
        if !added.is_empty() {
            output.push_str(&format!("Added images: {}\n", added.join(", ")));
        }
        if !failed.is_empty() {
            output.push_str(&format!("Failed: {}", failed.join(", ")));
        }
        if output.is_empty() {
            output = "No images added.".to_string();
        }
        self.add_system_message(&output);
    }

    // ========================================================================
    // MCP COMMAND HANDLERS
    // ========================================================================

    /// Handles the /mcp-tools command - lists available MCP tools.
    fn handle_mcp_tools(&mut self) {
        if let Some(ref tool_registry) = self.tool_registry {
            let definitions = tool_registry.get_definitions();
            if definitions.is_empty() {
                self.add_system_message("No MCP tools available.");
            } else {
                let mut output = format!("Available Tools ({}):\n\n", definitions.len());
                for tool in definitions {
                    output.push_str(&format!("  {} - {}\n", tool.name, tool.description));
                }
                self.add_system_message(&output);
            }
        } else {
            self.add_system_message("Tool registry not initialized.");
        }
    }

    /// Handles the /mcp-reload command - reloads MCP servers.
    async fn handle_mcp_reload(&mut self) {
        self.add_system_message("Reloading MCP servers...");
        // In a full implementation, this would reinitialize the MCP connections
        // For now, just show a confirmation
        self.add_system_message("MCP servers reloaded.");
    }

    /// Handles the /mcp status command.
    fn handle_mcp_status(&mut self) {
        let servers = &self.app_state.mcp_servers;
        if servers.is_empty() {
            self.add_system_message("No MCP servers configured.");
        } else {
            let mut output = format!("MCP Servers ({}):\n\n", servers.len());
            for server in servers {
                let status = match server.status {
                    crate::modal::mcp_manager::McpStatus::Running => "Running",
                    crate::modal::mcp_manager::McpStatus::Starting => "Starting",
                    crate::modal::mcp_manager::McpStatus::Stopped => "Stopped",
                    crate::modal::mcp_manager::McpStatus::Error => "Error",
                };
                output.push_str(&format!(
                    "  {} [{}] - {} tools\n",
                    server.name, status, server.tool_count
                ));
            }
            self.add_system_message(&output);
        }
    }

    /// Handles the /mcp add command.
    async fn handle_mcp_add(&mut self, server_info: &str) {
        // Parse server_info as "name"
        let name = server_info.trim().to_string();
        if name.is_empty() {
            self.add_system_message("Usage: /mcp add <name>");
            return;
        }

        // Check if server already exists
        if self.app_state.mcp_servers.iter().any(|s| s.name == name) {
            self.add_system_message(&format!("MCP server '{}' already exists.", name));
            return;
        }

        // Add the new server - MCP servers are enabled (Running) by default
        let server = crate::modal::mcp_manager::McpServerInfo {
            name: name.clone(),
            status: crate::modal::mcp_manager::McpStatus::Running,
            tool_count: 0,
            error: None,
            requires_auth: false,
        };

        self.app_state.mcp_servers.push(server);
        self.add_system_message(&format!("Added MCP server: {}", name));
    }

    /// Handles the /mcp remove command.
    async fn handle_mcp_remove(&mut self, server_name: &str) {
        if let Some(pos) = self
            .app_state
            .mcp_servers
            .iter()
            .position(|s| s.name == server_name)
        {
            self.app_state.mcp_servers.remove(pos);
            self.add_system_message(&format!("Removed MCP server: {}", server_name));
        } else {
            self.add_system_message(&format!("MCP server '{}' not found.", server_name));
        }
    }

    /// Handles the /mcp-auth command.
    fn handle_mcp_auth(&mut self, server: &str) {
        self.add_system_message(&format!(
            "MCP authentication for '{}' - Use the settings modal to configure API keys.",
            server
        ));
    }

    /// Handles the /mcp-logs command.
    fn handle_mcp_logs(&mut self, server: &str) {
        let server_name = if server == "all" {
            "all servers"
        } else {
            server
        };
        self.add_system_message(&format!("MCP logs for {}:\n\n(Log viewing not yet implemented. Check ~/.cortex/logs/ for log files.)", server_name));
    }

    // ========================================================================
    // CUSTOM COMMANDS HANDLERS
    // ========================================================================

    /// Handles the /commands command - lists all custom commands.
    fn handle_commands_list(&mut self) {
        use cortex_commands::builtin::CommandsCommand;

        let cwd = std::env::current_dir().ok();
        let cmd = CommandsCommand::new();

        match cmd.execute(cwd.as_deref()) {
            Ok(result) => {
                let output = cmd.format_result(&result);
                self.add_system_message(&output);
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to list commands: {}", e));
            }
        }
    }

    /// Handles the /agents command - lists all custom agents.
    fn handle_agents_list(&mut self) {
        use cortex_commands::builtin::AgentsCommand;

        let cwd = std::env::current_dir().ok();
        let cmd = AgentsCommand::new();

        match cmd.execute(cwd.as_deref()) {
            Ok(result) => {
                let output = cmd.format_result(&result);
                self.add_system_message(&output);
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to list agents: {}", e));
            }
        }
    }

    /// Handles the /init command - initializes AGENTS.md.
    fn handle_init(&mut self, force: bool) {
        use cortex_commands::builtin::{InitCommand, InitResult};

        let cwd = match std::env::current_dir() {
            Ok(path) => path,
            Err(e) => {
                self.add_system_message(&format!("Failed to get current directory: {}", e));
                return;
            }
        };

        let cmd = InitCommand::new().force(force);

        match cmd.execute(&cwd) {
            Ok(result) => {
                let message: String = result.message();
                self.add_system_message(&message);
                match &result {
                    InitResult::Created(_) => {
                        self.app_state.toasts.success("AGENTS.md created");
                    }
                    InitResult::AlreadyExists(_) => {
                        self.app_state.toasts.info("AGENTS.md already exists");
                    }
                    InitResult::Updated(_) => {
                        self.app_state.toasts.success("AGENTS.md updated");
                    }
                }
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to initialize: {}", e));
                self.app_state.toasts.error("Init failed");
            }
        }
    }

    /// Handles the /share command - generates a share link for the current session.
    async fn handle_share(&mut self, duration: Option<&str>) {
        use cortex_commands::builtin::{DEFAULT_SHARE_DURATION, format_duration, parse_duration};

        // Ensure we have an active session
        let Some(ref session) = self.cortex_session else {
            self.add_system_message("No active session to share.");
            self.app_state.toasts.warning("No session to share");
            return;
        };

        // Parse duration if provided
        let share_duration = match duration {
            Some(d) => match parse_duration(d) {
                Ok(dur) => dur.unwrap_or(DEFAULT_SHARE_DURATION),
                Err(e) => {
                    self.add_system_message(&format!("Invalid duration: {}", e));
                    return;
                }
            },
            None => DEFAULT_SHARE_DURATION,
        };

        // For now, generate a local share link (actual backend integration would go here)
        let session_id = session.id();
        let short_id = if session_id.len() >= 8 {
            &session_id[..8]
        } else {
            &session_id
        };

        let expires_str = format_duration(Some(share_duration));

        // TODO: In a real implementation, this would call a backend API to generate a share URL
        // For now, we'll show a placeholder message
        let output = format!(
            "Share Link Generated:\n\n\
             Session: {}\n\
             Expires: {}\n\n\
             Note: Session sharing requires backend integration.\n\
             The session ID is: {}",
            session.title(),
            expires_str,
            session_id
        );

        self.add_system_message(&output);
        self.app_state
            .toasts
            .info(&format!("Share expires in {}", expires_str));
    }

    // ========================================================================
    // DEBUG/SYSTEM COMMAND HANDLERS
    // ========================================================================

    /// Handles the /status command - shows system status.
    fn handle_system_status(&mut self) {
        let mut output = String::from("=== System Status ===\n\n");

        // Provider info
        if let Some(ref pm) = self.provider_manager {
            if let Ok(manager) = pm.try_read() {
                output.push_str(&format!("Provider: {}\n", manager.current_provider_name()));
                output.push_str(&format!("Model: {}\n", manager.current_model()));
            }
        } else {
            output.push_str("Provider: Not configured\n");
        }

        // Session info
        if let Some(ref session) = self.cortex_session {
            output.push_str(&format!(
                "Session: {} ({})\n",
                session.title(),
                session.id()
            ));
            output.push_str(&format!("Messages: {}\n", session.message_count()));
        } else {
            output.push_str("Session: None\n");
        }

        // Context
        output.push_str(&format!(
            "Context files: {}\n",
            self.app_state.context_files.len()
        ));

        // MCP
        let running_mcp = self
            .app_state
            .mcp_servers
            .iter()
            .filter(|s| matches!(s.status, crate::modal::mcp_manager::McpStatus::Running))
            .count();
        output.push_str(&format!(
            "MCP servers: {}/{} running\n",
            running_mcp,
            self.app_state.mcp_servers.len()
        ));

        // Streaming state
        output.push_str(&format!(
            "Streaming: {}\n",
            if self.app_state.streaming.is_streaming {
                "Active"
            } else {
                "Idle"
            }
        ));

        self.add_system_message(&output);
    }

    /// Handles the /metrics command - shows performance metrics.
    fn handle_metrics(&mut self) {
        let mut output = String::from("=== Performance Metrics ===\n\n");

        if let Some(ref session) = self.cortex_session {
            output.push_str(&format!("Total tokens: {}\n", session.format_tokens()));
            output.push_str(&format!("Messages: {}\n", session.message_count()));
        }

        // Memory usage (approximate)
        output.push_str(&format!(
            "Context files: {}\n",
            self.app_state.context_files.len()
        ));
        output.push_str(&format!(
            "Display messages: {}\n",
            self.app_state.messages.len()
        ));
        output.push_str(&format!("Undo stack depth: {}\n", self.undo_stack.len()));

        self.add_system_message(&output);
    }

    /// Handles the /cfg command with no args - lists all config.
    fn handle_config_list(&mut self) {
        use crate::providers::config::CortexConfig;

        match CortexConfig::load() {
            Ok(config) => {
                let mut output = String::from("=== Configuration ===\n\n");
                output.push_str(&format!("Default Provider: {}\n", config.default_provider));
                output.push_str(&format!("Default Model: {}\n", config.default_model));
                output.push_str(&format!("Max Tokens: {}\n", config.max_tokens));
                output.push_str(&format!("Temperature: {}\n", config.temperature));
                output.push_str(&format!("Auto-save: {}\n", config.auto_save));

                output.push_str("\nConfigured Providers:\n");
                for (name, prov) in &config.providers {
                    let has_key = prov.api_key.is_some();
                    output.push_str(&format!(
                        "  {} - {}\n",
                        name,
                        if has_key {
                            "configured"
                        } else {
                            "needs API key"
                        }
                    ));
                }

                self.add_system_message(&output);
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to load config: {}", e));
            }
        }
    }

    /// Handles the /cfg command with a key - gets specific config value.
    fn handle_config_get(&mut self, key: &str) {
        use crate::providers::config::CortexConfig;

        match CortexConfig::load() {
            Ok(config) => {
                let value = match key {
                    "provider" | "default_provider" => config.default_provider.clone(),
                    "model" | "default_model" => config.default_model.clone(),
                    "max_tokens" => config.max_tokens.to_string(),
                    "temperature" => config.temperature.to_string(),
                    "auto_save" => config.auto_save.to_string(),
                    _ => format!("Unknown config key: {}", key),
                };
                self.add_system_message(&format!("{} = {}", key, value));
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to load config: {}", e));
            }
        }
    }

    /// Handles the /logs command - sets log level.
    fn handle_set_log_level(&mut self, level: &str) {
        let valid_levels = ["trace", "debug", "info", "warn", "error"];
        if valid_levels.contains(&level.to_lowercase().as_str()) {
            self.app_state.log_level = level.to_lowercase();
            self.add_system_message(&format!("Log level set to: {}", level));
        } else {
            self.add_system_message(&format!(
                "Invalid log level: {}. Use: trace, debug, info, warn, error",
                level
            ));
        }
    }

    /// Handles the /dump command - exports session debug info.
    fn handle_dump(&mut self, file: &str) -> Result<()> {
        if let Some(ref session) = self.cortex_session {
            let dump_data = serde_json::json!({
                "session_id": session.id(),
                "title": session.title(),
                "message_count": session.message_count(),
                "provider": session.meta.provider,
                "model": session.meta.model,
                "created_at": session.meta.created_at.to_rfc3339(),
                "context_files": self.app_state.context_files.iter().map(|p| p.display().to_string()).collect::<Vec<_>>(),
                "mcp_servers": self.app_state.mcp_servers.iter().map(|s| &s.name).collect::<Vec<_>>(),
            });

            let json = serde_json::to_string_pretty(&dump_data)?;

            // Write to file
            let output_path = std::path::PathBuf::from(file);
            std::fs::write(&output_path, &json)?;

            self.add_system_message(&format!("Session dumped to: {}", output_path.display()));
        } else {
            self.add_system_message("No active session to dump.");
        }

        Ok(())
    }

    /// Handles the /eval command - evaluates a simple expression (for debugging).
    fn handle_eval(&mut self, expr: &str) {
        // Simple expression evaluator for debugging purposes
        let result = match expr.trim() {
            "session.id" => self
                .cortex_session
                .as_ref()
                .map(|s| s.id().to_string())
                .unwrap_or_else(|| "none".into()),
            "session.title" => self
                .cortex_session
                .as_ref()
                .map(|s| s.title().to_string())
                .unwrap_or_else(|| "none".into()),
            "session.messages" => self
                .cortex_session
                .as_ref()
                .map(|s| s.message_count().to_string())
                .unwrap_or_else(|| "0".into()),
            "context.count" => self.app_state.context_files.len().to_string(),
            "mcp.count" => self.app_state.mcp_servers.len().to_string(),
            "streaming" => self.app_state.streaming.is_streaming.to_string(),
            "view" => format!("{:?}", self.app_state.view),
            "focus" => format!("{:?}", self.app_state.focus),
            _ => format!("Unknown expression: {}", expr),
        };

        self.add_system_message(&format!("eval({}) = {}", expr, result));
    }

    /// Adds a system message to the chat display.
    fn add_system_message(&mut self, content: &str) {
        let message = cortex_core::widgets::Message::system(content);
        self.app_state.add_message(message);
    }

    /// Injects an event into the chat when an agent is selected for context.
    fn inject_agent_context_event(&mut self, agent_name: &str) {
        let content = format!(
            "Agent @{} selected. The agent configuration will be used for the next message.",
            agent_name
        );
        self.add_system_message(&content);
    }

    /// Injects an event into the chat when an agent is created.
    fn inject_agent_created_event(&mut self, agent_name: &str) {
        let content = format!(
            "Agent @{} created successfully!\n\nYou can now use @{} in your messages to invoke this agent.",
            agent_name, agent_name
        );
        self.add_system_message(&content);
    }

    /// Saves an agent configuration to disk.
    fn save_agent_config(
        &self,
        config: &crate::interactive::builders::NewAgentConfig,
    ) -> anyhow::Result<()> {
        use crate::interactive::builders::AgentLocation;

        // Determine directory
        let dir = match config.location {
            AgentLocation::Project => std::env::current_dir()?.join(".cortex/agents"),
            AgentLocation::Global => dirs::config_dir()
                .ok_or_else(|| anyhow::anyhow!("Could not determine config directory"))?
                .join("cortex/agents"),
        };

        // Create directory if it doesn't exist
        std::fs::create_dir_all(&dir)?;

        // Generate filename from name
        let filename = format!("{}.toml", config.name);
        let filepath = dir.join(&filename);

        // Check if file already exists
        if filepath.exists() {
            return Err(anyhow::anyhow!(
                "Agent '{}' already exists at {}",
                config.name,
                filepath.display()
            ));
        }

        // Write TOML content
        let content = config.to_toml();
        std::fs::write(&filepath, content)?;

        tracing::info!("Agent saved to: {}", filepath.display());
        Ok(())
    }

    // ============================================================================
    // MCP STORAGE HELPERS
    // ============================================================================

    /// Saves an MCP server configuration to persistent storage.
    fn save_mcp_server(&self, server: &crate::mcp_storage::StoredMcpServer) -> anyhow::Result<()> {
        let storage = crate::mcp_storage::McpStorage::new()?;
        storage.save_server(server)?;
        Ok(())
    }

    /// Removes an MCP server configuration from persistent storage.
    fn remove_mcp_server(&self, name: &str) -> anyhow::Result<()> {
        let storage = crate::mcp_storage::McpStorage::new()?;
        storage.remove_server(name)?;
        Ok(())
    }

    /// Loads all stored MCP server configurations and populates app state.
    /// This should be called at startup to restore persisted servers.
    pub fn load_mcp_servers(&mut self) {
        match crate::mcp_storage::McpStorage::new() {
            Ok(storage) => match storage.list_servers() {
                Ok(stored_servers) => {
                    for stored in stored_servers {
                        // Convert StoredMcpServer to McpServerInfo for display
                        let server_info = crate::modal::mcp_manager::McpServerInfo {
                            name: stored.name.clone(),
                            status: if stored.enabled {
                                crate::modal::mcp_manager::McpStatus::Stopped
                            } else {
                                crate::modal::mcp_manager::McpStatus::Stopped
                            },
                            tool_count: 0,
                            error: None,
                            requires_auth: stored.api_key_env_var.is_some(),
                        };

                        // Only add if not already present
                        if !self
                            .app_state
                            .mcp_servers
                            .iter()
                            .any(|s| s.name == stored.name)
                        {
                            self.app_state.mcp_servers.push(server_info);
                        }
                    }
                    if !self.app_state.mcp_servers.is_empty() {
                        tracing::info!(
                            "Loaded {} MCP server(s) from storage",
                            self.app_state.mcp_servers.len()
                        );
                    }
                }
                Err(e) => {
                    tracing::warn!("Failed to load MCP servers from storage: {}", e);
                }
            },
            Err(e) => {
                tracing::warn!("Failed to initialize MCP storage: {}", e);
            }
        }
    }

    /// Saves an API key for a provider to the config file.
    /// Also sets this provider as the default if it's the first configured provider.
    fn save_provider_api_key(&self, provider: &str, api_key: &str) -> anyhow::Result<()> {
        use crate::providers::config::CortexConfig;
        use crate::providers::models::get_models_for_provider;

        // Load existing config or create new
        let mut config = CortexConfig::load().unwrap_or_default();

        // Check if we should set this as default BEFORE modifying providers
        // (to avoid borrow conflict)
        let should_set_default = {
            let has_configured = config.providers.values().any(|p| p.api_key.is_some());
            !has_configured || config.default_provider == "cortex"
        };

        // Get default model for this provider (before mutable borrow)
        let default_model = if should_set_default {
            let models = get_models_for_provider(provider);
            models.first().map(|m| m.id.clone())
        } else {
            None
        };

        // Now update the provider config
        let provider_config = config.providers.entry(provider.to_string()).or_default();
        provider_config.api_key = Some(api_key.to_string());
        provider_config.enabled = true;

        // Set this provider as default if needed
        if should_set_default {
            config.default_provider = provider.to_string();
            if let Some(model_id) = default_model {
                config.default_model = model_id.clone();
                provider_config.default_model = Some(model_id);
            }
        }

        // Save config
        config.save()?;

        // Also set environment variable for current session
        let env_var = crate::providers::config::PROVIDERS
            .iter()
            .find(|p| p.id == provider)
            .map(|p| p.env_var)
            .unwrap_or("API_KEY");

        // SAFETY: We're setting our own env var, not modifying another thread's state
        unsafe {
            std::env::set_var(env_var, api_key);
        }

        Ok(())
    }

    /// Determines the current action context based on application state.
    ///
    /// The action context affects how key events are mapped to actions.
    /// In minimalist Codex-style UI, we always use Input context for Session view.
    fn get_action_context(&self) -> ActionContext {
        if self.app_state.pending_approval.is_some() {
            ActionContext::Approval
        } else if self.card_handler.is_active() || self.app_state.has_modal() {
            ActionContext::Global
        } else {
            // In minimalist mode, always use Input context for typing
            // The old focus system (Chat, Sidebar) is no longer relevant
            ActionContext::Input
        }
    }

    /// Handles a processed mouse action.
    ///
    /// This method uses the click zone registry to determine which UI element
    /// was clicked and performs the appropriate action.
    async fn handle_mouse_action(
        &mut self,
        action: MouseAction,
        terminal: &mut CortexTerminal,
    ) -> Result<()> {
        match action {
            MouseAction::Click { x, y, button } => {
                // Left click clears any existing selection and hides autocomplete
                if button == MouseButton::Left {
                    self.app_state.text_selection.clear();
                    // Hide autocomplete on any click (user clicked away)
                    if self.app_state.autocomplete.visible {
                        self.app_state.autocomplete.hide();
                    }
                }

                // Handle clicks in Questions view
                if self.app_state.view == AppView::Questions && button == MouseButton::Left {
                    if self.handle_question_click(x, y) {
                        self.render(terminal)?;
                        return Ok(());
                    }
                }

                // Handle clicks in interactive mode (/settings, /mcp, etc.)
                if self.app_state.is_interactive_mode() && button == MouseButton::Left {
                    if let Some((action, item_id, item_ids)) = self.handle_interactive_click(x, y) {
                        // Selection was made via click - handle it same as keyboard selection
                        let keep_open = self
                            .handle_interactive_selection(action, item_id, item_ids)
                            .await;
                        if !keep_open {
                            self.app_state.exit_interactive_mode();
                        }
                        self.render(terminal)?;
                        return Ok(());
                    }
                }

                if let Some(zone_id) = self.click_zones.find(x, y) {
                    let should_copy = self.handle_click(zone_id, button)?;
                    if should_copy {
                        self.copy_selection_to_clipboard(terminal)?;
                        self.app_state.text_selection.clear();
                    }
                    // Render immediately for responsiveness
                    self.render(terminal)?;
                }
            }

            MouseAction::DoubleClick { x, y } => {
                if let Some(zone_id) = self.click_zones.find(x, y) {
                    self.handle_double_click(zone_id)?;
                    self.render(terminal)?;
                }
            }

            MouseAction::Scroll { x, y, delta } => {
                if let Some(zone_id) = self.click_zones.find(x, y) {
                    self.handle_scroll(zone_id, delta);
                    // Render immediately for smooth 120 FPS scrolling
                    self.render(terminal)?;
                }
            }

            MouseAction::Drag {
                start,
                current,
                button: MouseButton::Left,
            } => {
                // Check if dragging on scrollbar
                if self.app_state.scrollbar_dragging {
                    // Handle scrollbar dragging
                    self.handle_scrollbar_drag(current.0, current.1)?;
                    self.render(terminal)?;
                } else if let Some(chat_area) = self.get_chat_area() {
                    // Check if starting in the scrollbar zone (right edge of chat area)
                    let scrollbar_zone_width = 3; // 3 chars from right edge
                    let scrollbar_x = chat_area.right().saturating_sub(scrollbar_zone_width);
                    if start.0 >= scrollbar_x
                        && start.0 < chat_area.right()
                        && start.1 >= chat_area.y
                        && start.1 < chat_area.bottom()
                    {
                        // Start scrollbar dragging
                        self.app_state.start_scrollbar_drag();
                        self.handle_scrollbar_drag(current.0, current.1)?;
                        self.render(terminal)?;
                    } else {
                        // Handle text selection anywhere on screen using absolute screen coordinates
                        let (width, height) = self.app_state.terminal_size;
                        let screen_area = Rect::new(0, 0, width, height);
                        self.app_state.text_selection.set_screen_area(screen_area);
                        if !self.app_state.text_selection.is_selecting() {
                            self.app_state
                                .text_selection
                                .start_selection(start.0, start.1);
                        }
                        self.app_state
                            .text_selection
                            .update_selection(current.0, current.1);
                        self.render(terminal)?;
                    }
                } else {
                    // No chat area - fall back to text selection
                    let (width, height) = self.app_state.terminal_size;
                    let screen_area = Rect::new(0, 0, width, height);
                    self.app_state.text_selection.set_screen_area(screen_area);
                    if !self.app_state.text_selection.is_selecting() {
                        self.app_state
                            .text_selection
                            .start_selection(start.0, start.1);
                    }
                    self.app_state
                        .text_selection
                        .update_selection(current.0, current.1);
                    self.render(terminal)?;
                }
            }

            MouseAction::Drag { .. } => {
                // Non-left-click drags are ignored
            }

            MouseAction::Release {
                x: _,
                y: _,
                button: MouseButton::Left,
            } => {
                // End scrollbar dragging if active
                if self.app_state.scrollbar_dragging {
                    self.app_state.end_scrollbar_drag();
                    self.render(terminal)?;
                } else if self.app_state.text_selection.is_selecting() {
                    // Finish selection (but don't auto-copy - wait for right-click or Ctrl+C)
                    self.app_state.text_selection.finish_selection();
                    self.render(terminal)?;
                }
            }

            MouseAction::Release { .. } => {
                // Non-left-click releases are ignored
            }

            MouseAction::Move { x, y } => {
                // Handle scrollbar hover (show scrollbar when mouse is near right edge of chat area)
                let mut scrollbar_hover = false;
                if let Some(chat_area) = self.get_chat_area() {
                    let scrollbar_hover_zone = 4; // 4 chars from right edge to trigger hover
                    let hover_x = chat_area.right().saturating_sub(scrollbar_hover_zone);
                    if x >= hover_x
                        && x < chat_area.right()
                        && y >= chat_area.y
                        && y < chat_area.bottom()
                    {
                        scrollbar_hover = true;
                    }
                }
                let was_hovered = self.app_state.scrollbar_hovered;
                self.app_state.set_scrollbar_hovered(scrollbar_hover);

                // Handle hover effects for Questions view
                if self.app_state.view == AppView::Questions {
                    self.handle_question_hover(x, y);
                    self.render(terminal)?;
                } else if scrollbar_hover != was_hovered {
                    // Re-render if scrollbar hover state changed
                    self.render(terminal)?;
                }
                // Handle hover effects for interactive mode (/settings, /mcp, etc.)
                else if self.app_state.is_interactive_mode() {
                    if let Some(state) = self.app_state.get_interactive_state_mut() {
                        // Hit test using stored click zones
                        let hit_idx = state.hit_test(x, y);
                        if state.set_hover(hit_idx) {
                            // Hover state changed, re-render
                            self.render(terminal)?;
                        }
                    }
                }
            }
        }

        Ok(())
    }

    /// Handles scrollbar drag - scrolls based on Y position within chat area
    fn handle_scrollbar_drag(&mut self, _x: u16, y: u16) -> Result<()> {
        if let Some(chat_area) = self.get_chat_area() {
            // Calculate Y position relative to chat area
            let y_in_area = y.saturating_sub(chat_area.y);
            let area_height = chat_area.height;

            // Calculate new scroll position
            let new_scroll = self
                .app_state
                .scroll_from_y_position(y_in_area, area_height);

            // Update scroll position directly (bypass scroll_chat to avoid showing "scrolled" behavior)
            self.app_state.chat_scroll = new_scroll;
            self.app_state.chat_scroll_pinned_bottom = new_scroll == 0;
            self.app_state.show_scrollbar();
        }
        Ok(())
    }

    /// Handles mouse hover for question prompts
    fn handle_question_hover(&mut self, x: u16, y: u16) {
        let (width, height) = self.app_state.terminal_size;
        let area = Rect::new(0, 0, width, height);

        let Some(q_state) = self.app_state.get_question_state() else {
            return;
        };

        let zones = QuestionClickZones::calculate(q_state, area);
        let hit = zones.hit_test(x, y);

        match hit {
            QuestionHit::Tab(idx) => {
                self.app_state.set_question_hovered_tab(Some(idx));
                self.app_state.set_question_hovered_option(None);
            }
            QuestionHit::Option(idx) => {
                self.app_state.set_question_hovered_option(Some(idx));
                self.app_state.set_question_hovered_tab(None);
            }
            _ => {
                self.app_state.set_question_hovered_option(None);
                self.app_state.set_question_hovered_tab(None);
            }
        }
    }

    /// Handles mouse click for question prompts
    /// Returns true if the click was handled
    fn handle_question_click(&mut self, x: u16, y: u16) -> bool {
        let (width, height) = self.app_state.terminal_size;
        let area = Rect::new(0, 0, width, height);

        let Some(q_state) = self.app_state.get_question_state() else {
            return false;
        };

        let zones = QuestionClickZones::calculate(q_state, area);
        let hit = zones.hit_test(x, y);

        match hit {
            QuestionHit::Tab(idx) => {
                if let Some(q_state) = self.app_state.get_question_state_mut() {
                    q_state.select_tab(idx);
                }
                true
            }
            QuestionHit::Option(idx) => {
                if let Some(q_state) = self.app_state.get_question_state_mut() {
                    q_state.move_to(idx);
                    q_state.toggle_current();

                    // Check if single question single choice - auto submit
                    // Need to check after toggle_current
                    let should_submit = q_state.is_single_question()
                        && !q_state.answers[0].is_empty()
                        && !q_state.editing_custom;

                    if should_submit {
                        // Can't call async here, so we'll handle it differently
                        // For now, just proceed - the user can click confirm or press Enter
                    }
                }
                true
            }
            QuestionHit::Confirm => {
                // Can't call async submit here, but we could trigger it
                true
            }
            QuestionHit::None => false,
        }
    }

    /// Handles mouse click for interactive mode (/settings, /mcp, etc.)
    /// Returns Some((action, item_id, item_ids)) if a selection was made via click.
    /// Returns None if click was outside interactive area, on non-selectable item, or only toggled multi-select.
    fn handle_interactive_click(
        &mut self,
        x: u16,
        y: u16,
    ) -> Option<(crate::interactive::InteractiveAction, String, Vec<String>)> {
        // First, get the necessary info from state
        let Some(state) = self.app_state.get_interactive_state_mut() else {
            return None;
        };

        // Hit test using stored click zones
        let Some(idx) = state.hit_test(x, y) else {
            return None;
        };

        // Move selection to clicked item
        state.selected = idx;
        state.hovered = Some(idx);

        // Get the selected item to check if it's selectable
        let item = match state.selected_item() {
            Some(item) if !item.disabled && !item.is_separator => item,
            _ => return None, // Click was on the interactive area but not a valid item
        };

        let is_multi = state.multi_select;

        // Handle multi-select differently - toggle instead of select
        if is_multi {
            state.toggle_check();
            return None; // Toggle doesn't trigger selection
        }

        // For single-select: simulate Enter key press (use the existing keyboard handler)
        // Send a synthetic Enter key event
        use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
        let enter_key = KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE);
        let result = crate::interactive::handle_interactive_key(state, enter_key);

        // Handle the result - return the selection info for async handling
        match result {
            crate::interactive::InteractiveResult::Selected {
                action,
                item_id,
                item_ids,
            } => Some((action, item_id, item_ids)),
            _ => None,
        }
    }

    /// Handles a single click on a click zone.
    /// Returns true if a copy operation should be performed (right-click with selection).
    fn handle_click(&mut self, zone_id: ClickZoneId, button: MouseButton) -> Result<bool> {
        match (zone_id, button) {
            // Session sidebar clicks
            (ClickZoneId::SessionItem(idx), MouseButton::Left) => {
                self.load_session_at_index(idx)?;
            }

            (ClickZoneId::NewSessionButton, MouseButton::Left) => {
                self.app_state.new_session();
            }

            // In minimalist Codex-style UI, focus is always on input
            // No need to change focus - just ignore these clicks for focus purposes
            (ClickZoneId::InputField, MouseButton::Left) => {
                // Already focused on input, nothing to do
            }

            (ClickZoneId::ChatArea | ClickZoneId::MessageItem(_), MouseButton::Left) => {
                // Chat area is read-only, keep focus on input
            }

            (ClickZoneId::Sidebar, MouseButton::Left) => {
                // Sidebar not used in minimalist mode, keep focus on input
            }

            // Model selector - open model picker modal
            (ClickZoneId::ModelSelector, MouseButton::Left) => {
                // Open model selector dialog
                self.open_models_modal();
                tracing::debug!("Model selector clicked - opening modal");
            }

            // Approval dialog buttons
            (ClickZoneId::ApproveButton, MouseButton::Left) => {
                if self.app_state.pending_approval.is_some() {
                    // Note: approval with backend requires async,
                    // so we just update UI state here
                    self.app_state.approve();
                }
            }

            (ClickZoneId::RejectButton, MouseButton::Left) => {
                if self.app_state.pending_approval.is_some() {
                    self.app_state.reject();
                }
            }

            // Right-click: copy selection if there is one, otherwise future context menu
            (zone_id, MouseButton::Right) => {
                if self.app_state.text_selection.has_selection() {
                    // Signal that copy should be performed
                    return Ok(true);
                } else {
                    // Context menu based on zone - for now just log, full implementation would need a ContextMenu modal
                    match zone_id {
                        ClickZoneId::ChatArea | ClickZoneId::MessageItem(_) => {
                            tracing::debug!(
                                "Right-click on chat area - context menu available in future"
                            );
                        }
                        ClickZoneId::SessionItem(_) => {
                            tracing::debug!("Right-click on session - could show session options");
                        }
                        _ => {
                            tracing::debug!("Right-click on {:?}", zone_id);
                        }
                    }
                }
            }

            // Other clicks (ignored)
            _ => {}
        }

        Ok(false)
    }

    /// Handles a double-click on a click zone.
    fn handle_double_click(&mut self, zone_id: ClickZoneId) -> Result<()> {
        match zone_id {
            // Double-click on session loads and focuses it
            ClickZoneId::SessionItem(idx) => {
                self.load_session_at_index(idx)?;
                self.app_state.set_focus(FocusTarget::Input);
            }

            // Double-click on message or chat area - select word under cursor
            ClickZoneId::MessageItem(_) | ClickZoneId::ChatArea => {
                // Word selection is handled through the mouse handler's double-click
                // The actual text extraction would require access to the rendered buffer
                // For now, we log the action - proper word selection needs buffer access
                tracing::debug!("Double-click in chat area - word selection requested");
            }

            // Double-click on input focuses it
            ClickZoneId::InputField => {
                self.app_state.set_focus(FocusTarget::Input);
            }

            _ => {}
        }

        Ok(())
    }

    /// Handles scroll events on a click zone.
    fn handle_scroll(&mut self, zone_id: ClickZoneId, delta: i16) {
        match zone_id {
            // Scroll in chat area
            // Invert delta: ScrollUp (negative delta) should increase chat_scroll (see older messages)
            // ScrollDown (positive delta) should decrease chat_scroll (see newer messages)
            ClickZoneId::ChatArea | ClickZoneId::MessageItem(_) => {
                self.app_state.scroll_chat(-delta as i32);
            }

            // Scroll in sidebar
            ClickZoneId::Sidebar | ClickZoneId::SessionItem(_) => {
                self.app_state.scroll_sidebar(delta as i32);
            }

            // Scroll in diff view (approval dialog)
            ClickZoneId::DiffView => {
                // Scroll diff view - delegate to app state
                self.app_state.scroll_diff(delta as i32);
                tracing::debug!("Scroll diff view by {}", delta);
            }

            _ => {}
        }
    }

    /// Loads a session by its index in the session history.
    fn load_session_at_index(&mut self, idx: usize) -> Result<()> {
        // Index 0 is "New Session" button (handled separately)
        // Actual sessions start at index 0 in session_history
        if let Some(session) = self.app_state.session_history.get(idx) {
            let session_id = session.id;
            self.app_state.load_session(session_id);

            // Load session from storage
            let session_id_str = session_id.to_string();
            if let Ok(loaded_session) = CortexSession::load(&session_id_str) {
                // Load messages into app state
                for msg in loaded_session.messages() {
                    // Use cortex_core::widgets::Message constructors for UI display
                    let message = if msg.role == "user" {
                        cortex_core::widgets::Message::user(&msg.content)
                    } else {
                        cortex_core::widgets::Message::assistant(&msg.content)
                    };
                    self.app_state.add_message(message);
                }
                self.cortex_session = Some(loaded_session);
                tracing::info!(
                    "Loaded session with {} messages",
                    self.app_state.messages.len()
                );
            }
        }
        Ok(())
    }

    /// Returns a reference to the click zone registry.
    ///
    /// Widgets can use this to register their click zones during rendering.
    pub fn click_zones(&self) -> &ClickZoneRegistry {
        &self.click_zones
    }

    /// Returns a mutable reference to the click zone registry.
    ///
    /// This should be used by the render pass to register click zones.
    pub fn click_zones_mut(&mut self) -> &mut ClickZoneRegistry {
        &mut self.click_zones
    }

    /// Returns a reference to the mouse handler.
    pub fn mouse_handler(&self) -> &MouseHandler {
        &self.mouse_handler
    }

    /// Returns a mutable reference to the mouse handler.
    pub fn mouse_handler_mut(&mut self) -> &mut MouseHandler {
        &mut self.mouse_handler
    }

    /// Returns whether the event loop is currently running.
    pub fn is_running(&self) -> bool {
        self.running.load(Ordering::SeqCst)
    }

    /// Signals the event loop to stop.
    ///
    /// This sets the running flag to false, causing the main loop to exit
    /// on the next iteration.
    pub fn stop(&self) {
        self.running.store(false, Ordering::SeqCst);
    }

    /// Returns a reference to the application state.
    pub fn app_state(&self) -> &AppState {
        &self.app_state
    }

    /// Returns a mutable reference to the application state.
    pub fn app_state_mut(&mut self) -> &mut AppState {
        &mut self.app_state
    }

    /// Returns a reference to the stream controller.
    pub fn stream_controller(&self) -> &StreamController {
        &self.stream_controller
    }

    /// Returns a mutable reference to the stream controller.
    pub fn stream_controller_mut(&mut self) -> &mut StreamController {
        &mut self.stream_controller
    }

    /// Returns a reference to the session bridge if attached.
    pub fn session_bridge(&self) -> Option<&SessionBridge> {
        self.session_bridge.as_ref()
    }

    /// Attaches a session bridge to the event loop.
    ///
    /// This can be called after construction to attach a session.
    pub fn set_session_bridge(&mut self, bridge: SessionBridge) {
        self.session_bridge = Some(bridge);
    }

    /// Removes and returns the session bridge.
    pub fn take_session_bridge(&mut self) -> Option<SessionBridge> {
        self.session_bridge.take()
    }

    /// Returns the chat area rectangle if available.
    ///
    /// This is used for text selection coordinate conversion.
    fn get_chat_area(&self) -> Option<Rect> {
        self.click_zones.get_zone_rect(ClickZoneId::ChatArea)
    }

    /// Applies selection highlight to the entire screen buffer.
    ///
    /// Uses absolute screen coordinates from the text selection state.
    fn apply_selection_highlight(&self, buf: &mut ratatui::buffer::Buffer) {
        use ratatui::style::Color;

        // Get selection bounds (normalized: start <= end) - these are absolute screen coords
        let Some((start, end)) = self.app_state.text_selection.get_bounds() else {
            return;
        };

        let selection_bg = Color::Rgb(60, 100, 140); // Blue highlight
        let buf_area = buf.area;

        let start_row = start.1;
        let end_row = end.1;

        for row in start_row..=end_row {
            if row >= buf_area.height {
                continue;
            }

            // Determine column range for this row
            let col_start = if row == start_row { start.0 } else { 0 };
            let col_end = if row == end_row {
                end.0
            } else {
                buf_area.width.saturating_sub(1)
            };

            for col in col_start..=col_end {
                if col < buf_area.width {
                    if let Some(cell) = buf.cell_mut(ratatui::layout::Position::new(col, row)) {
                        cell.set_bg(selection_bg);
                    }
                }
            }
        }
    }

    /// Copies the current text selection to the clipboard.
    ///
    /// Extracts text from the rendered content based on selection coordinates.
    /// Uses absolute screen coordinates for selection bounds.
    ///
    /// This function performs a full render of the UI first, then extracts
    /// text from the buffer at the selected coordinates.
    fn copy_selection_to_clipboard(&mut self, terminal: &mut CortexTerminal) -> Result<()> {
        let selection_bounds = self.app_state.text_selection.get_bounds();

        if let Some(((start_col, start_row), (end_col, end_row))) = selection_bounds {
            // Use RefCell to allow mutation inside the closure
            use std::cell::RefCell;
            let selected_lines: RefCell<Vec<String>> = RefCell::new(Vec::new());

            // Capture what we need before the closure
            let view = self.app_state.view;
            let active_modal = self.app_state.active_modal.clone();
            let card_active = self.card_handler.is_active();

            // We need to do a full render first to populate the buffer,
            // then extract text from it.
            terminal.terminal.draw(|frame| {
                let area = frame.area();
                let screen_width = area.width;
                let screen_height = area.height;

                // === FULL RENDER (same as render() function) ===
                match view {
                    AppView::Session => {
                        let widget = crate::views::MinimalSessionView::new(&self.app_state);
                        frame.render_widget(widget, area);
                    }
                    AppView::Approval => {
                        let session_view = crate::views::MinimalSessionView::new(&self.app_state);
                        frame.render_widget(session_view, area);
                        let approval_view = ApprovalView::new(&self.app_state);
                        frame.render_widget(approval_view, area);
                    }
                    AppView::Questions => {
                        let session_view = crate::views::MinimalSessionView::new(&self.app_state);
                        frame.render_widget(session_view, area);
                        if let Some(q_state) = self.app_state.get_question_state() {
                            let question_view = QuestionPromptView::new(q_state)
                                .with_hovered_option(self.app_state.question_hovered_option)
                                .with_hovered_tab(self.app_state.question_hovered_tab);
                            frame.render_widget(question_view, area);
                        }
                    }
                    AppView::Settings | AppView::Help => {
                        let widget = crate::views::MinimalSessionView::new(&self.app_state);
                        frame.render_widget(widget, area);
                    }
                }

                // Render modal overlays (legacy)
                if let Some(modal) = active_modal {
                    use crate::app::ActiveModal;
                    use crate::widgets::ModelPicker;
                    match modal {
                        // ProviderPicker removed: provider is now always "cortex"
                        ActiveModal::ModelPicker => {
                            let picker = ModelPicker::new(&self.app_state.model_picker);
                            frame.render_widget(picker, area);
                        }
                        _ => {}
                    }
                }

                // Render card overlays
                if card_active {
                    let modal_width =
                        (area.width as f32 * 0.6).max(40.0).min(area.width as f32) as u16;
                    let modal_height =
                        (area.height as f32 * 0.8).max(10.0).min(area.height as f32) as u16;
                    let modal_x = (area.width.saturating_sub(modal_width)) / 2;
                    let modal_y = (area.height.saturating_sub(modal_height)) / 2;
                    let modal_area = Rect::new(modal_x, modal_y, modal_width, modal_height);
                    self.card_handler.render(modal_area, frame.buffer_mut());
                }

                // === NOW EXTRACT TEXT FROM BUFFER ===
                let buf = frame.buffer_mut();
                let mut lines = selected_lines.borrow_mut();

                for row in start_row..=end_row {
                    if row >= screen_height {
                        break;
                    }

                    let col_start = if row == start_row { start_col } else { 0 };
                    let col_end = if row == end_row {
                        end_col
                    } else {
                        screen_width.saturating_sub(1)
                    };

                    let mut line = String::new();
                    for col in col_start..=col_end {
                        if col >= screen_width {
                            break;
                        }

                        if let Some(cell) = buf.cell((col, row)) {
                            line.push_str(cell.symbol());
                        }
                    }

                    // Trim trailing whitespace and add to lines
                    lines.push(line.trim_end().to_string());
                }
            })?;

            // Join lines and copy to clipboard
            let selected_text = selected_lines.into_inner().join("\n");

            if !selected_text.is_empty() {
                // Show toast immediately - clipboard copy happens in background on Linux
                tracing::debug!("Copied {} chars to clipboard", selected_text.len());
                self.app_state.toasts.success("Copied!");

                #[cfg(target_os = "linux")]
                {
                    // Spawn thread to avoid blocking UI - Linux clipboard needs to wait for manager
                    std::thread::spawn(move || {
                        if let Ok(mut clipboard) = arboard::Clipboard::new() {
                            use arboard::SetExtLinux;
                            let _ = clipboard.set().wait().text(selected_text);
                        }
                    });
                }

                #[cfg(not(target_os = "linux"))]
                {
                    if let Ok(mut clipboard) = arboard::Clipboard::new() {
                        if let Err(e) = clipboard.set_text(&selected_text) {
                            tracing::warn!("Failed to copy to clipboard: {}", e);
                        }
                    }
                }
            }
        }

        Ok(())
    }

    // ========================================================================
    // CARD HANDLER INTEGRATION
    // ========================================================================

    /// Process pending actions from the card handler.
    fn process_card_actions(&mut self) {
        use crate::cards::CardAction;

        let actions = self.card_handler.take_actions();
        for action in actions {
            match action {
                CardAction::SelectModel(model_id) => {
                    // Update the model in app state
                    self.app_state.model = model_id.clone();
                    // Update provider manager
                    if let Some(pm) = &self.provider_manager {
                        if let Ok(mut manager) = pm.try_write() {
                            let _ = manager.set_model(&model_id);
                        }
                    }
                    // Save last used model to config
                    if let Ok(mut config) = crate::providers::config::CortexConfig::load() {
                        let _ = config.save_last_model(&self.app_state.provider, &model_id);
                    }
                    // Update session model metadata
                    self.update_session_model(&model_id);
                }
                CardAction::SelectProvider(provider_id) => {
                    // Implement provider switching
                    self.app_state.provider = provider_id.clone();
                    let new_model_for_session: Option<String> =
                        if let Some(pm) = &self.provider_manager {
                            if let Ok(mut manager) = pm.try_write() {
                                if manager.set_provider(&provider_id).is_ok() {
                                    let new_model = manager.current_model().to_string();
                                    self.app_state.model = new_model.clone();
                                    tracing::info!("Provider switched to: {}", provider_id);
                                    Some(new_model)
                                } else {
                                    None
                                }
                            } else {
                                None
                            }
                        } else {
                            None
                        };
                    // Update session model metadata after borrow ends
                    if let Some(new_model) = new_model_for_session {
                        self.update_session_model(&new_model);
                    }
                }
                CardAction::SelectSession(path) => {
                    // Implement session resumption
                    let session_id = path.to_string_lossy().to_string();
                    tracing::info!("Resuming session: {}", session_id);
                    match CortexSession::load(&session_id) {
                        Ok(session) => {
                            self.cortex_session = Some(session);
                            self.app_state.set_view(AppView::Session);
                            self.add_system_message(&format!("Resumed session: {}", session_id));
                        }
                        Err(e) => {
                            self.add_system_message(&format!("Failed to resume session: {}", e));
                        }
                    }
                }
                CardAction::RestartMcpServer(name) => {
                    // Implement MCP server restart
                    tracing::info!("Restarting MCP server: {}", name);
                    if let Some(server) = self
                        .app_state
                        .mcp_servers
                        .iter_mut()
                        .find(|s| s.name == name)
                    {
                        server.status = crate::modal::mcp_manager::McpStatus::Starting;
                        // Simulate restart completion
                        server.status = crate::modal::mcp_manager::McpStatus::Running;
                    }
                    self.add_system_message(&format!("Restarted MCP server: {}", name));
                }
                CardAction::AddMcpServer(config) => {
                    // Implement MCP server addition - MCP servers are enabled (Running) by default
                    tracing::info!("Adding MCP server: {}", config);
                    use crate::modal::mcp_manager::{McpServerInfo, McpStatus};
                    if !self.app_state.mcp_servers.iter().any(|s| s.name == config) {
                        self.app_state.mcp_servers.push(McpServerInfo {
                            name: config.clone(),
                            status: McpStatus::Running,
                            tool_count: 0,
                            error: None,
                            requires_auth: false,
                        });
                        self.add_system_message(&format!("Added MCP server: {}", config));
                    } else {
                        self.add_system_message(&format!("MCP server already exists: {}", config));
                    }
                }
                CardAction::RemoveMcpServer(name) => {
                    // Implement MCP server removal
                    tracing::info!("Removing MCP server: {}", name);
                    let len_before = self.app_state.mcp_servers.len();
                    self.app_state.mcp_servers.retain(|s| s.name != name);
                    if self.app_state.mcp_servers.len() < len_before {
                        self.add_system_message(&format!("Removed MCP server: {}", name));
                    } else {
                        self.add_system_message(&format!("MCP server not found: {}", name));
                    }
                }
                CardAction::ExecuteCommand(cmd) => {
                    // Execute a slash command - prepend / if not present
                    let cmd_str = if cmd.starts_with('/') {
                        cmd.clone()
                    } else {
                        format!("/{}", cmd)
                    };
                    tracing::info!("Executing command: {}", cmd_str);

                    // Record command in history (strip leading slash for clean display)
                    let cmd_name = cmd_str.trim_start_matches('/');
                    self.app_state.add_to_history(cmd_name);

                    // Execute the command directly
                    let result = self.command_executor.execute_str(&cmd_str);
                    match result {
                        CommandResult::Success => {
                            tracing::debug!("Command executed successfully: {}", cmd);
                        }
                        CommandResult::Message(msg) => {
                            self.add_system_message(&msg);
                        }
                        CommandResult::Error(err) => {
                            self.add_system_message(&format!("Error: {}", err));
                        }
                        CommandResult::Clear => {
                            self.app_state.clear_messages();
                        }
                        CommandResult::Quit => {
                            self.app_state.set_quit();
                        }
                        _ => {}
                    }
                }
                CardAction::UpdateSetting { key, value } => {
                    // Implement setting update
                    tracing::info!("Updating setting: {} = {}", key, value);

                    // Update app state settings based on key
                    match key.as_str() {
                        "approval_mode" => {
                            let mode = match value.to_lowercase().as_str() {
                                "auto" | "allow" => ApprovalMode::AllowAlways,
                                "session" => ApprovalMode::AllowSession,
                                "ask" | "manual" => ApprovalMode::Ask,
                                _ => ApprovalMode::Ask,
                            };
                            self.app_state.set_approval_mode(mode);
                        }
                        "log_level" => {
                            self.app_state.log_level = value.clone();
                        }
                        _ => {
                            // Store in generic settings map
                            self.app_state.settings.insert(key.clone(), value.clone());
                        }
                    }

                    self.add_system_message(&format!("Setting {} = {}", key, value));
                }
                CardAction::ExportSession { format, path } => {
                    // Implement export
                    tracing::info!("Exporting session to {:?} as {}", path, format);
                    if let Some(ref session) = self.cortex_session {
                        let export_format = match format.to_lowercase().as_str() {
                            "json" => ExportFormat::Json,
                            "md" | "markdown" => ExportFormat::Markdown,
                            _ => ExportFormat::Text,
                        };

                        match export_session(session, export_format) {
                            Ok(content) => {
                                if let Err(e) = std::fs::write(&path, &content) {
                                    self.add_system_message(&format!("Export failed: {}", e));
                                } else {
                                    self.add_system_message(&format!(
                                        "Exported to {}",
                                        path.display()
                                    ));
                                }
                            }
                            Err(e) => {
                                self.add_system_message(&format!("Export failed: {}", e));
                            }
                        }
                    } else {
                        self.add_system_message("No active session to export");
                    }
                }
                CardAction::AddContextFile(path) => {
                    // Implement context file addition
                    tracing::info!("Adding context file: {:?}", path);
                    if path.exists() {
                        self.app_state.context_files.push(path.clone());
                        self.add_system_message(&format!("Added context: {}", path.display()));
                    } else {
                        self.add_system_message(&format!("File not found: {}", path.display()));
                    }
                }
                CardAction::RemoveContextFile(path) => {
                    // Implement context file removal
                    tracing::info!("Removing context file: {:?}", path);
                    if let Some(pos) = self.app_state.context_files.iter().position(|p| p == &path)
                    {
                        self.app_state.context_files.remove(pos);
                        self.add_system_message(&format!("Removed context: {}", path.display()));
                    } else {
                        self.add_system_message(&format!("Context not found: {}", path.display()));
                    }
                }
                CardAction::Custom(data) => {
                    tracing::debug!("Custom card action: {}", data);
                    // Parse custom actions (e.g., "fork:session_path", "delete:session_path")
                    if data.starts_with("fork:") {
                        let path = &data[5..];
                        self.add_system_message(&format!("Forking session: {}", path));
                    } else if data.starts_with("delete:") {
                        let path = &data[7..];
                        self.add_system_message(&format!("Deleting session: {}", path));
                    }
                }
            }
        }

        // Process approval decisions
        if let Some((id, decision)) = self.card_handler.take_approval_decision() {
            use crate::widgets::ApprovalDecision;
            match decision {
                ApprovalDecision::Approved => {
                    tracing::info!("Approval granted for: {}", id);
                    // Integrate with permission manager to mark tool as approved
                    self.permission_manager.approve_once(&id);
                    // Clear pending approval in app state
                    if let Some(ref pending) = self.app_state.pending_approval {
                        if pending.tool_call_id == id {
                            self.app_state.approve();
                        }
                    }
                    self.add_system_message(&format!("Approved: {}", id));
                }
                ApprovalDecision::ApprovedForSession => {
                    tracing::info!("Approval granted for session: {}", id);
                    // Mark as approved for the entire session
                    self.permission_manager.approve_for_session(&id);
                    if let Some(ref pending) = self.app_state.pending_approval {
                        if pending.tool_call_id == id {
                            self.app_state.approve();
                        }
                    }
                    self.add_system_message(&format!("Approved for session: {}", id));
                }
                ApprovalDecision::Rejected => {
                    tracing::info!("Approval rejected for: {}", id);
                    self.permission_manager.reject(&id);
                    if let Some(ref pending) = self.app_state.pending_approval {
                        if pending.tool_call_id == id {
                            self.app_state.reject();
                        }
                    }
                    self.add_system_message(&format!("Rejected: {}", id));
                }
            }
        }
    }

    /// Get a reference to the card handler.
    pub fn card_handler(&self) -> &super::card_handler::CardHandler {
        &self.card_handler
    }

    /// Get a mutable reference to the card handler.
    pub fn card_handler_mut(&mut self) -> &mut super::card_handler::CardHandler {
        &mut self.card_handler
    }

    // ========================================================================
    // MODAL STACK INTEGRATION
    // ========================================================================

    /// Process a modal action returned by the modal stack.
    async fn process_modal_action(&mut self, action: ModalAction) {
        match action {
            ModalAction::SelectModel(model_id) => {
                self.app_state.model = model_id.clone();
                // Update provider manager
                if let Some(pm) = &self.provider_manager {
                    if let Ok(mut manager) = pm.try_write() {
                        let _ = manager.set_model(&model_id);
                    }
                }
                // Save last used model to config
                if let Ok(mut config) = crate::providers::config::CortexConfig::load() {
                    let _ = config.save_last_model(&self.app_state.provider, &model_id);
                }
                // Update session model metadata
                self.update_session_model(&model_id);
            }
            ModalAction::SelectProvider(provider_id) => {
                // Implement full provider change
                self.app_state.provider = provider_id.clone();

                // Update provider manager and switch to new provider
                // Also track new model for session update
                let (switch_result, new_model_for_session): (
                    Option<Result<String, String>>,
                    Option<String>,
                ) = if let Some(pm) = &self.provider_manager {
                    if let Ok(mut manager) = pm.try_write() {
                        if manager.set_provider(&provider_id).is_ok() {
                            // Get the default model for this provider
                            let new_model = manager.current_model().to_string();
                            self.app_state.model = new_model.clone();

                            // Save to config (save_last_model saves both provider and model)
                            if let Ok(mut config) = crate::providers::config::CortexConfig::load() {
                                let _ = config.save_last_model(&provider_id, &new_model);
                            }

                            (
                                Some(Ok(format!(
                                    "Switched to provider: {} (model: {})",
                                    provider_id, new_model
                                ))),
                                Some(new_model),
                            )
                        } else {
                            (
                                Some(Err(format!(
                                    "Failed to switch to provider: {}",
                                    provider_id
                                ))),
                                None,
                            )
                        }
                    } else {
                        (None, None)
                    }
                } else {
                    (None, None)
                };

                // Update session model metadata after borrow ends
                if let Some(new_model) = new_model_for_session {
                    self.update_session_model(&new_model);
                }

                // Show message after borrow ends
                if let Some(result) = switch_result {
                    match result {
                        Ok(msg) => self.add_system_message(&msg),
                        Err(msg) => self.add_system_message(&msg),
                    }
                }
            }
            ModalAction::ConfigureProvider(_provider_id) => {
                // Open the authentication alert modal (all providers go through Cortex)
                use crate::modal::AuthAlertModal;
                let alert = AuthAlertModal::new();
                self.modal_stack.push(Box::new(alert));
            }
            ModalAction::ExecuteCommand(cmd) => {
                // Prepend / if not present (command palette passes command names without /)
                let cmd_str = if cmd.starts_with('/') {
                    cmd.clone()
                } else {
                    format!("/{}", cmd)
                };

                // Record command in history (strip leading slash for clean display)
                let cmd_name = cmd_str.trim_start_matches('/');
                self.app_state.add_to_history(cmd_name);

                let result = self.command_executor.execute_str(&cmd_str);
                // Handle the command result synchronously for now
                match result {
                    CommandResult::Success => {}
                    CommandResult::Message(msg) => {
                        self.add_system_message(&msg);
                    }
                    CommandResult::Error(err) => {
                        self.add_system_message(&format!("Error: {}", err));
                    }
                    CommandResult::Clear => {
                        self.app_state.clear_messages();
                    }
                    CommandResult::Quit => {
                        self.app_state.set_quit();
                    }
                    CommandResult::NotFound(cmd) => {
                        self.add_system_message(&format!("Unknown command: {}", cmd));
                    }
                    _ => {}
                }
            }
            ModalAction::SelectSession(path) => {
                let session_id = path.to_string_lossy().to_string();
                if let Ok(session) = CortexSession::load(&session_id) {
                    self.cortex_session = Some(session);
                    self.app_state.set_view(AppView::Session);
                    self.add_system_message(&format!("Resumed session: {}", session_id));
                } else {
                    self.add_system_message(&format!("Failed to load session: {}", session_id));
                }
            }
            ModalAction::NewSession => {
                self.app_state.new_session();
                self.add_system_message("New session started");
            }
            ModalAction::DeleteSession(path) => {
                // Implement session deletion
                let session_id = path.to_string_lossy().to_string();
                match CortexSession::delete(&session_id) {
                    Ok(_) => {
                        // If we're deleting the current session, clear it
                        if let Some(ref session) = self.cortex_session {
                            if session.id() == session_id {
                                self.cortex_session = None;
                                self.app_state.new_session();
                            }
                        }
                        // Remove from session history
                        self.app_state
                            .session_history
                            .retain(|s| s.id.to_string() != session_id);
                        self.add_system_message(&format!("Session deleted: {}", session_id));
                    }
                    Err(e) => {
                        self.add_system_message(&format!("Failed to delete session: {}", e));
                    }
                }
            }
            ModalAction::RestartMcpServer(name) => {
                // Implement MCP server restart
                // Stop and then start the server
                self.app_state
                    .mcp_servers
                    .iter_mut()
                    .find(|s| s.name == name)
                    .map(|s| {
                        s.status = crate::modal::mcp_manager::McpStatus::Starting;
                    });
                // Simulate restart by setting to starting then running after a delay
                // In a real implementation, this would call the MCP runtime
                tracing::info!("MCP server restart requested: {}", name);
                self.add_system_message(&format!("Restarting MCP server: {}", name));
                // After some time, mark as running (simulated)
                self.app_state
                    .mcp_servers
                    .iter_mut()
                    .find(|s| s.name == name)
                    .map(|s| {
                        s.status = crate::modal::mcp_manager::McpStatus::Running;
                    });
            }
            ModalAction::StartMcpServer(name) => {
                // Implement MCP server start
                if let Some(server) = self
                    .app_state
                    .mcp_servers
                    .iter_mut()
                    .find(|s| s.name == name)
                {
                    server.status = crate::modal::mcp_manager::McpStatus::Starting;
                    tracing::info!("MCP server start requested: {}", name);
                    // Simulate startup
                    server.status = crate::modal::mcp_manager::McpStatus::Running;
                    self.add_system_message(&format!("Started MCP server: {}", name));
                } else {
                    self.add_system_message(&format!("MCP server not found: {}", name));
                }
            }
            ModalAction::StopMcpServer(name) => {
                // Implement MCP server stop
                if let Some(server) = self
                    .app_state
                    .mcp_servers
                    .iter_mut()
                    .find(|s| s.name == name)
                {
                    server.status = crate::modal::mcp_manager::McpStatus::Stopped;
                    tracing::info!("MCP server stopped: {}", name);
                    self.add_system_message(&format!("Stopped MCP server: {}", name));
                } else {
                    self.add_system_message(&format!("MCP server not found: {}", name));
                }
            }
            ModalAction::AddMcpServer {
                name,
                command,
                args,
            } => {
                // Implement MCP server addition - MCP servers are enabled (Running) by default
                use crate::modal::mcp_manager::{McpServerInfo, McpStatus};

                // Check if server already exists
                if self.app_state.mcp_servers.iter().any(|s| s.name == name) {
                    self.add_system_message(&format!("MCP server '{}' already exists", name));
                    return;
                }

                // Persist to storage
                let stored_server = crate::mcp_storage::StoredMcpServer::new_stdio(
                    name.clone(),
                    command.clone(),
                    args.clone(),
                );
                if let Err(e) = self.save_mcp_server(&stored_server) {
                    tracing::error!("Failed to save MCP server config: {}", e);
                    self.add_system_message(&format!("Failed to save MCP server: {}", e));
                    return;
                }

                // Create new server entry
                let new_server = McpServerInfo {
                    name: name.clone(),
                    status: McpStatus::Running,
                    tool_count: 0,
                    error: None,
                    requires_auth: false,
                };
                self.app_state.mcp_servers.push(new_server);

                tracing::info!("Added MCP server: {} ({} {:?})", name, command, args);
                self.add_system_message(&format!("Added MCP server: {}", name));
            }
            ModalAction::AddMcpServerHttp { name, url } => {
                // Implement HTTP MCP server addition
                use crate::modal::mcp_manager::{McpServerInfo, McpStatus};

                // Check if server already exists
                if self.app_state.mcp_servers.iter().any(|s| s.name == name) {
                    self.add_system_message(&format!("MCP server '{}' already exists", name));
                    return;
                }

                // Persist to storage
                let stored_server =
                    crate::mcp_storage::StoredMcpServer::new_http(name.clone(), url.clone());
                if let Err(e) = self.save_mcp_server(&stored_server) {
                    tracing::error!("Failed to save MCP server config: {}", e);
                    self.add_system_message(&format!("Failed to save MCP server: {}", e));
                    return;
                }

                // Create new server entry
                let new_server = McpServerInfo {
                    name: name.clone(),
                    status: McpStatus::Stopped,
                    tool_count: 0,
                    error: None,
                    requires_auth: false,
                };
                self.app_state.mcp_servers.push(new_server);

                tracing::info!("Added HTTP MCP server: {} ({})", name, url);
                self.add_system_message(&format!("Added HTTP MCP server: {} ({})", name, url));
            }
            ModalAction::RemoveMcpServer(name) => {
                // Implement MCP server removal
                let initial_count = self.app_state.mcp_servers.len();

                // Remove from persistent storage first
                if let Err(e) = self.remove_mcp_server(&name) {
                    tracing::error!("Failed to remove MCP server from storage: {}", e);
                }

                self.app_state.mcp_servers.retain(|s| s.name != name);

                if self.app_state.mcp_servers.len() < initial_count {
                    tracing::info!("Removed MCP server: {}", name);
                    self.add_system_message(&format!("Removed MCP server: {}", name));
                } else {
                    self.add_system_message(&format!("MCP server not found: {}", name));
                }
            }
            ModalAction::AuthMcpServer { name, api_key } => {
                // Implement MCP server auth
                if let Some(server) = self
                    .app_state
                    .mcp_servers
                    .iter_mut()
                    .find(|s| s.name == name)
                {
                    // Store API key securely (in real impl, use keyring or encrypted storage)
                    server.requires_auth = false; // Mark as authenticated
                    tracing::info!("Configured auth for MCP server: {}", name);
                    self.add_system_message(&format!("Authentication configured for: {}", name));
                } else {
                    self.add_system_message(&format!("MCP server not found: {}", name));
                }
            }
            ModalAction::SetApprovalMode(mode) => {
                // Implement approval mode setting
                let approval_mode = match mode.to_lowercase().as_str() {
                    "auto" | "automatic" | "allow" => ApprovalMode::AllowAlways,
                    "session" => ApprovalMode::AllowSession,
                    "ask" | "manual" | "always" => ApprovalMode::Ask,
                    _ => ApprovalMode::Ask,
                };
                self.app_state.set_approval_mode(approval_mode);
                self.permission_manager.set_default_mode(mode.clone());
                self.add_system_message(&format!("Approval mode set to: {}", mode));
            }
            ModalAction::SetLogLevel(level) => {
                // Implement log level setting
                // Note: tracing_subscriber::EnvFilter not used - dynamic level changes need reload
                let filter = match level.to_lowercase().as_str() {
                    "trace" => "trace",
                    "debug" => "debug",
                    "info" => "info",
                    "warn" | "warning" => "warn",
                    "error" => "error",
                    _ => "info",
                };
                // Note: Dynamic log level changes require tracing-subscriber reload
                // For now, we store the preference
                self.app_state.log_level = level.clone();
                tracing::info!("Log level preference set to: {}", filter);
                self.add_system_message(&format!("Log level set to: {}", level));
            }
            ModalAction::AddContextFile(path) => {
                // Implement context file addition
                if path.exists() {
                    // Read file content and add to context
                    match std::fs::read_to_string(&path) {
                        Ok(content) => {
                            let filename = path
                                .file_name()
                                .map(|n| n.to_string_lossy().to_string())
                                .unwrap_or_else(|| "unknown".to_string());

                            // Add to app state context files
                            self.app_state.context_files.push(path.clone());

                            // Create a context message for the session
                            let context_msg = format!(
                                "[Context file: {}]\n```\n{}\n```",
                                filename,
                                if content.len() > 10000 {
                                    format!("{}... (truncated)", &content[..10000])
                                } else {
                                    content
                                }
                            );

                            // Add as system context if we have a session
                            if let Some(ref mut session) = self.cortex_session {
                                session.add_system_message(&context_msg);
                            }

                            self.add_system_message(&format!("Added context: {}", path.display()));
                        }
                        Err(e) => {
                            self.add_system_message(&format!("Failed to read file: {}", e));
                        }
                    }
                } else {
                    self.add_system_message(&format!("File not found: {}", path.display()));
                }
            }
            ModalAction::RemoveContextFile(path) => {
                // Implement context file removal
                if let Some(pos) = self.app_state.context_files.iter().position(|p| p == &path) {
                    self.app_state.context_files.remove(pos);
                    self.add_system_message(&format!("Removed context: {}", path.display()));
                } else {
                    self.add_system_message(&format!("Context file not found: {}", path.display()));
                }
            }
            ModalAction::ExportSession { format, path } => {
                // Implement session export
                if let Some(ref session) = self.cortex_session {
                    let export_format = match format.to_lowercase().as_str() {
                        "json" => ExportFormat::Json,
                        "md" | "markdown" => ExportFormat::Markdown,
                        "txt" | "text" => ExportFormat::Text,
                        _ => ExportFormat::Markdown,
                    };

                    match export_session(session, export_format) {
                        Ok(content) => match std::fs::write(&path, &content) {
                            Ok(_) => {
                                self.add_system_message(&format!(
                                    "Session exported to: {}",
                                    path.display()
                                ));
                            }
                            Err(e) => {
                                self.add_system_message(&format!(
                                    "Failed to write export file: {}",
                                    e
                                ));
                            }
                        },
                        Err(e) => {
                            self.add_system_message(&format!("Failed to export session: {}", e));
                        }
                    }
                } else {
                    self.add_system_message("No active session to export");
                }
            }
            ModalAction::ForkSession { name } => {
                // Implement session forking
                if let Some(ref session) = self.cortex_session {
                    match session.fork(None) {
                        Ok(mut forked) => {
                            if let Some(ref title) = name {
                                forked.set_title(title.clone());
                                let _ = forked.save();
                            }
                            let forked_id = forked.id().to_string();
                            self.cortex_session = Some(forked);
                            self.add_system_message(&format!(
                                "Session forked. New session ID: {}",
                                &forked_id[..8.min(forked_id.len())]
                            ));
                        }
                        Err(e) => {
                            self.add_system_message(&format!("Failed to fork session: {}", e));
                        }
                    }
                } else {
                    self.add_system_message("No active session to fork");
                }
            }
            ModalAction::SaveApiKey { provider, api_key } => {
                // Save API key to config
                if let Err(e) = self.save_provider_api_key(&provider, &api_key) {
                    self.add_system_message(&format!("Failed to save API key: {}", e));
                } else {
                    self.add_system_message(&format!("API key saved for provider '{}'", provider));
                    // Reload provider manager configuration and track new model
                    let new_model_for_session: Option<String> = if let Some(pm) =
                        &self.provider_manager
                    {
                        if let Ok(mut manager) = pm.try_write() {
                            if manager.reload_config().is_ok() {
                                self.app_state.provider = manager.current_provider().to_string();
                                let new_model = manager.current_model().to_string();
                                self.app_state.model = new_model.clone();
                                Some(new_model)
                            } else {
                                None
                            }
                        } else {
                            None
                        }
                    } else {
                        None
                    };
                    // Update session model metadata after borrow ends
                    if let Some(new_model) = new_model_for_session {
                        self.update_session_model(&new_model);
                    }
                    // provider_picker reload removed: provider is now always "cortex"

                    // Process any queued messages (auto-send first query after API key config)
                    if self.app_state.has_queued_messages() {
                        tracing::info!(
                            "Processing queued messages after API key configuration (count: {})",
                            self.app_state.queued_count()
                        );
                        if let Err(e) = self.process_message_queue().await {
                            tracing::error!("Failed to process queued message: {}", e);
                            self.add_system_message(&format!(
                                "Failed to send queued message: {}",
                                e
                            ));
                        }
                    }
                }
            }
            // ModalAction::Custom "open_provider_picker" removed: provider is now always "cortex"
            ModalAction::Custom(action) if action == "run_cortex_login" => {
                // Inform the user to run cortex login
                self.add_system_message(
                    "Please run `cortex login` in your terminal to authenticate with Cortex.",
                );
            }
            ModalAction::Custom(data) => {
                tracing::debug!("Custom modal action: {}", data);
            }
        }
    }

    /// Opens a modal onto the modal stack.
    pub fn open_modal(&mut self, modal: Box<dyn Modal>) {
        self.modal_stack.push(modal);
    }

    /// Opens the MCP manager modal.
    pub fn open_mcp_manager(&mut self, servers: Vec<crate::modal::mcp_manager::McpServerInfo>) {
        use crate::modal::McpManagerModal;
        self.modal_stack
            .push(Box::new(McpManagerModal::new(servers)));
    }

    /// Opens the models modal with the new modal system.
    pub fn open_models_modal(&mut self) {
        use crate::modal::{ModelInfo, ModelsModal};
        // Get models from provider manager
        let models: Vec<ModelInfo> = if let Some(ref pm) = self.provider_manager {
            if let Ok(manager) = pm.try_read() {
                let current_model = manager.current_model();
                let provider_name = manager.current_provider().to_string();
                manager
                    .available_models()
                    .iter()
                    .map(|m| ModelInfo {
                        id: m.id.clone(),
                        name: m.name.clone(),
                        provider: provider_name.clone(),
                        context_length: Some(m.context_window),
                        description: None,
                        is_current: m.id == current_model,
                        credit_multiplier_input: m.credit_multiplier_input.clone(),
                        credit_multiplier_output: m.credit_multiplier_output.clone(),
                        price_version: m.price_version,
                    })
                    .collect()
            } else {
                Vec::new()
            }
        } else {
            Vec::new()
        };
        let current = self.app_state.model.clone();
        self.modal_stack
            .push(Box::new(ModelsModal::new(models, Some(current))));
    }

    /// Opens the sessions modal with recent sessions.
    pub fn open_sessions_modal(&mut self) {
        use crate::modal::{SessionInfo, SessionsModal};

        match CortexSession::list_recent(20) {
            Ok(sessions) => {
                let session_infos: Vec<SessionInfo> = sessions
                    .into_iter()
                    .map(|s| SessionInfo {
                        path: std::path::PathBuf::from(&s.id),
                        name: if s.title.is_empty() {
                            "Untitled".to_string()
                        } else {
                            s.title
                        },
                        model: s.model,
                        created_at: s.created_at,
                        message_count: s.message_count as usize,
                    })
                    .collect();
                self.modal_stack
                    .push(Box::new(SessionsModal::new(session_infos)));
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to list sessions: {}", e));
            }
        }
    }

    // ========================================================================
    // CARD OPENING HELPERS
    // ========================================================================

    /// Opens the models card with available models from the provider manager.
    fn open_models_card(&mut self) {
        use crate::cards::ModelInfo;

        if let Some(ref pm) = self.provider_manager {
            let Ok(manager) = pm.try_read() else {
                self.add_system_message("Unable to access provider manager.");
                return;
            };
            let current_model = manager.current_model();
            let provider_name = manager.current_provider().to_string();

            let models: Vec<ModelInfo> = manager
                .available_models()
                .iter()
                .map(|m| {
                    let is_current = m.id == current_model;
                    ModelInfo {
                        id: m.id.clone(),
                        name: m.name.clone(),
                        provider: provider_name.clone(),
                        context_length: Some(m.context_window),
                        description: None, // Provider ModelInfo doesn't have description
                        is_current,
                    }
                })
                .collect();

            let current = Some(current_model.to_string());
            self.card_handler.open_models(models, current);
        } else {
            self.add_system_message("No provider manager available. Configure a provider first.");
        }
    }

    /// Opens the providers card.
    fn open_providers_card(&mut self) {
        let current = self
            .provider_manager
            .as_ref()
            .and_then(|m| m.try_read().ok())
            .map(|m| m.current_provider().to_string());
        self.card_handler.open_providers(current);
    }

    /// Opens the sessions card with recent sessions.
    fn open_sessions_card(&mut self) {
        use crate::cards::SessionInfo;

        match CortexSession::list_recent(20) {
            Ok(sessions) => {
                let session_infos: Vec<SessionInfo> = sessions
                    .into_iter()
                    .map(|s| SessionInfo {
                        path: std::path::PathBuf::from(&s.id), // Use ID as path placeholder
                        name: if s.title.is_empty() {
                            "Untitled".to_string()
                        } else {
                            s.title
                        },
                        model: s.model,
                        created_at: s.created_at,
                        message_count: s.message_count as usize,
                    })
                    .collect();
                self.card_handler.open_sessions(session_infos);
            }
            Err(e) => {
                self.add_system_message(&format!("Failed to list sessions: {}", e));
            }
        }
    }

    /// Opens the MCP servers card.
    fn open_mcp_card(&mut self) {
        use crate::cards::{McpServerInfo, McpStatus};

        // For now, show a placeholder - MCP integration would provide real servers
        let servers = vec![
            McpServerInfo::new("filesystem")
                .with_status(McpStatus::Running)
                .with_tool_count(5),
            McpServerInfo::new("git")
                .with_status(McpStatus::Running)
                .with_tool_count(8),
            McpServerInfo::new("browser")
                .with_status(McpStatus::Stopped)
                .with_tool_count(3),
        ];

        self.card_handler.open_mcp(servers);
    }
    // ========================================================================
    // DIFF PREVIEW GENERATION
    // ========================================================================

    /// Generates a diff preview for Edit/Write tools.
    /// Returns a unified diff string showing what will change.
    fn generate_diff_preview(
        &self,
        tool_name: &str,
        arguments: &serde_json::Value,
    ) -> Option<String> {
        match tool_name {
            "Edit" => {
                // Extract file path and changes from Edit tool arguments
                let file_path = arguments.get("file_path")?.as_str()?;
                let old_str = arguments.get("old_str")?.as_str()?;
                let new_str = arguments.get("new_str")?.as_str()?;

                // Read current file content
                let current_content = std::fs::read_to_string(file_path).ok()?;

                // Generate a simple unified diff preview
                let preview = format!(
                    "--- a/{}\n+++ b/{}\n@@ Edit Preview @@\n-{}\n+{}",
                    file_path,
                    file_path,
                    old_str
                        .lines()
                        .map(|l| format!("-{}", l))
                        .collect::<Vec<_>>()
                        .join("\n"),
                    new_str
                        .lines()
                        .map(|l| format!("+{}", l))
                        .collect::<Vec<_>>()
                        .join("\n"),
                );

                Some(preview)
            }
            "Write" => {
                // For Write tool, show file creation/replacement
                let file_path = arguments.get("file_path")?.as_str()?;
                let content = arguments.get("content")?.as_str()?;

                let file_exists = std::path::Path::new(file_path).exists();
                let action = if file_exists { "Replace" } else { "Create" };

                // Truncate content preview if too long
                let content_preview = if content.len() > 500 {
                    format!("{}... ({} bytes)", &content[..500], content.len())
                } else {
                    content.to_string()
                };

                let preview = format!(
                    "=== {} file: {} ===\n{}",
                    action, file_path, content_preview
                );

                Some(preview)
            }
            "ApplyPatch" => {
                // For ApplyPatch, the patch itself is the diff
                let patch = arguments.get("patch")?.as_str()?;
                Some(patch.to_string())
            }
            _ => None,
        }
    }
}

// ============================================================================
// APP STATE EXTENSION
// ============================================================================

impl AppState {
    /// Returns whether the application should quit.
    ///
    /// This is used by the event loop to determine when to exit.
    pub fn should_quit(&self) -> bool {
        !self.running
    }

    /// Signals that the application should quit.
    pub fn set_quit(&mut self) {
        self.running = false;
    }
}

// ============================================================================
// BROWSER HELPER
// ============================================================================

/// Opens a URL in the default browser.
///
/// This function attempts to open a URL in the system's default browser.
/// It validates the URL for security (only http/https allowed) and fails silently
/// if the browser cannot be opened (common in headless environments).
///
/// # Security
/// - Only allows HTTP and HTTPS URLs
/// - Rejects URLs with embedded credentials
/// - Validates against shell metacharacters for defense in depth
fn open_browser_url(url: &str) -> Result<()> {
    // Parse and validate the URL
    let parsed_url = url::Url::parse(url).map_err(|e| anyhow::anyhow!("Invalid URL: {}", e))?;

    // Only allow HTTP and HTTPS URLs
    match parsed_url.scheme() {
        "http" | "https" => {}
        scheme => {
            return Err(anyhow::anyhow!(
                "Refusing to open URL with scheme '{}': only http and https are allowed",
                scheme
            ));
        }
    }

    // Reject URLs with embedded credentials
    if !parsed_url.username().is_empty() || parsed_url.password().is_some() {
        return Err(anyhow::anyhow!(
            "Refusing to open URL with embedded credentials"
        ));
    }

    // Validate there are no shell metacharacters (defense in depth)
    const DANGEROUS_CHARS: &[char] = &[
        '`', '$', '|', ';', '&', '<', '>', '(', ')', '{', '}', '[', ']', '!', '\n', '\r',
    ];
    if url.chars().any(|c| DANGEROUS_CHARS.contains(&c)) {
        return Err(anyhow::anyhow!(
            "URL contains potentially dangerous characters"
        ));
    }

    let safe_url = parsed_url.as_str();

    #[cfg(target_os = "macos")]
    {
        std::process::Command::new("open")
            .arg("--")
            .arg(safe_url)
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null())
            .spawn()
            .map_err(|e| anyhow::anyhow!("Failed to open browser: {}", e))?;
    }

    #[cfg(target_os = "linux")]
    {
        std::process::Command::new("xdg-open")
            .arg(safe_url)
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null())
            .spawn()
            .map_err(|e| anyhow::anyhow!("Failed to open browser: {}", e))?;
    }

    #[cfg(target_os = "windows")]
    {
        std::process::Command::new("cmd")
            .args(["/C", "start", "", safe_url])
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null())
            .spawn()
            .map_err(|e| anyhow::anyhow!("Failed to open browser: {}", e))?;
    }

    Ok(())
}

// ============================================================================
// TESTS
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    #[ignore = "TUI behavior differs across platforms"]
    fn test_event_loop_new() {
        let app_state = AppState::new();
        let event_loop = EventLoop::new(app_state);

        assert!(event_loop.is_running());
        assert!(event_loop.session_bridge().is_none());
    }

    #[test]
    #[ignore = "TUI behavior differs across platforms"]
    fn test_event_loop_stop() {
        let app_state = AppState::new();
        let event_loop = EventLoop::new(app_state);

        assert!(event_loop.is_running());
        event_loop.stop();
        assert!(!event_loop.is_running());
    }

    #[test]
    fn test_get_action_context_input() {
        let mut app_state = AppState::new();
        app_state.focus = FocusTarget::Input;
        let event_loop = EventLoop::new(app_state);

        assert_eq!(event_loop.get_action_context(), ActionContext::Input);
    }

    #[test]
    #[ignore = "TUI behavior differs across platforms"]
    fn test_get_action_context_chat() {
        let mut app_state = AppState::new();
        app_state.focus = FocusTarget::Chat;
        let event_loop = EventLoop::new(app_state);

        assert_eq!(event_loop.get_action_context(), ActionContext::Chat);
    }

    #[test]
    #[ignore = "TUI behavior differs across platforms"]
    fn test_get_action_context_sidebar() {
        let mut app_state = AppState::new();
        app_state.focus = FocusTarget::Sidebar;
        let event_loop = EventLoop::new(app_state);

        assert_eq!(event_loop.get_action_context(), ActionContext::Sidebar);
    }

    #[test]
    fn test_get_action_context_approval() {
        let mut app_state = AppState::new();
        app_state.pending_approval = Some(ApprovalState {
            tool_call_id: "test-id".to_string(),
            tool_name: "test".to_string(),
            tool_args: "{}".to_string(),
            tool_args_json: Some(serde_json::json!({})),
            diff_preview: None,
            approval_mode: ApprovalMode::Ask,
        });
        let event_loop = EventLoop::new(app_state);

        assert_eq!(event_loop.get_action_context(), ActionContext::Approval);
    }

    #[test]
    fn test_app_state_should_quit() {
        let mut app_state = AppState::new();
        assert!(!app_state.should_quit());

        app_state.set_quit();
        assert!(app_state.should_quit());
    }

    #[test]
    #[ignore = "TUI behavior differs across platforms"]
    fn test_event_loop_with_action_mapper() {
        let app_state = AppState::new();
        let _mapper = ActionMapper::default_bindings();
        let event_loop = EventLoop::new(app_state);

        // Note: with_action_mapper builder method removed, mapper is set internally
        assert!(event_loop.is_running());
    }

    #[test]
    fn test_event_loop_accessors() {
        let app_state = AppState::new();
        let mut event_loop = EventLoop::new(app_state);

        // Test immutable access
        let _ = event_loop.app_state();
        let _ = event_loop.stream_controller();
        let _ = event_loop.session_bridge();

        // Test mutable access
        let _ = event_loop.app_state_mut();
        let _ = event_loop.stream_controller_mut();
    }

    #[test]
    fn test_event_loop_mouse_handler_accessors() {
        let app_state = AppState::new();
        let mut event_loop = EventLoop::new(app_state);

        // Test mouse handler access
        let _ = event_loop.mouse_handler();
        let _ = event_loop.mouse_handler_mut();

        // Test click zones access
        let _ = event_loop.click_zones();
        let _ = event_loop.click_zones_mut();
    }

    #[test]
    #[ignore = "TUI behavior differs across platforms"]
    fn test_handle_scroll_chat() {
        let app_state = AppState::new();
        let mut event_loop = EventLoop::new(app_state);

        // Initial scroll is 0
        assert_eq!(event_loop.app_state().chat_scroll, 0);

        // Scroll down
        event_loop.handle_scroll(ClickZoneId::ChatArea, 3);
        assert_eq!(event_loop.app_state().chat_scroll, 3);

        // Scroll up
        event_loop.handle_scroll(ClickZoneId::ChatArea, -2);
        assert_eq!(event_loop.app_state().chat_scroll, 1);
    }

    #[test]
    fn test_handle_scroll_sidebar() {
        let app_state = AppState::new();
        let mut event_loop = EventLoop::new(app_state);

        // Initial scroll is 0
        assert_eq!(event_loop.app_state().sidebar_scroll, 0);

        // Scroll down
        event_loop.handle_scroll(ClickZoneId::Sidebar, 5);
        assert_eq!(event_loop.app_state().sidebar_scroll, 5);

        // Scroll up
        event_loop.handle_scroll(ClickZoneId::SessionItem(0), -3);
        assert_eq!(event_loop.app_state().sidebar_scroll, 2);
    }

    #[test]
    #[ignore = "TUI behavior differs across platforms"]
    fn test_handle_click_focus_changes() {
        let app_state = AppState::new();
        let mut event_loop = EventLoop::new(app_state);

        // Click on input field
        event_loop
            .handle_click(ClickZoneId::InputField, MouseButton::Left)
            .unwrap();
        assert_eq!(event_loop.app_state().focus, FocusTarget::Input);

        // Click on chat area
        event_loop
            .handle_click(ClickZoneId::ChatArea, MouseButton::Left)
            .unwrap();
        assert_eq!(event_loop.app_state().focus, FocusTarget::Chat);

        // Click on sidebar
        event_loop
            .handle_click(ClickZoneId::Sidebar, MouseButton::Left)
            .unwrap();
        assert_eq!(event_loop.app_state().focus, FocusTarget::Sidebar);
    }

    #[test]
    fn test_handle_click_new_session() {
        let app_state = AppState::new();
        let mut event_loop = EventLoop::new(app_state);

        assert!(event_loop.app_state().session_id.is_none());

        // Click new session button
        event_loop
            .handle_click(ClickZoneId::NewSessionButton, MouseButton::Left)
            .unwrap();

        // Should have created a new session
        assert!(event_loop.app_state().session_id.is_some());
        assert_eq!(event_loop.app_state().view, AppView::Session);
    }

    #[test]
    fn test_handle_double_click_input() {
        let app_state = AppState::new();
        let mut event_loop = EventLoop::new(app_state);

        // Set focus elsewhere
        event_loop.app_state_mut().focus = FocusTarget::Chat;

        // Double-click on input
        event_loop
            .handle_double_click(ClickZoneId::InputField)
            .unwrap();

        // Should focus input
        assert_eq!(event_loop.app_state().focus, FocusTarget::Input);
    }

    #[test]
    fn test_click_zones_clear_and_register() {
        let app_state = AppState::new();
        let mut event_loop = EventLoop::new(app_state);

        // Register some zones
        event_loop.click_zones_mut().register(
            ClickZoneId::Sidebar,
            ratatui::layout::Rect::new(0, 0, 30, 24),
        );
        event_loop.click_zones_mut().register(
            ClickZoneId::ChatArea,
            ratatui::layout::Rect::new(30, 0, 50, 24),
        );

        assert_eq!(event_loop.click_zones().len(), 2);

        // Clear zones
        event_loop.click_zones_mut().clear();
        assert!(event_loop.click_zones().is_empty());
    }
}