batty_cli/team/

message.rs

//! Team message types and tmux injection.

use std::fs::{File, OpenOptions};
use std::io::{BufRead, BufReader, Write};
use std::path::{Path, PathBuf};

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};

use crate::tmux;

/// The end-of-message marker used by paste verification and stuck detection.
const END_MARKER: &str = "--- end message ---";
/// Maximum polls when waiting for paste to appear in the pane.
const PASTE_VERIFY_MAX_POLLS: u32 = 10;
/// Interval between paste verification polls (milliseconds).
const PASTE_VERIFY_POLL_MS: u64 = 200;
/// Number of pane lines to capture when verifying paste landed.
const PASTE_VERIFY_CAPTURE_LINES: u32 = 30;
/// Maximum Enter-key submission attempts when message appears stuck.
const SUBMIT_MAX_ATTEMPTS: u32 = 3;
/// Delay between Enter retries when checking for stuck messages (milliseconds).
const SUBMIT_RETRY_DELAY_MS: u64 = 800;
/// Number of pane lines captured to detect a stuck message.
const STUCK_CAPTURE_LINES: u32 = 5;

/// A message in the command queue.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum QueuedCommand {
    #[serde(rename = "send")]
    Send {
        from: String,
        to: String,
        message: String,
    },
    #[serde(rename = "assign")]
    Assign {
        from: String,
        engineer: String,
        task: String,
    },
}

/// Inject a text message into a tmux pane.
///
/// Uses load-buffer + paste-buffer for reliable delivery of long/special
/// content, then polls the pane to confirm the paste landed before
/// sending Enter. If the message appears stuck (end marker still at
/// the bottom of the pane), Enter is retried up to [`SUBMIT_MAX_ATTEMPTS`].
pub fn inject_message(pane_id: &str, from: &str, message: &str) -> Result<()> {
    let formatted = format!(
        "\n--- Message from {from} ---\n{message}\n{END_MARKER}\nTo reply, run: batty send {from} \"<your response>\"\n"
    );

    // Send a pre-injection Enter to wake up idle agents whose prompt may be stuck
    // (e.g., Claude Code with unsent input in the prompt buffer)
    let _ = tmux::send_keys(pane_id, "", true);
    std::thread::sleep(std::time::Duration::from_millis(200));

    paste_message_with_retry(pane_id, &formatted)?;

    // Wait for the paste to appear in the pane before sending Enter.
    // This replaces a fixed delay with active verification, avoiding the race
    // where Enter arrives before the paste buffer is processed.
    if !wait_for_paste(pane_id) {
        // Paste not confirmed — fall back to length-proportional delay.
        let delay_ms = 500 + (formatted.len() as u64 / 100) * 50;
        std::thread::sleep(std::time::Duration::from_millis(delay_ms.min(3000)));
    }

    // Submit the pasted text with Enter, retrying if the message is stuck.
    submit_with_retry(pane_id)?;

    Ok(())
}

/// Poll the pane capture until the end marker appears, confirming that the
/// paste-buffer operation completed in the terminal.
fn wait_for_paste(pane_id: &str) -> bool {
    for _ in 0..PASTE_VERIFY_MAX_POLLS {
        std::thread::sleep(std::time::Duration::from_millis(PASTE_VERIFY_POLL_MS));
        if let Ok(capture) = tmux::capture_pane_recent(pane_id, PASTE_VERIFY_CAPTURE_LINES) {
            if capture.contains(END_MARKER) {
                return true;
            }
        }
    }
    false
}

/// Send Enter to submit the pasted message. After each attempt, check whether
/// the message is stuck (end marker still visible in the bottom few lines of
/// the pane). If stuck, resend Enter. Up to [`SUBMIT_MAX_ATTEMPTS`] tries.
fn submit_with_retry(pane_id: &str) -> Result<()> {
    for attempt in 0..SUBMIT_MAX_ATTEMPTS {
        tmux::send_keys(pane_id, "", true)?;

        if attempt < SUBMIT_MAX_ATTEMPTS - 1 {
            std::thread::sleep(std::time::Duration::from_millis(SUBMIT_RETRY_DELAY_MS));
            let capture =
                tmux::capture_pane_recent(pane_id, STUCK_CAPTURE_LINES).unwrap_or_default();
            if !is_message_stuck_in_capture(&capture) {
                break;
            }
            // Message still visible at bottom — Enter was likely lost, retry.
        }
    }
    Ok(())
}

/// Check whether a short pane capture contains the message end marker,
/// indicating the message was pasted but not yet submitted (stuck).
pub(crate) fn is_message_stuck_in_capture(capture: &str) -> bool {
    capture.contains(END_MARKER)
}

fn paste_message_with_retry(pane_id: &str, formatted: &str) -> Result<()> {
    tmux::load_buffer(formatted)?;
    match tmux::paste_buffer(pane_id) {
        Ok(()) => Ok(()),
        Err(error) if error.to_string().contains("no buffer batty-inject") => {
            tmux::load_buffer(formatted)?;
            tmux::paste_buffer(pane_id)
        }
        Err(error) => Err(error),
    }
}

/// Write a command to the queue file.
pub fn enqueue_command(queue_path: &Path, cmd: &QueuedCommand) -> Result<()> {
    if let Some(parent) = queue_path.parent() {
        std::fs::create_dir_all(parent)?;
    }
    let json = serde_json::to_string(cmd)?;
    let mut file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(queue_path)
        .with_context(|| format!("failed to open command queue: {}", queue_path.display()))?;
    writeln!(file, "{json}")?;
    Ok(())
}

/// Read and drain all pending commands from the queue file.
#[cfg(test)]
pub fn drain_command_queue(queue_path: &Path) -> Result<Vec<QueuedCommand>> {
    let commands = read_command_queue(queue_path)?;
    if !commands.is_empty() {
        write_command_queue(queue_path, &[])?;
    }
    Ok(commands)
}

/// Read all pending commands from the queue file without clearing it.
pub fn read_command_queue(queue_path: &Path) -> Result<Vec<QueuedCommand>> {
    if !queue_path.exists() {
        return Ok(Vec::new());
    }

    let file = File::open(queue_path)
        .with_context(|| format!("failed to open command queue: {}", queue_path.display()))?;
    let reader = BufReader::new(file);

    let mut commands = Vec::new();
    for line in reader.lines() {
        let line = line?;
        let trimmed = line.trim();
        if trimmed.is_empty() {
            continue;
        }
        match serde_json::from_str::<QueuedCommand>(trimmed) {
            Ok(cmd) => commands.push(cmd),
            Err(e) => tracing::warn!(line = trimmed, error = %e, "skipping malformed command"),
        }
    }

    Ok(commands)
}

/// Atomically rewrite the command queue with the remaining commands.
pub fn write_command_queue(queue_path: &Path, commands: &[QueuedCommand]) -> Result<()> {
    if let Some(parent) = queue_path.parent() {
        std::fs::create_dir_all(parent)?;
    }

    let tmp_path = queue_path.with_extension("jsonl.tmp");
    {
        let mut file = OpenOptions::new()
            .create(true)
            .write(true)
            .truncate(true)
            .open(&tmp_path)
            .with_context(|| {
                format!("failed to open temp command queue: {}", tmp_path.display())
            })?;
        for cmd in commands {
            let json = serde_json::to_string(cmd)?;
            writeln!(file, "{json}")?;
        }
        file.flush()?;
    }

    std::fs::rename(&tmp_path, queue_path).with_context(|| {
        format!(
            "failed to replace command queue {} with {}",
            queue_path.display(),
            tmp_path.display()
        )
    })?;
    Ok(())
}

/// Resolve the command queue path.
pub fn command_queue_path(project_root: &Path) -> PathBuf {
    project_root
        .join(".batty")
        .join("team_config")
        .join("commands.jsonl")
}

#[cfg(test)]
mod tests {
    use super::*;
    use serial_test::serial;

    #[test]
    fn send_command_roundtrip() {
        let cmd = QueuedCommand::Send {
            from: "human".into(),
            to: "architect".into(),
            message: "prioritize auth".into(),
        };
        let json = serde_json::to_string(&cmd).unwrap();
        let parsed: QueuedCommand = serde_json::from_str(&json).unwrap();
        match parsed {
            QueuedCommand::Send { from, to, message } => {
                assert_eq!(from, "human");
                assert_eq!(to, "architect");
                assert_eq!(message, "prioritize auth");
            }
            _ => panic!("wrong variant"),
        }
    }

    #[test]
    fn assign_command_roundtrip() {
        let cmd = QueuedCommand::Assign {
            from: "black-lead".into(),
            engineer: "eng-1-1".into(),
            task: "fix bug".into(),
        };
        let json = serde_json::to_string(&cmd).unwrap();
        let parsed: QueuedCommand = serde_json::from_str(&json).unwrap();
        match parsed {
            QueuedCommand::Assign {
                from,
                engineer,
                task,
            } => {
                assert_eq!(from, "black-lead");
                assert_eq!(engineer, "eng-1-1");
                assert_eq!(task, "fix bug");
            }
            _ => panic!("wrong variant"),
        }
    }

    #[test]
    fn enqueue_and_drain() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");

        enqueue_command(
            &queue,
            &QueuedCommand::Send {
                from: "human".into(),
                to: "arch".into(),
                message: "hello".into(),
            },
        )
        .unwrap();
        enqueue_command(
            &queue,
            &QueuedCommand::Assign {
                from: "black-lead".into(),
                engineer: "eng-1".into(),
                task: "work".into(),
            },
        )
        .unwrap();

        let commands = drain_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 2);

        // After drain, queue should be empty
        let commands = drain_command_queue(&queue).unwrap();
        assert!(commands.is_empty());
    }

    #[test]
    fn drain_nonexistent_queue_returns_empty() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("nonexistent.jsonl");
        let commands = drain_command_queue(&queue).unwrap();
        assert!(commands.is_empty());
    }

    #[test]
    fn read_command_queue_keeps_file_contents_intact() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");
        enqueue_command(
            &queue,
            &QueuedCommand::Send {
                from: "human".into(),
                to: "arch".into(),
                message: "hello".into(),
            },
        )
        .unwrap();

        let commands = read_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 1);
        let persisted = std::fs::read_to_string(&queue).unwrap();
        assert!(persisted.contains("\"message\":\"hello\""));
    }

    #[test]
    fn write_command_queue_rewrites_remaining_commands_atomically() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");
        enqueue_command(
            &queue,
            &QueuedCommand::Send {
                from: "human".into(),
                to: "arch".into(),
                message: "hello".into(),
            },
        )
        .unwrap();

        write_command_queue(
            &queue,
            &[QueuedCommand::Assign {
                from: "manager".into(),
                engineer: "eng-1".into(),
                task: "Task #1".into(),
            }],
        )
        .unwrap();

        let commands = read_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 1);
        match &commands[0] {
            QueuedCommand::Assign { engineer, task, .. } => {
                assert_eq!(engineer, "eng-1");
                assert_eq!(task, "Task #1");
            }
            other => panic!("expected assign command after rewrite, got {other:?}"),
        }
    }

    #[test]
    fn drain_skips_malformed_lines() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");
        std::fs::write(
            &queue,
            "not json\n{\"type\":\"assign\",\"from\":\"manager\",\"engineer\":\"e1\",\"task\":\"t1\"}\n",
        )
        .unwrap();
        let commands = drain_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 1);
    }

    #[test]
    #[serial]
    #[cfg_attr(not(feature = "integration"), ignore)]
    fn test_inject_message_empty_message_writes_message_wrapper_to_pane() {
        let session = "batty-test-message-empty";
        let mut delivered = false;

        for _attempt in 0..3 {
            let _ = crate::tmux::kill_session(session);

            let tmp = tempfile::tempdir().unwrap();
            let log_path = tmp.path().join("message-empty.log");

            crate::tmux::create_session(session, "cat", &[], "/tmp").unwrap();
            let pane_id = crate::tmux::pane_id(session).unwrap();
            crate::tmux::setup_pipe_pane(&pane_id, &log_path).unwrap();
            std::thread::sleep(std::time::Duration::from_millis(200));

            inject_message(&pane_id, "manager", "").unwrap();
            let content = (0..30)
                .find_map(|_| {
                    let content = std::fs::read_to_string(&log_path).unwrap_or_default();
                    let ready = content.contains("--- Message from manager ---")
                        && content.contains("--- end message ---")
                        && content.contains("batty send manager");
                    if ready {
                        Some(content)
                    } else {
                        std::thread::sleep(std::time::Duration::from_millis(100));
                        None
                    }
                })
                .unwrap_or_else(|| std::fs::read_to_string(&log_path).unwrap_or_default());

            if content.contains("--- Message from manager ---")
                && content.contains("--- end message ---")
                && content.contains("batty send manager")
            {
                delivered = true;
                crate::tmux::kill_session(session).unwrap();
                break;
            }

            crate::tmux::kill_session(session).unwrap();
            std::thread::sleep(std::time::Duration::from_millis(100));
        }

        assert!(delivered, "expected wrapped empty message to reach pane");
    }

    #[test]
    #[serial]
    #[cfg_attr(not(feature = "integration"), ignore)]
    fn test_inject_message_long_special_message_preserves_content() {
        let session = format!("batty-test-message-special-{}", std::process::id());
        let _ = crate::tmux::kill_session(&session);

        let tmp = tempfile::tempdir().unwrap();
        let log_path = tmp.path().join("message-special.log");
        let repeated = "x".repeat(600);
        let long_message = format!(
            "symbols: !@#$%^&*()[]{{}}<>?/\\\\|~`'\" {}\nline-2",
            repeated
        );

        crate::tmux::create_session(&session, "cat", &[], "/tmp").unwrap();
        crate::tmux::setup_pipe_pane(&session, &log_path).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(200));

        inject_message(&session, "architect", &long_message).unwrap();
        let content = (0..30)
            .find_map(|_| {
                let content = std::fs::read_to_string(&log_path).unwrap_or_default();
                let ready = content.contains("--- Message from architect ---")
                    && content.contains("symbols: !@#$%^&*()[]{}<>?/\\\\|~`'\"")
                    && content.contains("line-2");
                if ready {
                    Some(content)
                } else {
                    std::thread::sleep(std::time::Duration::from_millis(100));
                    None
                }
            })
            .unwrap_or_else(|| std::fs::read_to_string(&log_path).unwrap_or_default());
        assert!(content.contains("--- Message from architect ---"));
        assert!(content.contains("symbols: !@#$%^&*()[]{}<>?/\\\\|~`'\""));
        assert!(content.contains(&"x".repeat(200)));
        assert!(content.contains("line-2"));
        assert!(content.contains("batty send architect"));

        crate::tmux::kill_session(&session).unwrap();
    }

    #[test]
    fn test_drain_command_queue_skips_unknown_and_incomplete_commands() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");
        std::fs::write(
            &queue,
            concat!(
                "{\"type\":\"noop\",\"from\":\"manager\"}\n",
                "{\"type\":\"send\",\"from\":\"manager\",\"message\":\"missing recipient\"}\n",
                "{\"type\":\"assign\",\"from\":\"manager\",\"engineer\":\"eng-1\"}\n",
                "{\"type\":\"send\",\"from\":\"manager\",\"to\":\"architect\",\"message\":\"valid\"}\n",
            ),
        )
        .unwrap();

        let commands = drain_command_queue(&queue).unwrap();

        assert_eq!(commands.len(), 1);
        match &commands[0] {
            QueuedCommand::Send { from, to, message } => {
                assert_eq!(from, "manager");
                assert_eq!(to, "architect");
                assert_eq!(message, "valid");
            }
            other => panic!("expected valid send command, got {other:?}"),
        }
    }

    // --- Additional serialization edge cases ---

    #[test]
    fn send_command_preserves_multiline_message() {
        let cmd = QueuedCommand::Send {
            from: "manager".into(),
            to: "eng-1".into(),
            message: "line one\nline two\nline three".into(),
        };
        let json = serde_json::to_string(&cmd).unwrap();
        let parsed: QueuedCommand = serde_json::from_str(&json).unwrap();
        match parsed {
            QueuedCommand::Send { message, .. } => {
                assert_eq!(message, "line one\nline two\nline three");
            }
            _ => panic!("wrong variant"),
        }
    }

    #[test]
    fn send_command_preserves_empty_message() {
        let cmd = QueuedCommand::Send {
            from: "human".into(),
            to: "architect".into(),
            message: "".into(),
        };
        let json = serde_json::to_string(&cmd).unwrap();
        let parsed: QueuedCommand = serde_json::from_str(&json).unwrap();
        match parsed {
            QueuedCommand::Send { message, .. } => assert!(message.is_empty()),
            _ => panic!("wrong variant"),
        }
    }

    #[test]
    fn send_command_preserves_unicode() {
        let cmd = QueuedCommand::Send {
            from: "人間".into(),
            to: "アーキ".into(),
            message: "日本語テスト 🚀".into(),
        };
        let json = serde_json::to_string(&cmd).unwrap();
        let parsed: QueuedCommand = serde_json::from_str(&json).unwrap();
        match parsed {
            QueuedCommand::Send { from, to, message } => {
                assert_eq!(from, "人間");
                assert_eq!(to, "アーキ");
                assert_eq!(message, "日本語テスト 🚀");
            }
            _ => panic!("wrong variant"),
        }
    }

    #[test]
    fn assign_command_preserves_special_chars_in_task() {
        let cmd = QueuedCommand::Assign {
            from: "manager".into(),
            engineer: "eng-1-1".into(),
            task: "Task #42: Fix \"auth\" — it's broken!".into(),
        };
        let json = serde_json::to_string(&cmd).unwrap();
        let parsed: QueuedCommand = serde_json::from_str(&json).unwrap();
        match parsed {
            QueuedCommand::Assign { task, .. } => {
                assert_eq!(task, "Task #42: Fix \"auth\" — it's broken!");
            }
            _ => panic!("wrong variant"),
        }
    }

    // --- enqueue_command edge cases ---

    #[test]
    fn enqueue_creates_parent_directories() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp
            .path()
            .join("deep")
            .join("nested")
            .join("commands.jsonl");

        enqueue_command(
            &queue,
            &QueuedCommand::Send {
                from: "human".into(),
                to: "arch".into(),
                message: "hello".into(),
            },
        )
        .unwrap();

        assert!(queue.exists());
        let commands = read_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 1);
    }

    #[test]
    fn enqueue_appends_multiple_commands_preserving_order() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");

        for i in 0..5 {
            enqueue_command(
                &queue,
                &QueuedCommand::Send {
                    from: "human".into(),
                    to: "arch".into(),
                    message: format!("msg-{i}"),
                },
            )
            .unwrap();
        }

        let commands = read_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 5);
        for (i, cmd) in commands.iter().enumerate() {
            match cmd {
                QueuedCommand::Send { message, .. } => {
                    assert_eq!(message, &format!("msg-{i}"));
                }
                _ => panic!("wrong variant at index {i}"),
            }
        }
    }

    // --- read_command_queue edge cases ---

    #[test]
    fn read_command_queue_skips_empty_lines() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");
        std::fs::write(
            &queue,
            "\n\n{\"type\":\"send\",\"from\":\"a\",\"to\":\"b\",\"message\":\"hi\"}\n\n\n",
        )
        .unwrap();

        let commands = read_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 1);
    }

    #[test]
    fn read_command_queue_skips_whitespace_only_lines() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");
        std::fs::write(
            &queue,
            "   \n\t\n{\"type\":\"send\",\"from\":\"a\",\"to\":\"b\",\"message\":\"ok\"}\n  \n",
        )
        .unwrap();

        let commands = read_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 1);
    }

    #[test]
    fn read_command_queue_mixed_valid_and_malformed() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");
        std::fs::write(
            &queue,
            concat!(
                "{\"type\":\"send\",\"from\":\"a\",\"to\":\"b\",\"message\":\"first\"}\n",
                "garbage line\n",
                "{\"type\":\"assign\",\"from\":\"m\",\"engineer\":\"e1\",\"task\":\"t1\"}\n",
                "{\"invalid json\n",
                "{\"type\":\"send\",\"from\":\"c\",\"to\":\"d\",\"message\":\"last\"}\n",
            ),
        )
        .unwrap();

        let commands = read_command_queue(&queue).unwrap();
        assert_eq!(
            commands.len(),
            3,
            "should parse 3 valid commands, skip 2 malformed"
        );
    }

    // --- write_command_queue edge cases ---

    #[test]
    fn write_command_queue_empty_slice_creates_empty_file() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");

        // First enqueue something
        enqueue_command(
            &queue,
            &QueuedCommand::Send {
                from: "a".into(),
                to: "b".into(),
                message: "hello".into(),
            },
        )
        .unwrap();

        // Overwrite with empty
        write_command_queue(&queue, &[]).unwrap();

        let commands = read_command_queue(&queue).unwrap();
        assert!(commands.is_empty());
    }

    #[test]
    fn write_command_queue_creates_parent_dirs() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("sub").join("dir").join("q.jsonl");

        write_command_queue(
            &queue,
            &[QueuedCommand::Assign {
                from: "m".into(),
                engineer: "e1".into(),
                task: "t1".into(),
            }],
        )
        .unwrap();

        let commands = read_command_queue(&queue).unwrap();
        assert_eq!(commands.len(), 1);
    }

    // --- command_queue_path ---

    #[test]
    fn command_queue_path_returns_expected_path() {
        let root = Path::new("/project");
        let path = command_queue_path(root);
        assert_eq!(
            path,
            PathBuf::from("/project/.batty/team_config/commands.jsonl")
        );
    }

    #[test]
    fn command_queue_path_with_trailing_slash() {
        let root = Path::new("/project/");
        let path = command_queue_path(root);
        assert_eq!(
            path,
            PathBuf::from("/project/.batty/team_config/commands.jsonl")
        );
    }

    // --- drain_command_queue ---

    #[test]
    fn drain_empties_queue_file_but_keeps_file() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");

        enqueue_command(
            &queue,
            &QueuedCommand::Send {
                from: "a".into(),
                to: "b".into(),
                message: "msg".into(),
            },
        )
        .unwrap();

        let drained = drain_command_queue(&queue).unwrap();
        assert_eq!(drained.len(), 1);

        // File should still exist but be effectively empty
        assert!(queue.exists());
        let commands = read_command_queue(&queue).unwrap();
        assert!(commands.is_empty());
    }

    #[test]
    fn drain_twice_second_returns_empty() {
        let tmp = tempfile::tempdir().unwrap();
        let queue = tmp.path().join("commands.jsonl");

        enqueue_command(
            &queue,
            &QueuedCommand::Assign {
                from: "m".into(),
                engineer: "e".into(),
                task: "t".into(),
            },
        )
        .unwrap();

        let first = drain_command_queue(&queue).unwrap();
        assert_eq!(first.len(), 1);

        let second = drain_command_queue(&queue).unwrap();
        assert!(second.is_empty());
    }

    // --- QueuedCommand Debug derive ---

    #[test]
    fn queued_command_debug_format() {
        let cmd = QueuedCommand::Send {
            from: "human".into(),
            to: "arch".into(),
            message: "test".into(),
        };
        let debug = format!("{cmd:?}");
        assert!(debug.contains("Send"));
        assert!(debug.contains("human"));
    }

    #[test]
    fn queued_command_clone() {
        let cmd = QueuedCommand::Assign {
            from: "manager".into(),
            engineer: "eng-1".into(),
            task: "build feature".into(),
        };
        let cloned = cmd.clone();
        let json_original = serde_json::to_string(&cmd).unwrap();
        let json_cloned = serde_json::to_string(&cloned).unwrap();
        assert_eq!(json_original, json_cloned);
    }

    // --- JSON tag format verification ---

    #[test]
    fn send_command_json_has_type_send_tag() {
        let cmd = QueuedCommand::Send {
            from: "a".into(),
            to: "b".into(),
            message: "c".into(),
        };
        let json = serde_json::to_string(&cmd).unwrap();
        assert!(json.contains("\"type\":\"send\""), "got: {json}");
    }

    #[test]
    fn assign_command_json_has_type_assign_tag() {
        let cmd = QueuedCommand::Assign {
            from: "a".into(),
            engineer: "b".into(),
            task: "c".into(),
        };
        let json = serde_json::to_string(&cmd).unwrap();
        assert!(json.contains("\"type\":\"assign\""), "got: {json}");
    }

    // ── inject_message Enter-key reliability tests ──

    #[test]
    fn injection_sequence_sends_enter_after_paste() {
        // The formatted message must contain END_MARKER so wait_for_paste()
        // can confirm the paste landed before Enter is sent.
        let formatted = format!(
            "\n--- Message from manager ---\nhello\n{}\nTo reply, run: batty send manager \"<your response>\"\n",
            super::END_MARKER
        );
        assert!(
            formatted.contains(super::END_MARKER),
            "formatted message must contain the end marker used by paste verification"
        );
        // END_MARKER must appear before the final line so the capture window
        // can reliably find it in the bottom N lines of the pane.
        let marker_pos = formatted.rfind(super::END_MARKER).unwrap();
        assert!(
            marker_pos < formatted.len() - 1,
            "end marker must not be the very last byte"
        );
    }

    #[test]
    fn verification_detects_stuck_message() {
        // When the end marker is in the bottom capture, the message is stuck.
        let stuck_capture =
            "some output\n--- end message ---\nTo reply, run: batty send mgr \"<resp>\"";
        assert!(
            super::is_message_stuck_in_capture(stuck_capture),
            "should detect stuck message when end marker is present"
        );

        // When the capture shows agent activity (no end marker), not stuck.
        let active_capture = "Working on task...\n$ cargo test\nrunning 5 tests";
        assert!(
            !super::is_message_stuck_in_capture(active_capture),
            "should not flag agent activity as stuck"
        );
    }

    #[test]
    fn retry_enter_on_stuck_detection() {
        // Empty capture — message was consumed, not stuck.
        assert!(
            !super::is_message_stuck_in_capture(""),
            "empty capture must not be stuck"
        );

        // Agent prompt only — not stuck.
        assert!(
            !super::is_message_stuck_in_capture("> "),
            "agent prompt alone must not be stuck"
        );

        // Partial marker doesn't trigger stuck detection.
        assert!(
            !super::is_message_stuck_in_capture("--- end mess"),
            "partial marker must not trigger stuck detection"
        );

        // Full end marker present — stuck.
        assert!(
            super::is_message_stuck_in_capture("text\n--- end message ---\nreply hint"),
            "full end marker must trigger stuck detection"
        );

        // Multiple lines of agent output after the marker — still detected
        // because the helper only checks presence, and caller limits capture
        // to STUCK_CAPTURE_LINES (bottom 5 lines) to avoid false positives.
        let capture_with_marker = "line1\nline2\n--- end message ---\nTo reply\nmore output";
        assert!(
            super::is_message_stuck_in_capture(capture_with_marker),
            "end marker anywhere in the short capture means stuck"
        );
    }
}