use ratatui::layout::Constraint;use ratatui::layout::Direction;use ratatui::layout::Layout;use ratatui::prelude::*;use ratatui::style::Color;use ratatui::style::Modifier;use ratatui::style::Style;use ratatui::style::Stylize;use ratatui::widgets::Block;use ratatui::widgets::BorderType;use ratatui::widgets::Borders;use ratatui::widgets::Clear;use ratatui::widgets::List;use ratatui::widgets::ListItem;use ratatui::widgets::ListState;use ratatui::widgets::Padding;use ratatui::widgets::Paragraph;use std::sync::OnceLock;use std::time::Instant;use crate::app::App;use crate::app::AttemptView;use crate::util::format_relative_time_now;use codex_cloud_tasks_client::AttemptStatus;use codex_cloud_tasks_client::TaskStatus;use codex_tui::render_markdown_text;pub fn draw(frame: &mut Frame, app: &mut App) {    let area = frame.area();    let chunks = Layout::default()        .direction(Direction::Vertical)        .constraints([            Constraint::Min(1),    // list            Constraint::Length(2), // two-line footer (help + status)        ])        .split(area);    if app.new_task.is_some() {        draw_new_task_page(frame, chunks[0], app);        draw_footer(frame, chunks[1], app);    } else {        draw_list(frame, chunks[0], app);        draw_footer(frame, chunks[1], app);    }    if app.diff_overlay.is_some() {        draw_diff_overlay(frame, area, app);    }    if app.env_modal.is_some() {        draw_env_modal(frame, area, app);    }    if app.best_of_modal.is_some() {        draw_best_of_modal(frame, area, app);    }    if app.apply_modal.is_some() {        draw_apply_modal(frame, area, app);    }}// ===== Overlay helpers (geometry + styling) =====static ROUNDED: OnceLock<bool> = OnceLock::new();fn rounded_enabled() -> bool {    *ROUNDED.get_or_init(|| {        std::env::var("CODEX_TUI_ROUNDED")            .ok()            .map(|v| v == "1")            .unwrap_or(true)    })}fn overlay_outer(area: Rect) -> Rect {    let outer_v = Layout::default()        .direction(Direction::Vertical)        .constraints([            Constraint::Percentage(10),            Constraint::Percentage(80),            Constraint::Percentage(10),        ])        .split(area)[1];    Layout::default()        .direction(Direction::Horizontal)        .constraints([            Constraint::Percentage(10),            Constraint::Percentage(80),            Constraint::Percentage(10),        ])        .split(outer_v)[1]}fn overlay_block() -> Block<'static> {    let base = Block::default().borders(Borders::ALL);    let base = if rounded_enabled() {        base.border_type(BorderType::Rounded)    } else {        base    };    base.padding(Padding::new(2, 2, 1, 1))}fn overlay_content(area: Rect) -> Rect {    overlay_block().inner(area)}pub fn draw_new_task_page(frame: &mut Frame, area: Rect, app: &mut App) {    let title_spans = {        let mut spans: Vec<ratatui::text::Span> = vec!["New Task".magenta().bold()];        if let Some(id) = app            .new_task            .as_ref()            .and_then(|p| p.env_id.as_ref())            .cloned()        {            spans.push("  • ".into());            // Try to map id to label            let label = app                .environments                .iter()                .find(|r| r.id == id)                .and_then(|r| r.label.clone())                .unwrap_or(id);            spans.push(label.dim());        } else {            spans.push("  • ".into());            spans.push("Env: none (press ctrl-o to choose)".red());        }        if let Some(page) = app.new_task.as_ref() {            spans.push("  • ".into());            let attempts = page.best_of_n;            let label = format!(                "{} attempt{}",                attempts,                if attempts == 1 { "" } else { "s" }            );            spans.push(label.cyan());        }        spans    };    let block = Block::default()        .borders(Borders::ALL)        .title(Line::from(title_spans));    frame.render_widget(Clear, area);    frame.render_widget(block.clone(), area);    let content = block.inner(area);    // Expand composer height up to (terminal height - 6), with a 3-line minimum.    let max_allowed = frame.area().height.saturating_sub(6).max(3);    let desired = app        .new_task        .as_ref()        .map(|p| p.composer.desired_height(content.width))        .unwrap_or(3)        .clamp(3, max_allowed);    // Anchor the composer to the bottom-left by allocating a flexible spacer    // above it and a fixed `desired`-height area for the composer.    let rows = Layout::default()        .direction(Direction::Vertical)        .constraints([Constraint::Min(1), Constraint::Length(desired)])        .split(content);    let composer_area = rows[1];    if let Some(page) = app.new_task.as_ref() {        page.composer.render_ref(composer_area, frame.buffer_mut());        // Composer renders its own footer hints; no extra row here.    }    // Place cursor where composer wants it    if let Some(page) = app.new_task.as_ref()        && let Some((x, y)) = page.composer.cursor_pos(composer_area)    {        frame.set_cursor_position((x, y));    }}fn draw_list(frame: &mut Frame, area: Rect, app: &mut App) {    let items: Vec<ListItem> = app.tasks.iter().map(|t| render_task_item(app, t)).collect();    // Selection reflects the actual task index (no artificial spacer item).    let mut state = ListState::default().with_selected(Some(app.selected));    // Dim task list when a modal/overlay is active to emphasize focus.    let dim_bg = app.env_modal.is_some()        || app.apply_modal.is_some()        || app.best_of_modal.is_some()        || app.diff_overlay.is_some();    // Dynamic title includes current environment filter    let suffix_span = if let Some(ref id) = app.env_filter {        let label = app            .environments            .iter()            .find(|r| &r.id == id)            .and_then(|r| r.label.clone())            .unwrap_or_else(|| "Selected".to_string());        format!(" • {label}").dim()    } else {        " • All".dim()    };    // Percent scrolled based on selection position in the list (0% at top, 100% at bottom).    let percent_span = if app.tasks.len() <= 1 {        "  • 0%".dim()    } else {        let p = ((app.selected as f32) / ((app.tasks.len() - 1) as f32) * 100.0).round() as i32;        format!("  • {}%", p.clamp(0, 100)).dim()    };    let title_line = {        let base = Line::from(vec!["Cloud Tasks".into(), suffix_span, percent_span]);        if dim_bg {            base.style(Style::default().add_modifier(Modifier::DIM))        } else {            base        }    };    let block = Block::default().borders(Borders::ALL).title(title_line);    // Render the outer block first    frame.render_widget(block.clone(), area);    // Draw list inside with a persistent top spacer row    let inner = block.inner(area);    let rows = Layout::default()        .direction(Direction::Vertical)        .constraints([Constraint::Length(1), Constraint::Min(1)])        .split(inner);    let mut list = List::new(items)        .highlight_symbol("› ")        .highlight_style(Style::default().bold());    if dim_bg {        list = list.style(Style::default().add_modifier(Modifier::DIM));    }    frame.render_stateful_widget(list, rows[1], &mut state);    // In-box spinner during initial/refresh loads    if app.refresh_inflight {        draw_centered_spinner(frame, inner, &mut app.spinner_start, "Loading tasks…");    }}fn draw_footer(frame: &mut Frame, area: Rect, app: &mut App) {    let mut help = vec![        "↑/↓".dim(),        ": Move  ".dim(),        "r".dim(),        ": Refresh  ".dim(),        "Enter".dim(),        ": Open  ".dim(),    ];    // Apply hint; show disabled note when overlay is open without a diff.    if let Some(ov) = app.diff_overlay.as_ref() {        if !ov.current_can_apply() {            help.push("a".dim());            help.push(": Apply (disabled)  ".dim());        } else {            help.push("a".dim());            help.push(": Apply  ".dim());        }        if ov.attempt_count() > 1 {            help.push("Tab".dim());            help.push(": Next attempt  ".dim());            help.push("[ ]".dim());            help.push(": Cycle attempts  ".dim());        }    } else {        help.push("a".dim());        help.push(": Apply  ".dim());    }    help.push("o : Set Env  ".dim());    if app.new_task.is_some() {        help.push("Ctrl+N".dim());        help.push(format!(": Attempts {}x  ", app.best_of_n).dim());        help.push("(editing new task)  ".dim());    } else {        help.push("n : New Task  ".dim());    }    help.extend(vec!["q".dim(), ": Quit  ".dim()]);    // Split footer area into two rows: help+spinner (top) and status (bottom)    let rows = Layout::default()        .direction(Direction::Vertical)        .constraints([Constraint::Length(1), Constraint::Length(1)])        .split(area);    // Top row: help text + spinner at right    let top = Layout::default()        .direction(Direction::Horizontal)        .constraints([Constraint::Fill(1), Constraint::Length(18)])        .split(rows[0]);    let para = Paragraph::new(Line::from(help));    // Draw help text; avoid clearing the whole footer area every frame.    frame.render_widget(para, top[0]);    // Right side: spinner or clear the spinner area if idle to prevent stale glyphs.    if app.refresh_inflight        || app.details_inflight        || app.env_loading        || app.apply_preflight_inflight        || app.apply_inflight    {        draw_inline_spinner(frame, top[1], &mut app.spinner_start, "Loading…");    } else {        frame.render_widget(Clear, top[1]);    }    // Bottom row: status/log text across full width (single-line; sanitize newlines)    let mut status_line = app.status.replace('\n', " ");    if status_line.len() > 2000 {        // hard cap to avoid TUI noise        status_line.truncate(2000);        status_line.push('…');    }    // Clear the status row to avoid trailing characters when the message shrinks.    frame.render_widget(Clear, rows[1]);    let status = Paragraph::new(status_line);    frame.render_widget(status, rows[1]);}fn draw_diff_overlay(frame: &mut Frame, area: Rect, app: &mut App) {    let inner = overlay_outer(area);    if app.diff_overlay.is_none() {        return;    }    let ov_can_apply = app        .diff_overlay        .as_ref()        .map(super::app::DiffOverlay::current_can_apply)        .unwrap_or(false);    let is_error = app        .diff_overlay        .as_ref()        .and_then(|o| o.sd.wrapped_lines().first().cloned())        .map(|s| s.trim_start().starts_with("Task failed:"))        .unwrap_or(false)        && !ov_can_apply;    let title = app        .diff_overlay        .as_ref()        .map(|o| o.title.clone())        .unwrap_or_default();    // Title block    let title_ref = title.as_str();    let mut title_spans: Vec<ratatui::text::Span> = if is_error {        vec![            "Details ".magenta(),            "[FAILED]".red().bold(),            " ".into(),            title_ref.magenta(),        ]    } else if ov_can_apply {        vec!["Diff: ".magenta(), title_ref.magenta()]    } else {        vec!["Details: ".magenta(), title_ref.magenta()]    };    if let Some(p) = app        .diff_overlay        .as_ref()        .and_then(|o| o.sd.percent_scrolled())    {        title_spans.push("  • ".dim());        title_spans.push(format!("{p}%").dim());    }    frame.render_widget(Clear, inner);    frame.render_widget(        overlay_block().title(Line::from(title_spans)).clone(),        inner,    );    // Content area and optional status bar    let content_full = overlay_content(inner);    let mut content_area = content_full;    if let Some(ov) = app.diff_overlay.as_mut() {        let has_text = ov.current_attempt().is_some_and(AttemptView::has_text);        let has_diff = ov.current_attempt().is_some_and(AttemptView::has_diff) || ov.base_can_apply;        if has_diff || has_text {            let rows = Layout::default()                .direction(Direction::Vertical)                .constraints([Constraint::Length(1), Constraint::Min(1)])                .split(content_full);            // Status bar label            let mut spans: Vec<ratatui::text::Span> = Vec::new();            if has_diff && has_text {                let prompt_lbl = if matches!(ov.current_view, crate::app::DetailView::Prompt) {                    "[Prompt]".magenta().bold()                } else {                    "Prompt".dim()                };                let diff_lbl = if matches!(ov.current_view, crate::app::DetailView::Diff) {                    "[Diff]".magenta().bold()                } else {                    "Diff".dim()                };                spans.extend(vec![                    prompt_lbl,                    "  ".into(),                    diff_lbl,                    "  ".into(),                    "(← → to switch view)".dim(),                ]);            } else if has_text {                spans.push("Conversation".magenta().bold());            } else {                spans.push("Diff".magenta().bold());            }            if let Some(total) = ov.expected_attempts().or({                if ov.attempts.is_empty() {                    None                } else {                    Some(ov.attempts.len())                }            }) && total > 1            {                spans.extend(vec![                    "  ".into(),                    format!("Attempt {}/{}", ov.selected_attempt + 1, total)                        .bold()                        .dim(),                    "  ".into(),                    "(Tab/Shift-Tab or [ ] to cycle attempts)".dim(),                ]);            }            frame.render_widget(Paragraph::new(Line::from(spans)), rows[0]);            ov.sd.set_width(rows[1].width);            ov.sd.set_viewport(rows[1].height);            content_area = rows[1];        } else {            ov.sd.set_width(content_full.width);            ov.sd.set_viewport(content_full.height);            content_area = content_full;        }    }    // Styled content render    // Choose styling by the active view, not just presence of a diff    let is_diff_view = app        .diff_overlay        .as_ref()        .map(|o| matches!(o.current_view, crate::app::DetailView::Diff))        .unwrap_or(false);    let styled_lines: Vec<Line<'static>> = if is_diff_view {        let raw = app.diff_overlay.as_ref().map(|o| o.sd.wrapped_lines());        raw.unwrap_or(&[])            .iter()            .map(|l| style_diff_line(l))            .collect()    } else {        app.diff_overlay            .as_ref()            .map(|o| style_conversation_lines(&o.sd, o.current_attempt()))            .unwrap_or_default()    };    let raw_empty = app        .diff_overlay        .as_ref()        .map(|o| o.sd.wrapped_lines().is_empty())        .unwrap_or(true);    if app.details_inflight && raw_empty {        draw_centered_spinner(            frame,            content_area,            &mut app.spinner_start,            "Loading details…",        );    } else {        let scroll = app            .diff_overlay            .as_ref()            .map(|o| o.sd.state.scroll)            .unwrap_or(0);        let content = Paragraph::new(Text::from(styled_lines)).scroll((scroll, 0));        frame.render_widget(content, content_area);    }}pub fn draw_apply_modal(frame: &mut Frame, area: Rect, app: &mut App) {    use ratatui::widgets::Wrap;    let inner = overlay_outer(area);    let title = Line::from("Apply Changes?".magenta().bold());    let block = overlay_block().title(title);    frame.render_widget(Clear, inner);    frame.render_widget(block.clone(), inner);    let content = overlay_content(inner);    if let Some(m) = &app.apply_modal {        // Header        let header = Paragraph::new(Line::from(            format!("Apply '{}' ?", m.title).magenta().bold(),        ))        .wrap(Wrap { trim: true });        // Footer instructions        let footer =            Paragraph::new(Line::from("Press Y to apply, P to preflight, N to cancel.").dim())                .wrap(Wrap { trim: true });        // Split into header/body/footer        let rows = Layout::default()            .direction(Direction::Vertical)            .constraints([                Constraint::Length(1),                Constraint::Min(1),                Constraint::Length(1),            ])            .split(content);        frame.render_widget(header, rows[0]);        // Body: spinner while preflight/apply runs; otherwise show result message and path lists        if app.apply_preflight_inflight {            draw_centered_spinner(frame, rows[1], &mut app.spinner_start, "Checking…");        } else if app.apply_inflight {            draw_centered_spinner(frame, rows[1], &mut app.spinner_start, "Applying…");        } else if m.result_message.is_none() {            draw_centered_spinner(frame, rows[1], &mut app.spinner_start, "Loading…");        } else if let Some(msg) = &m.result_message {            let mut body_lines: Vec<Line> = Vec::new();            let first = match m.result_level {                Some(crate::app::ApplyResultLevel::Success) => msg.clone().green(),                Some(crate::app::ApplyResultLevel::Partial) => msg.clone().magenta(),                Some(crate::app::ApplyResultLevel::Error) => msg.clone().red(),                None => msg.clone().into(),            };            body_lines.push(Line::from(first));            // On partial or error, show conflicts/skips if present            if !matches!(m.result_level, Some(crate::app::ApplyResultLevel::Success)) {                use ratatui::text::Span;                if !m.conflict_paths.is_empty() {                    body_lines.push(Line::from(""));                    body_lines.push(                        Line::from(format!("Conflicts ({}):", m.conflict_paths.len()))                            .red()                            .bold(),                    );                    for p in &m.conflict_paths {                        body_lines                            .push(Line::from(vec!["  • ".into(), Span::raw(p.clone()).dim()]));                    }                }                if !m.skipped_paths.is_empty() {                    body_lines.push(Line::from(""));                    body_lines.push(                        Line::from(format!("Skipped ({}):", m.skipped_paths.len()))                            .magenta()                            .bold(),                    );                    for p in &m.skipped_paths {                        body_lines                            .push(Line::from(vec!["  • ".into(), Span::raw(p.clone()).dim()]));                    }                }            }            let body = Paragraph::new(body_lines).wrap(Wrap { trim: true });            frame.render_widget(body, rows[1]);        }        frame.render_widget(footer, rows[2]);    }}#[derive(Clone, Copy, Debug, PartialEq, Eq)]enum ConversationSpeaker {    User,    Assistant,}fn style_conversation_lines(    sd: &crate::scrollable_diff::ScrollableDiff,    attempt: Option<&AttemptView>,) -> Vec<Line<'static>> {    use ratatui::text::Span;    let wrapped = sd.wrapped_lines();    if wrapped.is_empty() {        return Vec::new();    }    let indices = sd.wrapped_src_indices();    let mut styled: Vec<Line<'static>> = Vec::new();    let mut speaker: Option<ConversationSpeaker> = None;    let mut in_code = false;    let mut last_src: Option<usize> = None;    let mut bullet_indent: Option<usize> = None;    for (display, &src_idx) in wrapped.iter().zip(indices.iter()) {        let raw = sd.raw_line_at(src_idx);        let trimmed = raw.trim();        let is_new_raw = last_src.map(|prev| prev != src_idx).unwrap_or(true);        if trimmed.eq_ignore_ascii_case("user:") {            speaker = Some(ConversationSpeaker::User);            in_code = false;            bullet_indent = None;            styled.push(conversation_header_line(                ConversationSpeaker::User,                /*attempt*/ None,            ));            last_src = Some(src_idx);            continue;        }        if trimmed.eq_ignore_ascii_case("assistant:") {            speaker = Some(ConversationSpeaker::Assistant);            in_code = false;            bullet_indent = None;            styled.push(conversation_header_line(                ConversationSpeaker::Assistant,                attempt,            ));            last_src = Some(src_idx);            continue;        }        if raw.is_empty() {            let mut spans: Vec<Span> = Vec::new();            if let Some(role) = speaker {                spans.push(conversation_gutter_span(role));            } else {                spans.push(Span::raw(String::new()));            }            styled.push(Line::from(spans));            last_src = Some(src_idx);            bullet_indent = None;            continue;        }        if is_new_raw {            let trimmed_start = raw.trim_start();            if trimmed_start.starts_with("```") {                in_code = !in_code;                bullet_indent = None;            } else if !in_code                && (trimmed_start.starts_with("- ") || trimmed_start.starts_with("* "))            {                let indent = raw.chars().take_while(|c| c.is_whitespace()).count();                bullet_indent = Some(indent);            } else if !in_code {                bullet_indent = None;            }        }        let mut spans: Vec<Span> = Vec::new();        if let Some(role) = speaker {            spans.push(conversation_gutter_span(role));        }        spans.extend(conversation_text_spans(            display,            in_code,            is_new_raw,            bullet_indent,        ));        styled.push(Line::from(spans));        last_src = Some(src_idx);    }    if styled.is_empty() {        wrapped.iter().map(|l| Line::from(l.to_string())).collect()    } else {        styled    }}fn conversation_header_line(    speaker: ConversationSpeaker,    attempt: Option<&AttemptView>,) -> Line<'static> {    use ratatui::text::Span;    let mut spans: Vec<Span> = vec!["╭ ".dim()];    match speaker {        ConversationSpeaker::User => {            spans.push("User".cyan().bold());            spans.push(" prompt".dim());        }        ConversationSpeaker::Assistant => {            spans.push("Assistant".magenta().bold());            spans.push(" response".dim());            if let Some(attempt) = attempt                && let Some(status_span) = attempt_status_span(attempt.status)            {                spans.push("  • ".dim());                spans.push(status_span);            }        }    }    Line::from(spans)}fn conversation_gutter_span(speaker: ConversationSpeaker) -> ratatui::text::Span<'static> {    match speaker {        ConversationSpeaker::User => "│ ".cyan().dim(),        ConversationSpeaker::Assistant => "│ ".magenta().dim(),    }}fn conversation_text_spans(    display: &str,    in_code: bool,    is_new_raw: bool,    bullet_indent: Option<usize>,) -> Vec<ratatui::text::Span<'static>> {    use ratatui::text::Span;    if in_code {        return vec![Span::styled(            display.to_string(),            Style::default().fg(Color::Cyan),        )];    }    let trimmed = display.trim_start();    if let Some(indent) = bullet_indent {        if is_new_raw {            let rest = trimmed.get(2..).unwrap_or("").trim_start();            let mut spans: Vec<Span> = Vec::new();            if indent > 0 {                spans.push(Span::raw(" ".repeat(indent)));            }            spans.push("• ".into());            spans.push(Span::raw(rest.to_string()));            return spans;        }        let mut continuation = String::new();        continuation.push_str(&" ".repeat(indent + 2));        continuation.push_str(trimmed);        return vec![Span::raw(continuation)];    }    if is_new_raw        && (trimmed.starts_with("### ") || trimmed.starts_with("## ") || trimmed.starts_with("# "))    {        return vec![Span::styled(            display.to_string(),            Style::default()                .fg(Color::Magenta)                .add_modifier(Modifier::BOLD),        )];    }    let mut rendered = render_markdown_text(display);    if rendered.lines.is_empty() {        return vec![Span::raw(display.to_string())];    }    // `render_markdown_text` can yield multiple lines when the input contains    // explicit breaks. We only expect a single line here; join the spans of the    // first rendered line for styling.    rendered.lines.remove(0).spans.into_iter().collect()}fn attempt_status_span(status: AttemptStatus) -> Option<ratatui::text::Span<'static>> {    match status {        AttemptStatus::Completed => Some("Completed".green()),        AttemptStatus::Failed => Some("Failed".red().bold()),        AttemptStatus::InProgress => Some("In progress".magenta()),        AttemptStatus::Pending => Some("Pending".cyan()),        AttemptStatus::Cancelled => Some("Cancelled".dim()),        AttemptStatus::Unknown => None,    }}fn style_diff_line(raw: &str) -> Line<'static> {    use ratatui::style::Color;    use ratatui::style::Modifier;    use ratatui::style::Style;    use ratatui::text::Span;    if raw.starts_with("@@") {        return Line::from(vec![Span::styled(            raw.to_string(),            Style::default()                .fg(Color::Magenta)                .add_modifier(Modifier::BOLD),        )]);    }    if raw.starts_with("+++") || raw.starts_with("---") {        return Line::from(vec![Span::styled(            raw.to_string(),            Style::default().add_modifier(Modifier::DIM),        )]);    }    if raw.starts_with('+') {        return Line::from(vec![Span::styled(            raw.to_string(),            Style::default().fg(Color::Green),        )]);    }    if raw.starts_with('-') {        return Line::from(vec![Span::styled(            raw.to_string(),            Style::default().fg(Color::Red),        )]);    }    Line::from(vec![Span::raw(raw.to_string())])}fn render_task_item(_app: &App, t: &codex_cloud_tasks_client::TaskSummary) -> ListItem<'static> {    let status = match t.status {        TaskStatus::Ready => "READY".green(),        TaskStatus::Pending => "PENDING".magenta(),        TaskStatus::Applied => "APPLIED".blue(),        TaskStatus::Error => "ERROR".red(),    };    // Title line: [STATUS] Title    let title = Line::from(vec![        "[".into(),        status,        "] ".into(),        t.title.clone().into(),    ]);    // Meta line: environment label and relative time (dim)    let mut meta: Vec<ratatui::text::Span> = Vec::new();    if let Some(lbl) = t.environment_label.as_ref().filter(|s| !s.is_empty()) {        meta.push(lbl.clone().dim());    }    let when = format_relative_time_now(t.updated_at).dim();    if !meta.is_empty() {        meta.push("  ".into());        meta.push("•".dim());        meta.push("  ".into());    }    meta.push(when);    let meta_line = Line::from(meta);    // Subline: summary when present; otherwise show "no diff"    let sub = if t.summary.files_changed > 0        || t.summary.lines_added > 0        || t.summary.lines_removed > 0    {        let adds = t.summary.lines_added;        let dels = t.summary.lines_removed;        let files = t.summary.files_changed;        Line::from(vec![            format!("+{adds}").green(),            "/".into(),            format!("−{dels}").red(),            " ".into(),            "•".dim(),            " ".into(),            format!("{files}").into(),            " ".into(),            "files".dim(),        ])    } else {        Line::from("no diff".to_string().dim())    };    // Insert a blank spacer line after the summary to separate tasks    let spacer = Line::from("");    ListItem::new(vec![title, meta_line, sub, spacer])}fn draw_inline_spinner(    frame: &mut Frame,    area: Rect,    spinner_start: &mut Option<Instant>,    label: &str,) {    use ratatui::widgets::Paragraph;    let start = spinner_start.get_or_insert_with(Instant::now);    let blink_on = (start.elapsed().as_millis() / 600).is_multiple_of(2);    let dot = if blink_on {        "• ".into()    } else {        "◦ ".dim()    };    let label = label.cyan();    let line = Line::from(vec![dot, label]);    frame.render_widget(Paragraph::new(line), area);}fn draw_centered_spinner(    frame: &mut Frame,    area: Rect,    spinner_start: &mut Option<Instant>,    label: &str,) {    // Center a 1xN spinner within the given rect    let rows = Layout::default()        .direction(Direction::Vertical)        .constraints([            Constraint::Percentage(50),            Constraint::Length(1),            Constraint::Percentage(49),        ])        .split(area);    let cols = Layout::default()        .direction(Direction::Horizontal)        .constraints([            Constraint::Percentage(50),            Constraint::Length(18),            Constraint::Percentage(50),        ])        .split(rows[1]);    draw_inline_spinner(frame, cols[1], spinner_start, label);}// Styling helpers for diff rendering live inline where used.pub fn draw_env_modal(frame: &mut Frame, area: Rect, app: &mut App) {    use ratatui::widgets::Wrap;    // Use shared overlay geometry and padding.    let inner = overlay_outer(area);    // Title: primary only; move long hints to a subheader inside content.    let title = Line::from(vec!["Select Environment".magenta().bold()]);    let block = overlay_block().title(title);    frame.render_widget(Clear, inner);    frame.render_widget(block.clone(), inner);    let content = overlay_content(inner);    if app.env_loading {        draw_centered_spinner(            frame,            content,            &mut app.spinner_start,            "Loading environments…",        );        return;    }    // Layout: subheader + search + results list    let rows = Layout::default()        .direction(Direction::Vertical)        .constraints([            Constraint::Length(1), // subheader            Constraint::Length(1), // search            Constraint::Min(1),    // list        ])        .split(content);    // Subheader with usage hints (dim cyan)    let subheader = Paragraph::new(Line::from(        "Type to search, Enter select, Esc cancel".cyan().dim(),    ))    .wrap(Wrap { trim: true });    frame.render_widget(subheader, rows[0]);    let query = app        .env_modal        .as_ref()        .map(|m| m.query.clone())        .unwrap_or_default();    let ql = query.to_lowercase();    let search = Paragraph::new(format!("Search: {query}")).wrap(Wrap { trim: true });    frame.render_widget(search, rows[1]);    // Filter environments by query (case-insensitive substring over label/id/hints)    let envs: Vec<&crate::app::EnvironmentRow> = app        .environments        .iter()        .filter(|e| {            if ql.is_empty() {                return true;            }            let mut hay = String::new();            if let Some(l) = &e.label {                hay.push_str(&l.to_lowercase());                hay.push(' ');            }            hay.push_str(&e.id.to_lowercase());            if let Some(h) = &e.repo_hints {                hay.push(' ');                hay.push_str(&h.to_lowercase());            }            hay.contains(&ql)        })        .collect();    let mut items: Vec<ListItem> = Vec::new();    items.push(ListItem::new(Line::from("All Environments (Global)")));    for env in envs.iter() {        let primary = env.label.clone().unwrap_or_else(|| "<unnamed>".to_string());        let mut spans: Vec<ratatui::text::Span> = vec![primary.into()];        if env.is_pinned {            spans.push("  ".into());            spans.push("PINNED".magenta().bold());        }        spans.push("  ".into());        spans.push(env.id.clone().dim());        if let Some(hint) = &env.repo_hints {            spans.push("  ".into());            spans.push(hint.clone().dim());        }        items.push(ListItem::new(Line::from(spans)));    }    let sel_desired = app.env_modal.as_ref().map(|m| m.selected).unwrap_or(0);    let sel = sel_desired.min(envs.len());    let mut list_state = ListState::default().with_selected(Some(sel));    let list = List::new(items)        .highlight_symbol("› ")        .highlight_style(Style::default().bold())        .block(Block::default().borders(Borders::NONE));    frame.render_stateful_widget(list, rows[2], &mut list_state);}pub fn draw_best_of_modal(frame: &mut Frame, area: Rect, app: &mut App) {    use ratatui::widgets::Wrap;    let inner = overlay_outer(area);    const MAX_WIDTH: u16 = 40;    const MIN_WIDTH: u16 = 20;    const MAX_HEIGHT: u16 = 12;    const MIN_HEIGHT: u16 = 6;    let modal_width = inner.width.min(MAX_WIDTH).max(inner.width.min(MIN_WIDTH));    let modal_height = inner        .height        .min(MAX_HEIGHT)        .max(inner.height.min(MIN_HEIGHT));    let modal_x = inner.x + (inner.width.saturating_sub(modal_width)) / 2;    let modal_y = inner.y + (inner.height.saturating_sub(modal_height)) / 2;    let modal_area = Rect::new(modal_x, modal_y, modal_width, modal_height);    let title = Line::from(vec!["Parallel Attempts".magenta().bold()]);    let block = overlay_block().title(title);    frame.render_widget(Clear, modal_area);    frame.render_widget(block.clone(), modal_area);    let content = overlay_content(modal_area);    let rows = Layout::default()        .direction(Direction::Vertical)        .constraints([Constraint::Length(2), Constraint::Min(1)])        .split(content);    let hint = Paragraph::new(Line::from("Use ↑/↓ to choose, 1-4 jump".cyan().dim()))        .wrap(Wrap { trim: true });    frame.render_widget(hint, rows[0]);    let selected = app.best_of_modal.as_ref().map(|m| m.selected).unwrap_or(0);    let options = [1usize, 2, 3, 4];    let mut items: Vec<ListItem> = Vec::new();    for &attempts in &options {        let noun = if attempts == 1 { "attempt" } else { "attempts" };        let mut spans: Vec<ratatui::text::Span> = vec![format!("{attempts} {noun:<8}").into()];        spans.push("  ".into());        spans.push(format!("{attempts}x parallel").dim());        if attempts == app.best_of_n {            spans.push("  ".into());            spans.push("Current".magenta().bold());        }        items.push(ListItem::new(Line::from(spans)));    }    let sel = selected.min(options.len().saturating_sub(1));    let mut list_state = ListState::default().with_selected(Some(sel));    let list = List::new(items)        .highlight_symbol("› ")        .highlight_style(Style::default().bold())        .block(Block::default().borders(Borders::NONE));    frame.render_stateful_widget(list, rows[1], &mut list_state);}