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, AutocompleteItem, AutocompleteTrigger, FocusTarget,
    PendingToolResult, SubagentDisplayStatus, SubagentTaskDisplay,
};
use crate::bridge::{SessionBridge, StreamController, adapt_event};
use crate::commands::{CommandExecutor, 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, export_session};
use crate::views::tool_call::{ToolStatus, format_result_summary};
use crate::views::{ApprovalView, QuestionClickZones, QuestionHit, QuestionPromptView};
use cortex_engine::client::{Message, ResponseEvent, ToolDefinition as ClientToolDefinition};
use cortex_engine::streaming::StreamEvent;
use cortex_engine::tools::handlers::subagent::{ProgressEvent, SubagentExecutor};
use cortex_engine::tools::{ToolRegistry, UnifiedToolExecutor};

use crate::agent::build_system_prompt;

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

// ============================================================================
// 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>>,
}

/// 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);

        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(),
        }
    }

    /// 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)?;

        // 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;

        Ok(())
    }

    /// Spawns a subagent task (for Task tool).
    /// Based on OpenCode's task.ts implementation.
    fn spawn_subagent(&mut self, tool_call_id: String, args: serde_json::Value) {
        tracing::info!("Spawning subagent for tool call: {}", tool_call_id);

        // Parse args: { description, prompt, subagent_type, session_id? }
        let description = args
            .get("description")
            .and_then(|v| v.as_str())
            .unwrap_or("Subagent task")
            .to_string();
        let prompt = args
            .get("prompt")
            .and_then(|v| v.as_str())
            .unwrap_or("")
            .to_string();
        let subagent_type = args
            .get("subagent_type")
            .and_then(|v| v.as_str())
            .unwrap_or("default")
            .to_string();

        if prompt.is_empty() {
            self.app_state.add_pending_tool_result(
                tool_call_id,
                "Task".to_string(),
                "Task tool requires a 'prompt' parameter.".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: format!("Provider error: {}", e),
                                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,
        };
    }

    /// 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
        self.send_tool_results_to_llm(pending_results).await?;

        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(format!("Provider error: {}", e)))
                        .await;
                    return;
                }
                Err(_) => {
                    let _ = tx
                        .send(StreamEvent::Error("Connection timeout".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);
                    if let ModalResult::Action(action) = result {
                        self.process_modal_action(action);
                    }
                    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);
                        match result {
                            crate::interactive::InteractiveResult::Selected {
                                action,
                                item_id,
                                item_ids,
                            } => {
                                // Handle the selected action
                                self.handle_interactive_selection(action, item_id, item_ids)
                                    .await;
                                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() && self.card_handler.handle_key(key_event) {
                    // 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() && self.handle_modal_key(key_event)? {
                    self.render(terminal)?;
                    return Ok(());
                }

                // Handle Questions view input
                if self.app_state.view == AppView::Questions
                    && self.handle_question_key(key_event).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.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.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.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(());
                    }
                }

                // Reset Ctrl+C timer on other key presses
                self.app_state.reset_ctrl_c();

                let context = self.get_action_context();
                let action = self.action_mapper.get_action(key_event, 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()
                            {
                                // Keep trigger character (/ or @) and insert completion
                                let pos = self.app_state.autocomplete.trigger_position;
                                let current = self.app_state.input.text();
                                // Get trigger char (/ or @) to preserve it
                                let trigger = if pos < current.len() {
                                    &current[pos..pos + 1]
                                } else {
                                    ""
                                };
                                let new_text =
                                    format!("{}{}{} ", &current[..pos], trigger, completion_text);
                                self.app_state.input.set_text(&new_text);
                            }
                            self.app_state.autocomplete.hide();
                            self.render(terminal)?;
                            return Ok(());
                        }
                        KeyCode::Enter => {
                            // Enter hides autocomplete and continues to normal submit
                            self.app_state.autocomplete.hide();
                            // Don't return - fall through to normal Enter handling
                        }
                        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)?;
                }
            }

            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);
            }
        }

        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 (always execute immediately)
                    if text.starts_with('/') {
                        let result = self.command_executor.execute_str(&text);
                        self.handle_command_result(result).await?;
                    } else 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
                        // Auto-scroll to bottom when submitting a message
                        self.app_state.scroll_chat_to_bottom();

                        if self.provider_manager.is_some() {
                            // Try new provider system first, fall back to legacy bridge
                            self.handle_submit_with_provider(text).await?;
                        } else if let Some(ref bridge) = self.session_bridge {
                            // Add user message to state
                            let message = cortex_core::widgets::Message::user(&text);
                            self.app_state.add_message(message);

                            // Send to backend
                            bridge.send_message(text).await?;

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

            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();
            }
            KeyAction::SwitchProvider => {
                use crate::modal::ProvidersModal;
                let current = self
                    .provider_manager
                    .as_ref()
                    .and_then(|m| m.try_read().ok())
                    .map(|m| m.current_provider().to_string());
                // Use with_config to get actual configuration status
                if let Some(ref pm) = self.provider_manager {
                    if let Ok(manager) = pm.try_read() {
                        self.modal_stack.push(Box::new(ProvidersModal::with_config(
                            current,
                            manager.config(),
                        )));
                    } else {
                        self.modal_stack
                            .push(Box::new(ProvidersModal::with_known_providers(current)));
                    }
                } else {
                    self.modal_stack
                        .push(Box::new(ProvidersModal::with_known_providers(current)));
                }
            }

            // 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 modal
                // MCP servers would come from a dedicated MCP manager in production
                let servers = Vec::new(); // Placeholder - MCP integration pending
                self.open_mcp_manager(servers);
            }

            // 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();
                }
            }

            // 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
                && 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, ProviderPicker};

                match modal {
                    ActiveModal::ProviderPicker => {
                        let picker = ProviderPicker::new(&self.app_state.provider_picker);
                        frame.render_widget(picker, area);
                    }
                    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());
            }
        })?;

        // 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);
            }
        }
    }

    // ========================================================================
    // 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();
                }
            }
        }
    }

    /// 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 provider has API key configured (scope the borrow)
        {
            let pm_arc = self.provider_manager.as_ref().unwrap();
            let pm = pm_arc.read().await;
            if !pm.is_available() {
                let provider = pm.current_provider().to_string();
                let env_var = format!("{}_API_KEY", provider.to_uppercase().replace("-", "_"));
                // Get provider display name from PROVIDERS config
                use crate::providers::config::PROVIDERS;
                let provider_name = PROVIDERS
                    .iter()
                    .find(|p| p.id == provider)
                    .map(|p| p.name.to_string())
                    .unwrap_or_else(|| provider.clone());
                // Drop the borrow before opening modal
                drop(pm);
                // 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);
                // Open the provider alert modal
                use crate::modal::ProviderAlertModal;
                let alert = ProviderAlertModal::new(provider.clone(), provider_name, env_var);
                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(format!("Provider error: {}", e)))
                        .await;
                    return;
                }
                Err(_) => {
                    let _ = tx
                        .send(StreamEvent::Error("Connection timeout".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)
                    && 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).
                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 {
                        // No tool results pending - check for queued messages
                        self.process_message_queue().await;
                    }
                }
                // 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();
                self.add_system_message(&format!("Error: {}", 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
                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")
                    && 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" {
                    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,
            } => {
                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
                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;
                    }
                }
            }

            ToolEvent::Failed {
                id,
                name,
                error,
                duration,
            } => {
                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);
                        });
                    }

                    _ => {}
                }
            }

            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?;
                Ok(true)
            }
            KeyCode::Up | KeyCode::Char('k') => {
                q_state.move_up();
                Ok(true)
            }
            KeyCode::Down | KeyCode::Char('j') => {
                q_state.move_down();
                Ok(true)
            }
            KeyCode::Left | KeyCode::Char('h') => {
                q_state.prev_tab();
                Ok(true)
            }
            KeyCode::Right | KeyCode::Char('l') => {
                q_state.next_tab();
                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?;
                }
                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?;
                    }
                }
                Ok(true)
            }
            _ => 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.
    fn handle_modal_key(&mut self, key_event: crossterm::event::KeyEvent) -> Result<bool> {
        use crate::app::ActiveModal;
        use crate::widgets::PickerFocus;
        use crossterm::event::KeyCode;

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

        match modal {
            ActiveModal::ProviderPicker => {
                match key_event.code {
                    KeyCode::Esc => {
                        self.app_state.close_modal();
                    }
                    KeyCode::Up => {
                        self.app_state.provider_picker.select_prev();
                    }
                    KeyCode::Down => {
                        self.app_state.provider_picker.select_next();
                    }
                    KeyCode::Tab => {
                        self.app_state.provider_picker.toggle_focus();
                    }
                    KeyCode::Enter => {
                        // Select provider or save API key
                        if self.app_state.provider_picker.focus == PickerFocus::ApiKeyInput {
                            // Save API key to environment (temporary for this session)
                            let api_key = self.app_state.provider_picker.api_key_input.clone();
                            // Get env_var name before mutating
                            let env_var = self
                                .app_state
                                .provider_picker
                                .selected_provider()
                                .map(|p| p.env_var.clone());

                            if let Some(env_var) = env_var
                                && !api_key.is_empty()
                            {
                                // Set environment variable (safe wrapper)
                                // SAFETY: We're only setting our own env vars in a single-threaded context
                                unsafe {
                                    std::env::set_var(&env_var, &api_key);
                                }
                                self.app_state
                                    .provider_picker
                                    .set_status("API key saved for this session", false);
                                self.app_state.provider_picker.clear_input();
                                // Reload providers to update status
                                let current = self.app_state.provider.clone();
                                self.app_state.provider_picker.load_providers(&current);
                            }
                        } else {
                            // Select provider - extract data first
                            let provider_data = self
                                .app_state
                                .provider_picker
                                .selected_provider()
                                .map(|p| (p.id.clone(), p.name.clone(), p.is_configured));

                            if let Some((provider_id, provider_name, is_configured)) = provider_data
                            {
                                if is_configured {
                                    self.app_state.provider = provider_id.clone();

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

                                    self.app_state.close_modal();
                                    self.add_system_message(&format!(
                                        "Provider set to: {}",
                                        provider_name
                                    ));
                                } else {
                                    // Switch to API key input
                                    self.app_state.provider_picker.focus = PickerFocus::ApiKeyInput;
                                    self.app_state
                                        .provider_picker
                                        .set_status("Enter API key to configure", false);
                                }
                            }
                        }
                    }
                    KeyCode::Char('*') => {
                        self.app_state.provider_picker.toggle_show_key();
                    }
                    KeyCode::Char(c) => {
                        self.app_state.provider_picker.handle_char(c);
                    }
                    KeyCode::Backspace => {
                        self.app_state.provider_picker.handle_backspace();
                    }
                    _ => {}
                }
                Ok(true)
            }
            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
                                && 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);
                            }

                            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 => {
                        // Check if we're on the Submit button (focus_index == fields.len())
                        if form_state.focus_index == form_state.fields.len() {
                            // 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/checkbox 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(" "))
                }
            }
        };

        // 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 interactive = build_settings_selector(snapshot);
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    ModalType::ProviderPicker => {
                        // Use interactive mode instead of modal
                        let current = self
                            .provider_manager
                            .as_ref()
                            .and_then(|m| m.try_read().ok())
                            .map(|m| m.current_provider().to_string());
                        let interactive = crate::interactive::builders::build_provider_selector(
                            current.as_deref(),
                        );
                        self.app_state.enter_interactive_mode(interactive);
                    }
                    ModalType::ModelPicker => {
                        // Use interactive mode instead of modal
                        let provider = self
                            .provider_manager
                            .as_ref()
                            .and_then(|m| m.try_read().ok())
                            .map(|m| m.current_provider().to_string())
                            .unwrap_or_else(|| "openrouter".to_string());
                        let current_model = self
                            .provider_manager
                            .as_ref()
                            .and_then(|m| m.try_read().ok())
                            .map(|m| m.current_model().to_string());
                        let interactive = crate::interactive::builders::build_model_selector(
                            &provider,
                            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 => {
                        // Get MCP servers from app state
                        let servers = self.app_state.mcp_servers.clone();
                        self.open_mcp_manager(servers);
                    }
                    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>",
                                        "mcp-add" => "/mcp add <server-name>",
                                        "mcp-remove" => "/mcp remove <server-name>",
                                        "mcp-auth" => "/mcp-auth <server>",
                                        "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);
                    }
                    _ => {
                        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();
            }

            // === 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();
            }

            // === 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();
            }

            // === PATTERN-MATCHED COMMANDS ===
            _ => {
                // Handle commands with parameters
                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 {
                    tracing::debug!("Unhandled async command: {}", cmd);
                    self.add_system_message(&format!("Command not yet implemented: {}", cmd));
                }
            }
        }

        Ok(())
    }

    /// Lists all providers with their configuration status.
    fn handle_providers_list(&mut self) {
        use crate::providers::config::PROVIDERS;

        let current_provider = self
            .provider_manager
            .as_ref()
            .and_then(|m| m.try_read().ok())
            .map(|m| m.current_provider().to_string())
            .unwrap_or_default();

        let mut output = String::from("Providers:\n\n");

        // Configured providers
        let mut configured = Vec::new();
        let mut not_configured = Vec::new();

        for provider in PROVIDERS {
            let is_current = provider.id == current_provider;
            let has_key = if provider.requires_key {
                std::env::var(provider.env_var).is_ok()
            } else {
                true
            };

            if has_key {
                configured.push((provider, is_current));
            } else {
                not_configured.push(provider);
            }
        }

        // Show configured providers
        if !configured.is_empty() {
            output.push_str("  Ready to use:\n");
            for (provider, is_current) in &configured {
                let marker = if *is_current { " <- current" } else { "" };
                output.push_str(&format!(
                    "    [x] {} ({}){}\n",
                    provider.name, provider.id, marker
                ));
            }
            output.push('\n');
        }

        // Show providers needing configuration
        if !not_configured.is_empty() {
            output.push_str("  Need API key:\n");
            for provider in &not_configured {
                output.push_str(&format!(
                    "    [ ] {} - set {}\n",
                    provider.name, provider.env_var
                ));
            }
            output.push('\n');
        }

        output.push_str("Use /provider <name> to switch providers.");

        self.add_system_message(&output);
    }

    /// Lists available models for the current provider.
    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 {
            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() {
                "No models available for the current provider.".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);
    }

    /// 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 {
            match export_session(session, format) {
                Ok(content) => {
                    // For now, just show a preview in the chat
                    // In a full implementation, this would save to a file
                    let preview = if content.len() > 500 {
                        format!(
                            "{}...\n\n(Export truncated. Full export: {} bytes)",
                            &content[..500],
                            content.len()
                        )
                    } else {
                        content
                    };

                    self.add_system_message(&format!(
                        "Session exported as {}:\n\n{}",
                        format.name(),
                        preview
                    ));
                }
                Err(e) => {
                    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
                    && let Ok(mut manager) = pm.try_write()
                {
                    let _ = manager.set_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
                    && 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();
                self.app_state.settings.insert(key, is_fav.to_string());
                if is_fav {
                    self.app_state.toasts.success("Session marked as favorite");
                } else {
                    self.app_state.toasts.info("Favorite removed");
                }
            }
            "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>() {
                    self.app_state.max_tokens = Some(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
                            && 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());
            }
        }
    }

    /// 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};
        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 interactive = build_settings_selector(snapshot);
        self.app_state.enter_interactive_mode(interactive);
    }

    /// Handles actions from the interactive selection mode.
    async fn handle_interactive_selection(
        &mut self,
        action: crate::interactive::InteractiveAction,
        item_id: String,
        _checked: Vec<String>,
    ) {
        use crate::interactive::InteractiveAction;

        match action {
            InteractiveAction::SetProvider => {
                if let Some(pm) = &self.provider_manager
                    && let Ok(mut manager) = pm.try_write()
                {
                    let _ = manager.set_provider(&item_id);
                    self.app_state.provider = item_id.clone();
                }
            }
            InteractiveAction::SetModel => {
                if let Some(pm) = &self.provider_manager
                    && let Ok(mut manager) = pm.try_write()
                {
                    let _ = manager.set_model(&item_id);
                    self.app_state.model = item_id.clone();
                }
            }
            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
                }
                _ => {}
            },
            InteractiveAction::SetLogLevel => {
                self.app_state.log_level = item_id.clone();
            }
            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);
                }
            }
            InteractiveAction::ResumeSession => {
                // Resume picker - handle New, Resume, or Fork
                if item_id == "__new__" || item_id.starts_with("__sep_") {
                    self.app_state.new_session();
                } else {
                    // Resume the selected session
                    if let Ok(loaded) = crate::session::CortexSession::load(&item_id) {
                        // Load messages into app state
                        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);
                    }
                }
            }
            InteractiveAction::ForkSession => {
                // Fork the selected session (create copy and continue from there)
                if item_id != "__new__" && !item_id.starts_with("__sep_") {
                    if let Ok(forked) = crate::session::CortexSession::fork_from_id(&item_id) {
                        // Load messages into app state
                        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();
                }
            }
            InteractiveAction::McpServerAction => {
                // TODO: handle MCP server action (start/stop/restart)
            }
            InteractiveAction::AddContextFiles => {
                // Multi-select handled via _checked
                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);
                    }
                }
            }
            InteractiveAction::RemoveContextFiles => {
                // Multi-select handled via _checked
                for path in _checked.iter() {
                    let path_buf = std::path::PathBuf::from(path);
                    self.app_state.context_files.retain(|p| p != &path_buf);
                }
            }
            InteractiveAction::BrowseFiles { base_path } => {
                // Navigate into directory or add file
                let selected_path = std::path::PathBuf::from(&item_id);
                if selected_path.is_dir() {
                    // Navigate into directory - open new interactive state
                    let interactive =
                        crate::interactive::builders::build_file_browser(&selected_path);
                    self.app_state.enter_interactive_mode(interactive);
                } else {
                    // Add file to context
                    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);
                    }
                }
            }
            InteractiveAction::ToggleSetting => {
                // Skip category separators
                if item_id.starts_with("__cat_") {
                    // Re-open settings to stay in menu
                    self.reopen_settings_menu();
                    return;
                }
                // 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;
                    }
                    _ => {}
                };
                // Re-open settings menu to show updated state
                self.reopen_settings_menu();
            }
            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);
                        }
                        _ => {}
                    },
                    _ => {
                        tracing::debug!("Unhandled custom action: {}", custom_action);
                    }
                }
            }
        }
    }

    // ========================================================================
    // 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 = "=== Session Transcript ===\n".to_string();
            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 /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:"))
                        && (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) {
        let file_list: Vec<&str> = files.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() {
                if !self.app_state.context_files.contains(&path) {
                    self.app_state.context_files.push(path.clone());
                    added.push(file.to_string());
                }
            } else {
                failed.push(file.to_string());
            }
        }

        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) {
        let file_list: Vec<&str> = files.split(',').map(|s| s.trim()).collect();
        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.to_string());
            }
        }

        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
        let server = crate::modal::mcp_manager::McpServerInfo {
            name: name.clone(),
            status: crate::modal::mcp_manager::McpStatus::Stopped,
            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));
    }

    // ========================================================================
    // 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);
    }

    /// 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 == "openrouter"
        };

        // 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.
    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
                    && self.handle_question_click(x, y)
                {
                    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,
            } => {
                // 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)?;
            }

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

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

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

            MouseAction::Move { x, y } => {
                // Handle hover effects for Questions view
                if self.app_state.view == AppView::Questions {
                    self.handle_question_hover(x, y);
                    self.render(terminal)?;
                }
            }
        }

        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 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) {
                // Clear existing messages before loading session messages
                self.app_state.messages.clear();
                // 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
                    && 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, ProviderPicker};
                    match modal {
                        ActiveModal::ProviderPicker => {
                            let picker = ProviderPicker::new(&self.app_state.provider_picker);
                            frame.render_widget(picker, area);
                        }
                        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() {
                // Copy to clipboard using arboard
                match arboard::Clipboard::new() {
                    Ok(mut clipboard) => {
                        if let Err(e) = clipboard.set_text(&selected_text) {
                            tracing::warn!("Failed to copy to clipboard: {}", e);
                        } else {
                            tracing::debug!("Copied {} chars to clipboard", selected_text.len());
                            // Show toast notification
                            self.app_state.toasts.success("Copied!");
                        }
                    }
                    Err(e) => {
                        tracing::warn!("Clipboard unavailable: {}", 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
                        && 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);
                    }
                }
                CardAction::SelectProvider(provider_id) => {
                    // Implement provider switching
                    self.app_state.provider = provider_id.clone();
                    if let Some(pm) = &self.provider_manager
                        && let Ok(mut manager) = pm.try_write()
                        && manager.set_provider(&provider_id).is_ok()
                    {
                        let new_model = manager.current_model().to_string();
                        self.app_state.model = new_model;
                        tracing::info!("Provider switched to: {}", provider_id);
                    }
                }
                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
                    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::Stopped,
                            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
                    tracing::info!("Executing command: {}", cmd);
                    // Execute the command directly
                    let result = self.command_executor.execute_str(&cmd);
                    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 let Some(path) = data.strip_prefix("fork:") {
                        self.add_system_message(&format!("Forking session: {}", path));
                    } else if let Some(path) = data.strip_prefix("delete:") {
                        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
                        && 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
                        && 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
                        && 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.
    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
                    && 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);
                }
            }
            ModalAction::SelectProvider(provider_id) => {
                // Implement full provider change
                self.app_state.provider = provider_id.clone();

                // Update provider manager and switch to new provider
                let switch_result: Option<Result<String, 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
                            )))
                        } else {
                            Some(Err(format!(
                                "Failed to switch to provider: {}",
                                provider_id
                            )))
                        }
                    } else {
                        None
                    }
                } else {
                    None
                };

                // 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 API key form modal for this provider
                use crate::modal::ApiKeyFormModal;
                use crate::providers::config::PROVIDERS;

                // Find provider info to get display name
                let provider_name = PROVIDERS
                    .iter()
                    .find(|p| p.id == provider_id)
                    .map(|p| p.name.to_string())
                    .unwrap_or_else(|| provider_id.clone());

                let form = ApiKeyFormModal::new(provider_id, provider_name);
                self.modal_stack.push(Box::new(form));
            }
            ModalAction::ExecuteCommand(cmd) => {
                let result = self.command_executor.execute_str(&cmd);
                // 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
                            && 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
                if let Some(s) = self
                    .app_state
                    .mcp_servers
                    .iter_mut()
                    .find(|s| s.name == name)
                {
                    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)
                if let Some(s) = self
                    .app_state
                    .mcp_servers
                    .iter_mut()
                    .find(|s| s.name == name)
                {
                    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
                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;
                }

                // 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);

                // Save to config (in real impl)
                tracing::info!("Added MCP server: {} ({} {:?})", name, command, args);
                self.add_system_message(&format!("Added MCP server: {}", name));
            }
            ModalAction::RemoveMcpServer(name) => {
                // Implement MCP server removal
                let initial_count = self.app_state.mcp_servers.len();
                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
                    if let Some(pm) = &self.provider_manager
                        && let Ok(mut manager) = pm.try_write()
                        && manager.reload_config().is_ok()
                    {
                        self.app_state.provider = manager.current_provider().to_string();
                        self.app_state.model = manager.current_model().to_string();
                    }
                    // Reload provider picker to show updated status
                    self.app_state
                        .provider_picker
                        .load_providers(&self.app_state.provider);
                }
            }
            ModalAction::Custom(action) if action == "open_provider_picker" => {
                // Open provider picker modal
                use crate::modal::ProvidersModal;
                let current = self
                    .provider_manager
                    .as_ref()
                    .and_then(|pm| pm.try_read().ok())
                    .map(|pm| pm.current_provider().to_string());
                // Use with_config to get actual configuration status
                if let Some(ref pm) = self.provider_manager {
                    if let Ok(manager) = pm.try_read() {
                        self.modal_stack.push(Box::new(ProvidersModal::with_config(
                            current,
                            manager.config(),
                        )));
                    } else {
                        self.modal_stack
                            .push(Box::new(ProvidersModal::with_known_providers(current)));
                    }
                } else {
                    self.modal_stack
                        .push(Box::new(ProvidersModal::with_known_providers(current)));
                }
            }
            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,
                    })
                    .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;
    }
}

// ============================================================================
// TESTS
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;
    use crate::app::{ApprovalMode, ApprovalState};

    #[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());
    }
}