use anyhow::Result;
use std::time::{Duration, Instant};

#[derive(Debug, Clone)]
struct TurnMetrics {
    turn_number: usize,
    tokens_used: u32,
    wall_clock_time: Duration,
}

/// Generate a histogram showing tokens used and wall clock time per turn
fn generate_turn_histogram(turn_metrics: &[TurnMetrics]) -> String {
    if turn_metrics.is_empty() {
        return "   No turn data available".to_string();
    }

    let mut histogram = String::new();
    
    // Find max values for scaling
    let max_tokens = turn_metrics.iter().map(|t| t.tokens_used).max().unwrap_or(1);
    let max_time_ms = turn_metrics.iter()
        .map(|t| t.wall_clock_time.as_millis().min(u32::MAX as u128) as u32)
        .max()
        .unwrap_or(1);
    
    // Constants for histogram display
    const MAX_BAR_WIDTH: usize = 40;
    const TOKEN_CHAR: char = '█';
    const TIME_CHAR: char = '▓';
    
    histogram.push_str("\n📊 Per-Turn Performance Histogram:\n");
    histogram.push_str(&format!("   {} = Tokens Used (max: {})\n", TOKEN_CHAR, max_tokens));
    histogram.push_str(&format!("   {} = Wall Clock Time (max: {:.1}s)\n\n", TIME_CHAR, max_time_ms as f64 / 1000.0));
    
    for metrics in turn_metrics {
        let turn_time_ms = metrics.wall_clock_time.as_millis().min(u32::MAX as u128) as u32;
        
        // Calculate bar lengths (proportional to max values)
        let token_bar_len = if max_tokens > 0 {
            ((metrics.tokens_used as f64 / max_tokens as f64) * MAX_BAR_WIDTH as f64) as usize
        } else {
            0
        };
        
        let time_bar_len = if max_time_ms > 0 {
            ((turn_time_ms as f64 / max_time_ms as f64) * MAX_BAR_WIDTH as f64) as usize
        } else {
            0
        };
        
        // Format time duration
        let time_str = if turn_time_ms < 1000 {
            format!("{}ms", turn_time_ms)
        } else if turn_time_ms < 60_000 {
            format!("{:.1}s", turn_time_ms as f64 / 1000.0)
        } else {
            let minutes = turn_time_ms / 60_000;
            let seconds = (turn_time_ms % 60_000) as f64 / 1000.0;
            format!("{}m{:.1}s", minutes, seconds)
        };
        
        // Create the bars
        let token_bar = TOKEN_CHAR.to_string().repeat(token_bar_len);
        let time_bar = TIME_CHAR.to_string().repeat(time_bar_len);
        
        // Add turn information
        histogram.push_str(&format!(
            "   Turn {:2}: {:>6} tokens │{:<40}│\n",
            metrics.turn_number,
            metrics.tokens_used,
            token_bar
        ));
        histogram.push_str(&format!(
            "           {:>6}       │{:<40}│\n",
            time_str,
            time_bar
        ));
        
        // Add separator line between turns (except for last turn)
        if metrics.turn_number != turn_metrics.last().unwrap().turn_number {
            histogram.push_str("           ────────────┼────────────────────────────────────────┤\n");
        }
    }
    
    // Add summary statistics
    let total_tokens: u32 = turn_metrics.iter().map(|t| t.tokens_used).sum();
    let total_time: Duration = turn_metrics.iter().map(|t| t.wall_clock_time).sum();
    let avg_tokens = total_tokens as f64 / turn_metrics.len() as f64;
    let avg_time_ms = total_time.as_millis() as f64 / turn_metrics.len() as f64;
    
    histogram.push_str("\n📈 Summary Statistics:\n");
    histogram.push_str(&format!("   • Total Tokens: {} across {} turns\n", total_tokens, turn_metrics.len()));
    histogram.push_str(&format!("   • Average Tokens/Turn: {:.1}\n", avg_tokens));
    histogram.push_str(&format!("   • Total Time: {:.1}s\n", total_time.as_secs_f64()));
    histogram.push_str(&format!("   • Average Time/Turn: {:.1}s\n", avg_time_ms / 1000.0));
    
    histogram
}

/// Extract coach feedback by reading from the coach agent's specific log file
/// Uses the coach agent's session ID to find the exact log file
fn extract_coach_feedback_from_logs(
    coach_result: &g3_core::TaskResult,
    coach_agent: &g3_core::Agent<ConsoleUiWriter>,
    output: &SimpleOutput,
) -> Result<String> {
    // CORRECT APPROACH: Get the session ID from the current coach agent
    // and read its specific log file directly

    // Get the coach agent's session ID
    let session_id = coach_agent
        .get_session_id()
        .ok_or_else(|| anyhow::anyhow!("Coach agent has no session ID"))?;

    // Construct the log file path for this specific coach session
    let logs_dir = std::path::Path::new("logs");
    let log_file_path = logs_dir.join(format!("g3_session_{}.json", session_id));

    // Read the coach agent's specific log file
    if log_file_path.exists() {
        if let Ok(log_content) = std::fs::read_to_string(&log_file_path) {
            if let Ok(log_json) = serde_json::from_str::<serde_json::Value>(&log_content) {
                if let Some(context_window) = log_json.get("context_window") {
                    if let Some(conversation_history) = context_window.get("conversation_history") {
                        if let Some(messages) = conversation_history.as_array() {
                            // Simply get the last message content - this is the coach's final feedback
                            if let Some(last_message) = messages.last() {
                                if let Some(content) = last_message.get("content") {
                                    if let Some(content_str) = content.as_str() {
                                        output.print(&format!(
                                            "✅ Extracted coach feedback from session: {}",
                                            session_id
                                        ));
                                        return Ok(content_str.to_string());
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    // If we couldn't extract from logs, panic with detailed error
    panic!(
        "CRITICAL: Could not extract coach feedback from session: {}\n\
         Log file path: {:?}\n\
         Log file exists: {}\n\
         This indicates the coach did not call any tool or the log is corrupted.\n\
         Coach result response length: {} chars",
        session_id,
        log_file_path,
        log_file_path.exists(),
        coach_result.response.len()
    );
}

use clap::Parser;
use g3_config::Config;
use g3_core::{project::Project, ui_writer::UiWriter, Agent};
use rustyline::error::ReadlineError;
use rustyline::DefaultEditor;
use std::path::Path;
use std::path::PathBuf;
use tokio_util::sync::CancellationToken;
use tracing::{error, info};

use g3_core::error_handling::{classify_error, ErrorType, RecoverableError};
mod retro_tui;
mod theme;
pub mod tui;
mod ui_writer_impl;
use retro_tui::RetroTui;
use theme::ColorTheme;
use tui::SimpleOutput;
use ui_writer_impl::{ConsoleUiWriter, RetroTuiWriter};

#[derive(Parser)]
#[command(name = "g3")]
#[command(about = "A modular, composable AI coding agent")]
#[command(version)]
pub struct Cli {
    /// Enable verbose logging
    #[arg(short, long)]
    pub verbose: bool,

    /// Show the system prompt being sent to the LLM
    #[arg(long)]
    pub show_prompt: bool,

    /// Show the generated code before execution
    #[arg(long)]
    pub show_code: bool,

    /// Configuration file path
    #[arg(short, long)]
    pub config: Option<String>,

    /// Workspace directory (defaults to current directory)
    #[arg(short, long)]
    pub workspace: Option<PathBuf>,

    /// Task to execute (if provided, runs in single-shot mode instead of interactive)
    pub task: Option<String>,

    /// Enable autonomous mode with coach-player feedback loop
    #[arg(long)]
    pub autonomous: bool,

    /// Maximum number of turns in autonomous mode (default: 5)
    #[arg(long, default_value = "5")]
    pub max_turns: usize,

    /// Override requirements text for autonomous mode (instead of reading from requirements.md)
    #[arg(long, value_name = "TEXT")]
    pub requirements: Option<String>,

    /// Interactive mode: prompt for requirements and save to requirements.md before starting autonomous mode
    #[arg(long)]
    pub interactive_requirements: bool,

    /// Use retro terminal UI (inspired by 80s sci-fi)
    #[arg(long)]
    pub retro: bool,

    /// Color theme for retro mode (default, dracula, or path to theme file)
    #[arg(long, value_name = "THEME")]
    pub theme: Option<String>,

    /// Override the configured provider (anthropic, databricks, embedded, openai)
    #[arg(long, value_name = "PROVIDER")]
    pub provider: Option<String>,

    /// Override the model for the selected provider
    #[arg(long, value_name = "MODEL")]
    pub model: Option<String>,

    /// Disable log file creation (no logs/ directory or session logs)
    #[arg(long)]
    pub quiet: bool,

    /// Enable macOS Accessibility API tools for native app automation
    #[arg(long)]
    pub macax: bool,
}

pub async fn run() -> Result<()> {
    let cli = Cli::parse();

    // Only initialize logging if not in retro mode
    if !cli.retro {
        // Initialize logging with filtering
        use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};

        // Create a filter that suppresses llama_cpp logs unless in verbose mode
        let filter = if cli.verbose {
            EnvFilter::from_default_env()
                .add_directive(format!("{}=debug", env!("CARGO_PKG_NAME")).parse().unwrap())
                .add_directive("g3_core=debug".parse().unwrap())
                .add_directive("g3_cli=debug".parse().unwrap())
                .add_directive("g3_execution=debug".parse().unwrap())
                .add_directive("g3_providers=debug".parse().unwrap())
        } else {
            EnvFilter::from_default_env()
                .add_directive(format!("{}=info", env!("CARGO_PKG_NAME")).parse().unwrap())
                .add_directive("g3_core=info".parse().unwrap())
                .add_directive("g3_cli=info".parse().unwrap())
                .add_directive("g3_execution=info".parse().unwrap())
                .add_directive("g3_providers=info".parse().unwrap())
                .add_directive("llama_cpp=off".parse().unwrap()) // Suppress all llama_cpp logs
                .add_directive("llama=off".parse().unwrap()) // Suppress all llama.cpp logs
        };

        tracing_subscriber::registry()
            .with(tracing_subscriber::fmt::layer())
            .with(filter)
            .init();
    } else {
        // In retro mode, we don't want any logging output to interfere with the TUI
        // We'll use a no-op subscriber
        use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};

        // Create a filter that suppresses ALL logs in retro mode
        let filter = EnvFilter::from_default_env().add_directive("off".parse().unwrap()); // Turn off all logging

        tracing_subscriber::registry().with(filter).init();
    }

    if !cli.retro {
        info!("Starting G3 AI Coding Agent");
    }

    // Set up workspace directory
    let workspace_dir = if let Some(ws) = cli.workspace {
        ws
    } else if cli.autonomous {
        // For autonomous mode, use G3_WORKSPACE env var or default
        setup_workspace_directory()?
    } else {
        // Default to current directory for interactive/single-shot mode
        std::env::current_dir()?
    };

    // Check if we're in a project directory and read README and AGENTS.md if available
    // Load AGENTS.md first (if present) to provide agent-specific instructions
    let agents_content = read_agents_config(&workspace_dir);
    
    // Then load README for project context
    let readme_content = read_project_readme(&workspace_dir);

    // Create project model
    let project = if cli.autonomous {
        // Handle interactive requirements mode with AI enhancement
        if cli.interactive_requirements {
            println!("\n📝 Interactive Requirements Mode");
            println!("================================\n");
            println!("Describe what you want to build (can be brief):");
            println!("Press Ctrl+D (Unix) or Ctrl+Z (Windows) when done.\n");
            
            use std::io::{self, Read, Write};
            let mut requirements_input = String::new();
            io::stdin().read_to_string(&mut requirements_input)?;
            
            if requirements_input.trim().is_empty() {
                anyhow::bail!("No requirements provided. Exiting.");
            }
            
            println!("\n🤖 Enhancing your requirements with AI...\n");
            
            // Create a temporary agent to enhance the requirements
            let temp_config = Config::load_with_overrides(
                cli.config.as_deref(),
                cli.provider.clone(),
                cli.model.clone(),
            )?;
            
            let ui_writer = ConsoleUiWriter::new();
            let mut temp_agent = Agent::new_with_readme_and_quiet(
                temp_config,
                ui_writer,
                None,
                true, // quiet mode
            ).await?;
            
            // Craft the enhancement prompt
            let enhancement_prompt = format!(
                r#"You are a requirements analyst. Take this brief user input and expand it into a structured requirements document.

USER INPUT:
{}

Create a professional requirements document with:
1. A clear project title (# heading)
2. An overview section explaining what will be built
3. Organized requirements (functional, technical, quality)
4. Acceptance criteria
5. Any technical constraints or preferences mentioned

Format as proper markdown. Be specific and actionable. If the user's input is vague, make reasonable assumptions but keep it focused on what they described.

Output ONLY the markdown content, no explanations or meta-commentary."#,
                requirements_input.trim()
            );
            
            // Execute enhancement task
            let result = temp_agent
                .execute_task_with_timing(&enhancement_prompt, None, false, false, false, false)
                .await?;
            
            let enhanced_requirements = result.response.trim().to_string();
            
            // Show the enhanced requirements
            println!("\n📋 Enhanced Requirements Document:");
            println!("{}\n", "=".repeat(60));
            println!("{}", enhanced_requirements);
            println!("{}\n", "=".repeat(60));
            
            // Ask for confirmation
            println!("\n❓ Is this requirements document acceptable?");
            println!("   [y] Yes, proceed with autonomous mode");
            println!("   [e] Edit and save manually");
            println!("   [n] No, cancel\n");
            
            print!("Your choice (y/e/n): ");
            io::stdout().flush()?;
            
            let mut choice = String::new();
            io::stdin().read_line(&mut choice)?;
            let choice = choice.trim().to_lowercase();
            
            let requirements_path = workspace_dir.join("requirements.md");
            
            match choice.as_str() {
                "y" | "yes" => {
                    // Save enhanced requirements
                    std::fs::write(&requirements_path, &enhanced_requirements)?;
                    println!("\n✅ Requirements saved to: {}", requirements_path.display());
                    println!("🚀 Starting autonomous mode...\n");
                }
                "e" | "edit" => {
                    // Save enhanced requirements for manual editing
                    std::fs::write(&requirements_path, &enhanced_requirements)?;
                    println!("\n✅ Requirements saved to: {}", requirements_path.display());
                    println!("📝 Please edit the file and run: g3 --autonomous");
                    println!("   Exiting for now.\n");
                    return Ok(());
                }
                "n" | "no" => {
                    println!("\n❌ Cancelled. No files were saved.\n");
                    return Ok(());
                }
                _ => {
                    println!("\n❌ Invalid choice. Cancelled.\n");
                    return Ok(());
                }
            }
        }
        
        if let Some(requirements_text) = cli.requirements {
            // Use requirements text override
            Project::new_autonomous_with_requirements(workspace_dir.clone(), requirements_text)?
        } else {
            // Use traditional requirements.md file
            Project::new_autonomous(workspace_dir.clone())?
        }
    } else {
        Project::new(workspace_dir.clone())
    };

    // Ensure workspace exists and enter it
    project.ensure_workspace_exists()?;
    project.enter_workspace()?;

    if !cli.retro {
        info!("Using workspace: {}", project.workspace().display());
    }

    // Load configuration with CLI overrides
    let mut config = Config::load_with_overrides(
        cli.config.as_deref(),
        cli.provider.clone(),
        cli.model.clone(),
    )?;

    // Apply macax flag override
    if cli.macax {
        config.macax.enabled = true;
        if !cli.retro {
            info!("macOS Accessibility API tools enabled");
        }
    }

    // Validate provider if specified
    if let Some(ref provider) = cli.provider {
        let valid_providers = ["anthropic", "databricks", "embedded", "openai"];
        if !valid_providers.contains(&provider.as_str()) {
            return Err(anyhow::anyhow!(
                "Invalid provider '{}'. Valid options: {:?}",
                provider,
                valid_providers
            ));
        }
    }

    // Initialize agent
    let ui_writer = ConsoleUiWriter::new();
    
    // Combine AGENTS.md and README content if both exist
    let combined_content = match (agents_content.clone(), readme_content.clone()) {
        (Some(agents), Some(readme)) => {
            Some(format!("{}\n\n{}", agents, readme))
        }
        (Some(agents), None) => Some(agents),
        (None, Some(readme)) => Some(readme),
        (None, None) => None,
    };
    
    let mut agent = if cli.autonomous {
        Agent::new_autonomous_with_readme_and_quiet(
            config.clone(),
            ui_writer,
            combined_content.clone(),
            cli.quiet,
        )
        .await?
    } else {
        Agent::new_with_readme_and_quiet(
            config.clone(),
            ui_writer,
            combined_content.clone(),
            cli.quiet,
        )
        .await?
    };

    // Execute task, autonomous mode, or start interactive mode
    if cli.autonomous {
        // Autonomous mode with coach-player feedback loop
        if !cli.retro {
            info!("Starting autonomous mode");
        }
        run_autonomous(
            agent,
            project,
            cli.show_prompt,
            cli.show_code,
            cli.max_turns,
            cli.quiet,
        )
        .await?;
    } else if let Some(task) = cli.task {
        // Single-shot mode
        if !cli.retro {
            info!("Executing task: {}", task);
        }
        let output = SimpleOutput::new();
        let result = agent
            .execute_task_with_timing(&task, None, false, cli.show_prompt, cli.show_code, true)
            .await?;
        output.print_smart(&result.response);
    } else {
        // Interactive mode (default)
        if !cli.retro {
            info!("Starting interactive mode");
        }

        if cli.retro {
            // Use retro terminal UI
            run_interactive_retro(
                config, // Already has overrides applied
                cli.show_prompt,
                cli.show_code,
                cli.theme,
                combined_content,
            )
            .await?;
        } else {
            // Use standard terminal UI
            let output = SimpleOutput::new();
            output.print(&format!("📁 Workspace: {}", project.workspace().display()));
            run_interactive(agent, cli.show_prompt, cli.show_code, combined_content).await?;
        }
    }

    Ok(())
}

/// Check if we're in a project directory and read AGENTS.md if available
fn read_agents_config(workspace_dir: &Path) -> Option<String> {
    // Look for AGENTS.md in the current directory
    let agents_path = workspace_dir.join("AGENTS.md");
    
    if agents_path.exists() {
        match std::fs::read_to_string(&agents_path) {
            Ok(content) => {
                // Return the content with a note about which file was read
                info!("Loaded AGENTS.md from {}", agents_path.display());
                Some(format!(
                    "🤖 Agent Configuration (from AGENTS.md):\n\n{}",
                    content
                ))
            }
            Err(e) => {
                // Log the error but continue without the agents config
                error!("Failed to read AGENTS.md: {}", e);
                None
            }
        }
    } else {
        // Check for alternative names
        let alt_path = workspace_dir.join("agents.md");
        if alt_path.exists() {
            match std::fs::read_to_string(&alt_path) {
                Ok(content) => {
                    info!("Loaded agents.md from {}", alt_path.display());
                    Some(format!("🤖 Agent Configuration (from agents.md):\n\n{}", content))
                }
                Err(e) => {
                    error!("Failed to read agents.md: {}", e);
                    None
                }
            }
        } else {
            None
        }
    }
}

/// Check if we're in a project directory and read README if available
fn read_project_readme(workspace_dir: &Path) -> Option<String> {
    // Check if we're in a project directory (contains .g3 or .git)
    let is_project_dir = workspace_dir.join(".g3").exists() || workspace_dir.join(".git").exists();

    if !is_project_dir {
        return None;
    }

    // Look for README files in common formats
    let readme_names = [
        "README.md",
        "README.MD",
        "readme.md",
        "Readme.md",
        "README",
        "README.txt",
        "README.rst",
    ];

    for readme_name in &readme_names {
        let readme_path = workspace_dir.join(readme_name);
        if readme_path.exists() {
            match std::fs::read_to_string(&readme_path) {
                Ok(content) => {
                    // Return the content with a note about which file was read
                    return Some(format!(
                        "📚 Project README (from {}):\n\n{}",
                        readme_name, content
                    ));
                }
                Err(e) => {
                    // Log the error but continue looking for other README files
                    error!("Failed to read {}: {}", readme_path.display(), e);
                }
            }
        }
    }

    None
}

/// Extract the main heading or title from README content
fn extract_readme_heading(readme_content: &str) -> Option<String> {
    // Process the content line by line, skipping the prefix line if present
    let lines_iter = readme_content.lines();
    let mut content_lines = Vec::new();

    for line in lines_iter {
        // Skip the "📚 Project README (from ...):" line
        if line.starts_with("📚 Project README") {
            continue;
        }
        content_lines.push(line);
    }
    let content = content_lines.join("\n");

    // Look for the first markdown heading
    for line in content.lines() {
        let trimmed = line.trim();

        // Check for H1 heading (# Title)
        if let Some(stripped) = trimmed.strip_prefix("# ") {
            let title = stripped.trim();
            if !title.is_empty() {
                // Return the full title (including any description after dash)
                return Some(title.to_string());
            }
        }

        // Skip other markdown headings for now (##, ###, etc.)
        // We're only looking for the main H1 heading
    }

    // If no H1 heading found, look for the first non-empty, non-metadata line as a fallback
    for line in content.lines().take(5) {
        let trimmed = line.trim();
        // Skip empty lines, other heading markers, and metadata
        if !trimmed.is_empty()
            && !trimmed.starts_with("📚")
            && !trimmed.starts_with('#')
            && !trimmed.starts_with("==")
            && !trimmed.starts_with("--")
        {
            // Limit length for display
            return Some(if trimmed.len() > 100 {
                format!("{}...", &trimmed[..97])
            } else {
                trimmed.to_string()
            });
        }
    }
    None
}

async fn run_interactive_retro(
    config: Config,
    show_prompt: bool,
    show_code: bool,
    theme_name: Option<String>,
    combined_content: Option<String>,
) -> Result<()> {
    use crossterm::event::{self, Event, KeyCode, KeyModifiers};
    use std::time::Duration;

    // Set environment variable to suppress println in other crates
    std::env::set_var("G3_RETRO_MODE", "1");

    // Load the color theme
    let theme = match ColorTheme::load(theme_name.as_deref()) {
        Ok(t) => t,
        Err(e) => {
            eprintln!("Failed to load theme: {}. Using default.", e);
            ColorTheme::default()
        }
    };

    // Initialize the retro terminal UI
    let tui = RetroTui::start(theme).await?;

    // Create agent with RetroTuiWriter
    let ui_writer = RetroTuiWriter::new(tui.clone());
    let mut agent = Agent::new_with_readme_and_quiet(config, ui_writer, combined_content.clone(), false).await?;

    // Display initial system messages
    tui.output("SYSTEM: AGENT ONLINE\n\n");

    // Display message if AGENTS.md or README was loaded
    if let Some(ref content) = combined_content {
        // Check what was loaded
        let has_agents = content.contains("Agent Configuration");
        let has_readme = content.contains("Project README");
        
        if has_agents {
            tui.output("SYSTEM: AGENT CONFIGURATION LOADED\n\n");
        }
        
        if has_readme {
            // Extract the first heading or title from the README
            let readme_snippet = extract_readme_heading(content)
                .unwrap_or_else(|| "PROJECT DOCUMENTATION LOADED".to_string());
            
            tui.output(&format!(
                "SYSTEM: PROJECT README LOADED - {}\n\n",
                readme_snippet
            ));
        }
    }
    tui.output("SYSTEM: READY FOR INPUT\n\n");
    tui.output("\n\n");

    // Display provider and model information
    match agent.get_provider_info() {
        Ok((provider, model)) => {
            tui.update_provider_info(&provider, &model);
        }
        Err(e) => {
            tui.update_provider_info("ERROR", &e.to_string());
        }
    }

    // Track multiline input
    let mut multiline_buffer = String::new();
    let mut in_multiline = false;

    // Main event loop
    loop {
        // Update context window display
        let context = agent.get_context_window();
        tui.update_context(
            context.used_tokens,
            context.total_tokens,
            context.percentage_used(),
        );

        // Poll for keyboard events
        if event::poll(Duration::from_millis(50))? {
            if let Event::Key(key) = event::read()? {
                match key.code {
                    KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.exit();
                        break;
                    }
                    KeyCode::Char('d') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.exit();
                        break;
                    }
                    // Emacs/bash-like shortcuts
                    KeyCode::Char('a') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.cursor_home();
                    }
                    KeyCode::Char('e') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.cursor_end();
                    }
                    KeyCode::Char('w') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.delete_word();
                    }
                    KeyCode::Char('k') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.delete_to_end();
                    }
                    KeyCode::Char('u') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        // Delete from beginning to cursor (similar to Ctrl-K but opposite direction)
                        let (input_buffer, cursor_pos) = tui.get_input_state();
                        if cursor_pos > 0 {
                            let after = input_buffer.chars().skip(cursor_pos).collect::<String>();
                            tui.update_input(&after);
                            tui.cursor_home();
                        }
                    }
                    KeyCode::Left => {
                        tui.cursor_left();
                    }
                    KeyCode::Right => {
                        tui.cursor_right();
                    }
                    KeyCode::Home if !key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.cursor_home();
                    }
                    KeyCode::End if !key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.cursor_end();
                    }
                    KeyCode::Delete => {
                        tui.delete_char();
                    }
                    KeyCode::Enter => {
                        let (input_buffer, _) = tui.get_input_state();
                        if !input_buffer.is_empty() {
                            // Clear the input for next command
                            tui.update_input("");
                            let trimmed = input_buffer.trim_end();

                            // Check if line ends with backslash for continuation
                            if let Some(without_backslash) = trimmed.strip_suffix('\\') {
                                // Remove the backslash and add to buffer
                                multiline_buffer.push_str(without_backslash);
                                multiline_buffer.push('\n');
                                in_multiline = true;
                                tui.status("MULTILINE INPUT");
                                continue;
                            }

                            // If we're in multiline mode and no backslash, this is the final line
                            let final_input = if in_multiline {
                                multiline_buffer.push_str(&input_buffer);
                                in_multiline = false;
                                let result = multiline_buffer.clone();
                                multiline_buffer.clear();
                                tui.status("READY");
                                result
                            } else {
                                input_buffer.clone()
                            };

                            let input = final_input.trim().to_string();
                            if input.is_empty() {
                                continue;
                            }

                            if input == "exit" || input == "quit" {
                                tui.exit();
                                break;
                            }

                            // Execute the task
                            tui.output(&format!("> {}", input));
                            tui.status("PROCESSING");

                            const MAX_TIMEOUT_RETRIES: u32 = 3;
                            let mut attempt = 0;

                            loop {
                                attempt += 1;

                                match agent
                                    .execute_task_with_timing(
                                        &input,
                                        None,
                                        false,
                                        show_prompt,
                                        show_code,
                                        true,
                                    )
                                    .await
                                {
                                    Ok(result) => {
                                        if attempt > 1 {
                                            tui.output(&format!(
                                                "SYSTEM: REQUEST SUCCEEDED AFTER {} ATTEMPTS",
                                                attempt
                                            ));
                                        }
                                        tui.output(&result.response);
                                        tui.status("READY");
                                        break;
                                    }
                                    Err(e) => {
                                        // Check if this is a timeout error that we should retry
                                        let error_type = classify_error(&e);

                                        if matches!(
                                            error_type,
                                            ErrorType::Recoverable(RecoverableError::Timeout)
                                        ) && attempt < MAX_TIMEOUT_RETRIES
                                        {
                                            // Calculate retry delay with exponential backoff
                                            let delay_ms = 1000 * (2_u64.pow(attempt - 1));
                                            let delay = std::time::Duration::from_millis(delay_ms);

                                            tui.output(&format!("SYSTEM: TIMEOUT ERROR (ATTEMPT {}/{}). RETRYING IN {:?}...",
                                                attempt, MAX_TIMEOUT_RETRIES, delay));
                                            tui.status("RETRYING");

                                            // Wait before retrying
                                            tokio::time::sleep(delay).await;
                                            continue;
                                        }

                                        // For non-timeout errors or after max retries
                                        tui.error(&format!("Task execution failed: {}", e));
                                        tui.status("ERROR");
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    KeyCode::Char(c) => {
                        tui.insert_char(c);
                    }
                    KeyCode::Backspace => {
                        tui.backspace();
                    }
                    KeyCode::Up => {
                        tui.scroll_up();
                    }
                    KeyCode::Down => {
                        tui.scroll_down();
                    }
                    KeyCode::PageUp => {
                        tui.scroll_page_up();
                    }
                    KeyCode::PageDown => {
                        tui.scroll_page_down();
                    }
                    KeyCode::Home if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.scroll_home(); // Ctrl+Home for scrolling to top
                    }
                    KeyCode::End if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        tui.scroll_end(); // Ctrl+End for scrolling to bottom
                    }
                    _ => {}
                }
            }
        }

        // Small delay to prevent CPU spinning
        tokio::time::sleep(Duration::from_millis(10)).await;
    }

    tui.output("SYSTEM: SHUTDOWN INITIATED");
    Ok(())
}

async fn run_interactive<W: UiWriter>(
    mut agent: Agent<W>,
    show_prompt: bool,
    show_code: bool,
    combined_content: Option<String>,
) -> Result<()> {
    let output = SimpleOutput::new();

    output.print("");
    output.print("🪿 G3 AI Coding Agent");
    output.print("      >> what shall we build today?");
    output.print("");

    // Display provider and model information
    match agent.get_provider_info() {
        Ok((provider, model)) => {
            output.print(&format!("🔧 {} | {}", provider, model));
        }
        Err(e) => {
            error!("Failed to get provider info: {}", e);
        }
    }

    // Display message if AGENTS.md or README was loaded
    if let Some(ref content) = combined_content {
        // Check what was loaded
        let has_agents = content.contains("Agent Configuration");
        let has_readme = content.contains("Project README");
        
        if has_agents {
            output.print("🤖 AGENTS.md configuration loaded");
        }
        
        if has_readme {
            // Extract the first heading or title from the README
            let readme_snippet = extract_readme_heading(content)
                .unwrap_or_else(|| "Project documentation loaded".to_string());

            output.print(&format!("📚 detected: {}", readme_snippet));
        }
    }

    output.print("");

    // Initialize rustyline editor with history
    let mut rl = DefaultEditor::new()?;

    // Try to load history from a file in the user's home directory
    let history_file = dirs::home_dir().map(|mut path| {
        path.push(".g3_history");
        path
    });

    if let Some(ref history_path) = history_file {
        let _ = rl.load_history(history_path);
    }

    // Track multiline input
    let mut multiline_buffer = String::new();
    let mut in_multiline = false;

    loop {
        // Display context window progress bar before each prompt
        display_context_progress(&agent, &output);

        // Adjust prompt based on whether we're in multi-line mode
        let prompt = if in_multiline { "... > " } else { "g3> " };

        let readline = rl.readline(prompt);
        match readline {
            Ok(line) => {
                let trimmed = line.trim_end();

                // Check if line ends with backslash for continuation
                if let Some(without_backslash) = trimmed.strip_suffix('\\') {
                    // Remove the backslash and add to buffer
                    multiline_buffer.push_str(without_backslash);
                    multiline_buffer.push('\n');
                    in_multiline = true;
                    continue;
                }

                // If we're in multiline mode and no backslash, this is the final line
                if in_multiline {
                    multiline_buffer.push_str(&line);
                    in_multiline = false;
                    // Process the complete multiline input
                    let input = multiline_buffer.trim().to_string();
                    multiline_buffer.clear();

                    if input.is_empty() {
                        continue;
                    }

                    // Add complete multiline to history
                    rl.add_history_entry(&input)?;

                    if input == "exit" || input == "quit" {
                        break;
                    }

                    // Process the multiline input
                    execute_task(&mut agent, &input, show_prompt, show_code, &output).await;
                } else {
                    // Single line input
                    let input = line.trim().to_string();

                    if input.is_empty() {
                        continue;
                    }

                    if input == "exit" || input == "quit" {
                        break;
                    }

                    // Add to history
                    rl.add_history_entry(&input)?;

                    // Check for control commands
                    if input.starts_with('/') {
                        match input.as_str() {
                            "/help" => {
                                output.print("");
                                output.print("📖 Control Commands:");
                                output.print("  /compact   - Trigger auto-summarization (compacts conversation history)");
                                output.print("  /thinnify  - Trigger context thinning (replaces large tool results with file references)");
                                output.print("  /readme    - Reload README.md and AGENTS.md from disk");
                                output.print("  /stats     - Show detailed context and performance statistics");
                                output.print("  /help      - Show this help message");
                                output.print("  exit/quit  - Exit the interactive session");
                                output.print("");
                                continue;
                            }
                            "/compact" => {
                                output.print("🗜️ Triggering manual summarization...");
                                match agent.force_summarize().await {
                                    Ok(true) => {
                                        output.print("✅ Summarization completed successfully");
                                    }
                                    Ok(false) => {
                                        output.print("⚠️ Summarization failed");
                                    }
                                    Err(e) => {
                                        output.print(&format!("❌ Error during summarization: {}", e));
                                    }
                                }
                                continue;
                            }
                            "/thinnify" => {
                                let summary = agent.force_thin();
                                output.print_context_thinning(&summary);
                                continue;
                            }
                            "/readme" => {
                                output.print("📚 Reloading README.md and AGENTS.md...");
                                match agent.reload_readme() {
                                    Ok(true) => output.print("✅ README content reloaded successfully"),
                                    Ok(false) => output.print("⚠️ No README was loaded at startup, cannot reload"),
                                    Err(e) => output.print(&format!("❌ Error reloading README: {}", e)),
                                }
                                continue;
                            }
                            "/stats" => {
                                let stats = agent.get_stats();
                                output.print(&stats);
                                continue;
                            }
                            _ => {
                                output.print(&format!("❌ Unknown command: {}. Type /help for available commands.", input));
                                continue;
                            }
                        }
                    }

                    // Process the single line input
                    execute_task(&mut agent, &input, show_prompt, show_code, &output).await;
                }
            }
            Err(ReadlineError::Interrupted) => {
                // Ctrl-C pressed
                if in_multiline {
                    // Cancel multiline input
                    output.print("Multi-line input cancelled");
                    multiline_buffer.clear();
                    in_multiline = false;
                } else {
                    output.print("CTRL-C");
                }
                continue;
            }
            Err(ReadlineError::Eof) => {
                output.print("CTRL-D");
                break;
            }
            Err(err) => {
                error!("Error: {:?}", err);
                break;
            }
        }
    }

    // Save history before exiting
    if let Some(ref history_path) = history_file {
        let _ = rl.save_history(history_path);
    }

    output.print("👋 Goodbye!");
    Ok(())
}

async fn execute_task<W: UiWriter>(
    agent: &mut Agent<W>,
    input: &str,
    show_prompt: bool,
    show_code: bool,
    output: &SimpleOutput,
) {
    const MAX_TIMEOUT_RETRIES: u32 = 3;
    let mut attempt = 0;
    // Show thinking indicator immediately
    output.print("🤔 Thinking...");
    // Note: flush is handled internally by println

    // Create cancellation token for this request
    let cancellation_token = CancellationToken::new();
    let cancel_token_clone = cancellation_token.clone();

    loop {
        attempt += 1;

        // Execute task with cancellation support
        let execution_result = tokio::select! {
            result = agent.execute_task_with_timing_cancellable(
                input, None, false, show_prompt, show_code, true, cancellation_token.clone()
            ) => {
                result
            }
            _ = tokio::signal::ctrl_c() => {
                cancel_token_clone.cancel();
                output.print("\n⚠️  Operation cancelled by user (Ctrl+C)");
                return;
            }
        };

        match execution_result {
            Ok(result) => {
                if attempt > 1 {
                    output.print(&format!("✅ Request succeeded after {} attempts", attempt));
                }
                output.print_smart(&result.response);
                return;
            }
            Err(e) => {
                if e.to_string().contains("cancelled") {
                    output.print("⚠️  Operation cancelled by user");
                    return;
                }

                // Check if this is a timeout error that we should retry
                let error_type = classify_error(&e);

                if matches!(
                    error_type,
                    ErrorType::Recoverable(RecoverableError::Timeout)
                ) && attempt < MAX_TIMEOUT_RETRIES
                {
                    // Calculate retry delay with exponential backoff
                    let delay_ms = 1000 * (2_u64.pow(attempt - 1));
                    let delay = std::time::Duration::from_millis(delay_ms);

                    output.print(&format!(
                        "⏱️  Timeout error detected (attempt {}/{}). Retrying in {:?}...",
                        attempt, MAX_TIMEOUT_RETRIES, delay
                    ));

                    // Wait before retrying
                    tokio::time::sleep(delay).await;
                    continue;
                }

                // For non-timeout errors or after max retries, handle as before
                handle_execution_error(&e, input, output, attempt);
                return;
            }
        }
    }
}

fn handle_execution_error(e: &anyhow::Error, input: &str, output: &SimpleOutput, attempt: u32) {
    // Enhanced error logging with detailed information
    error!("=== TASK EXECUTION ERROR ===");
    error!("Error: {}", e);
    if attempt > 1 {
        error!("Failed after {} attempts", attempt);
    }

    // Log error chain
    let mut source = e.source();
    let mut depth = 1;
    while let Some(err) = source {
        error!("  Caused by [{}]: {}", depth, err);
        source = err.source();
        depth += 1;
    }

    // Log additional context
    error!("Task input: {}", input);
    error!("Error type: {}", std::any::type_name_of_val(&e));

    // Display user-friendly error message
    output.print(&format!("❌ Error: {}", e));

    // If it's a stream error, provide helpful guidance
    if e.to_string().contains("No response received") || e.to_string().contains("timed out") {
        output.print("💡 This may be a temporary issue. Please try again or check the logs for more details.");
        output.print("   Log files are saved in the 'logs/' directory.");
    }
}

fn display_context_progress<W: UiWriter>(agent: &Agent<W>, output: &SimpleOutput) {
    let context = agent.get_context_window();
    output.print_context(
        context.used_tokens,
        context.total_tokens,
        context.percentage_used(),
    );
}

/// Set up the workspace directory for autonomous mode
/// Uses G3_WORKSPACE environment variable or defaults to ~/tmp/workspace
fn setup_workspace_directory() -> Result<PathBuf> {
    let workspace_dir = if let Ok(env_workspace) = std::env::var("G3_WORKSPACE") {
        PathBuf::from(env_workspace)
    } else {
        // Default to ~/tmp/workspace
        let home_dir = dirs::home_dir()
            .ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
        home_dir.join("tmp").join("workspace")
    };

    // Create the directory if it doesn't exist
    if !workspace_dir.exists() {
        std::fs::create_dir_all(&workspace_dir)?;
        let output = SimpleOutput::new();
        output.print(&format!(
            "📁 Created workspace directory: {}",
            workspace_dir.display()
        ));
    }

    Ok(workspace_dir)
}

// Simplified autonomous mode implementation
async fn run_autonomous(
    mut agent: Agent<ConsoleUiWriter>,
    project: Project,
    show_prompt: bool,
    show_code: bool,
    max_turns: usize,
    quiet: bool,
) -> Result<()> {
    let start_time = std::time::Instant::now();
    let output = SimpleOutput::new();
    let mut turn_metrics: Vec<TurnMetrics> = Vec::new();

    output.print("🤖 G3 AI Coding Agent - Autonomous Mode");
    output.print(&format!(
        "📁 Using workspace: {}",
        project.workspace().display()
    ));

    // Check if requirements exist
    if !project.has_requirements() {
        output.print("❌ Error: requirements.md not found in workspace directory");
        output.print("   Please either:");
        output.print("   1. Create a requirements.md file with your project requirements at:");
        output.print(&format!(
            "      {}/requirements.md",
            project.workspace().display()
        ));
        output.print("   2. Or use the --requirements flag to provide requirements text directly:");
        output.print("      g3 --autonomous --requirements \"Your requirements here\"");
        output.print("");

        // Generate final report even for early exit
        let elapsed = start_time.elapsed();
        let context_window = agent.get_context_window();

        output.print(&format!("\n{}", "=".repeat(60)));
        output.print("📊 AUTONOMOUS MODE SESSION REPORT");
        output.print(&"=".repeat(60));

        output.print(&format!(
            "⏱️  Total Duration: {:.2}s",
            elapsed.as_secs_f64()
        ));
        output.print(&format!("🔄 Turns Taken: 0/{}", max_turns));
        output.print("📝 Final Status: ⚠️ NO REQUIREMENTS FILE");

        output.print("\n📈 Token Usage Statistics:");
        output.print(&format!("   • Used Tokens: {}", context_window.used_tokens));
        output.print(&format!(
            "   • Total Available: {}",
            context_window.total_tokens
        ));
        output.print(&format!(
            "   • Cumulative Tokens: {}",
            context_window.cumulative_tokens
        ));
        output.print(&format!(
            "   • Usage Percentage: {:.1}%",
            context_window.percentage_used()
        ));
        // Add per-turn histogram
        output.print(&generate_turn_histogram(&turn_metrics));
        output.print(&"=".repeat(60));

        return Ok(());
    }

    // Read requirements
    let requirements = match project.read_requirements()? {
        Some(content) => content,
        None => {
            output.print("❌ Error: Could not read requirements (neither --requirements flag nor requirements.md file provided)");

            // Generate final report even for early exit
            let elapsed = start_time.elapsed();
            let context_window = agent.get_context_window();

            output.print(&format!("\n{}", "=".repeat(60)));
            output.print("📊 AUTONOMOUS MODE SESSION REPORT");
            output.print(&"=".repeat(60));

            output.print(&format!(
                "⏱️  Total Duration: {:.2}s",
                elapsed.as_secs_f64()
            ));
            output.print(&format!("🔄 Turns Taken: 0/{}", max_turns));
            output.print("📝 Final Status: ⚠️ CANNOT READ REQUIREMENTS");

            output.print("\n📈 Token Usage Statistics:");
            output.print(&format!("   • Used Tokens: {}", context_window.used_tokens));
            output.print(&format!(
                "   • Total Available: {}",
                context_window.total_tokens
            ));
            output.print(&format!(
                "   • Cumulative Tokens: {}",
                context_window.cumulative_tokens
            ));
            output.print(&format!(
                "   • Usage Percentage: {:.1}%",
                context_window.percentage_used()
            ));
            // Add per-turn histogram
            output.print(&generate_turn_histogram(&turn_metrics));
            output.print(&"=".repeat(60));

            return Ok(());
        }
    };

    // Display appropriate message based on requirements source
    if project.requirements_text.is_some() {
        output.print("📋 Requirements loaded from --requirements flag");
    } else {
        output.print("📋 Requirements loaded from requirements.md");
    }
    output.print("🔄 Starting coach-player feedback loop...");

    // Check if implementation files already exist
    let skip_first_player = project.has_implementation_files();
    if skip_first_player {
        output.print("📂 Detected existing implementation files in workspace");
        output.print("⏭️  Skipping first player turn - proceeding directly to coach review");
    } else {
        output.print("📂 No existing implementation files detected");
        output.print("🎯 Starting with player implementation");
    }

    let mut turn = 1;
    let mut coach_feedback = String::new();
    let mut implementation_approved = false;

    loop {
        let turn_start_time = Instant::now();
        let turn_start_tokens = agent.get_context_window().used_tokens;
        // Skip player turn if it's the first turn and implementation files exist
        if !(turn == 1 && skip_first_player) {
            output.print(&format!(
                "\n=== TURN {}/{} - PLAYER MODE ===",
                turn, max_turns
            ));

            // Player mode: implement requirements (with coach feedback if available)
            let player_prompt = if coach_feedback.is_empty() {
                format!(
                    "You are G3 in implementation mode. Read and implement the following requirements:\n\n{}\n\nImplement this step by step, creating all necessary files and code.",
                    requirements
                )
            } else {
                format!(
                    "You are G3 in implementation mode. Address the following specific feedback from the coach:\n\n{}\n\nContext: You are improving an implementation based on these requirements:\n{}\n\nFocus on fixing the issues mentioned in the coach feedback above.",
                    coach_feedback, requirements
                )
            };

            output.print("🎯 Starting player implementation...");

            // Display what feedback the player is receiving
            // If there's no coach feedback on subsequent turns, this is an error
            if coach_feedback.is_empty() {
                if turn > 1 {
                    return Err(anyhow::anyhow!(
                        "Player mode error: No coach feedback received on turn {}",
                        turn
                    ));
                }
                output.print("📋 Player starting initial implementation (no prior coach feedback)");
            } else {
                output.print(&format!(
                    "📋 Player received coach feedback ({} chars):",
                    coach_feedback.len()
                ));
                output.print(&coach_feedback.to_string());
            }
            output.print(""); // Empty line for readability

            // Execute player task with retry on error
            let mut player_retry_count = 0;
            const MAX_PLAYER_RETRIES: u32 = 3;
            let mut player_failed = false;

            loop {
                match agent
                    .execute_task_with_timing(
                        &player_prompt,
                        None,
                        false,
                        show_prompt,
                        show_code,
                        true,
                    )
                    .await
                {
                    Ok(result) => {
                        // Display player's implementation result
                        output.print("📝 Player implementation completed:");
                        output.print_smart(&result.response);
                        break;
                    }
                    Err(e) => {
                        // Check if this is a panic (unrecoverable)
                        if e.to_string().contains("panic") {
                            output.print(&format!("💥 Player panic detected: {}", e));

                            // Generate final report even for panic
                            let elapsed = start_time.elapsed();
                            let context_window = agent.get_context_window();

                            output.print(&format!("\n{}", "=".repeat(60)));
                            output.print("📊 AUTONOMOUS MODE SESSION REPORT");
                            output.print(&"=".repeat(60));

                            output.print(&format!(
                                "⏱️  Total Duration: {:.2}s",
                                elapsed.as_secs_f64()
                            ));
                            output.print(&format!("🔄 Turns Taken: {}/{}", turn, max_turns));
                            output.print("📝 Final Status: 💥 PLAYER PANIC");

                            output.print("\n📈 Token Usage Statistics:");
                            output.print(&format!(
                                "   • Used Tokens: {}",
                                context_window.used_tokens
                            ));
                            output.print(&format!(
                                "   • Total Available: {}",
                                context_window.total_tokens
                            ));
                            output.print(&format!(
                                "   • Cumulative Tokens: {}",
                                context_window.cumulative_tokens
                            ));
                            output.print(&format!(
                                "   • Usage Percentage: {:.1}%",
                                context_window.percentage_used()
                            ));
                            // Add per-turn histogram
                            output.print(&generate_turn_histogram(&turn_metrics));
                            output.print(&"=".repeat(60));

                            return Err(e);
                        }

                        player_retry_count += 1;
                        output.print(&format!(
                            "⚠️ Player error (attempt {}/{}): {}",
                            player_retry_count, MAX_PLAYER_RETRIES, e
                        ));

                        if player_retry_count >= MAX_PLAYER_RETRIES {
                            output.print(
                                "🔄 Max retries reached for player, marking turn as failed...",
                            );
                            player_failed = true;
                            break; // Exit retry loop
                        }
                        output.print("🔄 Retrying player implementation...");
                    }
                }
            }

            // If player failed after max retries, increment turn and continue
            if player_failed {
                output.print(&format!(
                    "⚠️ Player turn {} failed after max retries. Moving to next turn.",
                    turn
                ));
                // Record turn metrics before incrementing
                let turn_duration = turn_start_time.elapsed();
                let turn_tokens = agent.get_context_window().used_tokens.saturating_sub(turn_start_tokens);
                turn_metrics.push(TurnMetrics {
                    turn_number: turn,
                    tokens_used: turn_tokens,
                    wall_clock_time: turn_duration,
                });
                turn += 1;

                // Check if we've reached max turns
                if turn > max_turns {
                    output.print("\n=== SESSION COMPLETED - MAX TURNS REACHED ===");
                    output.print(&format!("⏰ Maximum turns ({}) reached", max_turns));
                    break;
                }

                // Continue to next iteration with empty feedback (restart from scratch)
                coach_feedback = String::new();
                continue;
            }

            // Give some time for file operations to complete
            tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
        }

        // Create a new agent instance for coach mode to ensure fresh context
        // Use the same config with overrides that was passed to the player agent
        let base_config = agent.get_config().clone();
        let coach_config = base_config.for_coach()?;

        // Reset filter suppression state before creating coach agent
        g3_core::fixed_filter_json::reset_fixed_json_tool_state();

        let ui_writer = ConsoleUiWriter::new();
        let mut coach_agent =
            Agent::new_autonomous_with_readme_and_quiet(coach_config, ui_writer, None, quiet).await?;

        // Ensure coach agent is also in the workspace directory
        project.enter_workspace()?;

        output.print(&format!(
            "\n=== TURN {}/{} - COACH MODE ===",
            turn, max_turns
        ));

        // Coach mode: critique the implementation
        let coach_prompt = format!(
            "You are G3 in coach mode. Your role is to critique and review implementations against requirements and provide concise, actionable feedback.

REQUIREMENTS:
{}

IMPLEMENTATION REVIEW:
Review the current state of the project and provide a concise critique focusing on:
1. Whether the requirements are correctly implemented
2. Whether the project compiles successfully
3. What requirements are missing or incorrect
4. Specific improvements needed to satisfy requirements

CRITICAL INSTRUCTIONS:
1. You MUST use the final_output tool to provide your feedback
2. The summary in final_output should be CONCISE and ACTIONABLE
3. Focus ONLY on what needs to be fixed or improved
4. Do NOT include your analysis process, file contents, or compilation output in the summary

If the implementation generally meets all requirements and compiles without errors:
- Call final_output with summary: 'IMPLEMENTATION_APPROVED'

If improvements are needed:
- Call final_output with a brief summary listing ONLY the specific issues to fix

Remember: Be clear in your review and concise in your feedback. APPROVE if the implementation works and generally fits the requirements. Don't be picky.",
            requirements
        );

        output.print("🎓 Starting coach review...");

        // Execute coach task with retry on error
        let mut coach_retry_count = 0;
        const MAX_COACH_RETRIES: u32 = 3;
        let mut coach_failed = false;
        let coach_result_opt;

        loop {
            match coach_agent
                .execute_task_with_timing(&coach_prompt, None, false, show_prompt, show_code, true)
                .await
            {
                Ok(result) => {
                    coach_result_opt = Some(result);
                    break;
                }
                Err(e) => {
                    // Check if this is a panic (unrecoverable)
                    if e.to_string().contains("panic") {
                        output.print(&format!("💥 Coach panic detected: {}", e));

                        // Generate final report even for panic
                        let elapsed = start_time.elapsed();
                        let context_window = agent.get_context_window();

                        output.print(&format!("\n{}", "=".repeat(60)));
                        output.print("📊 AUTONOMOUS MODE SESSION REPORT");
                        output.print(&"=".repeat(60));

                        output.print(&format!(
                            "⏱️  Total Duration: {:.2}s",
                            elapsed.as_secs_f64()
                        ));
                        output.print(&format!("🔄 Turns Taken: {}/{}", turn, max_turns));
                        output.print("📝 Final Status: 💥 COACH PANIC");

                        output.print("\n📈 Token Usage Statistics:");
                        output.print(&format!("   • Used Tokens: {}", context_window.used_tokens));
                        output.print(&format!(
                            "   • Total Available: {}",
                            context_window.total_tokens
                        ));
                        output.print(&format!(
                            "   • Cumulative Tokens: {}",
                            context_window.cumulative_tokens
                        ));
                        output.print(&format!(
                            "   • Usage Percentage: {:.1}%",
                            context_window.percentage_used()
                        ));
                        // Add per-turn histogram
                        output.print(&generate_turn_histogram(&turn_metrics));
                        output.print(&"=".repeat(60));

                        return Err(e);
                    }

                    coach_retry_count += 1;
                    output.print(&format!(
                        "⚠️ Coach error (attempt {}/{}): {}",
                        coach_retry_count, MAX_COACH_RETRIES, e
                    ));

                    if coach_retry_count >= MAX_COACH_RETRIES {
                        output.print("🔄 Max retries reached for coach, using default feedback...");
                        // Provide default feedback and break out of retry loop
                        coach_result_opt = None;
                        coach_failed = true;
                        break; // Exit retry loop with default feedback
                    }
                    output.print("🔄 Retrying coach review...");
                }
            }
        }

        output.print("🎓 Coach review completed");

        // If coach failed after max retries, increment turn and continue with default feedback
        if coach_failed {
            output.print(&format!(
                "⚠️ Coach turn {} failed after max retries. Using default feedback.",
                turn
            ));
            coach_feedback = "The implementation needs review. Please ensure all requirements are met and the code compiles without errors.".to_string();
            // Record turn metrics before incrementing
            let turn_duration = turn_start_time.elapsed();
            let turn_tokens = agent.get_context_window().used_tokens.saturating_sub(turn_start_tokens);
            turn_metrics.push(TurnMetrics {
                turn_number: turn,
                tokens_used: turn_tokens,
                wall_clock_time: turn_duration,
            });
            turn += 1;

            if turn > max_turns {
                output.print("\n=== SESSION COMPLETED - MAX TURNS REACHED ===");
                output.print(&format!("⏰ Maximum turns ({}) reached", max_turns));
                break;
            }
            continue; // Continue to next iteration with default feedback
        }

        // We have a valid coach result, process it
        let coach_result = coach_result_opt.unwrap();

        // Extract the complete coach feedback from final_output
        let coach_feedback_text =
            extract_coach_feedback_from_logs(&coach_result, &coach_agent, &output)?;

        // Log the size of the feedback for debugging
        info!(
            "Coach feedback extracted: {} characters (from {} total)",
            coach_feedback_text.len(),
            coach_result.response.len()
        );

        // Check if we got empty feedback (this can happen if the coach doesn't call final_output)
        if coach_feedback_text.is_empty() {
            output.print("⚠️ Coach did not provide feedback. This may be a model issue.");
            coach_feedback = "The implementation needs review. Please ensure all requirements are met and the code compiles without errors.".to_string();
            // Record turn metrics before incrementing
            let turn_duration = turn_start_time.elapsed();
            let turn_tokens = agent.get_context_window().used_tokens.saturating_sub(turn_start_tokens);
            turn_metrics.push(TurnMetrics {
                turn_number: turn,
                tokens_used: turn_tokens,
                wall_clock_time: turn_duration,
            });
            turn += 1;
            continue;
        }

        output.print_smart(&format!("Coach feedback:\n{}", coach_feedback_text));

        // Check if coach approved the implementation
        if coach_result.is_approved() || coach_feedback_text.contains("IMPLEMENTATION_APPROVED") {
            output.print("\n=== SESSION COMPLETED - IMPLEMENTATION APPROVED ===");
            output.print("✅ Coach approved the implementation!");
            implementation_approved = true;
            break;
        }

        // Check if we've reached max turns
        if turn >= max_turns {
            output.print("\n=== SESSION COMPLETED - MAX TURNS REACHED ===");
            output.print(&format!("⏰ Maximum turns ({}) reached", max_turns));
            break;
        }

        // Store coach feedback for next iteration
        coach_feedback = coach_feedback_text;
        // Record turn metrics before incrementing
        let turn_duration = turn_start_time.elapsed();
        let turn_tokens = agent.get_context_window().used_tokens.saturating_sub(turn_start_tokens);
        turn_metrics.push(TurnMetrics {
            turn_number: turn,
            tokens_used: turn_tokens,
            wall_clock_time: turn_duration,
        });
        turn += 1;

        output.print("🔄 Coach provided feedback for next iteration");
    }

    // Generate final report
    let elapsed = start_time.elapsed();
    let context_window = agent.get_context_window();

    output.print(&format!("\n{}", "=".repeat(60)));
    output.print("📊 AUTONOMOUS MODE SESSION REPORT");
    output.print(&"=".repeat(60));

    output.print(&format!(
        "⏱️  Total Duration: {:.2}s",
        elapsed.as_secs_f64()
    ));
    output.print(&format!("🔄 Turns Taken: {}/{}", turn, max_turns));
    output.print(&format!(
        "📝 Final Status: {}",
        if implementation_approved {
            "✅ APPROVED"
        } else if turn >= max_turns {
            "⏰ MAX TURNS REACHED"
        } else {
            "⚠️ INCOMPLETE"
        }
    ));

    output.print("\n📈 Token Usage Statistics:");
    output.print(&format!("   • Used Tokens: {}", context_window.used_tokens));
    output.print(&format!(
        "   • Total Available: {}",
        context_window.total_tokens
    ));
    output.print(&format!(
        "   • Cumulative Tokens: {}",
        context_window.cumulative_tokens
    ));
    output.print(&format!(
        "   • Usage Percentage: {:.1}%",
        context_window.percentage_used()
    ));
    
    // Add per-turn histogram
    output.print(&generate_turn_histogram(&turn_metrics));
    output.print(&"=".repeat(60));

    if implementation_approved {
        output.print("\n🎉 Autonomous mode completed successfully");
    } else {
        output.print("\n🔄 Autonomous mode terminated (max iterations)");
    }

    Ok(())
}