aimux_server/

session.rs

use std::collections::HashMap;
use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::{Arc, Weak};
use std::time::{SystemTime, UNIX_EPOCH};

use anyhow::{bail, Context, Result};
use tokio::sync::{broadcast, RwLock};
use aimux_common::config::AimuxConfig;
use aimux_protocol::{
    PaneId, PaneInfo, ProcessInfo, SessionId, SessionInfo, WindowId, WindowInfo,
};

use crate::screen::{Screen, DEFAULT_SCROLLBACK_LIMIT};

const MIN_PANE_COLS: u16 = 2;
const MIN_PANE_ROWS: u16 = 1;
const MAX_PANE_COLS: u16 = 1000;
const MAX_PANE_ROWS: u16 = 1000;

// ---------------------------------------------------------------------------
// PtyBackend trait
// ---------------------------------------------------------------------------

pub trait PtyBackend: Send {
    fn write(&self, data: &[u8]) -> Result<()>;
    fn resize(&self, cols: u16, rows: u16) -> Result<()>;
    fn close(&mut self) -> Result<()>;
    fn pid(&self) -> u32;
}

/// Pane IDs + extracted PTY backends that the caller must close outside the lock.
pub type LayoutResult = Result<(Vec<PaneId>, Vec<Box<dyn PtyBackend>>)>;

// ---------------------------------------------------------------------------
// PtySpawnResult - returned by the factory
// ---------------------------------------------------------------------------

pub struct PtySpawnResult {
    pub backend: Box<dyn PtyBackend>,
    pub pid: u32,
    pub output_rx: tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>,
    pub exit_rx: tokio::sync::oneshot::Receiver<i32>,
}

/// Factory function type for creating PTY backends. Allows injection of MockPty in tests.
pub type PtyFactory = Box<dyn Fn(&str, u16, u16) -> Result<PtySpawnResult> + Send + Sync>;

// ---------------------------------------------------------------------------
// Pane
// ---------------------------------------------------------------------------

#[derive(Default)]
pub struct PaneOptions {
    pub remain_on_exit: bool,
}

pub struct Pane {
    pub id: PaneId,
    pub pty: Box<dyn PtyBackend>,
    pub screen: Arc<RwLock<Screen>>,
    pub process: ProcessInfo,
    pub size: (u16, u16), // (cols, rows)
    pub title: String,
    pub shell_command: String,
    pub options: PaneOptions,
    /// Notifies waiters when screen content is updated.
    pub update_tx: broadcast::Sender<()>,
    /// Forwards raw PTY output bytes for subscribers.
    pub raw_tx: broadcast::Sender<Vec<u8>>,
    /// Sends exit code when the process dies.
    pub exit_tx: broadcast::Sender<i32>,
}

impl Pane {
    pub fn to_info(&self) -> PaneInfo {
        PaneInfo {
            id: self.id.clone(),
            pid: self.process.pid,
            running: self.process.running,
            exit_code: self.process.exit_code,
            size: self.size,
            title: self.title.clone(),
            marks: Vec::new(),
        }
    }
}

// ---------------------------------------------------------------------------
// Layout
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, PartialEq)]
pub enum Layout {
    Single,
    EvenHorizontal,
    EvenVertical,
    MainVertical,
    Tiled,
    Custom(crate::layout_dsl::LayoutTree),
}

// ---------------------------------------------------------------------------
// Window
// ---------------------------------------------------------------------------

pub struct Window {
    pub id: WindowId,
    pub panes: Vec<Pane>,
    pub active_pane: usize,
    pub layout: Layout,
}

impl Window {
    pub fn split_pane(&mut self, pane: Pane, horizontal: bool) {
        self.panes.push(pane);
        // Custom layout invalidated when panes added outside apply_layout
        if matches!(self.layout, Layout::Custom(_)) {
            self.layout = Layout::EvenHorizontal;
        } else if self.panes.len() == 2 {
            self.layout = if horizontal {
                Layout::EvenHorizontal
            } else {
                Layout::EvenVertical
            };
        }
    }

    pub fn compute_pane_positions(
        &self,
        area_width: u16,
        area_height: u16,
    ) -> Vec<(PaneId, crate::layout::PanePosition)> {
        let positions =
            crate::layout::compute_layout(&self.layout, self.panes.len(), area_width, area_height);
        self.panes
            .iter()
            .zip(positions)
            .map(|(pane, pos)| (pane.id.clone(), pos))
            .collect()
    }

    /// Remove a pane by ID. Returns (window_empty, backend) so the
    /// caller can close the backend outside the session manager lock.
    pub fn kill_pane(&mut self, pane_id: &str) -> Result<(bool, Box<dyn PtyBackend>)> {
        let idx = self
            .panes
            .iter()
            .position(|p| p.id == pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;

        let pane = self.panes.remove(idx);
        let backend = pane.pty;

        // Adjust active_pane index.
        if self.panes.is_empty() {
            return Ok((true, backend));
        }
        if self.active_pane >= self.panes.len() {
            self.active_pane = self.panes.len() - 1;
        }
        if self.panes.len() == 1 {
            self.layout = Layout::Single;
        } else if matches!(self.layout, Layout::Custom(_)) {
            // Custom layout invalidated when panes removed outside apply_layout
            self.layout = Layout::EvenHorizontal;
        }
        Ok((false, backend))
    }

    pub fn to_info(&self) -> WindowInfo {
        let active_pane_id = self
            .panes
            .get(self.active_pane)
            .map(|p| p.id.clone())
            .unwrap_or_default();
        WindowInfo {
            id: self.id,
            panes: self.panes.iter().map(|p| p.to_info()).collect(),
            active_pane: active_pane_id,
        }
    }
}

// ---------------------------------------------------------------------------
// SessionOptions
// ---------------------------------------------------------------------------

pub struct SessionOptions {
    pub default_shell: String,
    pub prompt_pattern: String,
    pub scrollback_limit: usize,
}

fn default_shell() -> String {
    #[cfg(windows)]
    {
        "powershell.exe".to_string()
    }
    #[cfg(unix)]
    {
        std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".to_string())
    }
}

impl Default for SessionOptions {
    fn default() -> Self {
        Self {
            default_shell: default_shell(),
            prompt_pattern: ">".to_string(),
            scrollback_limit: DEFAULT_SCROLLBACK_LIMIT,
        }
    }
}

// ---------------------------------------------------------------------------
// Session
// ---------------------------------------------------------------------------

pub struct Session {
    pub name: SessionId,
    pub windows: Vec<Window>,
    pub active_window: usize,
    pub options: SessionOptions,
    pub created_at: SystemTime,
    next_window_id: u32,
}

impl Session {
    fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            windows: Vec::new(),
            active_window: 0,
            options: SessionOptions::default(),
            created_at: SystemTime::now(),
            next_window_id: 0,
        }
    }

    pub fn new_window(&mut self, pane: Pane) -> WindowId {
        let window_id = self.next_window_id;
        self.next_window_id += 1;
        self.windows.push(Window {
            id: window_id,
            panes: vec![pane],
            active_pane: 0,
            layout: Layout::Single,
        });
        window_id
    }

    /// Kill a window by ID. Returns (session_empty, backends) so the
    /// caller can close the backends outside the session manager lock.
    pub fn kill_window(&mut self, window_id: WindowId) -> Result<(bool, Vec<Box<dyn PtyBackend>>)> {
        let idx = self
            .windows
            .iter()
            .position(|w| w.id == window_id)
            .ok_or_else(|| anyhow::anyhow!("window not found: {}", window_id))?;

        let window = self.windows.remove(idx);
        let backends: Vec<Box<dyn PtyBackend>> =
            window.panes.into_iter().map(|p| p.pty).collect();

        if self.windows.is_empty() {
            return Ok((true, backends));
        }
        if self.active_window >= self.windows.len() {
            self.active_window = self.windows.len() - 1;
        }
        Ok((false, backends))
    }

    pub fn to_info(&self) -> SessionInfo {
        let created_at = self
            .created_at
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();
        SessionInfo {
            name: self.name.clone(),
            windows: self.windows.iter().map(|w| w.to_info()).collect(),
            created_at,
        }
    }

    /// Find a window by ID.
    pub fn find_window(&self, window_id: WindowId) -> Option<&Window> {
        self.windows.iter().find(|w| w.id == window_id)
    }

    pub fn find_window_mut(&mut self, window_id: WindowId) -> Option<&mut Window> {
        self.windows.iter_mut().find(|w| w.id == window_id)
    }
}

// ---------------------------------------------------------------------------
// Screen feed task
// ---------------------------------------------------------------------------

/// Async task that reads PTY output and feeds it to the screen state machine.
async fn run_screen_feed(
    mut output_rx: tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>,
    screen: Arc<RwLock<Screen>>,
    update_tx: broadcast::Sender<()>,
    raw_tx: broadcast::Sender<Vec<u8>>,
) {
    tracing::debug!("screen_feed: task started, waiting for PTY output");
    while let Some(data) = output_rx.recv().await {
        tracing::trace!("screen_feed: received {} bytes", data.len());
        {
            let mut s = screen.write().await;
            s.feed(&data);
        }
        let _ = update_tx.send(());
        let _ = raw_tx.send(data);
    }
    tracing::debug!("screen_feed: channel closed, task exiting");
}

/// Spawn the screen feed task and exit monitor task.
#[allow(clippy::too_many_arguments)]
fn spawn_pane_tasks(
    output_rx: tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>,
    screen: Arc<RwLock<Screen>>,
    exit_rx: tokio::sync::oneshot::Receiver<i32>,
    update_tx: broadcast::Sender<()>,
    raw_tx: broadcast::Sender<Vec<u8>>,
    exit_tx: broadcast::Sender<i32>,
    pane_id: PaneId,
    manager: Option<Arc<tokio::sync::Mutex<SessionManager>>>,
) {
    // Screen feed task: feeds VT data to screen, notifies waiters, forwards raw bytes
    tracing::debug!("spawn_pane_tasks: spawning screen feed for pane {}", pane_id);
    tokio::spawn(run_screen_feed(output_rx, screen, update_tx, raw_tx));

    // Exit monitor: updates pane state and optionally cascade-kills
    tokio::spawn(async move {
        if let Ok(code) = exit_rx.await {
            // Broadcast the exit code to subscribers
            let _ = exit_tx.send(code);

            if let Some(mgr_arc) = manager {
                let mut mgr = mgr_arc.lock().await;
                // Update process state
                if let Some(pane) = mgr.find_pane_mut(&pane_id) {
                    pane.process.running = false;
                    pane.process.exit_code = Some(code);
                    tracing::info!("pane {} exited with code {}", pane_id, code);

                    if !pane.options.remain_on_exit {
                        drop(mgr);
                        // Reacquire to cascade kill, then close backends outside lock
                        let backends = {
                            let mut mgr = mgr_arc.lock().await;
                            mgr.kill_pane(&pane_id).unwrap_or_default()
                        };
                        for mut b in backends {
                            let _ = b.close();
                        }
                    }
                }
            }
        }
    });
}

// ---------------------------------------------------------------------------
// SessionManager
// ---------------------------------------------------------------------------

fn validate_mark_name(name: &str) -> Result<()> {
    if name.is_empty() || name.len() > 32 {
        bail!("mark name must be 1-32 characters, got {}", name.len());
    }
    if !name
        .chars()
        .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
    {
        bail!(
            "mark name must be alphanumeric, hyphens, or underscores: {}",
            name
        );
    }
    Ok(())
}

fn parse_layout_name(name: &str) -> Result<Layout> {
    match name {
        "single" => Ok(Layout::Single),
        "even-horizontal" => Ok(Layout::EvenHorizontal),
        "even-vertical" => Ok(Layout::EvenVertical),
        "main-vertical" => Ok(Layout::MainVertical),
        "tiled" => Ok(Layout::Tiled),
        other => bail!(
            "unknown layout: {} (valid: single, even-horizontal, even-vertical, main-vertical, tiled)",
            other
        ),
    }
}

/// Recursively collect (mark, command) info from leaf nodes in DSL order.
fn collect_leaf_info(
    node: &aimux_common::config::LayoutNode,
    out: &mut Vec<(Option<String>, Option<String>)>,
) {
    if node.direction.is_none() {
        out.push((node.mark.clone(), node.command.clone()));
    } else if let Some(ref children) = node.children {
        for child in children {
            collect_leaf_info(child, out);
        }
    }
}

pub struct SessionManager {
    pub(crate) sessions: HashMap<SessionId, Session>,
    next_pane_id: AtomicU32,
    pty_factory: PtyFactory,
    self_arc: Option<Weak<tokio::sync::Mutex<SessionManager>>>,
    pub(crate) pane_index: HashMap<PaneId, (SessionId, WindowId)>,
    config: AimuxConfig,
    pub(crate) marks: HashMap<String, PaneId>,
    start_time: std::time::Instant,
}

impl SessionManager {
    pub fn new(pty_factory: PtyFactory, config: AimuxConfig) -> Self {
        Self {
            sessions: HashMap::new(),
            next_pane_id: AtomicU32::new(0),
            pty_factory,
            self_arc: None,
            pane_index: HashMap::new(),
            config,
            marks: HashMap::new(),
            start_time: std::time::Instant::now(),
        }
    }

    pub fn set_self_arc(&mut self, arc: &Arc<tokio::sync::Mutex<SessionManager>>) {
        self.self_arc = Some(Arc::downgrade(arc));
    }

    pub fn allocate_pane_id(&self) -> PaneId {
        let id = self.next_pane_id.fetch_add(1, Ordering::Relaxed);
        format!("%{}", id)
    }

    pub fn default_session_options(&self) -> SessionOptions {
        let mut opts = SessionOptions::default();
        if let Some(ref shell) = self.config.default_shell {
            opts.default_shell = shell.clone();
        }
        if let Some(ref pattern) = self.config.prompt_pattern {
            opts.prompt_pattern = pattern.clone();
        }
        if let Some(limit) = self.config.scrollback_limit {
            opts.scrollback_limit = limit;
        }
        opts
    }

    pub fn reload_config(&mut self, config: AimuxConfig) {
        self.config = config;
    }

    pub fn server_status(&self) -> aimux_protocol::ServerStatusInfo {
        let uptime_secs = self.start_time.elapsed().as_secs();
        let mut windows: u32 = 0;
        let mut panes: u32 = 0;
        for session in self.sessions.values() {
            windows += session.windows.len() as u32;
            for window in &session.windows {
                panes += window.panes.len() as u32;
            }
        }
        aimux_protocol::ServerStatusInfo {
            version: String::new(), // filled by dispatch with CARGO_PKG_VERSION
            uptime_secs,
            sessions: self.sessions.len() as u32,
            windows,
            panes,
            pid: 0, // filled by dispatch with std::process::id()
        }
    }

    pub fn config(&self) -> &AimuxConfig {
        &self.config
    }

    pub(crate) fn config_mut(&mut self) -> &mut AimuxConfig {
        &mut self.config
    }

    // -- Pane marks --

    pub fn resolve_pane_target(&self, target: &str) -> Result<String> {
        if let Some(mark_name) = target.strip_prefix('@') {
            self.marks
                .get(mark_name)
                .cloned()
                .ok_or_else(|| anyhow::anyhow!("mark not found: @{}", mark_name))
        } else {
            Ok(target.to_string())
        }
    }

    pub fn set_mark(&mut self, mark: &str, pane_id: &str) -> Result<()> {
        validate_mark_name(mark)?;
        if !self.pane_index.contains_key(pane_id) {
            bail!("pane not found: {}", pane_id);
        }
        self.marks.insert(mark.to_string(), pane_id.to_string());
        Ok(())
    }

    pub fn remove_mark(&mut self, mark: &str) -> Result<()> {
        self.marks
            .remove(mark)
            .ok_or_else(|| anyhow::anyhow!("mark not found: {}", mark))?;
        Ok(())
    }

    pub fn list_marks(&self) -> Vec<(String, String)> {
        self.marks
            .iter()
            .map(|(k, v)| (k.clone(), v.clone()))
            .collect()
    }

    pub fn marks_for_pane(&self, pane_id: &str) -> Vec<String> {
        self.marks
            .iter()
            .filter(|(_, v)| v.as_str() == pane_id)
            .map(|(k, _)| k.clone())
            .collect()
    }

    fn inject_marks(&self, pane_infos: &mut [PaneInfo]) {
        for info in pane_infos.iter_mut() {
            info.marks = self.marks_for_pane(&info.id);
        }
    }

    /// Apply a named layout from config to a window.
    /// Creates/kills panes to match leaf count, sets Custom layout, applies marks.
    /// Returns (pane_ids, backends_to_close) so the caller can close backends outside the lock.
    pub fn apply_layout(
        &mut self,
        session_name: &str,
        window_id: WindowId,
        layout_name: &str,
    ) -> LayoutResult {
        // Try config first, then fall back to saved layouts / presets via load_layout
        let layout_node = self
            .config
            .layouts
            .as_ref()
            .and_then(|layouts| layouts.get(layout_name))
            .cloned();

        let layout_node = match layout_node {
            Some(node) => node,
            None => {
                // Delegate to load_layout which handles saved files and presets
                return self.load_layout(session_name, window_id, layout_name);
            }
        };

        let tree = crate::layout_dsl::config_to_tree(&layout_node)
            .context("invalid layout definition")?;
        let leaf_count = tree.leaf_count();
        if leaf_count == 0 {
            bail!("layout must have at least one leaf pane");
        }

        // Collect leaf marks/commands from the layout DSL
        let mut leaf_info: Vec<(Option<String>, Option<String>)> = Vec::new();
        collect_leaf_info(&layout_node, &mut leaf_info);

        let session = self
            .sessions
            .get(session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;
        let default_shell = session.options.default_shell.clone();
        let scrollback_limit = session.options.scrollback_limit;
        let window = session
            .find_window(window_id)
            .ok_or_else(|| anyhow::anyhow!("window not found: {}", window_id))?;
        let current_count = window.panes.len();

        // Kill excess panes from the end — collect backends instead of closing
        let mut killed_backends = Vec::new();
        if current_count > leaf_count {
            let to_kill: Vec<PaneId> = {
                let session = self.sessions.get(session_name).unwrap();
                let window = session.find_window(window_id).unwrap();
                window.panes[leaf_count..]
                    .iter()
                    .map(|p| p.id.clone())
                    .collect()
            };
            for pane_id in &to_kill {
                self.pane_index.remove(pane_id);
                self.marks.retain(|_, v| v.as_str() != pane_id.as_str());
            }
            let session = self.sessions.get_mut(session_name).unwrap();
            let window = session.find_window_mut(window_id).unwrap();
            for pane_id in &to_kill {
                if let Some(idx) = window.panes.iter().position(|p| p.id == *pane_id) {
                    let pane = window.panes.remove(idx);
                    killed_backends.push(pane.pty);
                }
            }
        }

        // Create additional panes if needed
        if current_count < leaf_count {
            let needed = leaf_count - current_count;
            let mut new_panes = Vec::with_capacity(needed);
            for _ in 0..needed {
                let pane = self.create_pane(&default_shell, 80, 24, scrollback_limit)?;
                new_panes.push(pane);
            }
            for pane in new_panes {
                let pane_id = pane.id.clone();
                self.pane_index
                    .insert(pane_id, (session_name.to_string(), window_id));
                let session = self.sessions.get_mut(session_name).unwrap();
                let window = session.find_window_mut(window_id).unwrap();
                window.panes.push(pane);
            }
        }

        // Set the Custom layout
        let session = self.sessions.get_mut(session_name).unwrap();
        let window = session.find_window_mut(window_id).unwrap();
        window.layout = Layout::Custom(tree);
        if window.active_pane >= window.panes.len() {
            window.active_pane = window.panes.len().saturating_sub(1);
        }

        // Collect pane IDs and apply marks
        let pane_ids: Vec<PaneId> = window.panes.iter().map(|p| p.id.clone()).collect();
        for (i, (mark, _cmd)) in leaf_info.iter().enumerate() {
            if let Some(mark_name) = mark {
                if i < pane_ids.len() {
                    let _ = self.set_mark(mark_name, &pane_ids[i]);
                }
            }
        }

        Ok((pane_ids, killed_backends))
    }

    /// Select a preset layout for an existing window.
    pub fn select_layout(
        &mut self,
        session_name: &str,
        window_id: WindowId,
        layout_name: &str,
    ) -> Result<()> {
        let layout = parse_layout_name(layout_name)?;
        let session = self
            .sessions
            .get_mut(session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;
        let window = session
            .find_window_mut(window_id)
            .ok_or_else(|| anyhow::anyhow!("window not found: {}", window_id))?;
        window.layout = layout;
        Ok(())
    }

    pub(crate) fn create_pane(
        &self,
        shell: &str,
        cols: u16,
        rows: u16,
        scrollback_limit: usize,
    ) -> Result<Pane> {
        let pane_id = self.allocate_pane_id();
        let spawn_result = (self.pty_factory)(shell, cols, rows)?;

        let screen = Arc::new(RwLock::new(Screen::new(cols, rows, scrollback_limit)));

        // Broadcast channels for AI orchestration (wait, subscribe, exec)
        let (update_tx, _) = broadcast::channel(64);
        let (raw_tx, _) = broadcast::channel(64);
        let (exit_tx, _) = broadcast::channel(4);

        let manager_arc = self.self_arc.as_ref().and_then(|w| w.upgrade());

        // Spawn the screen feed and exit monitor tasks.
        spawn_pane_tasks(
            spawn_result.output_rx,
            screen.clone(),
            spawn_result.exit_rx,
            update_tx.clone(),
            raw_tx.clone(),
            exit_tx.clone(),
            pane_id.clone(),
            manager_arc,
        );

        Ok(Pane {
            id: pane_id,
            pty: spawn_result.backend,
            screen,
            process: ProcessInfo {
                pid: spawn_result.pid,
                running: true,
                exit_code: None,
            },
            size: (cols, rows),
            title: shell.to_string(),
            shell_command: shell.to_string(),
            options: PaneOptions::default(),
            update_tx,
            raw_tx,
            exit_tx,
        })
    }

    pub fn new_session(
        &mut self,
        name: &str,
        shell: Option<&str>,
    ) -> Result<(SessionId, PaneId)> {
        if self.sessions.contains_key(name) {
            bail!("session already exists: {}", name);
        }

        let mut session = Session::new(name);
        session.options = self.default_session_options();
        let shell = shell.unwrap_or(&session.options.default_shell).to_string();
        let scrollback_limit = session.options.scrollback_limit;
        let pane = self.create_pane(&shell, 80, 24, scrollback_limit)?;
        let pane_id = pane.id.clone();

        let window_id = session.new_window(pane);
        let session_id = session.name.clone();
        self.pane_index.insert(pane_id.clone(), (session_id.clone(), window_id));
        self.sessions.insert(session_id.clone(), session);

        Ok((session_id, pane_id))
    }

    pub fn kill_session(&mut self, name: &str) -> Result<Vec<Box<dyn PtyBackend>>> {
        let session = self
            .sessions
            .remove(name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", name))?;

        let pane_ids: Vec<String> = session
            .windows
            .iter()
            .flat_map(|w| w.panes.iter().map(|p| p.id.clone()))
            .collect();

        let mut backends = Vec::new();
        for window in session.windows {
            for pane in window.panes {
                self.pane_index.remove(&pane.id);
                backends.push(pane.pty);
            }
        }

        self.marks.retain(|_, v| !pane_ids.contains(v));
        Ok(backends)
    }

    pub fn list_sessions(&self) -> Vec<SessionInfo> {
        let mut sessions: Vec<SessionInfo> = self.sessions.values().map(|s| s.to_info()).collect();
        for session in &mut sessions {
            for window in &mut session.windows {
                self.inject_marks(&mut window.panes);
            }
        }
        sessions
    }

    pub fn has_session(&self, name: &str) -> bool {
        self.sessions.contains_key(name)
    }

    #[allow(dead_code)]
    pub fn get_session(&self, name: &str) -> Option<&Session> {
        self.sessions.get(name)
    }

    pub fn get_session_mut(&mut self, name: &str) -> Option<&mut Session> {
        self.sessions.get_mut(name)
    }

    /// Find a pane by its global ID across all sessions.
    pub fn find_pane(&self, pane_id: &str) -> Option<(&Session, &Window, &Pane)> {
        let (session_id, window_id) = self.pane_index.get(pane_id)?;
        let session = self.sessions.get(session_id)?;
        let window = session.find_window(*window_id)?;
        let pane = window.panes.iter().find(|p| p.id == pane_id)?;
        Some((session, window, pane))
    }

    /// Find a mutable pane by its global ID.
    pub fn find_pane_mut(&mut self, pane_id: &str) -> Option<&mut Pane> {
        let (session_id, window_id) = self.pane_index.get(pane_id)?;
        let session_id = session_id.clone();
        let window_id = *window_id;
        let session = self.sessions.get_mut(&session_id)?;
        let window = session.find_window_mut(window_id)?;
        window.panes.iter_mut().find(|p| p.id == pane_id)
    }

    /// Get the prompt pattern for a pane's parent session.
    pub fn get_prompt_pattern(&self, pane_id: &str) -> Option<String> {
        self.find_pane(pane_id)
            .map(|(session, _, _)| session.options.prompt_pattern.clone())
    }

    /// Send keys to a pane. Returns error if the pane has exited.
    pub fn send_keys(&self, pane_id: &str, keys: &str) -> Result<()> {
        let (_, _, pane) = self
            .find_pane(pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;
        if !pane.process.running {
            bail!("pane {} has exited", pane_id);
        }
        pane.pty.write(keys.as_bytes())
    }

    /// Get the screen and process info needed for a capture, without awaiting.
    /// Returns (screen_arc, process_info) so the caller can await the read lock
    /// without holding a reference to SessionManager across the await point.
    pub fn get_capture_info(
        &self,
        pane_id: &str,
    ) -> Result<(Arc<RwLock<Screen>>, ProcessInfo)> {
        let (_, _, pane) = self
            .find_pane(pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;
        Ok((pane.screen.clone(), pane.process.clone()))
    }

    /// Create a new window in a session.
    pub fn new_window(
        &mut self,
        session_name: &str,
        shell: Option<&str>,
    ) -> Result<(WindowId, PaneId)> {
        let (default_shell, scrollback_limit) = self
            .sessions
            .get(session_name)
            .map(|s| (s.options.default_shell.clone(), s.options.scrollback_limit))
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;

        let shell_cmd = shell.unwrap_or(&default_shell).to_string();
        let pane = self.create_pane(&shell_cmd, 80, 24, scrollback_limit)?;
        let pane_id = pane.id.clone();

        let session = self
            .sessions
            .get_mut(session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;
        let window_id = session.new_window(pane);
        self.pane_index.insert(pane_id.clone(), (session_name.to_string(), window_id));
        Ok((window_id, pane_id))
    }

    /// Kill a window. If it was the last window, kills the session too.
    /// Returns backends for the caller to close outside the lock.
    pub fn kill_window(&mut self, session_name: &str, window_id: WindowId) -> Result<Vec<Box<dyn PtyBackend>>> {
        let session = self
            .sessions
            .get_mut(session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;

        // Collect pane IDs for mark cleanup, and remove from index
        let mut pane_ids = Vec::new();
        if let Some(window) = session.find_window(window_id) {
            for pane in &window.panes {
                pane_ids.push(pane.id.clone());
                self.pane_index.remove(&pane.id);
            }
        }

        let (session_empty, backends) = session.kill_window(window_id)?;
        if session_empty {
            self.sessions.remove(session_name);
        }

        self.marks.retain(|_, v| !pane_ids.contains(v));
        Ok(backends)
    }

    /// Split a pane, adding a new pane to the same window.
    pub fn split_pane(
        &mut self,
        pane_id: &str,
        horizontal: bool,
        shell: Option<&str>,
    ) -> Result<PaneId> {
        let (session_name, window_id) = self.pane_index
            .get(pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;
        let session_name = session_name.clone();
        let window_id = *window_id;

        let session = self.sessions.get(&session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;
        let default_shell = session.options.default_shell.clone();
        let scrollback_limit = session.options.scrollback_limit;

        let shell_cmd = shell.unwrap_or(&default_shell).to_string();
        let new_pane = self.create_pane(&shell_cmd, 80, 24, scrollback_limit)?;
        let new_pane_id = new_pane.id.clone();

        let session = self
            .sessions
            .get_mut(&session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;
        let window = session
            .find_window_mut(window_id)
            .ok_or_else(|| anyhow::anyhow!("window not found: {}", window_id))?;
        window.split_pane(new_pane, horizontal);
        self.pane_index.insert(new_pane_id.clone(), (session_name, window_id));

        Ok(new_pane_id)
    }

    /// Kill a pane. Cascades: last pane kills window, last window kills session.
    /// Returns backends for the caller to close outside the lock.
    pub fn kill_pane(&mut self, pane_id: &str) -> Result<Vec<Box<dyn PtyBackend>>> {
        let (session_name, window_id) = self.pane_index
            .remove(pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;

        let session = self
            .sessions
            .get_mut(&session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;
        let window = session
            .find_window_mut(window_id)
            .ok_or_else(|| anyhow::anyhow!("window not found: {}", window_id))?;

        let (window_empty, backend) = window.kill_pane(pane_id)?;
        let mut backends = vec![backend];
        if window_empty {
            let (session_empty, mut window_backends) = session.kill_window(window_id)?;
            backends.append(&mut window_backends);
            if session_empty {
                self.sessions.remove(&session_name);
            }
        }

        self.marks.retain(|_, v| v.as_str() != pane_id);
        Ok(backends)
    }

    /// List panes for a session.
    pub fn list_panes(&self, session_name: &str) -> Result<Vec<PaneInfo>> {
        let session = self
            .sessions
            .get(session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;
        let mut panes = Vec::new();
        for window in &session.windows {
            for pane in &window.panes {
                panes.push(pane.to_info());
            }
        }
        self.inject_marks(&mut panes);
        Ok(panes)
    }

    /// Select a window as active in a session.
    pub fn select_window(&mut self, session_name: &str, window_id: WindowId) -> Result<()> {
        let session = self
            .sessions
            .get_mut(session_name)
            .ok_or_else(|| anyhow::anyhow!("session \"{}\" not found", session_name))?;
        let idx = session
            .windows
            .iter()
            .position(|w| w.id == window_id)
            .ok_or_else(|| {
                anyhow::anyhow!(
                    "window {} not found in session \"{}\"",
                    window_id,
                    session_name
                )
            })?;
        session.active_window = idx;
        Ok(())
    }

    /// Select a pane as active, finding it across all sessions.
    pub fn select_pane(&mut self, pane_id: &str) -> Result<()> {
        let (session_id, window_id) = self.pane_index
            .get(pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;
        let session_id = session_id.clone();
        let window_id = *window_id;
        let session = self.sessions.get_mut(&session_id)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_id))?;
        let window = session.find_window_mut(window_id)
            .ok_or_else(|| anyhow::anyhow!("window not found: {}", window_id))?;
        let idx = window.panes.iter().position(|p| p.id == pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;
        window.active_pane = idx;
        Ok(())
    }

    /// Swap two panes' positions within the same window.
    pub fn swap_panes(&mut self, pane_a: &str, pane_b: &str) -> Result<()> {
        let (session_a, window_a) = self
            .pane_index
            .get(pane_a)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_a))?;
        let (session_b, window_b) = self
            .pane_index
            .get(pane_b)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_b))?;

        if session_a != session_b || window_a != window_b {
            bail!("panes must be in the same window to swap");
        }

        let session_name = session_a.clone();
        let window_id = *window_a;

        if pane_a == pane_b {
            return Ok(());
        }

        let session = self.sessions.get_mut(&session_name).unwrap();
        let window = session.find_window_mut(window_id).unwrap();

        let idx_a = window.panes.iter().position(|p| p.id == pane_a).unwrap();
        let idx_b = window.panes.iter().position(|p| p.id == pane_b).unwrap();

        window.panes.swap(idx_a, idx_b);

        if window.active_pane == idx_a {
            window.active_pane = idx_b;
        } else if window.active_pane == idx_b {
            window.active_pane = idx_a;
        }

        Ok(())
    }

    /// Move a pane from its current window to a different window.
    pub fn move_pane(
        &mut self,
        pane_id: &str,
        target_session: &str,
        target_window_id: WindowId,
    ) -> Result<()> {
        // 1. Look up source location
        let (src_session, src_window) = self
            .pane_index
            .get(pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;
        let src_session = src_session.clone();
        let src_window = *src_window;

        // 2. Verify target exists
        let target_session_name = target_session.to_string();
        if !self.sessions.contains_key(&target_session_name) {
            bail!("session not found: {}", target_session);
        }
        {
            let session = self.sessions.get(&target_session_name).unwrap();
            if session.find_window(target_window_id).is_none() {
                bail!(
                    "window not found: {}:{}",
                    target_session,
                    target_window_id
                );
            }
        }

        // 3. No-op if same window
        if src_session == target_session_name && src_window == target_window_id {
            return Ok(());
        }

        // 4. Remove pane from source window
        let pane = {
            let session = self.sessions.get_mut(&src_session).unwrap();
            let window = session.find_window_mut(src_window).unwrap();
            let idx = window.panes.iter().position(|p| p.id == pane_id).unwrap();
            let pane = window.panes.remove(idx);
            if window.panes.is_empty() {
                window.active_pane = 0;
            } else if window.active_pane >= window.panes.len() {
                window.active_pane = window.panes.len() - 1;
            }
            if window.panes.len() == 1 {
                window.layout = Layout::Single;
            } else if matches!(window.layout, Layout::Custom(_)) {
                window.layout = Layout::EvenHorizontal;
            }
            pane
        };

        // 5. Insert pane into target window
        {
            let session = self.sessions.get_mut(&target_session_name).unwrap();
            let window = session.find_window_mut(target_window_id).unwrap();
            window.panes.push(pane);
            window.active_pane = window.panes.len() - 1;
            if matches!(window.layout, Layout::Custom(_))
                || (window.panes.len() == 2 && window.layout == Layout::Single)
            {
                window.layout = Layout::EvenHorizontal;
            }
        }

        // 6. Update pane index
        self.pane_index.insert(
            pane_id.to_string(),
            (target_session_name, target_window_id),
        );

        // 7. Cascade: if source window is now empty, kill it
        // (no backends to close — the window is already empty)
        {
            let session = self.sessions.get_mut(&src_session).unwrap();
            let window = session.find_window(src_window);
            if window.is_some_and(|w| w.panes.is_empty()) {
                let (session_empty, _) = session.kill_window(src_window)?;
                if session_empty {
                    self.sessions.remove(&src_session);
                }
            }
        }

        Ok(())
    }

    /// List windows for a session.
    pub fn list_windows(&self, session_name: &str) -> Result<Vec<WindowInfo>> {
        let session = self
            .sessions
            .get(session_name)
            .ok_or_else(|| anyhow::anyhow!("session not found: {}", session_name))?;
        Ok(session.windows.iter().map(|w| w.to_info()).collect())
    }

    /// Resize a pane's PTY backend and update its stored size.
    /// Returns the screen Arc so the caller can resize the screen after dropping the manager lock.
    pub fn resize_pane_pty(
        &mut self,
        pane_id: &str,
        cols: u16,
        rows: u16,
    ) -> Result<Arc<RwLock<Screen>>> {
        if cols < MIN_PANE_COLS || rows < MIN_PANE_ROWS {
            bail!(
                "dimensions too small: {}x{} (minimum {}x{})",
                cols, rows, MIN_PANE_COLS, MIN_PANE_ROWS
            );
        }
        if cols > MAX_PANE_COLS || rows > MAX_PANE_ROWS {
            bail!(
                "dimensions too large: {}x{} (maximum {}x{})",
                cols, rows, MAX_PANE_COLS, MAX_PANE_ROWS
            );
        }

        let pane = self
            .find_pane_mut(pane_id)
            .ok_or_else(|| anyhow::anyhow!("pane not found: {}", pane_id))?;

        if !pane.process.running {
            bail!("pane {} has exited", pane_id);
        }

        pane.pty.resize(cols, rows)?;
        pane.size = (cols, rows);
        Ok(pane.screen.clone())
    }

    /// Shut down all sessions. Returns backends for the caller to close.
    pub fn shutdown_all(&mut self) -> Vec<Box<dyn PtyBackend>> {
        self.pane_index.clear();
        self.marks.clear();
        let sessions = std::mem::take(&mut self.sessions);
        let mut backends = Vec::new();
        for (_, session) in sessions {
            for window in session.windows {
                for pane in window.panes {
                    backends.push(pane.pty);
                }
            }
        }
        backends
    }
}

// ---------------------------------------------------------------------------
// Shared test helpers
// ---------------------------------------------------------------------------

#[cfg(test)]
pub mod testing {
    use super::*;
    use std::sync::atomic::{AtomicU32, Ordering};

    pub struct MockPty {
        pid: u32,
    }

    impl PtyBackend for MockPty {
        fn write(&self, _data: &[u8]) -> Result<()> {
            Ok(())
        }
        fn resize(&self, _cols: u16, _rows: u16) -> Result<()> {
            Ok(())
        }
        fn close(&mut self) -> Result<()> {
            Ok(())
        }
        fn pid(&self) -> u32 {
            self.pid
        }
    }

    pub fn mock_factory() -> PtyFactory {
        let pid = AtomicU32::new(1000);
        Box::new(move |_cmd: &str, _cols: u16, _rows: u16| {
            let p = pid.fetch_add(1, Ordering::Relaxed);
            let (_, output_rx) = tokio::sync::mpsc::unbounded_channel();
            let (_, exit_rx) = tokio::sync::oneshot::channel();
            Ok(PtySpawnResult {
                backend: Box::new(MockPty { pid: p }),
                pid: p,
                output_rx,
                exit_rx,
            })
        })
    }

    pub fn new_manager() -> SessionManager {
        SessionManager::new(mock_factory(), AimuxConfig::default())
    }

    pub fn new_manager_arc() -> std::sync::Arc<tokio::sync::Mutex<SessionManager>> {
        std::sync::Arc::new(tokio::sync::Mutex::new(new_manager()))
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::testing::new_manager;
    use super::Layout;

    #[tokio::test]
    async fn create_and_list_session() {
        let mut mgr = new_manager();
        let (name, pane_id) = mgr.new_session("work", None).unwrap();
        assert_eq!(name, "work");
        assert_eq!(pane_id, "%0");

        let sessions = mgr.list_sessions();
        assert_eq!(sessions.len(), 1);
        assert_eq!(sessions[0].name, "work");
        assert_eq!(sessions[0].windows.len(), 1);
        assert_eq!(sessions[0].windows[0].panes.len(), 1);
    }

    #[tokio::test]
    async fn duplicate_session_name_errors() {
        let mut mgr = new_manager();
        mgr.new_session("dup", None).unwrap();
        let err = mgr.new_session("dup", None).unwrap_err();
        assert!(err.to_string().contains("already exists"));
    }

    #[tokio::test]
    async fn kill_session() {
        let mut mgr = new_manager();
        mgr.new_session("temp", None).unwrap();
        assert!(mgr.has_session("temp"));

        mgr.kill_session("temp").unwrap();
        assert!(!mgr.has_session("temp"));
        assert!(mgr.list_sessions().is_empty());
    }

    #[tokio::test]
    async fn has_session() {
        let mut mgr = new_manager();
        assert!(!mgr.has_session("nope"));
        mgr.new_session("yes", None).unwrap();
        assert!(mgr.has_session("yes"));
    }

    #[tokio::test]
    async fn new_window_in_session() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap();
        let (win_id, pane_id) = mgr.new_window("s1", None).unwrap();
        assert_eq!(win_id, 1);
        assert_eq!(pane_id, "%1");

        let windows = mgr.list_windows("s1").unwrap();
        assert_eq!(windows.len(), 2);
    }

    #[tokio::test]
    async fn kill_window() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap();
        mgr.new_window("s1", None).unwrap();

        mgr.kill_window("s1", 0).unwrap();
        let windows = mgr.list_windows("s1").unwrap();
        assert_eq!(windows.len(), 1);
        assert_eq!(windows[0].id, 1);
    }

    #[tokio::test]
    async fn split_pane() {
        let mut mgr = new_manager();
        let (_, pane0) = mgr.new_session("s1", None).unwrap();
        let pane1 = mgr.split_pane(&pane0, true, None).unwrap();
        assert_eq!(pane1, "%1");

        let panes = mgr.list_panes("s1").unwrap();
        assert_eq!(panes.len(), 2);
    }

    #[tokio::test]
    async fn kill_pane() {
        let mut mgr = new_manager();
        let (_, pane0) = mgr.new_session("s1", None).unwrap();
        let pane1 = mgr.split_pane(&pane0, true, None).unwrap();

        mgr.kill_pane(&pane1).unwrap();
        let panes = mgr.list_panes("s1").unwrap();
        assert_eq!(panes.len(), 1);
        assert_eq!(panes[0].id, pane0);
    }

    #[tokio::test]
    async fn kill_cascade_pane_to_window_to_session() {
        let mut mgr = new_manager();
        let (_, pane0) = mgr.new_session("s1", None).unwrap();

        mgr.kill_pane(&pane0).unwrap();
        assert!(!mgr.has_session("s1"));
    }

    #[tokio::test]
    async fn kill_last_window_kills_session() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap();

        mgr.kill_window("s1", 0).unwrap();
        assert!(!mgr.has_session("s1"));
    }

    #[tokio::test]
    async fn pane_ids_globally_unique_and_sequential() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap(); // %0
        mgr.new_session("s2", None).unwrap(); // %1
        let pane2 = mgr.split_pane("%0", true, None).unwrap(); // %2
        assert_eq!(pane2, "%2");

        let (_, pane3) = mgr.new_window("s1", None).unwrap(); // %3
        assert_eq!(pane3, "%3");
    }

    #[tokio::test]
    async fn find_pane_across_sessions() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap(); // %0
        mgr.new_session("s2", None).unwrap(); // %1

        let result = mgr.find_pane("%1");
        assert!(result.is_some());
        let (session, _window, pane) = result.unwrap();
        assert_eq!(session.name, "s2");
        assert_eq!(pane.id, "%1");

        assert!(mgr.find_pane("%99").is_none());
    }

    #[tokio::test]
    async fn select_window() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap();
        mgr.new_window("s1", None).unwrap(); // window 1

        // Default active is 0
        assert_eq!(mgr.get_session("s1").unwrap().active_window, 0);

        mgr.select_window("s1", 1).unwrap();
        assert_eq!(mgr.get_session("s1").unwrap().active_window, 1);

        // Non-existent window
        let err = mgr.select_window("s1", 99).unwrap_err();
        assert!(err.to_string().contains("not found"));

        // Non-existent session
        let err = mgr.select_window("nope", 0).unwrap_err();
        assert!(err.to_string().contains("not found"));
    }

    #[tokio::test]
    async fn select_pane() {
        let mut mgr = new_manager();
        let (_, pane0) = mgr.new_session("s1", None).unwrap();
        let pane1 = mgr.split_pane(&pane0, true, None).unwrap();

        // Default active pane is 0
        let (_, window, _) = mgr.find_pane(&pane0).unwrap();
        assert_eq!(window.active_pane, 0);

        mgr.select_pane(&pane1).unwrap();
        let (_, window, _) = mgr.find_pane(&pane0).unwrap();
        assert_eq!(window.active_pane, 1);

        // Non-existent pane
        let err = mgr.select_pane("%99").unwrap_err();
        assert!(err.to_string().contains("pane not found"));
    }

    #[tokio::test]
    async fn send_keys_to_pane() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();
        mgr.send_keys(&pane_id, "hello\r").unwrap();
    }

    #[tokio::test]
    async fn send_keys_unknown_pane_errors() {
        let mgr = new_manager();
        let err = mgr.send_keys("%99", "hello").unwrap_err();
        assert!(err.to_string().contains("pane not found"));
    }

    #[tokio::test]
    async fn capture_pane_returns_screen_content() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();

        // Feed data directly into the screen for testing
        {
            let (_, _, pane) = mgr.find_pane(&pane_id).unwrap();
            let mut screen = pane.screen.write().await;
            screen.feed(b"hello world");
        }

        let (screen_arc, process) = mgr.get_capture_info(&pane_id).unwrap();
        let screen = screen_arc.read().await;
        assert_eq!(screen.capture_text()[0], "hello world");
        assert_eq!(screen.size(), (80, 24));
        assert!(process.running);
    }

    #[tokio::test]
    async fn set_default_shell_option() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap();

        // Change default shell
        let session = mgr.get_session_mut("s1").unwrap();
        session.options.default_shell = "cmd.exe".to_string();

        // New window should use the updated default
        let (_, pane_id) = mgr.new_window("s1", None).unwrap();
        let (_, _, pane) = mgr.find_pane(&pane_id).unwrap();
        // The pane title reflects the shell command
        assert_eq!(pane.title, "cmd.exe");
    }

    #[tokio::test]
    async fn set_prompt_pattern_option() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap();

        // Change prompt pattern
        let session = mgr.get_session_mut("s1").unwrap();
        session.options.prompt_pattern = r"PS.*>".to_string();

        // Verify via get_prompt_pattern
        let pattern = mgr.get_prompt_pattern("%0");
        assert_eq!(pattern, Some(r"PS.*>".to_string()));
    }

    #[tokio::test]
    async fn remain_on_exit_option() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap();

        // Set remain-on-exit on
        let pane = mgr.find_pane_mut("%0").unwrap();
        pane.options.remain_on_exit = true;
        assert!(pane.options.remain_on_exit);

        // Set remain-on-exit off
        let pane = mgr.find_pane_mut("%0").unwrap();
        pane.options.remain_on_exit = false;
        assert!(!pane.options.remain_on_exit);
    }

    #[tokio::test]
    async fn send_keys_to_dead_pane_errors() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();

        // Simulate process exit
        let pane = mgr.find_pane_mut(&pane_id).unwrap();
        pane.process.running = false;
        pane.process.exit_code = Some(0);

        // send_keys should fail
        let err = mgr.send_keys(&pane_id, "hello").unwrap_err();
        assert!(err.to_string().contains("has exited"));
    }

    #[tokio::test]
    async fn capture_dead_pane_still_works() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();

        // Feed some data
        {
            let (_, _, pane) = mgr.find_pane(&pane_id).unwrap();
            let mut screen = pane.screen.write().await;
            screen.feed(b"last output");
        }

        // Simulate process exit
        let pane = mgr.find_pane_mut(&pane_id).unwrap();
        pane.options.remain_on_exit = true;
        pane.process.running = false;
        pane.process.exit_code = Some(0);

        // Capture should still work
        let (screen_arc, process) = mgr.get_capture_info(&pane_id).unwrap();
        let screen = screen_arc.read().await;
        assert_eq!(screen.capture_text()[0], "last output");
        assert!(!process.running);
        assert_eq!(process.exit_code, Some(0));
    }

    #[tokio::test]
    async fn resize_pane_pty_updates_size() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();

        // Default size is 80x24
        let (_, _, pane) = mgr.find_pane(&pane_id).unwrap();
        assert_eq!(pane.size, (80, 24));

        let screen_arc = mgr.resize_pane_pty(&pane_id, 120, 40).unwrap();
        // Verify pane size was updated
        let (_, _, pane) = mgr.find_pane(&pane_id).unwrap();
        assert_eq!(pane.size, (120, 40));

        // Verify screen can be resized after dropping manager
        {
            let mut screen = screen_arc.write().await;
            screen.resize(120, 40);
            assert_eq!(screen.size(), (120, 40));
        }
    }

    #[tokio::test]
    async fn resize_nonexistent_pane_errors() {
        let mut mgr = new_manager();
        let result = mgr.resize_pane_pty("%99", 80, 24);
        assert!(result.is_err());
        assert!(result.err().unwrap().to_string().contains("pane not found"));
    }

    #[tokio::test]
    async fn resize_exited_pane_errors() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();

        let pane = mgr.find_pane_mut(&pane_id).unwrap();
        pane.process.running = false;
        pane.process.exit_code = Some(0);

        let result = mgr.resize_pane_pty(&pane_id, 80, 24);
        assert!(result.is_err());
        assert!(result.err().unwrap().to_string().contains("has exited"));
    }

    #[tokio::test]
    async fn resize_out_of_range_dimensions_errors() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();

        // Too small
        let result = mgr.resize_pane_pty(&pane_id, 0, 0);
        assert!(result.is_err());
        assert!(result.err().unwrap().to_string().contains("too small"));

        let result = mgr.resize_pane_pty(&pane_id, 1, 1);
        assert!(result.is_err());
        assert!(result.err().unwrap().to_string().contains("too small"));

        // Too large
        let result = mgr.resize_pane_pty(&pane_id, 1001, 24);
        assert!(result.is_err());
        assert!(result.err().unwrap().to_string().contains("too large"));

        let result = mgr.resize_pane_pty(&pane_id, 80, 1001);
        assert!(result.is_err());
        assert!(result.err().unwrap().to_string().contains("too large"));
    }

    #[tokio::test]
    async fn new_pane_inherits_session_scrollback_limit() {
        let mut mgr = new_manager();
        let (_, pane0) = mgr.new_session("s1", None).unwrap();

        // Default scrollback limit is 2000
        {
            let (_, _, pane) = mgr.find_pane(&pane0).unwrap();
            let screen = pane.screen.read().await;
            assert_eq!(screen.scrollback_limit(), 2000);
        }

        // Change session scrollback limit
        let session = mgr.get_session_mut("s1").unwrap();
        session.options.scrollback_limit = 500;

        // New pane should inherit the updated limit
        let pane1 = mgr.split_pane(&pane0, true, None).unwrap();
        {
            let (_, _, pane) = mgr.find_pane(&pane1).unwrap();
            let screen = pane.screen.read().await;
            assert_eq!(screen.scrollback_limit(), 500);
        }
    }

    #[tokio::test]
    async fn session_scrollback_limit_does_not_affect_existing_panes() {
        let mut mgr = new_manager();
        let (_, pane0) = mgr.new_session("s1", None).unwrap();

        // Change session scrollback limit after pane creation
        let session = mgr.get_session_mut("s1").unwrap();
        session.options.scrollback_limit = 100;

        // Existing pane should still have the original limit
        {
            let (_, _, pane) = mgr.find_pane(&pane0).unwrap();
            let screen = pane.screen.read().await;
            assert_eq!(screen.scrollback_limit(), 2000);
        }
    }

    #[tokio::test]
    async fn pane_index_consistent_after_operations() {
        let mut mgr = new_manager();
        let (_, s1_p0) = mgr.new_session("s1", None).unwrap();
        let (_, s2_p0) = mgr.new_session("s2", None).unwrap();
        let s1_p1 = mgr.split_pane(&s1_p0, true, None).unwrap();
        let s2_p1 = mgr.split_pane(&s2_p0, true, None).unwrap();

        // All four panes should be findable
        assert!(mgr.find_pane(&s1_p0).is_some());
        assert!(mgr.find_pane(&s1_p1).is_some());
        assert!(mgr.find_pane(&s2_p0).is_some());
        assert!(mgr.find_pane(&s2_p1).is_some());

        // Kill some panes
        mgr.kill_pane(&s1_p1).unwrap();
        mgr.kill_pane(&s2_p0).unwrap();

        // Killed panes gone, survivors still accessible
        assert!(mgr.find_pane(&s1_p1).is_none());
        assert!(mgr.find_pane(&s2_p0).is_none());
        assert!(mgr.find_pane(&s1_p0).is_some());
        assert!(mgr.find_pane(&s2_p1).is_some());
    }

    #[tokio::test]
    async fn pane_index_after_window_kill() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap(); // window 0
        let (_, p1) = mgr.new_window("s1", None).unwrap(); // window 1

        // Both panes accessible
        assert!(mgr.find_pane(&p0).is_some());
        assert!(mgr.find_pane(&p1).is_some());

        // Kill window 0
        mgr.kill_window("s1", 0).unwrap();

        // p0 gone, p1 survives
        assert!(mgr.find_pane(&p0).is_none());
        assert!(mgr.find_pane(&p1).is_some());
    }

    #[tokio::test]
    async fn pane_index_after_session_kill() {
        let mut mgr = new_manager();
        let (_, s1_p0) = mgr.new_session("s1", None).unwrap();
        let s1_p1 = mgr.split_pane(&s1_p0, true, None).unwrap();
        let (_, s2_p0) = mgr.new_session("s2", None).unwrap();

        // All panes accessible
        assert!(mgr.find_pane(&s1_p0).is_some());
        assert!(mgr.find_pane(&s1_p1).is_some());
        assert!(mgr.find_pane(&s2_p0).is_some());

        // Kill session s1
        mgr.kill_session("s1").unwrap();

        // s1 panes gone, s2 pane survives
        assert!(mgr.find_pane(&s1_p0).is_none());
        assert!(mgr.find_pane(&s1_p1).is_none());
        assert!(mgr.find_pane(&s2_p0).is_some());
    }

    // -- Pane marks tests --

    #[tokio::test]
    async fn set_mark_and_resolve() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();
        mgr.set_mark("build", &pane_id).unwrap();

        let resolved = mgr.resolve_pane_target("@build").unwrap();
        assert_eq!(resolved, pane_id);
    }

    #[tokio::test]
    async fn resolve_passthrough() {
        let mgr = new_manager();
        let resolved = mgr.resolve_pane_target("%0").unwrap();
        assert_eq!(resolved, "%0");
    }

    #[tokio::test]
    async fn resolve_unknown_mark_errors() {
        let mgr = new_manager();
        let err = mgr.resolve_pane_target("@nonexistent").unwrap_err();
        assert!(err.to_string().contains("mark not found"));
    }

    #[tokio::test]
    async fn validate_mark_name_rules() {
        use super::validate_mark_name;

        // Valid names
        validate_mark_name("build").unwrap();
        validate_mark_name("my-pane").unwrap();
        validate_mark_name("test_1").unwrap();
        validate_mark_name("A").unwrap();
        validate_mark_name("a".repeat(32).as_str()).unwrap();

        // Empty
        assert!(validate_mark_name("").is_err());
        // Too long
        assert!(validate_mark_name(&"a".repeat(33)).is_err());
        // Invalid chars
        assert!(validate_mark_name("hello world").is_err());
        assert!(validate_mark_name("foo@bar").is_err());
        assert!(validate_mark_name("a.b").is_err());
    }

    #[tokio::test]
    async fn reassign_mark() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();

        mgr.set_mark("target", &p0).unwrap();
        assert_eq!(mgr.resolve_pane_target("@target").unwrap(), p0);

        // Reassign to different pane
        mgr.set_mark("target", &p1).unwrap();
        assert_eq!(mgr.resolve_pane_target("@target").unwrap(), p1);
    }

    #[tokio::test]
    async fn multiple_marks_per_pane() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();

        mgr.set_mark("build", &pane_id).unwrap();
        mgr.set_mark("main", &pane_id).unwrap();
        mgr.set_mark("dev", &pane_id).unwrap();

        assert_eq!(mgr.resolve_pane_target("@build").unwrap(), pane_id);
        assert_eq!(mgr.resolve_pane_target("@main").unwrap(), pane_id);
        assert_eq!(mgr.resolve_pane_target("@dev").unwrap(), pane_id);

        let mut marks = mgr.marks_for_pane(&pane_id);
        marks.sort();
        assert_eq!(marks, vec!["build", "dev", "main"]);
    }

    #[tokio::test]
    async fn kill_pane_cleans_marks() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();

        mgr.set_mark("a", &p0).unwrap();
        mgr.set_mark("b", &p1).unwrap();

        mgr.kill_pane(&p0).unwrap();
        assert!(mgr.resolve_pane_target("@a").is_err());
        // Mark on surviving pane remains
        assert_eq!(mgr.resolve_pane_target("@b").unwrap(), p1);
    }

    #[tokio::test]
    async fn kill_session_cleans_marks() {
        let mut mgr = new_manager();
        let (_, s1_p0) = mgr.new_session("s1", None).unwrap();
        let s1_p1 = mgr.split_pane(&s1_p0, true, None).unwrap();
        let (_, s2_p0) = mgr.new_session("s2", None).unwrap();

        mgr.set_mark("a", &s1_p0).unwrap();
        mgr.set_mark("b", &s1_p1).unwrap();
        mgr.set_mark("c", &s2_p0).unwrap();

        mgr.kill_session("s1").unwrap();
        assert!(mgr.resolve_pane_target("@a").is_err());
        assert!(mgr.resolve_pane_target("@b").is_err());
        assert_eq!(mgr.resolve_pane_target("@c").unwrap(), s2_p0);
    }

    #[tokio::test]
    async fn kill_window_cleans_marks() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let (_, p1) = mgr.new_window("s1", None).unwrap();

        mgr.set_mark("win0", &p0).unwrap();
        mgr.set_mark("win1", &p1).unwrap();

        mgr.kill_window("s1", 0).unwrap();
        assert!(mgr.resolve_pane_target("@win0").is_err());
        assert_eq!(mgr.resolve_pane_target("@win1").unwrap(), p1);
    }

    #[tokio::test]
    async fn list_marks_returns_all() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();

        mgr.set_mark("alpha", &p0).unwrap();
        mgr.set_mark("beta", &p1).unwrap();

        let mut marks = mgr.list_marks();
        marks.sort_by(|a, b| a.0.cmp(&b.0));
        assert_eq!(marks.len(), 2);
        assert_eq!(marks[0], ("alpha".to_string(), p0));
        assert_eq!(marks[1], ("beta".to_string(), p1));
    }

    #[tokio::test]
    async fn remove_mark() {
        let mut mgr = new_manager();
        let (_, pane_id) = mgr.new_session("s1", None).unwrap();
        mgr.set_mark("temp", &pane_id).unwrap();
        mgr.remove_mark("temp").unwrap();
        assert!(mgr.resolve_pane_target("@temp").is_err());
    }

    #[tokio::test]
    async fn remove_nonexistent_mark_errors() {
        let mut mgr = new_manager();
        let err = mgr.remove_mark("nope").unwrap_err();
        assert!(err.to_string().contains("mark not found"));
    }

    #[tokio::test]
    async fn set_mark_nonexistent_pane_errors() {
        let mut mgr = new_manager();
        mgr.new_session("s1", None).unwrap();
        let err = mgr.set_mark("x", "%99").unwrap_err();
        assert!(err.to_string().contains("pane not found"));
    }

    #[tokio::test]
    async fn inject_marks_populates_pane_info() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();

        mgr.set_mark("build", &p0).unwrap();
        mgr.set_mark("test", &p1).unwrap();
        mgr.set_mark("main", &p0).unwrap();

        let panes = mgr.list_panes("s1").unwrap();
        let p0_info = panes.iter().find(|p| p.id == p0).unwrap();
        let p1_info = panes.iter().find(|p| p.id == p1).unwrap();

        let mut p0_marks = p0_info.marks.clone();
        p0_marks.sort();
        assert_eq!(p0_marks, vec!["build", "main"]);
        assert_eq!(p1_info.marks, vec!["test"]);
    }

    // -- swap_panes tests --

    #[tokio::test]
    async fn swap_panes_basic() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();

        // Before swap: panes order is [p0, p1]
        let panes_before = mgr.list_panes("s1").unwrap();
        assert_eq!(panes_before[0].id, p0);
        assert_eq!(panes_before[1].id, p1);

        mgr.swap_panes(&p0, &p1).unwrap();

        // After swap: panes order is [p1, p0]
        let panes_after = mgr.list_panes("s1").unwrap();
        assert_eq!(panes_after[0].id, p1);
        assert_eq!(panes_after[1].id, p0);
    }

    #[tokio::test]
    async fn swap_panes_active_tracking() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();

        // Active pane is p0 at index 0
        mgr.select_pane(&p0).unwrap();

        mgr.swap_panes(&p0, &p1).unwrap();

        // After swap, active should follow p0 to index 1
        let session = mgr.get_session("s1").unwrap();
        let window = &session.windows[0];
        assert_eq!(window.panes[window.active_pane].id, p0);
    }

    #[tokio::test]
    async fn swap_panes_noop() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        mgr.split_pane(&p0, true, None).unwrap();

        // Swapping a pane with itself is a no-op
        mgr.swap_panes(&p0, &p0).unwrap();

        let panes = mgr.list_panes("s1").unwrap();
        assert_eq!(panes[0].id, p0);
    }

    #[tokio::test]
    async fn swap_panes_cross_window_error() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let (_, p1) = mgr.new_window("s1", None).unwrap();

        let err = mgr.swap_panes(&p0, &p1).unwrap_err();
        assert!(err.to_string().contains("same window"));
    }

    #[tokio::test]
    async fn swap_panes_not_found() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();

        let err = mgr.swap_panes(&p0, "%99").unwrap_err();
        assert!(err.to_string().contains("pane not found"));

        let err = mgr.swap_panes("%99", &p0).unwrap_err();
        assert!(err.to_string().contains("pane not found"));
    }

    #[tokio::test]
    async fn swap_panes_three_panes() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();
        let p2 = mgr.split_pane(&p1, true, None).unwrap();

        // Swap first and last, middle unchanged
        mgr.swap_panes(&p0, &p2).unwrap();

        let panes = mgr.list_panes("s1").unwrap();
        assert_eq!(panes[0].id, p2);
        assert_eq!(panes[1].id, p1);
        assert_eq!(panes[2].id, p0);
    }

    #[tokio::test]
    async fn swap_panes_marks_survive() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();

        mgr.set_mark("build", &p0).unwrap();
        mgr.set_mark("test", &p1).unwrap();

        mgr.swap_panes(&p0, &p1).unwrap();

        // Marks still resolve to same pane IDs
        assert_eq!(mgr.resolve_pane_target("@build").unwrap(), p0);
        assert_eq!(mgr.resolve_pane_target("@test").unwrap(), p1);
    }

    // -- move_pane tests --

    #[tokio::test]
    async fn move_pane_basic() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("src", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();
        let (_, _p2) = mgr.new_session("dst", None).unwrap();

        // dst has window 0
        let dst_windows = mgr.list_windows("dst").unwrap();
        let dst_win = dst_windows[0].id;

        mgr.move_pane(&p1, "dst", dst_win).unwrap();

        // p1 should now be in dst
        let dst_panes = mgr.list_panes("dst").unwrap();
        assert!(dst_panes.iter().any(|p| p.id == p1));

        // p1 should be gone from src
        let src_panes = mgr.list_panes("src").unwrap();
        assert!(!src_panes.iter().any(|p| p.id == p1));
    }

    #[tokio::test]
    async fn move_pane_cascade_kills_window_and_session() {
        let mut mgr = new_manager();
        // src session with 1 window, 1 pane
        let (_, p0) = mgr.new_session("src", None).unwrap();
        let (_, _p1) = mgr.new_session("dst", None).unwrap();

        let dst_windows = mgr.list_windows("dst").unwrap();
        let dst_win = dst_windows[0].id;

        // Move the only pane out of src
        mgr.move_pane(&p0, "dst", dst_win).unwrap();

        // src session should be killed (cascade)
        assert!(!mgr.has_session("src"));
    }

    #[tokio::test]
    async fn move_pane_cascade_kills_window_not_session() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("src", None).unwrap();
        // Add a second window so session survives
        let (_, _p_extra) = mgr.new_window("src", None).unwrap();
        let (_, _p1) = mgr.new_session("dst", None).unwrap();

        let dst_windows = mgr.list_windows("dst").unwrap();
        let dst_win = dst_windows[0].id;

        // Move p0 out of window 0 — only 1 pane in that window
        mgr.move_pane(&p0, "dst", dst_win).unwrap();

        // Session survives, but window 0 should be gone
        assert!(mgr.has_session("src"));
        let src_windows = mgr.list_windows("src").unwrap();
        assert_eq!(src_windows.len(), 1);
        // The remaining window is window 1 (the second one)
        assert!(!src_windows.iter().any(|w| w.id == 0));
    }

    #[tokio::test]
    async fn move_pane_same_window_noop() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let _ = mgr.split_pane(&p0, true, None).unwrap();

        let windows = mgr.list_windows("s1").unwrap();
        let win_id = windows[0].id;

        // Move to same window is a no-op
        mgr.move_pane(&p0, "s1", win_id).unwrap();

        // Still 2 panes in window
        let panes = mgr.list_panes("s1").unwrap();
        assert_eq!(panes.len(), 2);
    }

    #[tokio::test]
    async fn move_pane_active_pane_update() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("src", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();
        let (_, _p2) = mgr.new_session("dst", None).unwrap();

        let dst_windows = mgr.list_windows("dst").unwrap();
        let dst_win = dst_windows[0].id;

        // Move p1 to dst
        mgr.move_pane(&p1, "dst", dst_win).unwrap();

        // Moved pane should be active in target
        let dst_session = mgr.get_session("dst").unwrap();
        let dst_window = dst_session.find_window(dst_win).unwrap();
        assert_eq!(dst_window.panes[dst_window.active_pane].id, p1);
    }

    #[tokio::test]
    async fn move_pane_layout_update() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("src", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();
        let (_, _p2) = mgr.new_session("dst", None).unwrap();

        let dst_windows = mgr.list_windows("dst").unwrap();
        let dst_win = dst_windows[0].id;

        // Before: src has 2 panes (EvenHorizontal), dst has 1 (Single)
        let src_session = mgr.get_session("src").unwrap();
        assert_eq!(src_session.windows[0].layout, Layout::EvenHorizontal);
        let dst_session = mgr.get_session("dst").unwrap();
        let dst_window = dst_session.find_window(dst_win).unwrap();
        assert_eq!(dst_window.layout, Layout::Single);

        mgr.move_pane(&p1, "dst", dst_win).unwrap();

        // After: src has 1 pane (Single), dst has 2 (EvenHorizontal)
        let src_session = mgr.get_session("src").unwrap();
        assert_eq!(src_session.windows[0].layout, Layout::Single);
        let dst_session = mgr.get_session("dst").unwrap();
        let dst_window = dst_session.find_window(dst_win).unwrap();
        assert_eq!(dst_window.layout, Layout::EvenHorizontal);
    }

    #[tokio::test]
    async fn move_pane_index_updated() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("src", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();
        let (_, _p2) = mgr.new_session("dst", None).unwrap();

        let dst_windows = mgr.list_windows("dst").unwrap();
        let dst_win = dst_windows[0].id;

        mgr.move_pane(&p1, "dst", dst_win).unwrap();

        // find_pane should locate p1 in dst session now
        let (session, window, pane) = mgr.find_pane(&p1).unwrap();
        assert_eq!(session.name, "dst");
        assert_eq!(window.id, dst_win);
        assert_eq!(pane.id, p1);
    }

    #[tokio::test]
    async fn move_pane_marks_survive() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("src", None).unwrap();
        let p1 = mgr.split_pane(&p0, true, None).unwrap();
        let (_, _p2) = mgr.new_session("dst", None).unwrap();

        mgr.set_mark("build", &p1).unwrap();

        let dst_windows = mgr.list_windows("dst").unwrap();
        let dst_win = dst_windows[0].id;

        mgr.move_pane(&p1, "dst", dst_win).unwrap();

        // Mark still resolves
        assert_eq!(mgr.resolve_pane_target("@build").unwrap(), p1);
    }

    #[tokio::test]
    async fn move_pane_not_found() {
        let mut mgr = new_manager();
        let (_, _p0) = mgr.new_session("s1", None).unwrap();

        let err = mgr.move_pane("%99", "s1", 0).unwrap_err();
        assert!(err.to_string().contains("pane not found"));
    }

    #[tokio::test]
    async fn move_pane_target_session_not_found() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();

        let err = mgr.move_pane(&p0, "nonexistent", 0).unwrap_err();
        assert!(err.to_string().contains("session not found"));
    }

    #[tokio::test]
    async fn move_pane_target_window_not_found() {
        let mut mgr = new_manager();
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        let (_, _p1) = mgr.new_session("dst", None).unwrap();

        let err = mgr.move_pane(&p0, "dst", 99).unwrap_err();
        assert!(err.to_string().contains("window not found"));
    }

    #[tokio::test]
    async fn server_status_counts() {
        let mut mgr = new_manager();

        // Empty server
        let status = mgr.server_status();
        assert_eq!(status.sessions, 0);
        assert_eq!(status.windows, 0);
        assert_eq!(status.panes, 0);

        // Create sessions and panes
        let (_, p0) = mgr.new_session("s1", None).unwrap();
        mgr.split_pane(&p0, true, None).unwrap();
        mgr.new_session("s2", None).unwrap();
        mgr.new_window("s2", None).unwrap();

        let status = mgr.server_status();
        assert_eq!(status.sessions, 2);
        assert_eq!(status.windows, 3); // s1:1 window + s2:2 windows
        assert_eq!(status.panes, 4);   // s1:2 panes + s2:2 panes

        // uptime should be very small
        assert!(status.uptime_secs < 5);
    }
}