psmux 0.3.1

use std::io::{self, Write, BufRead, BufReader};
use std::time::{Duration, Instant};
use std::env;

use chrono::Local;
use crossterm::event::{self, Event, KeyCode, KeyModifiers, KeyEventKind};
use ratatui::prelude::*;
use ratatui::widgets::*;

use crate::layout::LayoutJson;
use crate::util::*;
use crate::session::*;
use crate::rendering::*;
use crate::config::parse_key_string;
use crate::copy_mode::{copy_to_system_clipboard, read_from_system_clipboard};
use crate::layout::RowRunsJson;
use crate::tree::split_with_gaps;

/// Parse a tmux-style color name to a ratatui Color.
/// Supports: "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
/// "default", "colour0"-"colour255", "#rrggbb", and "brightX" variants.
fn parse_tmux_color(s: &str) -> Option<Color> {
    match s.trim().to_lowercase().as_str() {
        "default" | "" => None,
        "black" => Some(Color::Black),
        "red" => Some(Color::Red),
        "green" => Some(Color::Green),
        "yellow" => Some(Color::Yellow),
        "blue" => Some(Color::Blue),
        "magenta" => Some(Color::Magenta),
        "cyan" => Some(Color::Cyan),
        "white" => Some(Color::White),
        "brightblack" => Some(Color::DarkGray),
        "brightred" => Some(Color::LightRed),
        "brightgreen" => Some(Color::LightGreen),
        "brightyellow" => Some(Color::LightYellow),
        "brightblue" => Some(Color::LightBlue),
        "brightmagenta" => Some(Color::LightMagenta),
        "brightcyan" => Some(Color::LightCyan),
        "brightwhite" => Some(Color::Gray),
        s if s.starts_with("colour") || s.starts_with("color") => {
            let num_part = if s.starts_with("colour") { &s[6..] } else { &s[5..] };
            num_part.parse::<u8>().ok().map(Color::Indexed)
        }
        s if s.starts_with('#') && s.len() == 7 => {
            let r = u8::from_str_radix(&s[1..3], 16).ok()?;
            let g = u8::from_str_radix(&s[3..5], 16).ok()?;
            let b = u8::from_str_radix(&s[5..7], 16).ok()?;
            Some(Color::Rgb(r, g, b))
        }
        _ => None,
    }
}

/// Parse a tmux status-style string like "fg=white,bg=blue,bold" into (fg, bg, bold).
fn parse_tmux_style(style: &str) -> (Option<Color>, Option<Color>, bool) {
    let mut fg = None;
    let mut bg = None;
    let mut bold = false;
    for part in style.split(',') {
        let part = part.trim();
        if let Some(val) = part.strip_prefix("fg=") {
            fg = parse_tmux_color(val);
        } else if let Some(val) = part.strip_prefix("bg=") {
            bg = parse_tmux_color(val);
        } else if part == "bold" {
            bold = true;
        } else if part == "nobold" {
            bold = false;
        }
    }
    (fg, bg, bold)
}

/// Extract selected text from the layout tree given absolute terminal coordinates.
/// Computes pane areas via the same Layout splitting render_json uses, then reads
/// characters from the run-length-encoded rows_v2 data.
fn extract_selection_text(
    layout: &LayoutJson,
    term_width: u16,
    content_height: u16, // excluding status bar
    start: (u16, u16),   // (col, row)
    end: (u16, u16),
) -> String {
    // Normalise so (r0,c0) <= (r1,c1) in reading order
    let (r0, c0, r1, c1) = if (start.1, start.0) <= (end.1, end.0) {
        (start.1, start.0, end.1, end.0)
    } else {
        (end.1, end.0, start.1, start.0)
    };

    // Collect leaf panes with their inner areas and content
    struct PaneLeaf<'a> {
        inner: Rect,
        rows_v2: &'a [RowRunsJson],
    }

    fn collect_leaves<'a>(node: &'a LayoutJson, area: Rect, out: &mut Vec<PaneLeaf<'a>>) {
        match node {
            LayoutJson::Leaf { rows_v2, .. } => {
                // No borders — content fills entire area (tmux-style)
                out.push(PaneLeaf { inner: area, rows_v2 });
            }
            LayoutJson::Split { kind, sizes, children } => {
                let effective_sizes: Vec<u16> = if sizes.len() == children.len() {
                    sizes.clone()
                } else {
                    vec![(100 / children.len().max(1)) as u16; children.len()]
                };
                let is_horizontal = kind == "Horizontal";
                let rects = split_with_gaps(is_horizontal, &effective_sizes, area);
                for (i, child) in children.iter().enumerate() {
                    if i < rects.len() {
                        collect_leaves(child, rects[i], out);
                    }
                }
            }
        }
    }

    let content_area = Rect { x: 0, y: 0, width: term_width, height: content_height };
    let mut leaves: Vec<PaneLeaf> = Vec::new();
    collect_leaves(layout, content_area, &mut leaves);

    // Helper: get character at a local column position within a row's runs
    fn char_at_col(runs: &[crate::layout::CellRunJson], local_col: usize) -> char {
        let mut cursor = 0usize;
        for run in runs {
            let run_width = run.width.max(1) as usize;
            if local_col >= cursor && local_col < cursor + run_width {
                let offset = local_col - cursor;
                // Run text may be shorter than run_width (e.g. single char repeated)
                // or multi-char for wide chars. Pick the nth char if available.
                return run.text.chars().nth(offset).unwrap_or(' ');
            }
            cursor += run_width;
        }
        ' '
    }

    let mut result = String::new();
    for row in r0..=r1 {
        let col_start = if row == r0 { c0 } else { 0 };
        let col_end = if row == r1 { c1 } else { term_width.saturating_sub(1) };

        let mut line = String::new();
        for col in col_start..=col_end {
            let mut ch = ' ';
            for leaf in &leaves {
                let inner = &leaf.inner;
                if col >= inner.x && col < inner.x + inner.width
                    && row >= inner.y && row < inner.y + inner.height
                {
                    let local_row = (row - inner.y) as usize;
                    let local_col = (col - inner.x) as usize;
                    if local_row < leaf.rows_v2.len() {
                        ch = char_at_col(&leaf.rows_v2[local_row].runs, local_col);
                    }
                    break;
                }
            }
            line.push(ch);
        }
        // Trim trailing whitespace per line
        let trimmed = line.trim_end();
        result.push_str(trimmed);
        if row < r1 {
            result.push('\n');
        }
    }

    result
}

/// Check if screen coordinates (x, y) fall on a separator line in the layout.
/// Used to distinguish border-drag (resize) from text selection on left-click.
fn is_on_separator(layout: &LayoutJson, area: Rect, x: u16, y: u16) -> bool {
    match layout {
        LayoutJson::Leaf { .. } => false,
        LayoutJson::Split { kind, sizes, children } => {
            let effective_sizes: Vec<u16> = if sizes.len() == children.len() {
                sizes.clone()
            } else {
                vec![(100 / children.len().max(1)) as u16; children.len()]
            };
            let is_horizontal = kind == "Horizontal";
            let rects = split_with_gaps(is_horizontal, &effective_sizes, area);

            // Check if (x, y) is on any separator between children
            for i in 0..children.len().saturating_sub(1) {
                if i >= rects.len() { break; }
                if is_horizontal {
                    let sep_x = rects[i].x + rects[i].width;
                    if x == sep_x && y >= area.y && y < area.y + area.height {
                        return true;
                    }
                } else {
                    let sep_y = rects[i].y + rects[i].height;
                    if y == sep_y && x >= area.x && x < area.x + area.width {
                        return true;
                    }
                }
            }

            // Recurse into children
            for (i, child) in children.iter().enumerate() {
                if i < rects.len() && is_on_separator(child, rects[i], x, y) {
                    return true;
                }
            }

            false
        }
    }
}

/// Check if any leaf in a LayoutJson subtree is the active pane.
/// Compute the rectangle of the active pane by searching the LayoutJson tree.
fn compute_active_rect_json(node: &LayoutJson, area: Rect) -> Option<Rect> {
    match node {
        LayoutJson::Leaf { active, .. } => {
            if *active { Some(area) } else { None }
        }
        LayoutJson::Split { kind, sizes, children } => {
            let effective_sizes: Vec<u16> = if sizes.len() == children.len() {
                sizes.clone()
            } else {
                vec![(100 / children.len().max(1)) as u16; children.len()]
            };
            let is_horizontal = kind == "Horizontal";
            let rects = split_with_gaps(is_horizontal, &effective_sizes, area);
            for (i, child) in children.iter().enumerate() {
                if i < rects.len() {
                    if let Some(r) = compute_active_rect_json(child, rects[i]) {
                        return Some(r);
                    }
                }
            }
            None
        }
    }
}

pub fn run_remote(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>) -> io::Result<()> {
    let name = env::var("PSMUX_SESSION_NAME").unwrap_or_else(|_| "default".to_string());
    let home = env::var("USERPROFILE").or_else(|_| env::var("HOME")).unwrap_or_default();
    let path = format!("{}\\.psmux\\{}.port", home, name);
    let port = std::fs::read_to_string(&path).ok().and_then(|s| s.trim().parse::<u16>().ok())
        .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "no session"))?;
    let addr = format!("127.0.0.1:{}", port);
    let session_key = read_session_key(&name).unwrap_or_default();
    let last_path = format!("{}\\.psmux\\last_session", home);
    let _ = std::fs::write(&last_path, &name);

    // ── Open persistent TCP connection ───────────────────────────────────
    let stream = std::net::TcpStream::connect(&addr)?;
    stream.set_nodelay(true)?; // Disable Nagle's algorithm for low latency
    let mut writer = stream.try_clone()?;
    writer.set_nodelay(true)?;
    let mut reader = BufReader::new(stream);

    // AUTH handshake
    let _ = writer.write_all(format!("AUTH {}\n", session_key).as_bytes());
    let _ = writer.flush();
    let mut auth_line = String::new();
    reader.read_line(&mut auth_line)?;
    if !auth_line.trim().starts_with("OK") {
        return Err(io::Error::new(io::ErrorKind::PermissionDenied, "auth failed"));
    }

    // Enter persistent mode + attach
    let _ = writer.write_all(b"PERSISTENT\n");
    let _ = writer.write_all(b"client-attach\n");
    let _ = writer.flush();

    // Spawn a dedicated reader thread so the event loop never blocks on I/O.
    // The reader thread reads lines from the server and sends them via channel.
    let _ = reader.get_ref().set_read_timeout(None); // blocking reads in reader thread
    let (frame_tx, frame_rx) = std::sync::mpsc::channel::<String>();
    std::thread::spawn(move || {
        let mut reader = reader;
        let mut buf = String::with_capacity(64 * 1024);
        loop {
            buf.clear();
            match reader.read_line(&mut buf) {
                Ok(0) | Err(_) => break,
                Ok(_) => {
                    let line = std::mem::take(&mut buf);
                    buf = String::with_capacity(64 * 1024);
                    if frame_tx.send(line).is_err() { break; }
                }
            }
        }
    });

    let mut quit = false;
    let mut prefix_armed = false;
    let mut renaming = false;
    let mut session_renaming = false;
    let mut rename_buf = String::new();
    let mut pane_renaming = false;
    let mut pane_title_buf = String::new();
    let mut command_input = false;
    let mut command_buf = String::new();
    let mut chooser = false;
    let mut choices: Vec<(usize, usize)> = Vec::new();
    let mut tree_chooser = false;
    let mut tree_entries: Vec<(bool, usize, usize, String, String)> = Vec::new();  // (is_win, id, sub_id, label, session_name)
    let mut tree_selected: usize = 0;
    let mut session_chooser = false;
    let mut session_entries: Vec<(String, String)> = Vec::new();
    let mut session_selected: usize = 0;
    let mut confirm_cmd: Option<String> = None;  // pending kill confirmation
    let current_session = name.clone();
    let mut last_sent_size: (u16, u16) = (0, 0);
    let mut last_dump_time = Instant::now() - Duration::from_millis(250);
    let mut force_dump = true;
    let mut last_tree: Vec<WinTree> = Vec::new();
    // Default prefix is Ctrl+B, updated dynamically from server config
    let mut prefix_key: (KeyCode, KeyModifiers) = (KeyCode::Char('b'), KeyModifiers::CONTROL);
    // Precompute the raw control character for the default prefix
    let mut prefix_raw_char: Option<char> = Some('\x02');
    // Status bar style from server (parsed from tmux status-style format)
    let mut status_fg: Color = Color::Black;
    let mut status_bg: Color = Color::Green;
    let mut status_bold: bool = false;
    let mut custom_status_left: Option<String> = None;
    let mut custom_status_right: Option<String> = None;
    let mut pane_border_fg: Color = Color::DarkGray;
    let mut pane_active_border_fg: Color = Color::Green;
    let mut win_status_fmt: String = "#I:#W#F".to_string();
    let mut win_status_current_fmt: String = "#I:#W#F".to_string();
    let mut win_status_sep: String = " ".to_string();
    let mut win_status_style: Option<(Option<Color>, Option<Color>, bool)> = None;
    let mut win_status_current_style: Option<(Option<Color>, Option<Color>, bool)> = None;
    // Synced bindings from server (updated each frame from DumpState)
    let mut synced_bindings: Vec<BindingEntry> = Vec::new();

    #[derive(serde::Deserialize, Default)]
    struct WinStatus { id: usize, name: String, active: bool, #[serde(default)] activity: bool, #[serde(default)] tab_text: String }
    
    fn default_base_index() -> usize { 1 }
    fn default_prediction_dimming() -> bool { dim_predictions_enabled() }

    /// A single key binding synced from the server.
    #[derive(serde::Deserialize, Clone, Debug)]
    struct BindingEntry {
        /// Key table name (e.g. "prefix", "root")
        t: String,
        /// Key string (e.g. "C-a", "-", "F12")
        k: String,
        /// Command string (e.g. "split-window -v")
        c: String,
        /// Whether the binding is repeatable
        #[serde(default)]
        r: bool,
    }

    #[derive(serde::Deserialize)]
    struct DumpState {
        layout: LayoutJson,
        windows: Vec<WinStatus>,
        #[serde(default)]
        prefix: Option<String>,
        #[serde(default)]
        tree: Vec<WinTree>,
        #[serde(default = "default_base_index")]
        base_index: usize,
        #[serde(default = "default_prediction_dimming")]
        prediction_dimming: bool,
        #[serde(default)]
        status_style: Option<String>,
        #[serde(default)]
        status_left: Option<String>,
        #[serde(default)]
        status_right: Option<String>,
        #[serde(default)]
        pane_border_style: Option<String>,
        #[serde(default)]
        pane_active_border_style: Option<String>,
        /// window-status-format (short key to save bandwidth)
        #[serde(default)]
        wsf: Option<String>,
        /// window-status-current-format
        #[serde(default)]
        wscf: Option<String>,
        /// window-status-separator
        #[serde(default)]
        wss: Option<String>,
        /// window-status-style
        #[serde(default)]
        ws_style: Option<String>,
        /// window-status-current-style
        #[serde(default)]
        wsc_style: Option<String>,
        /// clock-mode active
        #[serde(default)]
        clock_mode: bool,
        /// Dynamic key bindings from server
        #[serde(default)]
        bindings: Vec<BindingEntry>,
    }

    let mut cmd_batch: Vec<String> = Vec::new();
    let mut dump_buf = String::new();
    let mut prev_dump_buf = String::new();
    let mut last_key_send_time: Option<Instant> = None;
    let mut dump_in_flight = false;

    // Diagnostic latency log: set PSMUX_LATENCY_LOG=1 to enable
    let latency_log_enabled = env::var("PSMUX_LATENCY_LOG").unwrap_or_default() == "1";
    let mut latency_log: Option<std::fs::File> = if latency_log_enabled {
        let home = env::var("USERPROFILE").or_else(|_| env::var("HOME")).unwrap_or_default();
        let path = format!("{}\\.psmux\\latency.log", home);
        std::fs::File::create(&path).ok()
    } else { None };
    let mut loop_count: u64 = 0;
    let mut last_key_char: Option<char> = None;
    let mut key_send_instant: Option<Instant> = None; // when the key was SENT to server

    // Text selection state (client-side only, left-click drag like pwsh)
    let mut rsel_start: Option<(u16, u16)> = None;  // (col, row) in terminal coords
    let mut rsel_end: Option<(u16, u16)> = None;
    let mut rsel_dragged = false;
    let mut selection_changed = false; // forces redraw for selection overlay
    let mut border_drag = false; // true when dragging a pane separator (resize)
    loop {
        // Expire stale key_send_instant after 30ms — ConPTY echo should
        // have arrived by then; stop force-dumping to save CPU.
        if let Some(ks) = key_send_instant {
            if ks.elapsed().as_millis() > 30 { key_send_instant = None; }
        }
        // ── STEP 0: Receive latest frame from reader thread (non-blocking) ──
        // Drain channel, keeping only the most recent frame.
        let mut got_frame = false;
        let mut nc_count = 0u32;
        loop {
            match frame_rx.try_recv() {
                Ok(line) => {
                    if line.trim() == "NC" {
                        nc_count += 1;
                        // Server says nothing changed — release dump_in_flight
                        // without touching dump_buf (saves 50-100KB clone + parse).
                        dump_in_flight = false;
                        last_dump_time = Instant::now();
                        // If we're waiting for a key echo, force an
                        // immediate dump-state re-request (~1ms TCP RTT)
                        // instead of waiting the full 10ms typing interval.
                        if key_send_instant.is_some() {
                            force_dump = true;
                        }
                    } else {
                        dump_buf = line; got_frame = true; dump_in_flight = false;
                    }
                }
                Err(std::sync::mpsc::TryRecvError::Empty) => break,
                Err(std::sync::mpsc::TryRecvError::Disconnected) => { quit = true; break; }
            }
        }
        if quit && !got_frame { break; }

        // ── STEP 1: Poll events with adaptive timeout ────────────────────
        let since_dump = last_dump_time.elapsed().as_millis() as u64;
        // Expire typing timer after 100ms of no new keys
        if let Some(kt) = last_key_send_time {
            if kt.elapsed().as_millis() > 100 { last_key_send_time = None; }
        }
        let typing_active = last_key_send_time.is_some();
        // When typing: cap at ~100fps to avoid flooding the server with
        // dump-state requests (each one is ~50-100KB of JSON over TCP).
        // When idle: 50ms refresh (20fps) saves CPU.
        let poll_ms = if got_frame { 0 }
            else if dump_in_flight { 1 }
            else if force_dump { 0 }
            else if typing_active {
                // Rate-limit to ~100fps (10ms) when typing.  The snapshot-
                // based serialisation in dump_layout_json_fast now holds
                // the parser mutex for only ~1ms (cell snapshot), so
                // polling at 10ms no longer starves the ConPTY reader
                // thread.  10ms is notably shorter than ConPTY's ~16ms
                // render interval, avoiding systematic alignment delays.
                let remaining = 10u64.saturating_sub(since_dump);
                remaining
            }
            else {
                let idle_frame: u64 = 50;
                let remaining = idle_frame.saturating_sub(since_dump);
                if remaining == 0 { 0 } else { remaining.min(50) }
            };

        cmd_batch.clear();
        if event::poll(Duration::from_millis(poll_ms))? {
            loop {
                match event::read()? {
                    Event::Key(key) if key.kind == KeyEventKind::Press || key.kind == KeyEventKind::Repeat => {
                        let is_ctrl_q = (matches!(key.code, KeyCode::Char('q')) && key.modifiers.contains(KeyModifiers::CONTROL))
                            || matches!(key.code, KeyCode::Char('\x11'));
                        // Dynamic prefix key check (default: Ctrl+B, configurable via .psmux.conf)
                        let is_prefix = (key.code, key.modifiers) == prefix_key
                            || prefix_raw_char.map_or(false, |c| matches!(key.code, KeyCode::Char(ch) if ch == c));

                        if is_ctrl_q { quit = true; }
                        // Overlay Esc must be checked BEFORE selection-Esc so that
                        // pressing Esc always closes the active overlay first.
                        else if matches!(key.code, KeyCode::Esc) && (command_input || renaming || pane_renaming || chooser || tree_chooser || session_chooser || confirm_cmd.is_some()) {
                            command_input = false;
                            renaming = false;
                            pane_renaming = false;
                            chooser = false;
                            tree_chooser = false;
                            session_chooser = false;
                            confirm_cmd = None;
                            // Also clear any lingering selection
                            rsel_start = None;
                            rsel_end = None;
                            selection_changed = true;
                        }
                        else if rsel_start.is_some() && matches!(key.code, KeyCode::Esc) {
                            // Escape clears any active text selection
                            rsel_start = None;
                            rsel_end = None;
                            selection_changed = true;
                        }
                        else if is_prefix { prefix_armed = true; }
                        // Check root-table bindings (bind-key -n / bind-key -T root)
                        // These fire without prefix, before keys are forwarded to PTY
                        else if !command_input && !renaming && !pane_renaming && !chooser && !tree_chooser && !session_chooser && confirm_cmd.is_none() && {
                            let key_tuple = (key.code, key.modifiers);
                            synced_bindings.iter().any(|b| b.t == "root" && parse_key_string(&b.k).map_or(false, |k| k == key_tuple))
                        } {
                            let key_tuple = (key.code, key.modifiers);
                            if let Some(entry) = synced_bindings.iter().find(|b| {
                                b.t == "root" && parse_key_string(&b.k).map_or(false, |k| k == key_tuple)
                            }) {
                                cmd_batch.push(format!("{}\n", entry.c));
                            }
                        }
                        else if prefix_armed {
                            // Check user-defined synced bindings FIRST (like server-side input.rs).
                            // This lets users override any default hardcoded key binding.
                            let key_tuple = (key.code, key.modifiers);
                            let user_binding = synced_bindings.iter().find(|b| {
                                b.t == "prefix" && parse_key_string(&b.k).map_or(false, |k| k == key_tuple)
                            });
                            if let Some(entry) = user_binding {
                                // User-defined binding takes priority
                                if entry.c == "detach-client" || entry.c == "detach" {
                                    quit = true;
                                } else if entry.c.starts_with("confirm-before") || entry.c == "kill-pane" {
                                    confirm_cmd = Some(entry.c.clone());
                                } else {
                                    cmd_batch.push(format!("{}\n", entry.c));
                                }
                            } else {
                            // Default hardcoded bindings (only reached if no user override)
                            match key.code {
                                KeyCode::Char('c') => { cmd_batch.push("new-window\n".into()); }
                                KeyCode::Char('%') => { cmd_batch.push("split-window -h\n".into()); }
                                KeyCode::Char('"') => { cmd_batch.push("split-window -v\n".into()); }
                                KeyCode::Char('x') => { confirm_cmd = Some("kill-pane".into()); }
                                KeyCode::Char('&') => { confirm_cmd = Some("kill-window".into()); }
                                KeyCode::Char('z') => { cmd_batch.push("zoom-pane\n".into()); }
                                KeyCode::Char('[') => { cmd_batch.push("copy-enter\n".into()); }
                                KeyCode::Char(']') => { cmd_batch.push("paste-buffer\n".into()); }
                                KeyCode::Char('{') => { cmd_batch.push("swap-pane -U\n".into()); }
                                KeyCode::Char('}') => { cmd_batch.push("swap-pane -D\n".into()); }
                                KeyCode::Char('n') => { cmd_batch.push("next-window\n".into()); }
                                KeyCode::Char('p') => { cmd_batch.push("previous-window\n".into()); }
                                KeyCode::Char('l') => { cmd_batch.push("last-window\n".into()); }
                                KeyCode::Char(';') => { cmd_batch.push("last-pane\n".into()); }
                                KeyCode::Char(' ') => { cmd_batch.push("next-layout\n".into()); }
                                KeyCode::Char('!') => { cmd_batch.push("break-pane\n".into()); }
                                KeyCode::Char(d) if d.is_ascii_digit() => {
                                    let idx = d.to_digit(10).unwrap() as usize;
                                    cmd_batch.push(format!("select-window {}\n", idx));
                                }
                                KeyCode::Char('o') => { cmd_batch.push("select-pane -t :.+\n".into()); }
                                // Alt+Arrow: resize pane by 5 (must be before plain Arrow)
                                KeyCode::Up if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("resize-pane -U 5\n".into()); }
                                KeyCode::Down if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("resize-pane -D 5\n".into()); }
                                KeyCode::Left if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("resize-pane -L 5\n".into()); }
                                KeyCode::Right if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("resize-pane -R 5\n".into()); }
                                // Ctrl+Arrow: resize pane by 1
                                KeyCode::Up if key.modifiers.contains(KeyModifiers::CONTROL) => { cmd_batch.push("resize-pane -U 1\n".into()); }
                                KeyCode::Down if key.modifiers.contains(KeyModifiers::CONTROL) => { cmd_batch.push("resize-pane -D 1\n".into()); }
                                KeyCode::Left if key.modifiers.contains(KeyModifiers::CONTROL) => { cmd_batch.push("resize-pane -L 1\n".into()); }
                                KeyCode::Right if key.modifiers.contains(KeyModifiers::CONTROL) => { cmd_batch.push("resize-pane -R 1\n".into()); }
                                // Plain Arrow: select pane
                                KeyCode::Up => { cmd_batch.push("select-pane -U\n".into()); }
                                KeyCode::Down => { cmd_batch.push("select-pane -D\n".into()); }
                                KeyCode::Left => { cmd_batch.push("select-pane -L\n".into()); }
                                KeyCode::Right => { cmd_batch.push("select-pane -R\n".into()); }
                                KeyCode::Char('d') => { quit = true; }
                                KeyCode::Char(',') => { renaming = true; rename_buf.clear(); }
                                KeyCode::Char('$') => {
                                    // Rename session — reuse rename overlay
                                    renaming = true;
                                    rename_buf.clear();
                                    // Mark that we're renaming the session, not a window
                                    // We'll detect this by checking if pane_renaming is used as a flag
                                    session_renaming = true;
                                }
                                KeyCode::Char('?') => {
                                    // List keys — send to server and display result
                                    cmd_batch.push("list-keys\n".into());
                                }
                                KeyCode::Char('t') => { cmd_batch.push("clock-mode\n".into()); }
                                KeyCode::Char('=') => { cmd_batch.push("choose-buffer\n".into()); }
                                KeyCode::Char(':') => { command_input = true; command_buf.clear(); }
                                KeyCode::Char('w') => {
                                    tree_chooser = true;
                                    tree_entries.clear();
                                    tree_selected = 0;
                                    // Query ALL sessions (like tmux choose-tree)
                                    let dir = format!("{}\\.psmux", home);
                                    if let Ok(entries) = std::fs::read_dir(&dir) {
                                        let mut sessions: Vec<(String, Vec<(usize, String, Vec<(usize, String)>)>)> = Vec::new();
                                        for e in entries.flatten() {
                                            if let Some(fname) = e.file_name().to_str().map(|s| s.to_string()) {
                                                if let Some((base, ext)) = fname.rsplit_once('.') {
                                                    if ext == "port" {
                                                        if let Ok(port_str) = std::fs::read_to_string(e.path()) {
                                                            if let Ok(p) = port_str.trim().parse::<u16>() {
                                                                let sess_addr = format!("127.0.0.1:{}", p);
                                                                let sess_key = read_session_key(base).unwrap_or_default();
                                                                if let Ok(mut ss) = std::net::TcpStream::connect_timeout(
                                                                    &sess_addr.parse().unwrap(), Duration::from_millis(50)
                                                                ) {
                                                                    let _ = ss.set_read_timeout(Some(Duration::from_millis(100)));
                                                                    let _ = write!(ss, "AUTH {}\n", sess_key);
                                                                    let _ = ss.write_all(b"list-tree\n");
                                                                    let _ = ss.flush();
                                                                    let mut br = BufReader::new(ss);
                                                                    let mut al = String::new();
                                                                    let _ = br.read_line(&mut al); // AUTH OK
                                                                    let mut tree_line = String::new();
                                                                    if br.read_line(&mut tree_line).is_ok() {
                                                                        // Parse JSON array of WinTree
                                                                        if let Ok(wins) = serde_json::from_str::<Vec<WinTree>>(&tree_line.trim()) {
                                                                            let mut win_data = Vec::new();
                                                                            for w in &wins {
                                                                                let panes: Vec<(usize, String)> = w.panes.iter().map(|p| (p.id, p.title.clone())).collect();
                                                                                win_data.push((w.id, w.name.clone(), panes));
                                                                            }
                                                                            sessions.push((base.to_string(), win_data));
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        // Sort sessions: current session first, then alphabetical
                                        sessions.sort_by(|a, b| {
                                            if a.0 == current_session { std::cmp::Ordering::Less }
                                            else if b.0 == current_session { std::cmp::Ordering::Greater }
                                            else { a.0.cmp(&b.0) }
                                        });
                                        // Build tree entries: session > window > pane
                                        // tree_entries format: (is_win, id, sub_id, label, session_name)
                                        // For session headers: is_win=true with id=usize::MAX as sentinel
                                        // For windows: is_win=true
                                        // For panes: is_win=false
                                        for (sess_name, wins) in &sessions {
                                            let is_current = sess_name == &current_session;
                                            let attached = if is_current { " (attached)" } else { "" };
                                            let nw = wins.len();
                                            // Session header line
                                            tree_entries.push((true, usize::MAX, 0,
                                                format!("{}: {} windows{}", sess_name, nw, attached),
                                                sess_name.clone()));
                                            if is_current {
                                                // Show windows and panes for current session
                                                for (wi, (wid, wname, panes)) in wins.iter().enumerate() {
                                                    let flag = if panes.len() > 0 { "" } else { "" };
                                                    tree_entries.push((true, *wid, 0,
                                                        format!("  {}: {}{} ({} panes)", wi, wname, flag, panes.len()),
                                                        sess_name.clone()));
                                                    for (pid, ptitle) in panes {
                                                        tree_entries.push((false, *wid, *pid,
                                                            format!("    {}", ptitle),
                                                            sess_name.clone()));
                                                    }
                                                }
                                            } else {
                                                // Show windows for other sessions (collapsed)
                                                for (wi, (wid, wname, panes)) in wins.iter().enumerate() {
                                                    tree_entries.push((true, *wid, 0,
                                                        format!("  {}: {} ({} panes)", wi, wname, panes.len()),
                                                        sess_name.clone()));
                                                }
                                            }
                                        }
                                    }
                                    // Fallback: if no sessions found, use current session data
                                    if tree_entries.is_empty() {
                                        for wi in &last_tree {
                                            tree_entries.push((true, wi.id, 0, wi.name.clone(), current_session.clone()));
                                            for pi in &wi.panes {
                                                tree_entries.push((false, wi.id, pi.id, pi.title.clone(), current_session.clone()));
                                            }
                                        }
                                    }
                                }
                                KeyCode::Char('s') => {
                                    session_chooser = true;
                                    session_entries.clear();
                                    session_selected = 0;
                                    let dir = format!("{}\\.psmux", home);
                                    if let Ok(entries) = std::fs::read_dir(&dir) {
                                        for e in entries.flatten() {
                                            if let Some(fname) = e.file_name().to_str() {
                                                if let Some((base, ext)) = fname.rsplit_once('.') {
                                                    if ext == "port" {
                                                        if let Ok(port_str) = std::fs::read_to_string(e.path()) {
                                                            if let Ok(p) = port_str.trim().parse::<u16>() {
                                                                let sess_addr = format!("127.0.0.1:{}", p);
                                                                let sess_key = read_session_key(base).unwrap_or_default();
                                                                let info = if let Ok(mut ss) = std::net::TcpStream::connect_timeout(
                                                                    &sess_addr.parse().unwrap(), Duration::from_millis(25)
                                                                ) {
                                                                    let _ = ss.set_read_timeout(Some(Duration::from_millis(25)));
                                                                    let _ = write!(ss, "AUTH {}\n", sess_key);
                                                                    let _ = ss.write_all(b"session-info\n");
                                                                    let mut br = BufReader::new(ss);
                                                                    let mut al = String::new();
                                                                    let _ = br.read_line(&mut al);
                                                                    let mut line = String::new();
                                                                    if br.read_line(&mut line).is_ok() && !line.trim().is_empty() {
                                                                        line.trim().to_string()
                                                                    } else {
                                                                        format!("{}: (no info)", base)
                                                                    }
                                                                } else {
                                                                    format!("{}: (not responding)", base)
                                                                };
                                                                session_entries.push((base.to_string(), info));
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    if session_entries.is_empty() {
                                        session_entries.push((current_session.clone(), format!("{}: (current)", current_session)));
                                    }
                                    for (i, (sname, _)) in session_entries.iter().enumerate() {
                                        if sname == &current_session { session_selected = i; break; }
                                    }
                                }
                                KeyCode::Char('q') => { chooser = true; }
                                KeyCode::Char('v') => { cmd_batch.push("copy-anchor\n".into()); }
                                KeyCode::Char('y') => { cmd_batch.push("copy-yank\n".into()); }
                                // Session navigation (like tmux prefix+( and prefix+))
                                KeyCode::Char('(') | KeyCode::Char(')') => {
                                    let dir_next = key.code == KeyCode::Char(')');
                                    // Enumerate sessions
                                    let dir = format!("{}\\.psmux", home);
                                    let mut names: Vec<String> = Vec::new();
                                    if let Ok(entries) = std::fs::read_dir(&dir) {
                                        for e in entries.flatten() {
                                            if let Some(fname) = e.file_name().to_str() {
                                                if let Some((base, ext)) = fname.rsplit_once('.') {
                                                    if ext == "port" {
                                                        if let Ok(ps) = std::fs::read_to_string(e.path()) {
                                                            if let Ok(p) = ps.trim().parse::<u16>() {
                                                                let a = format!("127.0.0.1:{}", p);
                                                                if std::net::TcpStream::connect_timeout(
                                                                    &a.parse().unwrap(), Duration::from_millis(25)
                                                                ).is_ok() {
                                                                    names.push(base.to_string());
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    names.sort();
                                    if names.len() > 1 {
                                        if let Some(cur_pos) = names.iter().position(|n| *n == current_session) {
                                            let next_pos = if dir_next {
                                                (cur_pos + 1) % names.len()
                                            } else {
                                                (cur_pos + names.len() - 1) % names.len()
                                            };
                                            let next_name = names[next_pos].clone();
                                            cmd_batch.push("client-detach\n".into());
                                            env::set_var("PSMUX_SWITCH_TO", &next_name);
                                            quit = true;
                                        }
                                    }
                                }
                                // Meta+1..5 preset layouts (like tmux)
                                KeyCode::Char('1') if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("select-layout even-horizontal\n".into()); }
                                KeyCode::Char('2') if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("select-layout even-vertical\n".into()); }
                                KeyCode::Char('3') if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("select-layout main-horizontal\n".into()); }
                                KeyCode::Char('4') if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("select-layout main-vertical\n".into()); }
                                KeyCode::Char('5') if key.modifiers.contains(KeyModifiers::ALT) => { cmd_batch.push("select-layout tiled\n".into()); }
                                // Display pane info
                                KeyCode::Char('i') => { cmd_batch.push("display-message\n".into()); }
                                _ => {
                                    // No default binding for this key (user bindings already checked above)
                                }
                            }
                            } // end of else (no user binding override)
                            prefix_armed = false;
                        } else {
                            match key.code {
                                KeyCode::Up if session_chooser => { if session_selected > 0 { session_selected -= 1; } }
                                KeyCode::Down if session_chooser => { if session_selected + 1 < session_entries.len() { session_selected += 1; } }
                                KeyCode::Enter if session_chooser => {
                                    if let Some((sname, _)) = session_entries.get(session_selected) {
                                        if sname != &current_session {
                                            cmd_batch.push("client-detach\n".into());
                                            env::set_var("PSMUX_SWITCH_TO", sname);
                                            quit = true;
                                        }
                                        session_chooser = false;
                                    }
                                }
                                KeyCode::Esc if session_chooser => { session_chooser = false; }
                                KeyCode::Char('x') if session_chooser => {
                                    // Kill the selected session (like tmux session chooser)
                                    if let Some((sname, _)) = session_entries.get(session_selected) {
                                        let sname = sname.clone();
                                        if sname == current_session {
                                            // Killing current session — exit after kill
                                            cmd_batch.push("kill-session\n".into());
                                            session_chooser = false;
                                            quit = true;
                                        } else {
                                            // Kill another session by connecting to it
                                            let h = env::var("USERPROFILE").or_else(|_| env::var("HOME")).unwrap_or_default();
                                            let port_path = format!("{}\\.psmux\\{}.port", h, sname);
                                            let key_path = format!("{}\\.psmux\\{}.key", h, sname);
                                            if let Ok(port_str) = std::fs::read_to_string(&port_path) {
                                                if let Ok(port) = port_str.trim().parse::<u16>() {
                                                    let addr = format!("127.0.0.1:{}", port);
                                                    let sess_key = std::fs::read_to_string(&key_path).unwrap_or_default();
                                                    if let Ok(mut ss) = std::net::TcpStream::connect_timeout(
                                                        &addr.parse().unwrap(), Duration::from_millis(100)
                                                    ) {
                                                        let _ = write!(ss, "AUTH {}\n", sess_key.trim());
                                                        let _ = ss.write_all(b"kill-session\n");
                                                    }
                                                }
                                            }
                                            // Remove the killed session from the list
                                            session_entries.remove(session_selected);
                                            if session_selected >= session_entries.len() && session_selected > 0 {
                                                session_selected -= 1;
                                            }
                                            if session_entries.is_empty() {
                                                session_chooser = false;
                                            }
                                        }
                                    }
                                }
                                KeyCode::Up if tree_chooser => { if tree_selected > 0 { tree_selected -= 1; } }
                                KeyCode::Down if tree_chooser => { if tree_selected + 1 < tree_entries.len() { tree_selected += 1; } }
                                KeyCode::Enter if tree_chooser => {
                                    if let Some((is_win, wid, pid, _label, sess_name)) = tree_entries.get(tree_selected) {
                                        if *wid == usize::MAX {
                                            // Session header — switch to that session
                                            if *sess_name != current_session {
                                                cmd_batch.push("client-detach\n".into());
                                                env::set_var("PSMUX_SWITCH_TO", sess_name);
                                                quit = true;
                                            }
                                            tree_chooser = false;
                                        } else if *sess_name != current_session {
                                            // Window/pane in another session — switch to that session
                                            cmd_batch.push("client-detach\n".into());
                                            env::set_var("PSMUX_SWITCH_TO", sess_name);
                                            quit = true;
                                            tree_chooser = false;
                                        } else if *is_win {
                                            cmd_batch.push(format!("focus-window {}\n", wid));
                                            tree_chooser = false;
                                        } else {
                                            cmd_batch.push(format!("focus-pane {}\n", pid));
                                            tree_chooser = false;
                                        }
                                    }
                                }
                                KeyCode::Esc if tree_chooser => { tree_chooser = false; }
                                // --- kill confirmation: y/Y/Enter confirms, n/N/Esc cancels ---
                                KeyCode::Char('y') | KeyCode::Char('Y') | KeyCode::Enter if confirm_cmd.is_some() => {
                                    if let Some(cmd) = confirm_cmd.take() {
                                        cmd_batch.push(format!("{}\n", cmd));
                                    }
                                }
                                KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc if confirm_cmd.is_some() => {
                                    confirm_cmd = None;
                                }
                                KeyCode::Char(c) if renaming && !key.modifiers.contains(KeyModifiers::CONTROL) => { rename_buf.push(c); }
                                KeyCode::Char(c) if pane_renaming && !key.modifiers.contains(KeyModifiers::CONTROL) => { pane_title_buf.push(c); }
                                KeyCode::Char(c) if command_input && !key.modifiers.contains(KeyModifiers::CONTROL) => { command_buf.push(c); }
                                KeyCode::Backspace if renaming => { let _ = rename_buf.pop(); }
                                KeyCode::Backspace if pane_renaming => { let _ = pane_title_buf.pop(); }
                                KeyCode::Backspace if command_input => { let _ = command_buf.pop(); }
                                KeyCode::Enter if renaming => {
                                    if session_renaming {
                                        cmd_batch.push(format!("rename-session {}\n", rename_buf));
                                        session_renaming = false;
                                    } else {
                                        cmd_batch.push(format!("rename-window {}\n", rename_buf));
                                    }
                                    renaming = false;
                                }
                                KeyCode::Enter if pane_renaming => { cmd_batch.push(format!("set-pane-title {}\n", pane_title_buf)); pane_renaming = false; }
                                KeyCode::Enter if command_input => {
                                    let trimmed = command_buf.trim().to_string();
                                    if !trimmed.is_empty() {
                                        cmd_batch.push(format!("{}\n", trimmed));
                                    }
                                    command_input = false;
                                }
                                KeyCode::Esc if renaming => { renaming = false; session_renaming = false; }
                                KeyCode::Esc if pane_renaming => { pane_renaming = false; }
                                KeyCode::Esc if command_input => { command_input = false; }
                                KeyCode::Char(d) if chooser && d.is_ascii_digit() => {
                                    let raw = d.to_digit(10).unwrap() as usize;
                                    let choice = if raw == 0 { 10 } else { raw };
                                    if let Some((_, pid)) = choices.iter().find(|(n, _)| *n == choice) {
                                        cmd_batch.push(format!("focus-pane {}\n", pid));
                                        chooser = false;
                                    }
                                }
                                KeyCode::Esc if chooser => { chooser = false; }
                                KeyCode::Char(' ') => { cmd_batch.push("send-key space\n".into()); }
                                KeyCode::Char(c) if key.modifiers.contains(KeyModifiers::CONTROL) && key.modifiers.contains(KeyModifiers::ALT) => {
                                    cmd_batch.push(format!("send-key C-M-{}\n", c.to_ascii_lowercase()));
                                }
                                KeyCode::Char(c) if key.modifiers.contains(KeyModifiers::ALT) => {
                                    cmd_batch.push(format!("send-key M-{}\n", c));
                                }
                                KeyCode::Char(c) if key.modifiers.contains(KeyModifiers::CONTROL) => {
                                    cmd_batch.push(format!("send-key C-{}\n", c.to_ascii_lowercase()));
                                }
                                KeyCode::Char(c) if (c as u8) >= 0x01 && (c as u8) <= 0x1A => {
                                    let ctrl_letter = ((c as u8) + b'a' - 1) as char;
                                    cmd_batch.push(format!("send-key C-{}\n", ctrl_letter));
                                }
                                KeyCode::Char(c) => {
                                    let escaped = match c {
                                        '"' => "\\\"".to_string(),
                                        '\\' => "\\\\".to_string(),
                                        _ => c.to_string(),
                                    };
                                    cmd_batch.push(format!("send-text \"{}\"\n", escaped));
                                }
                                KeyCode::Enter => { cmd_batch.push("send-key enter\n".into()); }
                                KeyCode::Tab => { cmd_batch.push("send-key tab\n".into()); }
                                KeyCode::Backspace => { cmd_batch.push("send-key backspace\n".into()); }
                                KeyCode::Delete => { cmd_batch.push("send-key delete\n".into()); }
                                KeyCode::Esc => { cmd_batch.push("send-key esc\n".into()); }
                                KeyCode::Left => { cmd_batch.push("send-key left\n".into()); }
                                KeyCode::Right => { cmd_batch.push("send-key right\n".into()); }
                                KeyCode::Up => { cmd_batch.push("send-key up\n".into()); }
                                KeyCode::Down => { cmd_batch.push("send-key down\n".into()); }
                                KeyCode::PageUp => { cmd_batch.push("send-key pageup\n".into()); }
                                KeyCode::PageDown => { cmd_batch.push("send-key pagedown\n".into()); }
                                KeyCode::Home => { cmd_batch.push("send-key home\n".into()); }
                                KeyCode::End => { cmd_batch.push("send-key end\n".into()); }
                                KeyCode::Insert => { cmd_batch.push("send-key insert\n".into()); }
                                KeyCode::F(n) => { cmd_batch.push(format!("send-key f{}\n", n)); }
                                _ => {}
                            }
                        }
                    }
                    Event::Paste(data) => {
                        let encoded = base64_encode(&data);
                        cmd_batch.push(format!("send-paste {}\n", encoded));
                    }
                    Event::Mouse(me) => {
                        use crossterm::event::{MouseEventKind, MouseButton};
                        match me.kind {
                            MouseEventKind::Down(MouseButton::Left) => {
                                // Detect if click is on a separator line (for border resize)
                                let on_sep = if !prev_dump_buf.is_empty() {
                                    if let Ok(state) = serde_json::from_str::<DumpState>(&prev_dump_buf) {
                                        let content_area = Rect { x: 0, y: 0, width: last_sent_size.0, height: last_sent_size.1 };
                                        is_on_separator(&state.layout, content_area, me.column, me.row)
                                    } else { false }
                                } else { false };

                                // Always forward to server for pane focus, tab clicks, border resize
                                cmd_batch.push(format!("mouse-down {} {}\n", me.column, me.row));

                                if on_sep {
                                    // Border resize mode — server handles drag
                                    border_drag = true;
                                    rsel_start = None;
                                    rsel_end = None;
                                    selection_changed = true;
                                } else {
                                    // Text selection mode
                                    border_drag = false;
                                    rsel_start = Some((me.column, me.row));
                                    rsel_end = Some((me.column, me.row));
                                    rsel_dragged = false;
                                    selection_changed = true;
                                }
                            }
                            MouseEventKind::Down(MouseButton::Right) => {
                                // pwsh-style: right-click with active selection → copy + clear
                                // right-click without selection → paste from clipboard
                                if rsel_start.is_some() && rsel_dragged {
                                    // Copy selection to clipboard and clear it
                                    if let (Some(s), Some(e)) = (rsel_start, rsel_end) {
                                        if let Ok(state) = serde_json::from_str::<DumpState>(&prev_dump_buf) {
                                            let text = extract_selection_text(
                                                &state.layout,
                                                last_sent_size.0,
                                                last_sent_size.1,
                                                s, e,
                                            );
                                            if !text.is_empty() {
                                                copy_to_system_clipboard(&text);
                                            }
                                        }
                                    }
                                    rsel_start = None;
                                    rsel_end = None;
                                    rsel_dragged = false;
                                    selection_changed = true;
                                } else {
                                    // No selection — paste from clipboard
                                    rsel_start = None;
                                    rsel_end = None;
                                    selection_changed = true;
                                    if let Some(text) = read_from_system_clipboard() {
                                        if !text.is_empty() {
                                            let encoded = base64_encode(&text);
                                            cmd_batch.push(format!("send-paste {}\n", encoded));
                                        }
                                    }
                                }
                            }
                            MouseEventKind::Down(MouseButton::Middle) => { cmd_batch.push(format!("mouse-down-middle {} {}\n", me.column, me.row)); }
                            MouseEventKind::Drag(MouseButton::Left) => {
                                if border_drag {
                                    // Forward drag to server for border resize
                                    cmd_batch.push(format!("mouse-drag {} {}\n", me.column, me.row));
                                } else {
                                    // Left-drag: extend text selection (pwsh behavior)
                                    if rsel_start.is_some() {
                                        rsel_end = Some((me.column, me.row));
                                        rsel_dragged = true;
                                        selection_changed = true;
                                    }
                                }
                            }
                            MouseEventKind::Drag(MouseButton::Right) => {}
                            MouseEventKind::Up(MouseButton::Left) => {
                                if border_drag {
                                    // Forward mouse-up to server to finalize border resize
                                    cmd_batch.push(format!("mouse-up {} {}\n", me.column, me.row));
                                    border_drag = false;
                                } else if rsel_dragged {
                                    // Left-drag completed — copy selected text to clipboard
                                    rsel_end = Some((me.column, me.row));
                                    if let (Some(s), Some(e)) = (rsel_start, rsel_end) {
                                        if let Ok(state) = serde_json::from_str::<DumpState>(&prev_dump_buf) {
                                            let text = extract_selection_text(
                                                &state.layout,
                                                last_sent_size.0,
                                                last_sent_size.1,
                                                s, e,
                                            );
                                            if !text.is_empty() {
                                                copy_to_system_clipboard(&text);
                                            }
                                        }
                                    }
                                    // Keep selection visible (clears on next click or Escape)
                                } else {
                                    // Plain left-click (no drag) — clear any old selection, forward mouse-up
                                    rsel_start = None;
                                    rsel_end = None;
                                    selection_changed = true;
                                    cmd_batch.push(format!("mouse-up {} {}\n", me.column, me.row));
                                }
                            }
                            MouseEventKind::Up(MouseButton::Right) => {}
                            MouseEventKind::Up(MouseButton::Middle) => {}
                            MouseEventKind::Moved => {
                                // Don't send bare mouse-move to server - wasteful and server ignores it
                            }
                            MouseEventKind::ScrollUp => { cmd_batch.push(format!("scroll-up {} {}\n", me.column, me.row)); }
                            MouseEventKind::ScrollDown => { cmd_batch.push(format!("scroll-down {} {}\n", me.column, me.row)); }
                            _ => {}
                        }
                    }
                    Event::FocusGained => {
                        cmd_batch.push("focus-in\n".into());
                    }
                    Event::FocusLost => {
                        cmd_batch.push("focus-out\n".into());
                    }
                    _ => {}
                }
                if quit || !event::poll(Duration::from_millis(0))? { break; }
            }
        }
        if quit { break; }

        // ── STEP 2: Send commands immediately, refresh screen at capped rate ──
        // Send client-size if changed
        let mut size_changed = false;
        {
            let ts = terminal.size()?;
            let new_size = (ts.width, ts.height.saturating_sub(1));
            if new_size != last_sent_size {
                last_sent_size = new_size;
                size_changed = true;
                if writer.write_all(format!("client-size {} {}\n", new_size.0, new_size.1).as_bytes()).is_err() {
                    break; // Connection lost
                }
            }
        }

        // Send all batched commands immediately — keys reach the server
        // without waiting for a dump-state round-trip
        let sent_keys_this_iter = !cmd_batch.is_empty();
        if sent_keys_this_iter {
            for cmd in &cmd_batch {
                if writer.write_all(cmd.as_bytes()).is_err() {
                    break; // Connection lost
                }
            }
            let _ = writer.flush(); // push keys to server NOW
            last_key_send_time = Some(Instant::now());
            key_send_instant = Some(Instant::now());
            // Force immediate dump-state so we start the echo-detection
            // polling chain right away (eliminates 0-10ms initial wait).
            force_dump = true;
        }

        // ── STEP 2b: Request screen update (non-blocking) ────────────────
        // Rate-limit dump-state requests to avoid flooding the server.
        // dump_in_flight prevents >1 concurrent request; the interval check
        // ensures we don't re-request faster than ~100fps when typing.
        let overlays_active = command_input || renaming || pane_renaming || chooser || tree_chooser || session_chooser || confirm_cmd.is_some();
        let should_dump = if force_dump || size_changed {
            true
        } else if typing_active {
            since_dump >= 10  // ~100fps cap when typing (matches poll_ms)
        } else {
            let idle_frame: u64 = if overlays_active { 33 } else { 50 };
            since_dump >= idle_frame
        };
        if should_dump && !dump_in_flight {
            if writer.write_all(b"dump-state\n").is_err() { break; }
            if writer.flush().is_err() { break; }
            dump_in_flight = true;
        }

        // ── STEP 3: Render if we have a frame ────────────────────────────
        // Also render if selection changed (for highlight overlay) even without new frame
        // Always render when overlays are active (command prompt, rename, choosers)
        if !got_frame && !selection_changed && !overlays_active { continue; }

        // Skip parse + render when the raw JSON is identical to the previous
        // frame AND selection hasn't changed AND no overlays are active.
        if dump_buf == prev_dump_buf && !selection_changed && !overlays_active {
            last_dump_time = Instant::now();
            continue;
        }

        // Parse the frame (use prev_dump_buf for selection-only redraws)
        let frame_to_parse = if got_frame && dump_buf != prev_dump_buf { &dump_buf } else { &prev_dump_buf };
        let _t_parse = Instant::now();
        let state: DumpState = match serde_json::from_str(frame_to_parse) {
            Ok(s) => s,
            Err(_) => {
                force_dump = true;
                selection_changed = false;
                continue;
            }
        };
        let _parse_us = _t_parse.elapsed().as_micros();

        let root = state.layout;
        let windows = state.windows;
        last_tree = state.tree;
        let base_index = state.base_index;
        let dim_preds = state.prediction_dimming;
        let clock_active = state.clock_mode;

        // Update prefix key from server config (if provided)
        if let Some(ref prefix_str) = state.prefix {
            if let Some((kc, km)) = parse_key_string(prefix_str) {
                if (kc, km) != prefix_key {
                    prefix_key = (kc, km);
                    // Compute raw control character for Ctrl+<letter> prefix
                    prefix_raw_char = if km.contains(KeyModifiers::CONTROL) {
                        if let KeyCode::Char(c) = kc {
                            Some((c as u8 & 0x1f) as char)
                        } else { None }
                    } else { None };
                }
            }
        }

        // Update status-style from server config (if provided)
        if let Some(ref ss) = state.status_style {
            if !ss.is_empty() {
                let (fg, bg, bold) = parse_tmux_style(ss);
                status_fg = fg.unwrap_or(Color::Black);
                status_bg = bg.unwrap_or(Color::Green);
                status_bold = bold;
            }
        }

        // Sync key bindings from server
        if !state.bindings.is_empty() || !synced_bindings.is_empty() {
            synced_bindings = state.bindings;
        }
        // Update status-left / status-right from server (already format-expanded)
        if let Some(sl) = state.status_left {
            if !sl.is_empty() { custom_status_left = Some(sl); }
        }
        if let Some(sr) = state.status_right {
            if !sr.is_empty() { custom_status_right = Some(sr); }
        }
        // Update pane border styles
        if let Some(ref pbs) = state.pane_border_style {
            if !pbs.is_empty() {
                let (fg, _bg, _bold) = parse_tmux_style(pbs);
                if let Some(c) = fg { pane_border_fg = c; }
            }
        }
        if let Some(ref pabs) = state.pane_active_border_style {
            if !pabs.is_empty() {
                let (fg, _bg, _bold) = parse_tmux_style(pabs);
                if let Some(c) = fg { pane_active_border_fg = c; }
            }
        }
        // Update window-status-format strings
        if let Some(ref f) = state.wsf { if !f.is_empty() { win_status_fmt = f.clone(); } }
        if let Some(ref f) = state.wscf { if !f.is_empty() { win_status_current_fmt = f.clone(); } }
        if let Some(ref s) = state.wss { win_status_sep = s.clone(); }
        // Update window-status styles
        if let Some(ref s) = state.ws_style {
            if !s.is_empty() {
                win_status_style = Some(parse_tmux_style(s));
            }
        }
        if let Some(ref s) = state.wsc_style {
            if !s.is_empty() {
                win_status_current_style = Some(parse_tmux_style(s));
            }
        }

        // ── STEP 3: Render ───────────────────────────────────────────────
        let sel_s = rsel_start;
        let sel_e = rsel_end;
        terminal.draw(|f| {
            let area = f.size();
            let chunks = Layout::default().direction(Direction::Vertical)
                .constraints([Constraint::Min(1), Constraint::Length(1)].as_ref()).split(area);

            /// Render a large ASCII clock overlay (tmux clock-mode)
            fn render_clock_overlay(f: &mut Frame, area: Rect) {
                // Big digit font (5 rows high, 3 cols wide per digit + colon)
                const DIGITS: [&[&str; 5]; 10] = [
                    &["###", "# #", "# #", "# #", "###"],  // 0
                    &["  #", "  #", "  #", "  #", "  #"],  // 1
                    &["###", "  #", "###", "#  ", "###"],  // 2
                    &["###", "  #", "###", "  #", "###"],  // 3
                    &["# #", "# #", "###", "  #", "  #"],  // 4
                    &["###", "#  ", "###", "  #", "###"],  // 5
                    &["###", "#  ", "###", "# #", "###"],  // 6
                    &["###", "  #", "  #", "  #", "  #"],  // 7
                    &["###", "# #", "###", "# #", "###"],  // 8
                    &["###", "# #", "###", "  #", "###"],  // 9
                ];
                const COLON: [&str; 5] = [" ", "#", " ", "#", " "];
                let now = Local::now();
                let time_str = now.format("%H:%M:%S").to_string();
                // Each char is 3 wide + 1 gap, colon is 1 wide + 1 gap
                let total_w: u16 = time_str.chars().map(|c| if c == ':' { 2 } else { 4 }).sum::<u16>() - 1;
                let total_h: u16 = 5;
                if area.width < total_w || area.height < total_h { return; }
                let start_x = area.x + (area.width.saturating_sub(total_w)) / 2;
                let start_y = area.y + (area.height.saturating_sub(total_h)) / 2;
                // Clear the area
                let clock_area = Rect::new(start_x.saturating_sub(1), start_y, total_w + 2, total_h);
                f.render_widget(Clear, clock_area);
                for row in 0..5u16 {
                    let mut x = start_x;
                    for ch in time_str.chars() {
                        if ch == ':' {
                            let cell_area = Rect::new(x, start_y + row, 1, 1);
                            let s = Span::styled(COLON[row as usize], Style::default().fg(Color::Cyan));
                            f.render_widget(Paragraph::new(Line::from(s)), cell_area);
                            x += 2;
                        } else if let Some(d) = ch.to_digit(10) {
                            let pattern = DIGITS[d as usize][row as usize];
                            let cell_area = Rect::new(x, start_y + row, 3, 1);
                            let s = Span::styled(pattern, Style::default().fg(Color::Cyan));
                            f.render_widget(Paragraph::new(Line::from(s)), cell_area);
                            x += 4;
                        }
                    }
                }
            }

            fn render_json(f: &mut Frame, node: &LayoutJson, area: Rect, dim_preds: bool, border_fg: Color, active_border_fg: Color, clock_mode: bool, active_rect: Option<Rect>) {
                match node {
                    LayoutJson::Leaf {
                        id: _,
                        rows: _,
                        cols: _,
                        cursor_row,
                        cursor_col,
                        alternate_screen,
                        active,
                        copy_mode,
                        scroll_offset,
                        sel_start_row,
                        sel_start_col,
                        sel_end_row,
                        sel_end_col,
                        content,
                        rows_v2,
                    } => {
                        // No borders — content fills entire area (tmux-style)
                        let inner = area;
                        let mut lines: Vec<Line> = Vec::new();
                        let use_full_cells = *copy_mode && *active && !content.is_empty();
                        if use_full_cells || rows_v2.is_empty() {
                            for r in 0..inner.height.min(content.len() as u16) {
                                let mut spans: Vec<Span> = Vec::new();
                                let row = &content[r as usize];
                                let max_c = inner.width.min(row.len() as u16);
                                let mut c: u16 = 0;
                                while c < max_c {
                                    let cell = &row[c as usize];
                                    let mut fg = map_color(&cell.fg);
                                    let mut bg = map_color(&cell.bg);
                                    if cell.inverse { std::mem::swap(&mut fg, &mut bg); }
                                    let in_selection = if *copy_mode && *active {
                                        if let (Some(sr), Some(sc), Some(er), Some(ec)) = (sel_start_row, sel_start_col, sel_end_row, sel_end_col) {
                                            r >= *sr && r <= *er && c >= *sc && c <= *ec
                                        } else { false }
                                    } else { false };
                                    if *active && dim_preds && !*alternate_screen
                                        && (r > *cursor_row || (r == *cursor_row && c >= *cursor_col))
                                    {
                                        fg = dim_color(fg);
                                    }
                                    let mut style = Style::default().fg(fg).bg(bg);
                                    if in_selection {
                                        style = style.fg(Color::Black).bg(Color::LightYellow);
                                    }
                                    if cell.dim { style = style.add_modifier(Modifier::DIM); }
                                    if cell.bold { style = style.add_modifier(Modifier::BOLD); }
                                    if cell.italic { style = style.add_modifier(Modifier::ITALIC); }
                                    if cell.underline { style = style.add_modifier(Modifier::UNDERLINED); }
                                    let text: &str = if cell.text.is_empty() { " " } else { &cell.text };
                                    let char_width = unicode_width::UnicodeWidthStr::width(text) as u16;
                                    spans.push(Span::styled(text, style));
                                    if char_width >= 2 {
                                        c += 2;
                                    } else {
                                        c += 1;
                                    }
                                }
                                lines.push(Line::from(spans));
                            }
                        } else {
                            for r in 0..inner.height.min(rows_v2.len() as u16) {
                                let mut spans: Vec<Span> = Vec::new();
                                let mut c: u16 = 0;
                                for run in &rows_v2[r as usize].runs {
                                    if c >= inner.width { break; }
                                    let mut fg = map_color(&run.fg);
                                    let mut bg = map_color(&run.bg);
                                    if run.flags & 16 != 0 { std::mem::swap(&mut fg, &mut bg); }
                                    if *active && dim_preds && !*alternate_screen
                                        && (r > *cursor_row || (r == *cursor_row && c >= *cursor_col))
                                    {
                                        fg = dim_color(fg);
                                    }
                                    let mut style = Style::default().fg(fg).bg(bg);
                                    if run.flags & 1 != 0 { style = style.add_modifier(Modifier::DIM); }
                                    if run.flags & 2 != 0 { style = style.add_modifier(Modifier::BOLD); }
                                    if run.flags & 4 != 0 { style = style.add_modifier(Modifier::ITALIC); }
                                    if run.flags & 8 != 0 { style = style.add_modifier(Modifier::UNDERLINED); }
                                    let text: &str = if run.text.is_empty() { " " } else { &run.text };
                                    spans.push(Span::styled(text, style));
                                    c = c.saturating_add(run.width.max(1));
                                }
                                lines.push(Line::from(spans));
                            }
                        }
                        f.render_widget(Clear, inner);
                        let para = Paragraph::new(Text::from(lines));
                        f.render_widget(para, inner);

                        // Copy mode indicator (replaces the old block title "[copy mode]")
                        if *copy_mode && *active {
                            let label = "[copy mode]";
                            let lw = label.len() as u16;
                            if area.width >= lw {
                                let lx = area.x + area.width.saturating_sub(lw);
                                let la = Rect::new(lx, area.y, lw, 1);
                                let ls = Span::styled(label, Style::default().fg(Color::Black).bg(Color::Yellow));
                                f.render_widget(Paragraph::new(Line::from(ls)), la);
                            }
                        }

                        if *copy_mode && *active && *scroll_offset > 0 {
                            let indicator = format!("[{}/{}]", scroll_offset, scroll_offset);
                            let indicator_width = indicator.len() as u16;
                            if area.width > indicator_width + 2 {
                                let indicator_x = area.x + area.width - indicator_width - 1;
                                let indicator_y = if *copy_mode { area.y + 1 } else { area.y };
                                let indicator_area = Rect::new(indicator_x, indicator_y, indicator_width, 1);
                                let indicator_span = Span::styled(indicator, Style::default().fg(Color::Black).bg(Color::Yellow));
                                f.render_widget(Paragraph::new(Line::from(indicator_span)), indicator_area);
                            }
                        }

                        if *active && !*copy_mode {
                            // Clock mode overlay
                            if clock_mode {
                                render_clock_overlay(f, inner);
                            }
                            let cy = inner.y + (*cursor_row).min(inner.height.saturating_sub(1));
                            let cx = inner.x + (*cursor_col).min(inner.width.saturating_sub(1));
                            f.set_cursor(cx, cy);
                        }
                    }
                    LayoutJson::Split { kind, sizes, children } => {
                        let effective_sizes: Vec<u16> = if sizes.len() == children.len() {
                            sizes.clone()
                        } else {
                            vec![(100 / children.len().max(1)) as u16; children.len()]
                        };
                        let is_horizontal = kind == "Horizontal";
                        let rects = split_with_gaps(is_horizontal, &effective_sizes, area);

                        // Render children first
                        for (i, child) in children.iter().enumerate() {
                            if i < rects.len() { render_json(f, child, rects[i], dim_preds, border_fg, active_border_fg, clock_mode, active_rect); }
                        }

                        // Draw separator lines between children using direct buffer access.
                        let border_style = Style::default().fg(border_fg);
                        let active_border_style = Style::default().fg(active_border_fg);
                        let buf = f.buffer_mut();
                        for i in 0..children.len().saturating_sub(1) {
                            if i >= rects.len() { break; }

                            // When both neighbours are direct leaves, use the midpoint
                            // half-highlight so the colored half indicates which side
                            // is active.  For nested splits, use adjacency to the
                            // computed active pane rect so only the correct portion of
                            // the separator is highlighted.
                            let both_leaves = matches!(&children[i], LayoutJson::Leaf { .. })
                                && matches!(children.get(i + 1), Some(LayoutJson::Leaf { .. }));

                            if is_horizontal {
                                // Vertical separator line between left/right children.
                                let sep_x = rects[i].x + rects[i].width;
                                if sep_x < buf.area.x + buf.area.width {
                                    if both_leaves {
                                        let left_active = matches!(&children[i], LayoutJson::Leaf { active, .. } if *active);
                                        let right_active = matches!(children.get(i + 1), Some(LayoutJson::Leaf { active, .. }) if *active);
                                        let left_sty = if left_active { active_border_style } else { border_style };
                                        let right_sty = if right_active { active_border_style } else { border_style };
                                        let mid_y = area.y + area.height / 2;
                                        for y in area.y..area.y + area.height {
                                            let sty = if y < mid_y { left_sty } else { right_sty };
                                            let idx = (y - buf.area.y) as usize * buf.area.width as usize
                                                + (sep_x - buf.area.x) as usize;
                                            if idx < buf.content.len() {
                                                buf.content[idx].set_char('│');
                                                buf.content[idx].set_style(sty);
                                            }
                                        }
                                    } else {
                                        for y in area.y..area.y + area.height {
                                            let active = active_rect.map_or(false, |ar| {
                                                y >= ar.y && y < ar.y + ar.height
                                                && (sep_x == ar.x + ar.width || sep_x + 1 == ar.x)
                                            });
                                            let sty = if active { active_border_style } else { border_style };
                                            let idx = (y - buf.area.y) as usize * buf.area.width as usize
                                                + (sep_x - buf.area.x) as usize;
                                            if idx < buf.content.len() {
                                                buf.content[idx].set_char('│');
                                                buf.content[idx].set_style(sty);
                                            }
                                        }
                                    }
                                }
                            } else {
                                // Horizontal separator line between top/bottom children.
                                let sep_y = rects[i].y + rects[i].height;
                                if sep_y < buf.area.y + buf.area.height {
                                    if both_leaves {
                                        let top_active = matches!(&children[i], LayoutJson::Leaf { active, .. } if *active);
                                        let bot_active = matches!(children.get(i + 1), Some(LayoutJson::Leaf { active, .. }) if *active);
                                        let top_sty = if top_active { active_border_style } else { border_style };
                                        let bot_sty = if bot_active { active_border_style } else { border_style };
                                        let mid_x = area.x + area.width / 2;
                                        for x in area.x..area.x + area.width {
                                            let sty = if x < mid_x { top_sty } else { bot_sty };
                                            let idx = (sep_y - buf.area.y) as usize * buf.area.width as usize
                                                + (x - buf.area.x) as usize;
                                            if idx < buf.content.len() {
                                                buf.content[idx].set_char('─');
                                                buf.content[idx].set_style(sty);
                                            }
                                        }
                                    } else {
                                        for x in area.x..area.x + area.width {
                                            let active = active_rect.map_or(false, |ar| {
                                                x >= ar.x && x < ar.x + ar.width
                                                && (sep_y == ar.y + ar.height || sep_y + 1 == ar.y)
                                            });
                                            let sty = if active { active_border_style } else { border_style };
                                            let idx = (sep_y - buf.area.y) as usize * buf.area.width as usize
                                                + (x - buf.area.x) as usize;
                                            if idx < buf.content.len() {
                                                buf.content[idx].set_char('─');
                                                buf.content[idx].set_style(sty);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            let active_rect = compute_active_rect_json(&root, chunks[0]);
            render_json(f, &root, chunks[0], dim_preds, pane_border_fg, pane_active_border_fg, clock_active, active_rect);

            // ── Left-click drag text selection overlay ────────────────
            if let (Some(s), Some(e)) = (sel_s, sel_e) {
                // Normalise so (r0,c0) <= (r1,c1) in reading order
                let (r0, c0, r1, c1) = if (s.1, s.0) <= (e.1, e.0) {
                    (s.1, s.0, e.1, e.0)
                } else {
                    (e.1, e.0, s.1, s.0)
                };
                let buf = f.buffer_mut();
                let buf_area = buf.area;
                for row in r0..=r1 {
                    let col_start = if row == r0 { c0 } else { 0 };
                    let col_end = if row == r1 { c1 } else { area.width.saturating_sub(1) };
                    for col in col_start..=col_end {
                        if row < buf_area.height && col < buf_area.width {
                            let idx = (row - buf_area.y) as usize * buf_area.width as usize
                                + (col - buf_area.x) as usize;
                            if idx < buf.content.len() {
                                buf.content[idx].set_style(Style::default().fg(Color::Black).bg(Color::LightCyan));
                            }
                        }
                    }
                }
            }

            if session_chooser {
                let overlay = Block::default().borders(Borders::ALL).title("choose-session (enter=switch, x=kill, esc=close)");
                let oa = centered_rect(70, 20, chunks[0]);
                f.render_widget(Clear, oa);
                f.render_widget(&overlay, oa);
                let mut lines: Vec<Line> = Vec::new();
                for (i, (sname, info)) in session_entries.iter().enumerate() {
                    let marker = if sname == &current_session { "*" } else { " " };
                    let line = if i == session_selected {
                        Line::from(Span::styled(format!("{} {}", marker, info), Style::default().bg(Color::Yellow).fg(Color::Black)))
                    } else {
                        Line::from(format!("{} {}", marker, info))
                    };
                    lines.push(line);
                }
                let para = Paragraph::new(Text::from(lines));
                f.render_widget(para, overlay.inner(oa));
            }
            if tree_chooser {
                let overlay = Block::default().borders(Borders::ALL).title("choose-tree");
                let oa = centered_rect(60, 30, chunks[0]);
                f.render_widget(Clear, oa);
                f.render_widget(&overlay, oa);
                let mut lines: Vec<Line> = Vec::new();
                for (i, (is_win, wid, _pid, label, _sess)) in tree_entries.iter().enumerate() {
                    let line = if i == tree_selected {
                        Line::from(Span::styled(label.clone(), Style::default().bg(Color::Yellow).fg(Color::Black)))
                    } else if *is_win && *wid == usize::MAX {
                        // Session header — bold
                        Line::from(Span::styled(label.clone(), Style::default().add_modifier(Modifier::BOLD)))
                    } else {
                        Line::from(label.clone())
                    };
                    lines.push(line);
                }
                let para = Paragraph::new(Text::from(lines));
                f.render_widget(para, overlay.inner(oa));
            }
            if chooser {
                let mut rects: Vec<(usize, Rect)> = Vec::new();
                fn rec(node: &LayoutJson, area: Rect, out: &mut Vec<(usize, Rect)>) {
                    match node {
                        LayoutJson::Leaf { id, .. } => { out.push((*id, area)); }
                        LayoutJson::Split { kind, sizes, children } => {
                            let effective_sizes: Vec<u16> = if sizes.len() == children.len() {
                                sizes.clone()
                            } else {
                                vec![(100 / children.len().max(1)) as u16; children.len()]
                            };
                            let is_horizontal = kind == "Horizontal";
                            let rects = split_with_gaps(is_horizontal, &effective_sizes, area);
                            for (i, child) in children.iter().enumerate() {
                                if i < rects.len() { rec(child, rects[i], out); }
                            }
                        }
                    }
                }
                rec(&root, chunks[0], &mut rects);
                choices.clear();
                for (i, (pid, r)) in rects.iter().enumerate() {
                    if i < 10 {
                        choices.push((i + 1, *pid));
                        let bw = 7u16; let bh = 3u16;
                        let bx = r.x + r.width.saturating_sub(bw) / 2;
                        let by = r.y + r.height.saturating_sub(bh) / 2;
                        let b = Rect { x: bx, y: by, width: bw, height: bh };
                        let block = Block::default().borders(Borders::ALL).style(Style::default().bg(Color::Yellow).fg(Color::Black));
                        let inner = block.inner(b);
                        let disp = if i + 1 == 10 { 0 } else { i + 1 };
                        let para = Paragraph::new(Line::from(Span::styled(
                            format!(" {} ", disp),
                            Style::default().fg(Color::Black).bg(Color::Yellow).add_modifier(Modifier::BOLD),
                        ))).alignment(Alignment::Center);
                        f.render_widget(Clear, b);
                        f.render_widget(block, b);
                        f.render_widget(para, inner);
                    }
                }
            }
            let sb_fg = status_fg;
            let sb_bg = status_bg;
            let sb_base = if status_bold {
                Style::default().fg(sb_fg).bg(sb_bg).add_modifier(Modifier::BOLD)
            } else {
                Style::default().fg(sb_fg).bg(sb_bg)
            };
            // Left portion: custom status_left or default [session] prefix
            let left_prefix = match custom_status_left {
                Some(ref sl) => format!("{} ", sl),
                None => format!("[{}] ", name),
            };
            let mut status_spans: Vec<Span> = vec![
                Span::styled(left_prefix, sb_base),
            ];
            for (i, w) in windows.iter().enumerate() {
                // Use pre-expanded tab_text from server (full format expansion)
                let tab_text = if !w.tab_text.is_empty() {
                    w.tab_text.clone()
                } else {
                    // Fallback for old server: naive expansion
                    let display_idx = i + base_index;
                    let fmt = if w.active { &win_status_current_fmt } else { &win_status_fmt };
                    fmt.replace("#I", &display_idx.to_string())
                       .replace("#W", &w.name)
                       .replace("#F", if w.active { "*" } else { "" })
                };
                if i > 0 {
                    status_spans.push(Span::styled(win_status_sep.clone(), sb_base));
                }
                if w.active {
                    let active_style = if let Some((fg, bg, bold)) = win_status_current_style {
                        let mut s = Style::default();
                        if let Some(c) = fg { s = s.fg(c); } else { s = s.fg(Color::Black); }
                        if let Some(c) = bg { s = s.bg(c); } else { s = s.bg(Color::Yellow); }
                        if bold { s = s.add_modifier(Modifier::BOLD); }
                        s
                    } else {
                        Style::default()
                            .fg(Color::Black)
                            .bg(Color::Yellow)
                            .add_modifier(Modifier::BOLD)
                    };
                    status_spans.push(Span::styled(tab_text, active_style));
                } else if w.activity {
                    // Activity visual notification: reverse video for windows with activity
                    status_spans.push(Span::styled(
                        tab_text,
                        Style::default()
                            .fg(Color::Black)
                            .bg(Color::White)
                            .add_modifier(Modifier::BOLD),
                    ));
                } else {
                    let inactive_style = if let Some((fg, bg, bold)) = win_status_style {
                        let mut s = Style::default();
                        if let Some(c) = fg { s = s.fg(c); }
                        if let Some(c) = bg { s = s.bg(c); }
                        if bold { s = s.add_modifier(Modifier::BOLD); }
                        s
                    } else {
                        sb_base
                    };
                    status_spans.push(Span::styled(tab_text, inactive_style));
                }
            }
            // Right portion: custom status_right (already expanded by server)
            let right_text = custom_status_right.as_deref().unwrap_or("").to_string();
            // Compute how many columns are used by left + window tabs
            let left_used: usize = status_spans.iter().map(|s| s.content.len()).sum();
            let right_len = right_text.len();
            let total_width = chunks[1].width as usize;
            if left_used + right_len < total_width {
                let pad = total_width - left_used - right_len;
                status_spans.push(Span::styled(" ".repeat(pad), sb_base));
                status_spans.push(Span::styled(right_text, sb_base));
            }
            let status_bar = Paragraph::new(Line::from(status_spans)).style(sb_base);
            f.render_widget(Clear, chunks[1]);
            f.render_widget(status_bar, chunks[1]);
            if renaming {
                let overlay = Block::default().borders(Borders::ALL).title("rename window");
                let oa = centered_rect(60, 3, chunks[0]);
                f.render_widget(Clear, oa);
                f.render_widget(&overlay, oa);
                let para = Paragraph::new(format!("name: {}", rename_buf));
                f.render_widget(para, overlay.inner(oa));
            }
            if pane_renaming {
                let overlay = Block::default().borders(Borders::ALL).title("set pane title");
                let oa = centered_rect(60, 3, chunks[0]);
                f.render_widget(Clear, oa);
                f.render_widget(&overlay, oa);
                let para = Paragraph::new(format!("title: {}", pane_title_buf));
                f.render_widget(para, overlay.inner(oa));
            }
            if command_input {
                let overlay = Block::default().borders(Borders::ALL).title("command");
                let oa = centered_rect(60, 3, chunks[0]);
                f.render_widget(Clear, oa);
                f.render_widget(&overlay, oa);
                let para = Paragraph::new(format!(": {}", command_buf));
                f.render_widget(para, overlay.inner(oa));
            }
            if let Some(ref cmd) = confirm_cmd {
                let overlay = Block::default().borders(Borders::ALL).title("confirm");
                let oa = centered_rect(50, 3, chunks[0]);
                f.render_widget(Clear, oa);
                f.render_widget(&overlay, oa);
                let para = Paragraph::new(format!("{}? (y/n)", cmd));
                f.render_widget(para, overlay.inner(oa));
            }
        })?;
        let _render_us = _t_parse.elapsed().as_micros().saturating_sub(_parse_us as u128);
        last_dump_time = Instant::now();
        // Latency log: measure full cycle from key-send to render-complete
        if let (Some(ref mut log), Some(ks)) = (&mut latency_log, key_send_instant) {
            let elapsed_ms = ks.elapsed().as_millis();
            loop_count += 1;
            use std::io::Write;
            let _ = writeln!(log, "L{}: key->render {}ms  parse={}us  render={}us  json_len={}  since_dump={}",
                loop_count, elapsed_ms, _parse_us, _render_us, dump_buf.len(), since_dump);
            // Only clear after we rendered a DIFFERENT frame (echo arrived)
            if got_frame && dump_buf != prev_dump_buf {
                let _ = writeln!(log, "L{}: ECHO VISIBLE after {}ms  (parse={}us render={}us)",
                    loop_count, elapsed_ms, _parse_us, _render_us);
                key_send_instant = None;
            }
        }
        selection_changed = false;
        // Cache this frame so we can skip identical re-renders.
        // Only update cache when we got a genuinely new frame (not selection-only redraw)
        if got_frame && dump_buf != prev_dump_buf {
            std::mem::swap(&mut prev_dump_buf, &mut dump_buf);
        }
        // DON'T clear last_key_send_time — keep fast-dumping for 100ms
        // after last keystroke so we catch the ConPTY echo promptly.
        // The timer expires naturally in the poll_ms calculation above.
        // Clear key_send_instant once echo arrives (frame differs).
        if got_frame && dump_buf != prev_dump_buf {
            key_send_instant = None;
        }
        force_dump = false;
    }

    // Clean disconnect on persistent connection
    let _ = writer.write_all(b"client-detach\n");
    let _ = writer.flush();
    Ok(())
}