batty_cli/team/

mod.rs

//! Team mode — hierarchical agent org chart with daemon-managed communication.
//!
//! A YAML-defined team (architect ↔ manager ↔ N engineers) runs in a tmux
//! session. The daemon monitors panes, routes messages between roles, and
//! manages agent lifecycles.

pub mod artifact;
pub mod auto_merge;
#[cfg(test)]
mod behavioral_tests;
pub mod board;
pub mod board_cmd;
pub mod board_health;
pub mod capability;
pub mod checkpoint;
pub mod comms;
pub mod completion;
pub mod config;
pub mod cost;
pub mod daemon;
pub mod delivery;
pub mod deps;
pub mod doctor;
pub mod errors;
pub mod estimation;
pub mod events;
pub mod failure_patterns;
pub mod git_cmd;
pub mod harness;
pub mod hierarchy;
pub mod inbox;
pub mod layout;
pub mod merge;
pub mod message;
pub mod metrics;
pub mod metrics_cmd;
pub mod nudge;
pub mod policy;
pub mod resolver;
pub mod retrospective;
pub mod retry;
pub mod review;
pub mod standup;
pub mod status;
pub mod task_cmd;
pub mod task_loop;
pub mod telegram;
pub mod telemetry_db;
#[cfg(test)]
pub mod test_helpers;
#[cfg(test)]
pub mod test_support;
pub mod validation;
pub mod watcher;
pub mod workflow;

use std::collections::HashMap;
use std::fs::File;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

use anyhow::{Context, Result, bail};
use serde::{Deserialize, Serialize};
use tracing::{info, warn};

use crate::tmux;

/// Team config directory name inside `.batty/`.
pub const TEAM_CONFIG_DIR: &str = "team_config";
/// Team config filename.
pub const TEAM_CONFIG_FILE: &str = "team.yaml";

/// Default duration window for load graph rendering, in seconds (1 hour).
const LOAD_GRAPH_WINDOW_SECONDS: u64 = 3_600;
const LOAD_GRAPH_WIDTH: usize = 30;
const INBOX_BODY_PREVIEW_CHARS: usize = 140;
const TRIAGE_RESULT_FRESHNESS_SECONDS: u64 = 300;
const LOG_ROTATION_BYTES: u64 = 5 * 1024 * 1024;
const LOG_ROTATION_KEEP: usize = 3;
pub(crate) const DEFAULT_EVENT_LOG_MAX_BYTES: u64 = 10 * 1024 * 1024;
const DAEMON_SHUTDOWN_GRACE_PERIOD: Duration = Duration::from_secs(5);
const DAEMON_SHUTDOWN_POLL_INTERVAL: Duration = Duration::from_millis(100);

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum AssignmentResultStatus {
    Delivered,
    Failed,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct AssignmentDeliveryResult {
    pub message_id: String,
    pub status: AssignmentResultStatus,
    pub engineer: String,
    pub task_summary: String,
    pub branch: Option<String>,
    pub work_dir: Option<String>,
    pub detail: String,
    pub ts: u64,
}

/// Resolve the team config directory for a project root.
pub fn team_config_dir(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join(TEAM_CONFIG_DIR)
}

/// Resolve the path to team.yaml.
pub fn team_config_path(project_root: &Path) -> PathBuf {
    team_config_dir(project_root).join(TEAM_CONFIG_FILE)
}

pub fn team_events_path(project_root: &Path) -> PathBuf {
    team_config_dir(project_root).join("events.jsonl")
}

pub(crate) fn orchestrator_log_path(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("orchestrator.log")
}

pub(crate) fn orchestrator_ansi_log_path(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("orchestrator.ansi.log")
}

/// Returns `~/.batty/templates/`.
pub fn templates_base_dir() -> Result<PathBuf> {
    let home = std::env::var("HOME").context("cannot determine home directory")?;
    Ok(PathBuf::from(home).join(".batty").join("templates"))
}

#[derive(Debug, Clone, Copy)]
pub struct TeamLoadSnapshot {
    pub timestamp: u64,
    pub total_members: usize,
    pub working_members: usize,
    pub load: f64,
    pub session_running: bool,
}

fn assignment_results_dir(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("assignment_results")
}

fn assignment_result_path(project_root: &Path, message_id: &str) -> PathBuf {
    assignment_results_dir(project_root).join(format!("{message_id}.json"))
}

pub(crate) fn store_assignment_result(
    project_root: &Path,
    result: &AssignmentDeliveryResult,
) -> Result<()> {
    let path = assignment_result_path(project_root, &result.message_id);
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent)?;
    }
    let content = serde_json::to_vec_pretty(result)?;
    std::fs::write(&path, content)
        .with_context(|| format!("failed to write assignment result {}", path.display()))?;
    Ok(())
}

pub fn load_assignment_result(
    project_root: &Path,
    message_id: &str,
) -> Result<Option<AssignmentDeliveryResult>> {
    let path = assignment_result_path(project_root, message_id);
    if !path.exists() {
        return Ok(None);
    }
    let data = std::fs::read(&path)
        .with_context(|| format!("failed to read assignment result {}", path.display()))?;
    let result = serde_json::from_slice(&data)
        .with_context(|| format!("failed to parse assignment result {}", path.display()))?;
    Ok(Some(result))
}

pub fn wait_for_assignment_result(
    project_root: &Path,
    message_id: &str,
    timeout: Duration,
) -> Result<Option<AssignmentDeliveryResult>> {
    let deadline = std::time::Instant::now() + timeout;
    loop {
        if let Some(result) = load_assignment_result(project_root, message_id)? {
            return Ok(Some(result));
        }
        if std::time::Instant::now() >= deadline {
            return Ok(None);
        }
        std::thread::sleep(Duration::from_millis(200));
    }
}

pub fn format_assignment_result(result: &AssignmentDeliveryResult) -> String {
    let mut text = match result.status {
        AssignmentResultStatus::Delivered => {
            format!(
                "Assignment delivered: {} -> {}",
                result.message_id, result.engineer
            )
        }
        AssignmentResultStatus::Failed => {
            format!(
                "Assignment failed: {} -> {}",
                result.message_id, result.engineer
            )
        }
    };

    text.push_str(&format!("\nTask: {}", result.task_summary));
    if let Some(branch) = result.branch.as_deref() {
        text.push_str(&format!("\nBranch: {branch}"));
    }
    if let Some(work_dir) = result.work_dir.as_deref() {
        text.push_str(&format!("\nWorktree: {work_dir}"));
    }
    if !result.detail.is_empty() {
        text.push_str(&format!("\nDetail: {}", result.detail));
    }
    text
}

pub(crate) fn now_unix() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs()
}

/// Scaffold `.batty/team_config/` with default team.yaml and prompt templates.
pub fn init_team(project_root: &Path, template: &str) -> Result<Vec<PathBuf>> {
    let config_dir = team_config_dir(project_root);
    std::fs::create_dir_all(&config_dir)
        .with_context(|| format!("failed to create {}", config_dir.display()))?;

    let mut created = Vec::new();

    let yaml_path = config_dir.join(TEAM_CONFIG_FILE);
    if yaml_path.exists() {
        bail!(
            "team config already exists at {}; remove it first or edit directly",
            yaml_path.display()
        );
    }

    let yaml_content = match template {
        "solo" => include_str!("templates/team_solo.yaml"),
        "pair" => include_str!("templates/team_pair.yaml"),
        "squad" => include_str!("templates/team_squad.yaml"),
        "large" => include_str!("templates/team_large.yaml"),
        "research" => include_str!("templates/team_research.yaml"),
        "software" => include_str!("templates/team_software.yaml"),
        "batty" => include_str!("templates/team_batty.yaml"),
        _ => include_str!("templates/team_simple.yaml"),
    };
    std::fs::write(&yaml_path, yaml_content)
        .with_context(|| format!("failed to write {}", yaml_path.display()))?;
    created.push(yaml_path);

    // Install prompt .md files matching the template's roles
    let prompt_files: &[(&str, &str)] = match template {
        "research" => &[
            (
                "research_lead.md",
                include_str!("templates/research_lead.md"),
            ),
            ("sub_lead.md", include_str!("templates/sub_lead.md")),
            ("researcher.md", include_str!("templates/researcher.md")),
        ],
        "software" => &[
            ("tech_lead.md", include_str!("templates/tech_lead.md")),
            ("eng_manager.md", include_str!("templates/eng_manager.md")),
            ("developer.md", include_str!("templates/developer.md")),
        ],
        "batty" => &[
            (
                "batty_architect.md",
                include_str!("templates/batty_architect.md"),
            ),
            (
                "batty_manager.md",
                include_str!("templates/batty_manager.md"),
            ),
            (
                "batty_engineer.md",
                include_str!("templates/batty_engineer.md"),
            ),
        ],
        _ => &[
            ("architect.md", include_str!("templates/architect.md")),
            ("manager.md", include_str!("templates/manager.md")),
            ("engineer.md", include_str!("templates/engineer.md")),
        ],
    };

    for (name, content) in prompt_files {
        let path = config_dir.join(name);
        if !path.exists() {
            std::fs::write(&path, content)
                .with_context(|| format!("failed to write {}", path.display()))?;
            created.push(path);
        }
    }

    let directive_files = [
        (
            "replenishment_context.md",
            include_str!("templates/replenishment_context.md"),
        ),
        (
            "review_policy.md",
            include_str!("templates/review_policy.md"),
        ),
        (
            "escalation_policy.md",
            include_str!("templates/escalation_policy.md"),
        ),
    ];
    for (name, content) in directive_files {
        let path = config_dir.join(name);
        if !path.exists() {
            std::fs::write(&path, content)
                .with_context(|| format!("failed to write {}", path.display()))?;
            created.push(path);
        }
    }

    // Initialize kanban-md board in the team config directory
    let board_dir = config_dir.join("board");
    if !board_dir.exists() {
        let output = std::process::Command::new("kanban-md")
            .args(["init", "--dir", &board_dir.to_string_lossy()])
            .output();
        match output {
            Ok(out) if out.status.success() => {
                created.push(board_dir);
            }
            Ok(out) => {
                let stderr = String::from_utf8_lossy(&out.stderr);
                warn!("kanban-md init failed: {stderr}; falling back to plain kanban.md");
                let kanban_path = config_dir.join("kanban.md");
                std::fs::write(
                    &kanban_path,
                    "# Kanban Board\n\n## Backlog\n\n## In Progress\n\n## Done\n",
                )?;
                created.push(kanban_path);
            }
            Err(_) => {
                warn!("kanban-md not found; falling back to plain kanban.md");
                let kanban_path = config_dir.join("kanban.md");
                std::fs::write(
                    &kanban_path,
                    "# Kanban Board\n\n## Backlog\n\n## In Progress\n\n## Done\n",
                )?;
                created.push(kanban_path);
            }
        }
    }

    info!(dir = %config_dir.display(), files = created.len(), "scaffolded team config");
    Ok(created)
}

pub fn list_available_templates() -> Result<Vec<String>> {
    let templates_dir = templates_base_dir()?;
    if !templates_dir.is_dir() {
        bail!(
            "no templates directory found at {}",
            templates_dir.display()
        );
    }

    let mut templates = Vec::new();
    for entry in std::fs::read_dir(&templates_dir)
        .with_context(|| format!("failed to read {}", templates_dir.display()))?
    {
        let entry = entry?;
        if entry.path().is_dir() {
            templates.push(entry.file_name().to_string_lossy().into_owned());
        }
    }
    templates.sort();
    Ok(templates)
}

fn copy_template_dir(src: &Path, dst: &Path, created: &mut Vec<PathBuf>) -> Result<()> {
    std::fs::create_dir_all(dst).with_context(|| format!("failed to create {}", dst.display()))?;
    for entry in
        std::fs::read_dir(src).with_context(|| format!("failed to read {}", src.display()))?
    {
        let entry = entry?;
        let src_path = entry.path();
        let dst_path = dst.join(entry.file_name());
        if src_path.is_dir() {
            copy_template_dir(&src_path, &dst_path, created)?;
        } else {
            std::fs::copy(&src_path, &dst_path).with_context(|| {
                format!(
                    "failed to copy template file from {} to {}",
                    src_path.display(),
                    dst_path.display()
                )
            })?;
            created.push(dst_path);
        }
    }
    Ok(())
}

pub fn init_from_template(project_root: &Path, template_name: &str) -> Result<Vec<PathBuf>> {
    let templates_dir = templates_base_dir()?;
    if !templates_dir.is_dir() {
        bail!(
            "no templates directory found at {}",
            templates_dir.display()
        );
    }

    let available = list_available_templates()?;
    if !available.iter().any(|name| name == template_name) {
        let available_display = if available.is_empty() {
            "(none)".to_string()
        } else {
            available.join(", ")
        };
        bail!(
            "template '{}' not found in {}; available templates: {}",
            template_name,
            templates_dir.display(),
            available_display
        );
    }

    let config_dir = team_config_dir(project_root);
    let yaml_path = config_dir.join(TEAM_CONFIG_FILE);
    if yaml_path.exists() {
        bail!(
            "team config already exists at {}; remove it first or edit directly",
            yaml_path.display()
        );
    }

    let source_dir = templates_dir.join(template_name);
    let mut created = Vec::new();
    copy_template_dir(&source_dir, &config_dir, &mut created)?;
    info!(
        template = template_name,
        source = %source_dir.display(),
        dest = %config_dir.display(),
        files = created.len(),
        "copied team config from user template"
    );
    Ok(created)
}

/// Export the current team config as a reusable template.
pub fn export_template(project_root: &Path, name: &str) -> Result<usize> {
    let config_dir = team_config_dir(project_root);
    let team_yaml = config_dir.join(TEAM_CONFIG_FILE);
    if !team_yaml.is_file() {
        bail!("team config missing at {}", team_yaml.display());
    }

    let template_dir = templates_base_dir()?.join(name);
    if template_dir.exists() {
        eprintln!(
            "warning: overwriting existing template at {}",
            template_dir.display()
        );
    }
    std::fs::create_dir_all(&template_dir)
        .with_context(|| format!("failed to create {}", template_dir.display()))?;

    let mut copied = 0usize;
    copy_template_file(&team_yaml, &template_dir.join(TEAM_CONFIG_FILE))?;
    copied += 1;

    let mut prompt_paths = std::fs::read_dir(&config_dir)?
        .filter_map(|entry| entry.ok().map(|entry| entry.path()))
        .filter(|path| path.extension().is_some_and(|ext| ext == "md"))
        .collect::<Vec<_>>();
    prompt_paths.sort();

    for source in prompt_paths {
        let file_name = source
            .file_name()
            .context("template source missing file name")?;
        copy_template_file(&source, &template_dir.join(file_name))?;
        copied += 1;
    }

    Ok(copied)
}

pub fn export_run(project_root: &Path) -> Result<PathBuf> {
    let team_yaml = team_config_path(project_root);
    if !team_yaml.is_file() {
        bail!("team config missing at {}", team_yaml.display());
    }

    let export_dir = create_run_export_dir(project_root)?;
    copy_template_file(&team_yaml, &export_dir.join(TEAM_CONFIG_FILE))?;

    copy_dir_if_exists(
        &team_config_dir(project_root).join("board").join("tasks"),
        &export_dir.join("board").join("tasks"),
    )?;
    copy_file_if_exists(
        &team_events_path(project_root),
        &export_dir.join("events.jsonl"),
    )?;
    copy_file_if_exists(
        &daemon_log_path(project_root),
        &export_dir.join("daemon.log"),
    )?;
    copy_file_if_exists(
        &orchestrator_log_path(project_root),
        &export_dir.join("orchestrator.log"),
    )?;
    copy_dir_if_exists(
        &project_root.join(".batty").join("retrospectives"),
        &export_dir.join("retrospectives"),
    )?;
    copy_file_if_exists(
        &project_root.join(".batty").join("test_timing.jsonl"),
        &export_dir.join("test_timing.jsonl"),
    )?;

    Ok(export_dir)
}

fn copy_template_file(source: &Path, destination: &Path) -> Result<()> {
    if let Some(parent) = destination.parent() {
        std::fs::create_dir_all(parent)
            .with_context(|| format!("failed to create {}", parent.display()))?;
    }
    std::fs::copy(source, destination).with_context(|| {
        format!(
            "failed to copy {} to {}",
            source.display(),
            destination.display()
        )
    })?;
    Ok(())
}

/// Path to the daemon PID file.
fn daemon_pid_path(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("daemon.pid")
}

fn exports_dir(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("exports")
}

fn create_run_export_dir(project_root: &Path) -> Result<PathBuf> {
    let base = exports_dir(project_root);
    std::fs::create_dir_all(&base)
        .with_context(|| format!("failed to create {}", base.display()))?;

    let timestamp = now_unix();
    let primary = base.join(timestamp.to_string());
    if !primary.exists() {
        std::fs::create_dir(&primary)
            .with_context(|| format!("failed to create {}", primary.display()))?;
        return Ok(primary);
    }

    for suffix in 1.. {
        let candidate = base.join(format!("{timestamp}-{suffix}"));
        if candidate.exists() {
            continue;
        }
        std::fs::create_dir(&candidate)
            .with_context(|| format!("failed to create {}", candidate.display()))?;
        return Ok(candidate);
    }

    unreachable!("infinite suffix iterator should always return or continue");
}

/// Path to the daemon log file.
fn daemon_log_path(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("daemon.log")
}

fn rotated_log_path(path: &Path, generation: usize) -> PathBuf {
    PathBuf::from(format!("{}.{}", path.display(), generation))
}

pub(crate) fn rotate_log_if_needed(path: &Path) -> Result<()> {
    let len = match std::fs::metadata(path) {
        Ok(metadata) => metadata.len(),
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(()),
        Err(error) => {
            return Err(error).with_context(|| format!("failed to stat {}", path.display()));
        }
    };

    if len <= LOG_ROTATION_BYTES {
        return Ok(());
    }

    let oldest = rotated_log_path(path, LOG_ROTATION_KEEP);
    if oldest.exists() {
        std::fs::remove_file(&oldest)
            .with_context(|| format!("failed to remove {}", oldest.display()))?;
    }

    for generation in (1..LOG_ROTATION_KEEP).rev() {
        let source = rotated_log_path(path, generation);
        if !source.exists() {
            continue;
        }
        let destination = rotated_log_path(path, generation + 1);
        std::fs::rename(&source, &destination).with_context(|| {
            format!(
                "failed to rotate {} to {}",
                source.display(),
                destination.display()
            )
        })?;
    }

    let rotated = rotated_log_path(path, 1);
    std::fs::rename(path, &rotated).with_context(|| {
        format!(
            "failed to rotate {} to {}",
            path.display(),
            rotated.display()
        )
    })?;
    Ok(())
}

fn copy_file_if_exists(source: &Path, destination: &Path) -> Result<()> {
    if source.is_file() {
        copy_template_file(source, destination)?;
    }
    Ok(())
}

fn copy_dir_if_exists(source: &Path, destination: &Path) -> Result<()> {
    if source.is_dir() {
        let mut created = Vec::new();
        copy_template_dir(source, destination, &mut created)?;
    }
    Ok(())
}

pub(crate) fn open_log_for_append(path: &Path) -> Result<File> {
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent)?;
    }
    rotate_log_if_needed(path)?;
    File::options()
        .append(true)
        .create(true)
        .open(path)
        .with_context(|| format!("failed to open log file: {}", path.display()))
}

fn daemon_spawn_args(root_str: &str, resume: bool) -> Vec<String> {
    let mut args = vec![
        "-v".to_string(),
        "daemon".to_string(),
        "--project-root".to_string(),
        root_str.to_string(),
    ];
    if resume {
        args.push("--resume".to_string());
    }
    args
}

pub(crate) fn daemon_state_path(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("daemon-state.json")
}

fn workflow_mode_declared(config_path: &Path) -> Result<bool> {
    let content = std::fs::read_to_string(config_path)
        .with_context(|| format!("failed to read {}", config_path.display()))?;
    let value: serde_yaml::Value = serde_yaml::from_str(&content)
        .with_context(|| format!("failed to parse {}", config_path.display()))?;
    let Some(mapping) = value.as_mapping() else {
        return Ok(false);
    };

    Ok(mapping.contains_key(serde_yaml::Value::String("workflow_mode".to_string())))
}

fn migration_validation_notes(
    team_config: &config::TeamConfig,
    workflow_mode_is_explicit: bool,
) -> Vec<String> {
    if !workflow_mode_is_explicit {
        return vec![
            "Migration: workflow_mode omitted; defaulting to legacy so existing teams and boards run unchanged.".to_string(),
        ];
    }

    match team_config.workflow_mode {
        config::WorkflowMode::Legacy => vec![
            "Migration: legacy mode selected; Batty keeps current runtime behavior and treats workflow metadata as optional.".to_string(),
        ],
        config::WorkflowMode::Hybrid => vec![
            "Migration: hybrid mode selected; workflow adoption is incremental and legacy runtime behavior remains available.".to_string(),
        ],
        config::WorkflowMode::WorkflowFirst => vec![
            "Migration: workflow_first mode selected; complete board metadata and orchestrator rollout before treating workflow state as primary truth.".to_string(),
        ],
    }
}

/// Spawn the daemon as a detached background process.
///
/// The daemon runs in its own process group with stdio redirected to a log
/// file, so it survives terminal closure. PID is saved to `.batty/daemon.pid`.
fn spawn_daemon(project_root: &Path, resume: bool) -> Result<u32> {
    use std::process::{Command, Stdio};

    let log_path = daemon_log_path(project_root);
    let pid_path = daemon_pid_path(project_root);

    // Ensure .batty/ exists
    if let Some(parent) = log_path.parent() {
        std::fs::create_dir_all(parent)?;
    }

    let log_file = open_log_for_append(&log_path)?;
    let log_err = log_file
        .try_clone()
        .context("failed to clone log file handle")?;

    let exe = std::env::current_exe().context("failed to resolve current executable")?;
    let root_str = project_root
        .canonicalize()
        .unwrap_or_else(|_| project_root.to_path_buf())
        .to_string_lossy()
        .to_string();

    let mut cmd = Command::new(exe);
    let args = daemon_spawn_args(&root_str, resume);
    cmd.args(&args)
        .stdin(Stdio::null())
        .stdout(log_file)
        .stderr(log_err);

    // Detach into a new process group so it survives terminal closure
    #[cfg(unix)]
    {
        use std::os::unix::process::CommandExt;
        cmd.process_group(0);
    }

    let mut child = cmd.spawn().context("failed to spawn daemon process")?;
    let pid = child.id();

    // Give the child a moment to start up and verify it didn't exit immediately
    // (e.g. due to an unrecognized subcommand in an outdated binary).
    std::thread::sleep(std::time::Duration::from_millis(500));
    match child.try_wait() {
        Ok(Some(status)) => {
            let _ = std::fs::remove_file(&pid_path);
            // Read the last few lines of the daemon log for the actual error
            let tail = std::fs::read_to_string(&log_path)
                .ok()
                .and_then(|s| {
                    let lines: Vec<&str> = s.lines().collect();
                    let start = lines.len().saturating_sub(5);
                    let tail = lines[start..].join("\n");
                    if tail.trim().is_empty() { None } else { Some(tail) }
                });
            match tail {
                Some(detail) => bail!(
                    "daemon process exited immediately with {status}\n\n\
                     {detail}\n\n\
                     see full log: {log}",
                    log = log_path.display(),
                ),
                None => bail!(
                    "daemon process exited immediately with {status}; \
                     see {log} for details",
                    log = log_path.display(),
                ),
            }
        }
        Ok(None) => {} // still running — good
        Err(e) => {
            warn!(pid, error = %e, "failed to check daemon process status");
        }
    }

    std::fs::write(&pid_path, pid.to_string())
        .with_context(|| format!("failed to write PID file: {}", pid_path.display()))?;

    info!(pid, log = %log_path.display(), "daemon spawned");
    Ok(pid)
}

/// Kill the daemon process if it's running.
fn read_daemon_pid(project_root: &Path) -> Option<u32> {
    let pid_path = daemon_pid_path(project_root);
    let pid_str = std::fs::read_to_string(pid_path).ok()?;
    pid_str.trim().parse::<u32>().ok()
}

#[cfg(unix)]
fn send_unix_signal(pid: u32, signal: libc::c_int) -> bool {
    let status = unsafe { libc::kill(pid as libc::pid_t, signal) };
    if status == 0 {
        true
    } else {
        let error = std::io::Error::last_os_error();
        warn!(pid, signal, error = %error, "failed to signal daemon");
        false
    }
}

#[cfg(not(unix))]
fn send_unix_signal(_pid: u32, _signal: i32) -> bool {
    false
}

#[cfg(unix)]
fn daemon_process_exists(pid: u32) -> bool {
    let status = unsafe { libc::kill(pid as libc::pid_t, 0) };
    if status == 0 {
        true
    } else {
        !matches!(
            std::io::Error::last_os_error().raw_os_error(),
            Some(libc::ESRCH)
        )
    }
}

#[cfg(not(unix))]
fn daemon_process_exists(_pid: u32) -> bool {
    false
}

fn wait_for_graceful_daemon_shutdown(
    project_root: &Path,
    pid: u32,
    previous_saved_at: Option<u64>,
    timeout: Duration,
) -> bool {
    let deadline = std::time::Instant::now() + timeout;
    loop {
        let clean_snapshot = daemon_state_indicates_clean_shutdown(project_root, previous_saved_at);
        if clean_snapshot {
            let _ = std::fs::remove_file(daemon_pid_path(project_root));
            return true;
        }
        let running = daemon_process_exists(pid);
        if !running {
            let _ = std::fs::remove_file(daemon_pid_path(project_root));
            return false;
        }
        if std::time::Instant::now() >= deadline {
            return false;
        }
        std::thread::sleep(DAEMON_SHUTDOWN_POLL_INTERVAL);
    }
}

fn request_graceful_daemon_shutdown(project_root: &Path, timeout: Duration) -> bool {
    let Some(pid) = read_daemon_pid(project_root) else {
        return true;
    };

    let previous_saved_at = read_daemon_state_probe(project_root).and_then(|state| state.saved_at);
    #[cfg(unix)]
    {
        if !send_unix_signal(pid, libc::SIGTERM) {
            return false;
        }
        info!(pid, "sent SIGTERM to daemon");
    }
    #[cfg(not(unix))]
    {
        warn!(
            pid,
            "graceful daemon shutdown is not supported on this platform"
        );
        return false;
    }

    wait_for_graceful_daemon_shutdown(project_root, pid, previous_saved_at, timeout)
}

fn force_kill_daemon(project_root: &Path) {
    let Some(pid) = read_daemon_pid(project_root) else {
        return;
    };

    #[cfg(unix)]
    {
        if send_unix_signal(pid, libc::SIGKILL) {
            info!(pid, "sent SIGKILL to daemon");
        }
    }
    #[cfg(not(unix))]
    {
        warn!(pid, "cannot force-kill daemon on this platform");
    }

    let _ = std::fs::remove_file(daemon_pid_path(project_root));
}

/// Start a team session: load config, resolve hierarchy, create tmux layout,
/// spawn the daemon as a background process, and optionally attach.
///
/// Returns the tmux session name.
pub fn start_team(project_root: &Path, attach: bool) -> Result<String> {
    let config_path = team_config_path(project_root);
    if !config_path.exists() {
        bail!(
            "no team config found at {}; run `batty init` first",
            config_path.display()
        );
    }

    let team_config = config::TeamConfig::load(&config_path)?;
    team_config.validate()?;

    let members = hierarchy::resolve_hierarchy(&team_config)?;
    let session = format!("batty-{}", team_config.name);

    if tmux::session_exists(&session) {
        bail!("session '{session}' already exists; use `batty attach` or `batty stop` first");
    }

    layout::build_layout(
        &session,
        &members,
        &team_config.layout,
        project_root,
        team_config.workflow_mode,
        team_config.orchestrator_enabled(),
        team_config.orchestrator_position,
    )?;

    // Initialize Maildir inboxes for all members
    let inboxes = inbox::inboxes_root(project_root);
    for member in &members {
        inbox::init_inbox(&inboxes, &member.name)?;
    }

    // Check for resume marker (left by a prior `batty stop`)
    let marker = resume_marker_path(project_root);
    let resume = marker.exists() || should_resume_from_daemon_state(project_root);
    if resume {
        if marker.exists() {
            // Consume the marker — it's a one-shot flag
            std::fs::remove_file(&marker).ok();
        }
        info!("resuming agent sessions from previous run");
    }

    info!(session = %session, members = members.len(), resume, "team session started");

    // Spawn daemon as a detached background process
    let pid = spawn_daemon(project_root, resume)?;
    info!(pid, "daemon process launched");

    // Give daemon a moment to start spawning agents
    std::thread::sleep(std::time::Duration::from_secs(2));

    if attach {
        tmux::attach(&session)?;
    }

    Ok(session)
}

/// Run the daemon loop directly (called by the hidden `batty daemon` subcommand).
///
/// This is the entry point for the daemonized background process.
pub fn run_daemon(project_root: &Path, resume: bool) -> Result<()> {
    let config_path = team_config_path(project_root);
    if !config_path.exists() {
        bail!(
            "no team config found at {}; run `batty init` first",
            config_path.display()
        );
    }

    let team_config = config::TeamConfig::load(&config_path)?;
    let members = hierarchy::resolve_hierarchy(&team_config)?;
    let session = format!("batty-{}", team_config.name);

    // Wait for tmux session to be ready (start_team creates it before spawning us)
    for _ in 0..30 {
        if tmux::session_exists(&session) {
            break;
        }
        std::thread::sleep(std::time::Duration::from_millis(200));
    }

    if !tmux::session_exists(&session) {
        bail!("tmux session '{session}' not found — did `batty start` create it?");
    }

    // Reconstruct pane_map from tmux pane options
    let mut pane_map = std::collections::HashMap::new();
    for member in &members {
        // Query tmux for the pane ID tagged with this member's role
        if let Some(pane_id) = find_pane_for_member(&session, &member.name) {
            pane_map.insert(member.name.clone(), pane_id);
        }
    }

    let daemon_config = daemon::DaemonConfig {
        project_root: project_root.to_path_buf(),
        team_config,
        session,
        members,
        pane_map,
    };

    let events_path = project_root
        .join(".batty")
        .join("team_config")
        .join("events.jsonl");

    let mut d = daemon::TeamDaemon::new(daemon_config)?;

    // Wrap in catch_unwind so panics are logged to events before exit
    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| d.run(resume)));

    match result {
        Ok(Ok(())) => Ok(()),
        Ok(Err(e)) => {
            eprintln!("daemon exited with error: {e:#}");
            // Try to log the error event
            if let Ok(mut sink) = events::EventSink::new(&events_path) {
                let _ = sink.emit(events::TeamEvent::daemon_stopped_with_reason(
                    &format!("error: {e:#}"),
                    0,
                ));
            }
            Err(e)
        }
        Err(panic_payload) => {
            let reason = match panic_payload.downcast_ref::<&str>() {
                Some(s) => s.to_string(),
                None => match panic_payload.downcast_ref::<String>() {
                    Some(s) => s.clone(),
                    None => "unknown panic".to_string(),
                },
            };
            eprintln!("daemon panicked: {reason}");
            // Log panic event
            if let Ok(mut sink) = events::EventSink::new(&events_path) {
                let _ = sink.emit(events::TeamEvent::daemon_panic(&reason));
            }
            std::panic::resume_unwind(panic_payload);
        }
    }
}

/// Find the tmux pane ID tagged with `@batty_role=<member_name>` in a session.
fn find_pane_for_member(session: &str, member_name: &str) -> Option<String> {
    let output = std::process::Command::new("tmux")
        .args([
            "list-panes",
            "-t",
            session,
            "-F",
            "#{pane_id} #{@batty_role}",
        ])
        .output()
        .ok()?;

    if !output.status.success() {
        return None;
    }

    let stdout = String::from_utf8_lossy(&output.stdout);
    for line in stdout.lines() {
        let parts: Vec<&str> = line.splitn(2, ' ').collect();
        if parts.len() == 2 && parts[1] == member_name {
            return Some(parts[0].to_string());
        }
    }
    None
}

/// Path to the resume marker file. Presence indicates agents have prior sessions.
fn resume_marker_path(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("resume")
}

#[derive(Debug, Deserialize)]
struct DaemonStateResumeProbe {
    #[serde(default)]
    clean_shutdown: bool,
    #[serde(default)]
    saved_at: Option<u64>,
}

fn read_daemon_state_probe(project_root: &Path) -> Option<DaemonStateResumeProbe> {
    let path = daemon_state_path(project_root);
    let content = std::fs::read_to_string(&path).ok()?;

    match serde_json::from_str::<DaemonStateResumeProbe>(&content) {
        Ok(state) => Some(state),
        Err(error) => {
            warn!(
                path = %path.display(),
                error = %error,
                "failed to parse daemon state while probing for resume"
            );
            None
        }
    }
}

fn daemon_state_indicates_clean_shutdown(
    project_root: &Path,
    previous_saved_at: Option<u64>,
) -> bool {
    let Some(state) = read_daemon_state_probe(project_root) else {
        return false;
    };

    state.clean_shutdown
        && match (state.saved_at, previous_saved_at) {
            (Some(saved_at), Some(previous_saved_at)) => saved_at > previous_saved_at,
            (Some(_), None) => true,
            (None, Some(_)) => false,
            (None, None) => true,
        }
}

fn should_resume_from_daemon_state(project_root: &Path) -> bool {
    read_daemon_state_probe(project_root)
        .map(|state| !state.clean_shutdown)
        .unwrap_or(false)
}

/// Path to the pause marker file. Presence pauses nudges and standups.
pub fn pause_marker_path(project_root: &Path) -> PathBuf {
    project_root.join(".batty").join("paused")
}

/// Create the pause marker file, pausing nudges and standups.
pub fn pause_team(project_root: &Path) -> Result<()> {
    let marker = pause_marker_path(project_root);
    if marker.exists() {
        bail!("Team is already paused.");
    }
    if let Some(parent) = marker.parent() {
        std::fs::create_dir_all(parent).ok();
    }
    std::fs::write(&marker, "").context("failed to write pause marker")?;
    info!("paused nudges and standups");
    Ok(())
}

/// Remove the pause marker file, resuming nudges and standups.
pub fn resume_team(project_root: &Path) -> Result<()> {
    let marker = pause_marker_path(project_root);
    if !marker.exists() {
        bail!("Team is not paused.");
    }
    std::fs::remove_file(&marker).context("failed to remove pause marker")?;
    info!("resumed nudges and standups");
    Ok(())
}

/// Path to the nudge-disabled marker for a given intervention.
pub fn nudge_disabled_marker_path(project_root: &Path, intervention: &str) -> PathBuf {
    project_root
        .join(".batty")
        .join(format!("nudge_{intervention}_disabled"))
}

/// Create a nudge-disabled marker file, disabling the intervention at runtime.
pub fn disable_nudge(project_root: &Path, intervention: &str) -> Result<()> {
    let marker = nudge_disabled_marker_path(project_root, intervention);
    if marker.exists() {
        bail!("Intervention '{intervention}' is already disabled.");
    }
    if let Some(parent) = marker.parent() {
        std::fs::create_dir_all(parent).ok();
    }
    std::fs::write(&marker, "").context("failed to write nudge disabled marker")?;
    info!(intervention, "disabled intervention");
    Ok(())
}

/// Remove a nudge-disabled marker file, re-enabling the intervention.
pub fn enable_nudge(project_root: &Path, intervention: &str) -> Result<()> {
    let marker = nudge_disabled_marker_path(project_root, intervention);
    if !marker.exists() {
        bail!("Intervention '{intervention}' is not disabled.");
    }
    std::fs::remove_file(&marker).context("failed to remove nudge disabled marker")?;
    info!(intervention, "enabled intervention");
    Ok(())
}

/// Print a table showing config, runtime, and effective state for each intervention.
pub fn nudge_status(project_root: &Path) -> Result<()> {
    use crate::cli::NudgeIntervention;

    let config_path = team_config_path(project_root);
    let automation = if config_path.exists() {
        let team_config = config::TeamConfig::load(&config_path)?;
        Some(team_config.automation)
    } else {
        None
    };

    println!(
        "{:<16} {:<10} {:<10} {:<10}",
        "INTERVENTION", "CONFIG", "RUNTIME", "EFFECTIVE"
    );

    for intervention in NudgeIntervention::ALL {
        let name = intervention.marker_name();
        let config_enabled = automation
            .as_ref()
            .map(|a| match intervention {
                NudgeIntervention::Replenish => true, // no dedicated config flag
                NudgeIntervention::Triage => a.triage_interventions,
                NudgeIntervention::Review => a.review_interventions,
                NudgeIntervention::Dispatch => a.manager_dispatch_interventions,
                NudgeIntervention::Utilization => a.architect_utilization_interventions,
                NudgeIntervention::OwnedTask => a.owned_task_interventions,
            })
            .unwrap_or(true);

        let runtime_disabled = nudge_disabled_marker_path(project_root, name).exists();
        let runtime_str = if runtime_disabled {
            "disabled"
        } else {
            "enabled"
        };
        let config_str = if config_enabled {
            "enabled"
        } else {
            "disabled"
        };
        let effective = config_enabled && !runtime_disabled;
        let effective_str = if effective { "enabled" } else { "DISABLED" };

        println!(
            "{:<16} {:<10} {:<10} {:<10}",
            name, config_str, runtime_str, effective_str
        );
    }

    Ok(())
}

/// Stop a running team session and clean up any orphaned `batty-` sessions.
/// Summary statistics for a completed session.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct SessionSummary {
    pub tasks_completed: u32,
    pub tasks_merged: u32,
    pub runtime_secs: u64,
}

impl SessionSummary {
    pub fn display(&self) -> String {
        format!(
            "Session summary: {} tasks completed, {} merged, runtime {}",
            self.tasks_completed,
            self.tasks_merged,
            format_runtime(self.runtime_secs),
        )
    }
}

fn format_runtime(secs: u64) -> String {
    if secs < 60 {
        format!("{secs}s")
    } else if secs < 3600 {
        format!("{}m", secs / 60)
    } else {
        let hours = secs / 3600;
        let mins = (secs % 3600) / 60;
        if mins == 0 {
            format!("{hours}h")
        } else {
            format!("{hours}h {mins}m")
        }
    }
}

/// Compute session summary from the event log.
///
/// Finds the most recent `daemon_started` event and counts completions and
/// merges that occurred after it. Runtime is calculated from the daemon start
/// timestamp to now.
pub(crate) fn compute_session_summary(project_root: &Path) -> Option<SessionSummary> {
    let events_path = team_events_path(project_root);
    let all_events = events::read_events(&events_path).ok()?;

    // Find the most recent daemon_started event.
    let session_start = all_events
        .iter()
        .rev()
        .find(|e| e.event == "daemon_started")?;
    let start_ts = session_start.ts;
    let now_ts = now_unix();

    let session_events: Vec<_> = all_events.iter().filter(|e| e.ts >= start_ts).collect();

    let tasks_completed = session_events
        .iter()
        .filter(|e| e.event == "task_completed")
        .count() as u32;

    let tasks_merged = session_events
        .iter()
        .filter(|e| e.event == "task_auto_merged" || e.event == "task_manual_merged")
        .count() as u32;

    let runtime_secs = now_ts.saturating_sub(start_ts);

    Some(SessionSummary {
        tasks_completed,
        tasks_merged,
        runtime_secs,
    })
}

pub fn stop_team(project_root: &Path) -> Result<()> {
    // Compute session summary before shutting down (events log is still available).
    let summary = compute_session_summary(project_root);

    // Write resume marker before tearing down — agents have sessions to continue
    let marker = resume_marker_path(project_root);
    if let Some(parent) = marker.parent() {
        std::fs::create_dir_all(parent).ok();
    }
    std::fs::write(&marker, "").ok();

    // Ask the daemon to persist a final clean snapshot before the tmux session is torn down.
    if !request_graceful_daemon_shutdown(project_root, DAEMON_SHUTDOWN_GRACE_PERIOD) {
        warn!("daemon did not stop gracefully; forcing shutdown");
        force_kill_daemon(project_root);
    }

    let config_path = team_config_path(project_root);
    let primary_session = if config_path.exists() {
        let team_config = config::TeamConfig::load(&config_path)?;
        Some(format!("batty-{}", team_config.name))
    } else {
        None
    };

    // Kill only the session belonging to this project
    match &primary_session {
        Some(session) if tmux::session_exists(session) => {
            tmux::kill_session(session)?;
            info!(session = %session, "team session stopped");
        }
        Some(session) => {
            info!(session = %session, "no running session to stop");
        }
        None => {
            bail!("no team config found at {}", config_path.display());
        }
    }

    // Print session summary after teardown.
    if let Some(summary) = summary {
        println!();
        println!("{}", summary.display());
    }

    Ok(())
}

/// Attach to a running team session.
///
/// First tries the team config in the project root. If not found, looks for
/// any running `batty-*` tmux session and attaches to it.
pub fn attach_team(project_root: &Path) -> Result<()> {
    let config_path = team_config_path(project_root);

    let session = if config_path.exists() {
        let team_config = config::TeamConfig::load(&config_path)?;
        format!("batty-{}", team_config.name)
    } else {
        // No local config — find any running batty session
        let mut sessions = tmux::list_sessions_with_prefix("batty-");
        match sessions.len() {
            0 => bail!("no team config found and no batty sessions running"),
            1 => sessions.swap_remove(0),
            _ => {
                let list = sessions.join(", ");
                bail!(
                    "no team config found and multiple batty sessions running: {list}\n\
                     Run from the project directory, or use: tmux attach -t <session>"
                );
            }
        }
    };

    if !tmux::session_exists(&session) {
        bail!("no running session '{session}'; run `batty start` first");
    }

    tmux::attach(&session)
}

/// Show team status.
pub fn team_status(project_root: &Path, json: bool) -> Result<()> {
    let config_path = team_config_path(project_root);
    if !config_path.exists() {
        bail!("no team config found at {}", config_path.display());
    }

    let team_config = config::TeamConfig::load(&config_path)?;
    let members = hierarchy::resolve_hierarchy(&team_config)?;
    let session = format!("batty-{}", team_config.name);
    let session_running = tmux::session_exists(&session);
    let runtime_statuses = if session_running {
        match status::list_runtime_member_statuses(&session) {
            Ok(statuses) => statuses,
            Err(error) => {
                warn!(session = %session, error = %error, "failed to read live runtime statuses");
                std::collections::HashMap::new()
            }
        }
    } else {
        std::collections::HashMap::new()
    };
    let pending_inbox_counts = status::pending_inbox_counts(project_root, &members);
    let triage_backlog_counts = status::triage_backlog_counts(project_root, &members);
    let owned_task_buckets = status::owned_task_buckets(project_root, &members);
    let agent_health = status::agent_health_by_member(project_root, &members);
    let paused = pause_marker_path(project_root).exists();
    let mut rows = status::build_team_status_rows(
        &members,
        session_running,
        &runtime_statuses,
        &pending_inbox_counts,
        &triage_backlog_counts,
        &owned_task_buckets,
        &agent_health,
    );

    // Populate ETA estimates for members with active tasks.
    let active_task_elapsed: Vec<(u32, u64)> = rows
        .iter()
        .filter(|row| !row.active_owned_tasks.is_empty())
        .flat_map(|row| {
            let elapsed = row.health.task_elapsed_secs.unwrap_or(0);
            row.active_owned_tasks
                .iter()
                .map(move |&task_id| (task_id, elapsed))
        })
        .collect();
    let etas = estimation::compute_etas(project_root, &active_task_elapsed);
    for row in &mut rows {
        if let Some(&task_id) = row.active_owned_tasks.first() {
            if let Some(eta) = etas.get(&task_id) {
                row.eta = eta.clone();
            }
        }
    }

    let workflow_metrics = status::workflow_metrics_section(project_root, &members);
    let (active_tasks, review_queue) = match status::board_status_task_queues(project_root) {
        Ok(queues) => queues,
        Err(error) => {
            warn!(error = %error, "failed to load board task queues for status json");
            (Vec::new(), Vec::new())
        }
    };

    if json {
        let report = status::build_team_status_json_report(status::TeamStatusJsonReportInput {
            team: team_config.name.clone(),
            session: session.clone(),
            session_running,
            paused,
            workflow_metrics: workflow_metrics
                .as_ref()
                .map(|(_, metrics)| metrics.clone()),
            active_tasks,
            review_queue,
            members: rows,
        });
        println!("{}", serde_json::to_string_pretty(&report)?);
    } else {
        println!("Team: {}", team_config.name);
        println!(
            "Session: {} ({})",
            session,
            if session_running {
                "running"
            } else {
                "stopped"
            }
        );
        println!();
        println!(
            "{:<20} {:<12} {:<10} {:<12} {:>5} {:>6} {:<14} {:<14} {:<16} {:<18} {:<24} {:<20}",
            "MEMBER",
            "ROLE",
            "AGENT",
            "STATE",
            "INBOX",
            "TRIAGE",
            "ACTIVE",
            "REVIEW",
            "ETA",
            "HEALTH",
            "SIGNAL",
            "REPORTS TO"
        );
        println!("{}", "-".repeat(195));
        for row in &rows {
            println!(
                "{:<20} {:<12} {:<10} {:<12} {:>5} {:>6} {:<14} {:<14} {:<16} {:<18} {:<24} {:<20}",
                row.name,
                row.role,
                row.agent.as_deref().unwrap_or("-"),
                row.state,
                row.pending_inbox,
                row.triage_backlog,
                status::format_owned_tasks_summary(&row.active_owned_tasks),
                status::format_owned_tasks_summary(&row.review_owned_tasks),
                row.eta,
                row.health_summary,
                row.signal.as_deref().unwrap_or("-"),
                row.reports_to.as_deref().unwrap_or("-"),
            );
        }
        if let Some((formatted, _)) = workflow_metrics {
            println!();
            println!("{formatted}");
        }
    }

    Ok(())
}

/// Show an estimated team load value from live state, store it, and show recent load trends.
pub fn show_load(project_root: &Path) -> Result<()> {
    let current = capture_team_load(project_root)?;
    if let Err(error) = log_team_load_snapshot(project_root, &current) {
        warn!(error = %error, "failed to append load snapshot to team event log");
    }

    let mut history = read_team_load_history(project_root)?;
    history.push(current);
    history.sort_by_key(|snapshot| snapshot.timestamp);

    println!(
        "Current load: {:.1}% ({} / {} members working)",
        current.load * 100.0,
        current.working_members,
        current.total_members.max(1)
    );
    println!(
        "Session: {}",
        if current.session_running {
            "running"
        } else {
            "stopped"
        }
    );

    if let Some(avg) = average_load(&history, current.timestamp, 10 * 60) {
        println!("10m avg: {:.1}%", avg * 100.0);
    } else {
        println!("10m avg: n/a");
    }
    println!(
        "30m avg: {}",
        average_load(&history, current.timestamp, 30 * 60)
            .map(|avg| format!("{:.1}%", avg * 100.0))
            .unwrap_or_else(|| "n/a".to_string())
    );
    println!(
        "60m avg: {}",
        average_load(&history, current.timestamp, 60 * 60)
            .map(|avg| format!("{:.1}%", avg * 100.0))
            .unwrap_or_else(|| "n/a".to_string())
    );

    println!("Load graph (1h):");
    println!("{}", render_load_graph(&history, current.timestamp));
    Ok(())
}

fn capture_team_load(project_root: &Path) -> Result<TeamLoadSnapshot> {
    let config_path = team_config_path(project_root);
    if !config_path.exists() {
        bail!("no team config found at {}", config_path.display());
    }

    let team_config = config::TeamConfig::load(&config_path)?;
    let members = hierarchy::resolve_hierarchy(&team_config)?;
    let session = format!("batty-{}", team_config.name);
    let session_running = tmux::session_exists(&session);
    let runtime_statuses = if session_running {
        match status::list_runtime_member_statuses(&session) {
            Ok(statuses) => statuses,
            Err(error) => {
                warn!(session = %session, error = %error, "failed to read runtime statuses for load sampling");
                std::collections::HashMap::new()
            }
        }
    } else {
        std::collections::HashMap::new()
    };

    let triage_backlog_counts = status::triage_backlog_counts(project_root, &members);
    let owned_task_buckets = status::owned_task_buckets(project_root, &members);
    let rows = status::build_team_status_rows(
        &members,
        session_running,
        &runtime_statuses,
        &Default::default(),
        &triage_backlog_counts,
        &owned_task_buckets,
        &Default::default(),
    );
    let mut total_members = 0usize;
    let mut working_members = 0usize;

    for row in &rows {
        if row.role_type == "User" {
            continue;
        }
        total_members += 1;
        if counts_as_active_load(row) {
            working_members += 1;
        }
    }

    let load = if total_members == 0 {
        0.0
    } else {
        working_members as f64 / total_members as f64
    };

    Ok(TeamLoadSnapshot {
        timestamp: now_unix(),
        total_members,
        working_members: working_members.min(total_members),
        load,
        session_running,
    })
}

fn counts_as_active_load(row: &status::TeamStatusRow) -> bool {
    matches!(row.state.as_str(), "working" | "triaging" | "reviewing")
}

fn log_team_load_snapshot(project_root: &Path, snapshot: &TeamLoadSnapshot) -> Result<()> {
    let events_path = team_events_path(project_root);
    let mut sink = events::EventSink::new(&events_path)?;
    let event = events::TeamEvent::load_snapshot(
        snapshot.working_members as u32,
        snapshot.total_members as u32,
        snapshot.session_running,
    );
    sink.emit(event)?;
    Ok(())
}

fn read_team_load_history(project_root: &Path) -> Result<Vec<TeamLoadSnapshot>> {
    let events_path = team_events_path(project_root);
    let events = events::read_events(&events_path)?;
    let mut history = Vec::new();
    for event in events {
        if event.event != "load_snapshot" {
            continue;
        }
        let Some(load) = event.load else {
            continue;
        };
        let Some(working_members) = event.working_members else {
            continue;
        };
        let Some(total_members) = event.total_members else {
            continue;
        };

        history.push(TeamLoadSnapshot {
            timestamp: event.ts,
            total_members: total_members as usize,
            working_members: working_members as usize,
            load,
            session_running: event.session_running.unwrap_or(false),
        });
    }
    Ok(history)
}

fn average_load(samples: &[TeamLoadSnapshot], now: u64, window_seconds: u64) -> Option<f64> {
    let cutoff = now.saturating_sub(window_seconds);
    let mut values = Vec::new();
    for sample in samples {
        if sample.timestamp >= cutoff && sample.timestamp <= now {
            values.push(sample.load);
        }
    }
    if values.is_empty() {
        return None;
    }
    let sum: f64 = values.iter().copied().sum();
    Some(sum / values.len() as f64)
}

fn render_load_graph(samples: &[TeamLoadSnapshot], now: u64) -> String {
    if samples.is_empty() {
        return "(no historical load data yet)".to_string();
    }

    let bucket_size = (LOAD_GRAPH_WINDOW_SECONDS / LOAD_GRAPH_WIDTH as u64).max(1);
    let window_start = now.saturating_sub(LOAD_GRAPH_WINDOW_SECONDS);
    let mut history = String::new();
    let mut previous = 0.0;
    for index in 0..LOAD_GRAPH_WIDTH {
        let bucket_start = window_start + (index as u64 * bucket_size);
        let bucket_end = if index + 1 == LOAD_GRAPH_WIDTH {
            now + 1
        } else {
            bucket_start + bucket_size
        };

        let mut sum = 0.0;
        let mut count = 0usize;
        for sample in samples {
            if sample.timestamp >= bucket_start && sample.timestamp < bucket_end {
                sum += sample.load;
                count += 1;
            }
        }

        let value = if count == 0 {
            previous
        } else {
            sum / count as f64
        };
        previous = value;
        history.push(load_point_char(value));
    }

    history
}

fn load_point_char(value: f64) -> char {
    let clamped = value.clamp(0.0, 1.0);
    match (clamped * 5.0).round() as usize {
        0 => ' ',
        1 => '.',
        2 => ':',
        3 => '=',
        4 => '#',
        _ => '@',
    }
}

/// Validate team config without launching.
pub fn validate_team(project_root: &Path, verbose: bool) -> Result<()> {
    let config_path = team_config_path(project_root);
    if !config_path.exists() {
        bail!("no team config found at {}", config_path.display());
    }

    let team_config = config::TeamConfig::load(&config_path)?;

    if verbose {
        let checks = team_config.validate_verbose();
        let mut any_failed = false;
        for check in &checks {
            let status = if check.passed { "PASS" } else { "FAIL" };
            println!("[{status}] {}: {}", check.name, check.detail);
            if !check.passed {
                any_failed = true;
            }
        }
        if any_failed {
            bail!("validation failed — see FAIL checks above");
        }
    } else {
        team_config.validate()?;
    }

    let workflow_mode_is_explicit = workflow_mode_declared(&config_path)?;

    let members = hierarchy::resolve_hierarchy(&team_config)?;

    println!("Config: {}", config_path.display());
    println!("Team: {}", team_config.name);
    println!(
        "Workflow mode: {}",
        match team_config.workflow_mode {
            config::WorkflowMode::Legacy => "legacy",
            config::WorkflowMode::Hybrid => "hybrid",
            config::WorkflowMode::WorkflowFirst => "workflow_first",
        }
    );
    println!("Roles: {}", team_config.roles.len());
    println!("Total members: {}", members.len());
    for note in migration_validation_notes(&team_config, workflow_mode_is_explicit) {
        println!("{note}");
    }
    println!("Valid.");
    Ok(())
}

/// Resolve a member instance name (e.g. "eng-1-2") to its role definition name
/// (e.g. "engineer"). Returns the name itself if no config is available.
fn resolve_role_name(project_root: &Path, member_name: &str) -> String {
    // "human" is not a member instance — it's the CLI user
    if matches!(member_name, "human" | "daemon") {
        return member_name.to_string();
    }
    let config_path = team_config_path(project_root);
    if let Ok(team_config) = config::TeamConfig::load(&config_path) {
        if let Ok(members) = hierarchy::resolve_hierarchy(&team_config) {
            if let Some(m) = members.iter().find(|m| m.name == member_name) {
                return m.role_name.clone();
            }
        }
    }
    // Fallback: the name might already be a role name
    member_name.to_string()
}

/// Resolve a caller-facing role/member name to a concrete member instance.
///
/// Examples:
/// - exact member names pass through unchanged (`sam-designer-1-1`)
/// - unique role aliases resolve to their single member instance (`sam-designer`)
/// - ambiguous aliases error and require an explicit member name
fn resolve_member_name(project_root: &Path, member_name: &str) -> Result<String> {
    if matches!(member_name, "human" | "daemon") {
        return Ok(member_name.to_string());
    }

    let config_path = team_config_path(project_root);
    if let Ok(team_config) = config::TeamConfig::load(&config_path) {
        if let Ok(members) = hierarchy::resolve_hierarchy(&team_config) {
            if let Some(member) = members.iter().find(|m| m.name == member_name) {
                return Ok(member.name.clone());
            }

            let matches: Vec<String> = members
                .iter()
                .filter(|m| m.role_name == member_name)
                .map(|m| m.name.clone())
                .collect();

            return match matches.len() {
                0 => Ok(member_name.to_string()),
                1 => Ok(matches[0].clone()),
                _ => bail!(
                    "'{member_name}' matches multiple members: {}. Use the explicit member name.",
                    matches.join(", ")
                ),
            };
        }
    }

    Ok(member_name.to_string())
}

/// Send a message to a role via their Maildir inbox.
///
/// The sender is auto-detected from the `@batty_role` tmux pane option
/// (set during layout). Falls back to "human" if not in a batty pane.
/// Enforces communication routing rules from team config.
pub fn send_message(project_root: &Path, role: &str, msg: &str) -> Result<()> {
    let from = detect_sender().unwrap_or_else(|| "human".to_string());
    let recipient = resolve_member_name(project_root, role)?;

    // Enforce routing: check talks_to rules
    let config_path = team_config_path(project_root);
    if config_path.exists() {
        if let Ok(team_config) = config::TeamConfig::load(&config_path) {
            let from_role = resolve_role_name(project_root, &from);
            let to_role = resolve_role_name(project_root, &recipient);
            if !team_config.can_talk(&from_role, &to_role) {
                bail!(
                    "{from} ({from_role}) is not allowed to message {recipient} ({to_role}). \
                     Check talks_to in team.yaml."
                );
            }
        }
    }

    let root = inbox::inboxes_root(project_root);
    let inbox_msg = inbox::InboxMessage::new_send(&from, &recipient, msg);
    let id = inbox::deliver_to_inbox(&root, &inbox_msg)?;
    if let Err(error) = completion::ingest_completion_message(project_root, msg) {
        warn!(from, to = %recipient, error = %error, "failed to ingest completion packet");
    }
    info!(to = %recipient, id = %id, "message delivered to inbox");
    Ok(())
}

/// Detect who is calling `batty send` by reading the `@batty_role` option
/// from the current tmux pane.
fn detect_sender() -> Option<String> {
    let pane_id = std::env::var("TMUX_PANE").ok()?;
    let output = std::process::Command::new("tmux")
        .args(["show-options", "-p", "-t", &pane_id, "-v", "@batty_role"])
        .output()
        .ok()?;
    if output.status.success() {
        let role = String::from_utf8_lossy(&output.stdout).trim().to_string();
        if !role.is_empty() { Some(role) } else { None }
    } else {
        None
    }
}

/// Assign a task to an engineer via their Maildir inbox.
pub fn assign_task(project_root: &Path, engineer: &str, task: &str) -> Result<String> {
    let from = detect_sender().unwrap_or_else(|| "human".to_string());
    let recipient = resolve_member_name(project_root, engineer)?;

    let config_path = team_config_path(project_root);
    if config_path.exists() {
        if let Ok(team_config) = config::TeamConfig::load(&config_path) {
            let from_role = resolve_role_name(project_root, &from);
            let to_role = resolve_role_name(project_root, &recipient);
            if !team_config.can_talk(&from_role, &to_role) {
                bail!(
                    "{from} ({from_role}) is not allowed to assign {recipient} ({to_role}). \
                     Check talks_to in team.yaml."
                );
            }
        }
    }

    let root = inbox::inboxes_root(project_root);
    let msg = inbox::InboxMessage::new_assign(&from, &recipient, task);
    let id = inbox::deliver_to_inbox(&root, &msg)?;
    info!(from, engineer = %recipient, task, id = %id, "assignment delivered to inbox");
    Ok(id)
}

/// List inbox messages for a member.
pub fn list_inbox(project_root: &Path, member: &str, limit: Option<usize>) -> Result<()> {
    let member = resolve_member_name(project_root, member)?;
    let root = inbox::inboxes_root(project_root);
    let messages = inbox::all_messages(&root, &member)?;
    print!("{}", format_inbox_listing(&member, &messages, limit));
    Ok(())
}

fn format_inbox_listing(
    member: &str,
    messages: &[(inbox::InboxMessage, bool)],
    limit: Option<usize>,
) -> String {
    if messages.is_empty() {
        return format!("No messages for {member}.\n");
    }

    let start = match limit {
        Some(0) => messages.len(),
        Some(n) => messages.len().saturating_sub(n),
        None => 0,
    };
    let shown = &messages[start..];
    let refs = inbox_message_refs(messages);
    let shown_refs = &refs[start..];

    let mut out = String::new();
    if shown.len() < messages.len() {
        out.push_str(&format!(
            "Showing {} of {} messages for {member}. Use `-n <N>` or `--all` to see more.\n",
            shown.len(),
            messages.len()
        ));
    }
    out.push_str(&format!(
        "{:<10} {:<12} {:<12} {:<14} BODY\n",
        "STATUS", "FROM", "TYPE", "REF"
    ));
    out.push_str(&format!("{}\n", "-".repeat(96)));
    for ((msg, delivered), msg_ref) in shown.iter().zip(shown_refs.iter()) {
        let status = if *delivered { "delivered" } else { "pending" };
        let body_short = truncate_chars(&msg.body, INBOX_BODY_PREVIEW_CHARS);
        out.push_str(&format!(
            "{:<10} {:<12} {:<12} {:<14} {}\n",
            status,
            msg.from,
            format!("{:?}", msg.msg_type).to_lowercase(),
            msg_ref,
            body_short,
        ));
    }
    out
}

fn inbox_message_refs(messages: &[(inbox::InboxMessage, bool)]) -> Vec<String> {
    let mut totals = HashMap::new();
    for (msg, _) in messages {
        *totals.entry(msg.timestamp).or_insert(0usize) += 1;
    }

    let mut seen = HashMap::new();
    messages
        .iter()
        .map(|(msg, _)| {
            let ordinal = seen.entry(msg.timestamp).or_insert(0usize);
            *ordinal += 1;
            if totals.get(&msg.timestamp).copied().unwrap_or(0) <= 1 {
                msg.timestamp.to_string()
            } else {
                format!("{}-{}", msg.timestamp, ordinal)
            }
        })
        .collect()
}

fn resolve_inbox_message_indices(
    messages: &[(inbox::InboxMessage, bool)],
    selector: &str,
) -> Vec<usize> {
    let refs = inbox_message_refs(messages);
    messages
        .iter()
        .enumerate()
        .filter_map(|(idx, (msg, _))| {
            if msg.id == selector || msg.id.starts_with(selector) || refs[idx] == selector {
                Some(idx)
            } else {
                None
            }
        })
        .collect()
}

fn truncate_chars(input: &str, max_chars: usize) -> String {
    if input.chars().count() <= max_chars {
        return input.to_string();
    }
    let mut truncated: String = input.chars().take(max_chars).collect();
    truncated.push_str("...");
    truncated
}

/// Read a specific message from a member's inbox by ID, ID prefix, or REF.
pub fn read_message(project_root: &Path, member: &str, id: &str) -> Result<()> {
    let member = resolve_member_name(project_root, member)?;
    let root = inbox::inboxes_root(project_root);
    let messages = inbox::all_messages(&root, &member)?;

    let matching = resolve_inbox_message_indices(&messages, id);

    match matching.len() {
        0 => bail!("no message matching '{id}' in {member}'s inbox"),
        1 => {
            let (msg, delivered) = &messages[matching[0]];
            let status = if *delivered { "delivered" } else { "pending" };
            println!("ID:     {}", msg.id);
            println!("From:   {}", msg.from);
            println!("To:     {}", msg.to);
            println!("Type:   {:?}", msg.msg_type);
            println!("Status: {status}");
            println!("Time:   {}", msg.timestamp);
            println!();
            println!("{}", msg.body);
        }
        n => {
            bail!(
                "'{id}' matches {n} messages — use a longer prefix or the REF column from `batty inbox`"
            );
        }
    }

    Ok(())
}

/// Acknowledge (mark delivered) a message in a member's inbox by ID, prefix, or REF.
pub fn ack_message(project_root: &Path, member: &str, id: &str) -> Result<()> {
    let member = resolve_member_name(project_root, member)?;
    let root = inbox::inboxes_root(project_root);
    let messages = inbox::all_messages(&root, &member)?;
    let matching = resolve_inbox_message_indices(&messages, id);
    let resolved_id = match matching.len() {
        0 => bail!("no message matching '{id}' in {member}'s inbox"),
        1 => messages[matching[0]].0.id.clone(),
        n => bail!(
            "'{id}' matches {n} messages — use a longer prefix or the REF column from `batty inbox`"
        ),
    };
    inbox::mark_delivered(&root, &member, &resolved_id)?;
    info!(member, id = %resolved_id, "message acknowledged");
    Ok(())
}

/// Purge delivered messages from one inbox or all inboxes.
pub fn purge_inbox(
    project_root: &Path,
    member: Option<&str>,
    all_roles: bool,
    before: Option<u64>,
    purge_all: bool,
) -> Result<inbox::InboxPurgeSummary> {
    if !purge_all && before.is_none() {
        bail!("use `--all` or `--before <unix-timestamp>` with `batty inbox purge`");
    }

    let root = inbox::inboxes_root(project_root);
    if all_roles {
        return inbox::purge_delivered_messages_for_all(&root, before, purge_all);
    }

    let member = member.context("member is required unless using `--all-roles`")?;
    let member = resolve_member_name(project_root, member)?;
    let messages = inbox::purge_delivered_messages(&root, &member, before, purge_all)?;
    Ok(inbox::InboxPurgeSummary { roles: 1, messages })
}

/// Merge an engineer's worktree branch.
pub fn merge_worktree(project_root: &Path, engineer: &str) -> Result<()> {
    let engineer = resolve_member_name(project_root, engineer)?;
    match merge::merge_engineer_branch(project_root, &engineer)? {
        merge::MergeOutcome::Success => Ok(()),
        merge::MergeOutcome::RebaseConflict(stderr) => {
            bail!("merge blocked by rebase conflict: {stderr}")
        }
        merge::MergeOutcome::MergeFailure(stderr) => bail!("merge failed: {stderr}"),
    }
}

/// Run the interactive Telegram setup wizard.
pub fn setup_telegram(project_root: &Path) -> Result<()> {
    telegram::setup_telegram(project_root)
}

#[cfg(test)]
mod tests {
    use super::status;
    use super::*;
    use crate::team::config::RoleType;
    use serial_test::serial;
    use std::ffi::OsString;

    struct HomeGuard {
        original_home: Option<OsString>,
    }

    impl HomeGuard {
        fn set(path: &Path) -> Self {
            let original_home = std::env::var_os("HOME");
            unsafe {
                std::env::set_var("HOME", path);
            }
            Self { original_home }
        }
    }

    impl Drop for HomeGuard {
        fn drop(&mut self) {
            match &self.original_home {
                Some(home) => unsafe {
                    std::env::set_var("HOME", home);
                },
                None => unsafe {
                    std::env::remove_var("HOME");
                },
            }
        }
    }

    struct EnvVarGuard {
        key: &'static str,
        original: Option<String>,
    }

    impl EnvVarGuard {
        fn unset(key: &'static str) -> Self {
            let original = std::env::var(key).ok();
            unsafe {
                std::env::remove_var(key);
            }
            Self { key, original }
        }
    }

    impl Drop for EnvVarGuard {
        fn drop(&mut self) {
            match self.original.as_deref() {
                Some(value) => unsafe {
                    std::env::set_var(self.key, value);
                },
                None => unsafe {
                    std::env::remove_var(self.key);
                },
            }
        }
    }

    #[test]
    fn team_config_dir_is_under_batty() {
        let root = Path::new("/tmp/project");
        assert_eq!(
            team_config_dir(root),
            PathBuf::from("/tmp/project/.batty/team_config")
        );
    }

    #[test]
    fn team_config_path_points_to_yaml() {
        let root = Path::new("/tmp/project");
        assert_eq!(
            team_config_path(root),
            PathBuf::from("/tmp/project/.batty/team_config/team.yaml")
        );
    }

    #[test]
    fn init_team_creates_scaffolding() {
        let tmp = tempfile::tempdir().unwrap();
        let created = init_team(tmp.path(), "simple").unwrap();
        assert!(!created.is_empty());
        assert!(team_config_path(tmp.path()).exists());
        assert!(team_config_dir(tmp.path()).join("architect.md").exists());
        assert!(team_config_dir(tmp.path()).join("manager.md").exists());
        assert!(team_config_dir(tmp.path()).join("engineer.md").exists());
        assert!(
            team_config_dir(tmp.path())
                .join("replenishment_context.md")
                .exists()
        );
        assert!(
            team_config_dir(tmp.path())
                .join("review_policy.md")
                .exists()
        );
        assert!(
            team_config_dir(tmp.path())
                .join("escalation_policy.md")
                .exists()
        );
        // kanban-md creates board/ directory; fallback creates kanban.md
        let config = team_config_dir(tmp.path());
        assert!(config.join("board").is_dir() || config.join("kanban.md").exists());
    }

    #[test]
    fn init_team_refuses_if_exists() {
        let tmp = tempfile::tempdir().unwrap();
        init_team(tmp.path(), "simple").unwrap();
        let result = init_team(tmp.path(), "simple");
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("already exists"));
    }

    #[test]
    #[serial]
    fn init_from_template_copies_files() {
        let project = tempfile::tempdir().unwrap();
        let home = tempfile::tempdir().unwrap();
        let _home_guard = HomeGuard::set(home.path());

        let template_dir = home.path().join(".batty").join("templates").join("custom");
        std::fs::create_dir_all(template_dir.join("board")).unwrap();
        std::fs::write(template_dir.join("team.yaml"), "name: custom\nroles: []\n").unwrap();
        std::fs::write(template_dir.join("architect.md"), "# Architect\n").unwrap();
        std::fs::write(template_dir.join("board").join("task.md"), "task\n").unwrap();

        let created = init_from_template(project.path(), "custom").unwrap();

        assert!(!created.is_empty());
        assert_eq!(
            std::fs::read_to_string(team_config_path(project.path())).unwrap(),
            "name: custom\nroles: []\n"
        );
        assert!(
            team_config_dir(project.path())
                .join("architect.md")
                .exists()
        );
        assert!(
            team_config_dir(project.path())
                .join("board")
                .join("task.md")
                .exists()
        );
    }

    #[test]
    #[serial]
    fn init_from_template_missing_template_errors_with_available_list() {
        let project = tempfile::tempdir().unwrap();
        let home = tempfile::tempdir().unwrap();
        let _home_guard = HomeGuard::set(home.path());

        let templates_root = home.path().join(".batty").join("templates");
        std::fs::create_dir_all(templates_root.join("alpha")).unwrap();
        std::fs::create_dir_all(templates_root.join("beta")).unwrap();

        let error = init_from_template(project.path(), "missing").unwrap_err();
        let message = error.to_string();
        assert!(message.contains("template 'missing' not found"));
        assert!(message.contains("alpha"));
        assert!(message.contains("beta"));
    }

    #[test]
    #[serial]
    fn init_from_template_errors_when_templates_dir_is_missing() {
        let project = tempfile::tempdir().unwrap();
        let home = tempfile::tempdir().unwrap();
        let _home_guard = HomeGuard::set(home.path());

        let error = init_from_template(project.path(), "missing").unwrap_err();
        assert!(error.to_string().contains("no templates directory found"));
    }

    #[test]
    fn init_team_large_template() {
        let tmp = tempfile::tempdir().unwrap();
        let created = init_team(tmp.path(), "large").unwrap();
        assert!(!created.is_empty());
        let content = std::fs::read_to_string(team_config_path(tmp.path())).unwrap();
        assert!(content.contains("instances: 3") || content.contains("instances: 5"));
    }

    #[test]
    fn init_team_solo_template() {
        let tmp = tempfile::tempdir().unwrap();
        let created = init_team(tmp.path(), "solo").unwrap();
        assert!(!created.is_empty());
        let content = std::fs::read_to_string(team_config_path(tmp.path())).unwrap();
        assert!(content.contains("role_type: engineer"));
        assert!(!content.contains("role_type: manager"));
    }

    #[test]
    fn init_team_pair_template() {
        let tmp = tempfile::tempdir().unwrap();
        let created = init_team(tmp.path(), "pair").unwrap();
        assert!(!created.is_empty());
        let content = std::fs::read_to_string(team_config_path(tmp.path())).unwrap();
        assert!(content.contains("role_type: architect"));
        assert!(content.contains("role_type: engineer"));
        assert!(!content.contains("role_type: manager"));
    }

    #[test]
    fn init_team_squad_template() {
        let tmp = tempfile::tempdir().unwrap();
        let created = init_team(tmp.path(), "squad").unwrap();
        assert!(!created.is_empty());
        let content = std::fs::read_to_string(team_config_path(tmp.path())).unwrap();
        assert!(content.contains("instances: 5"));
        assert!(content.contains("layout:"));
    }

    #[test]
    fn init_team_research_template() {
        let tmp = tempfile::tempdir().unwrap();
        let created = init_team(tmp.path(), "research").unwrap();
        assert!(!created.is_empty());
        let content = std::fs::read_to_string(team_config_path(tmp.path())).unwrap();
        assert!(content.contains("principal"));
        assert!(content.contains("sub-lead"));
        assert!(content.contains("researcher"));
        // Research-specific .md files installed
        assert!(
            team_config_dir(tmp.path())
                .join("research_lead.md")
                .exists()
        );
        assert!(team_config_dir(tmp.path()).join("sub_lead.md").exists());
        assert!(team_config_dir(tmp.path()).join("researcher.md").exists());
        // Generic files NOT installed
        assert!(!team_config_dir(tmp.path()).join("architect.md").exists());
    }

    #[test]
    fn init_team_software_template() {
        let tmp = tempfile::tempdir().unwrap();
        let created = init_team(tmp.path(), "software").unwrap();
        assert!(!created.is_empty());
        let content = std::fs::read_to_string(team_config_path(tmp.path())).unwrap();
        assert!(content.contains("tech-lead"));
        assert!(content.contains("backend-mgr"));
        assert!(content.contains("frontend-mgr"));
        assert!(content.contains("developer"));
        // Software-specific .md files installed
        assert!(team_config_dir(tmp.path()).join("tech_lead.md").exists());
        assert!(team_config_dir(tmp.path()).join("eng_manager.md").exists());
        assert!(team_config_dir(tmp.path()).join("developer.md").exists());
    }

    #[test]
    fn init_team_batty_template() {
        let tmp = tempfile::tempdir().unwrap();
        let created = init_team(tmp.path(), "batty").unwrap();
        assert!(!created.is_empty());
        let content = std::fs::read_to_string(team_config_path(tmp.path())).unwrap();
        assert!(content.contains("batty-dev"));
        assert!(content.contains("role_type: architect"));
        assert!(content.contains("role_type: manager"));
        assert!(content.contains("instances: 4"));
        assert!(content.contains("batty_architect.md"));
        // Batty-specific .md files installed
        assert!(
            team_config_dir(tmp.path())
                .join("batty_architect.md")
                .exists()
        );
        assert!(
            team_config_dir(tmp.path())
                .join("batty_manager.md")
                .exists()
        );
        assert!(
            team_config_dir(tmp.path())
                .join("batty_engineer.md")
                .exists()
        );
        assert!(
            team_config_dir(tmp.path())
                .join("review_policy.md")
                .exists()
        );
    }

    #[test]
    #[serial]
    fn export_template_creates_directory_and_copies_files() {
        let tmp = tempfile::tempdir().unwrap();
        let _home = HomeGuard::set(tmp.path());
        let project_root = tmp.path().join("project");
        let config_dir = team_config_dir(&project_root);
        std::fs::create_dir_all(&config_dir).unwrap();
        std::fs::write(config_dir.join("team.yaml"), "name: demo\n").unwrap();
        std::fs::write(config_dir.join("architect.md"), "architect prompt\n").unwrap();

        let copied = export_template(&project_root, "demo-template").unwrap();
        let template_dir = templates_base_dir().unwrap().join("demo-template");

        assert_eq!(copied, 2);
        assert_eq!(
            std::fs::read_to_string(template_dir.join("team.yaml")).unwrap(),
            "name: demo\n"
        );
        assert_eq!(
            std::fs::read_to_string(template_dir.join("architect.md")).unwrap(),
            "architect prompt\n"
        );
    }

    #[test]
    #[serial]
    fn export_template_overwrites_existing() {
        let tmp = tempfile::tempdir().unwrap();
        let _home = HomeGuard::set(tmp.path());
        let project_root = tmp.path().join("project");
        let config_dir = team_config_dir(&project_root);
        std::fs::create_dir_all(&config_dir).unwrap();
        std::fs::write(config_dir.join("team.yaml"), "name: first\n").unwrap();
        std::fs::write(config_dir.join("manager.md"), "v1\n").unwrap();

        export_template(&project_root, "demo-template").unwrap();

        std::fs::write(config_dir.join("team.yaml"), "name: second\n").unwrap();
        std::fs::write(config_dir.join("manager.md"), "v2\n").unwrap();

        let copied = export_template(&project_root, "demo-template").unwrap();
        let template_dir = templates_base_dir().unwrap().join("demo-template");

        assert_eq!(copied, 2);
        assert_eq!(
            std::fs::read_to_string(template_dir.join("team.yaml")).unwrap(),
            "name: second\n"
        );
        assert_eq!(
            std::fs::read_to_string(template_dir.join("manager.md")).unwrap(),
            "v2\n"
        );
    }

    #[test]
    #[serial]
    fn export_template_missing_team_yaml_errors() {
        let tmp = tempfile::tempdir().unwrap();
        let _home = HomeGuard::set(tmp.path());
        let project_root = tmp.path().join("project");
        std::fs::create_dir_all(team_config_dir(&project_root)).unwrap();

        let error = export_template(&project_root, "demo-template").unwrap_err();

        assert!(error.to_string().contains("team config missing"));
    }

    #[test]
    fn export_run_copies_requested_run_state_only() {
        let tmp = tempfile::tempdir().unwrap();
        let project_root = tmp.path().join("project");
        let config_dir = team_config_dir(&project_root);
        let tasks_dir = config_dir.join("board").join("tasks");
        let retrospectives_dir = project_root.join(".batty").join("retrospectives");
        let worktree_dir = project_root
            .join(".batty")
            .join("worktrees")
            .join("eng-1-1")
            .join(".codex")
            .join("sessions");
        std::fs::create_dir_all(&tasks_dir).unwrap();
        std::fs::create_dir_all(&retrospectives_dir).unwrap();
        std::fs::create_dir_all(&worktree_dir).unwrap();

        std::fs::write(config_dir.join("team.yaml"), "name: demo\n").unwrap();
        std::fs::write(tasks_dir.join("001-task.md"), "---\nid: 1\n---\n").unwrap();
        std::fs::write(
            team_events_path(&project_root),
            "{\"event\":\"daemon_started\"}\n",
        )
        .unwrap();
        std::fs::write(daemon_log_path(&project_root), "daemon-log\n").unwrap();
        std::fs::write(orchestrator_log_path(&project_root), "orchestrator-log\n").unwrap();
        std::fs::write(retrospectives_dir.join("retro.md"), "# Retro\n").unwrap();
        std::fs::write(
            project_root.join(".batty").join("test_timing.jsonl"),
            "{\"task_id\":1}\n",
        )
        .unwrap();
        std::fs::write(worktree_dir.join("session.jsonl"), "secret\n").unwrap();

        let export_dir = export_run(&project_root).unwrap();

        assert_eq!(
            std::fs::read_to_string(export_dir.join("team.yaml")).unwrap(),
            "name: demo\n"
        );
        assert_eq!(
            std::fs::read_to_string(export_dir.join("board").join("tasks").join("001-task.md"))
                .unwrap(),
            "---\nid: 1\n---\n"
        );
        assert_eq!(
            std::fs::read_to_string(export_dir.join("events.jsonl")).unwrap(),
            "{\"event\":\"daemon_started\"}\n"
        );
        assert_eq!(
            std::fs::read_to_string(export_dir.join("daemon.log")).unwrap(),
            "daemon-log\n"
        );
        assert_eq!(
            std::fs::read_to_string(export_dir.join("orchestrator.log")).unwrap(),
            "orchestrator-log\n"
        );
        assert_eq!(
            std::fs::read_to_string(export_dir.join("retrospectives").join("retro.md")).unwrap(),
            "# Retro\n"
        );
        assert_eq!(
            std::fs::read_to_string(export_dir.join("test_timing.jsonl")).unwrap(),
            "{\"task_id\":1}\n"
        );
        assert!(!export_dir.join("worktrees").exists());
        assert!(!export_dir.join(".codex").exists());
        assert!(!export_dir.join("sessions").exists());
    }

    #[test]
    fn export_run_skips_missing_optional_paths() {
        let tmp = tempfile::tempdir().unwrap();
        let project_root = tmp.path().join("project");
        let config_dir = team_config_dir(&project_root);
        std::fs::create_dir_all(&config_dir).unwrap();
        std::fs::write(config_dir.join("team.yaml"), "name: demo\n").unwrap();

        let export_dir = export_run(&project_root).unwrap();

        assert!(export_dir.join("team.yaml").is_file());
        assert!(!export_dir.join("board").exists());
        assert!(!export_dir.join("events.jsonl").exists());
        assert!(!export_dir.join("daemon.log").exists());
        assert!(!export_dir.join("orchestrator.log").exists());
        assert!(!export_dir.join("retrospectives").exists());
        assert!(!export_dir.join("test_timing.jsonl").exists());
    }

    #[test]
    fn export_run_missing_team_yaml_errors() {
        let tmp = tempfile::tempdir().unwrap();
        let project_root = tmp.path().join("project");
        std::fs::create_dir_all(team_config_dir(&project_root)).unwrap();

        let error = export_run(&project_root).unwrap_err();

        assert!(error.to_string().contains("team config missing"));
    }

    #[test]
    fn nudge_disable_creates_marker_and_enable_removes_it() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(tmp.path().join(".batty")).unwrap();

        let marker = nudge_disabled_marker_path(tmp.path(), "triage");
        assert!(!marker.exists());

        disable_nudge(tmp.path(), "triage").unwrap();
        assert!(marker.exists());

        // Double-disable should fail
        assert!(disable_nudge(tmp.path(), "triage").is_err());

        enable_nudge(tmp.path(), "triage").unwrap();
        assert!(!marker.exists());

        // Double-enable should fail
        assert!(enable_nudge(tmp.path(), "triage").is_err());
    }

    #[test]
    fn nudge_marker_path_uses_intervention_name() {
        let root = std::path::Path::new("/tmp/test-project");
        assert_eq!(
            nudge_disabled_marker_path(root, "replenish"),
            root.join(".batty").join("nudge_replenish_disabled")
        );
        assert_eq!(
            nudge_disabled_marker_path(root, "owned-task"),
            root.join(".batty").join("nudge_owned-task_disabled")
        );
    }

    #[test]
    fn nudge_multiple_interventions_independent() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(tmp.path().join(".batty")).unwrap();

        disable_nudge(tmp.path(), "triage").unwrap();
        disable_nudge(tmp.path(), "review").unwrap();

        assert!(nudge_disabled_marker_path(tmp.path(), "triage").exists());
        assert!(nudge_disabled_marker_path(tmp.path(), "review").exists());
        assert!(!nudge_disabled_marker_path(tmp.path(), "dispatch").exists());

        enable_nudge(tmp.path(), "triage").unwrap();
        assert!(!nudge_disabled_marker_path(tmp.path(), "triage").exists());
        assert!(nudge_disabled_marker_path(tmp.path(), "review").exists());
    }

    #[test]
    fn pause_creates_marker_and_resume_removes_it() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(tmp.path().join(".batty")).unwrap();

        assert!(!pause_marker_path(tmp.path()).exists());
        pause_team(tmp.path()).unwrap();
        assert!(pause_marker_path(tmp.path()).exists());

        // Double-pause should fail
        assert!(pause_team(tmp.path()).is_err());

        resume_team(tmp.path()).unwrap();
        assert!(!pause_marker_path(tmp.path()).exists());

        // Double-resume should fail
        assert!(resume_team(tmp.path()).is_err());
    }

    #[test]
    fn daemon_state_probe_requests_resume_after_unclean_shutdown() {
        let tmp = tempfile::tempdir().unwrap();
        let path = daemon_state_path(tmp.path());
        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
        std::fs::write(&path, r#"{"clean_shutdown":false}"#).unwrap();

        assert!(should_resume_from_daemon_state(tmp.path()));
    }

    #[test]
    fn daemon_state_probe_ignores_clean_shutdown() {
        let tmp = tempfile::tempdir().unwrap();
        let path = daemon_state_path(tmp.path());
        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
        std::fs::write(&path, r#"{"clean_shutdown":true}"#).unwrap();

        assert!(!should_resume_from_daemon_state(tmp.path()));
    }

    #[cfg(unix)]
    fn write_daemon_script(script_path: &Path, body: &str) {
        std::fs::write(script_path, body).unwrap();
        use std::os::unix::fs::PermissionsExt;
        std::fs::set_permissions(script_path, std::fs::Permissions::from_mode(0o755)).unwrap();
    }

    #[cfg(unix)]
    #[test]
    #[serial]
    fn graceful_daemon_shutdown_waits_for_clean_snapshot() {
        let tmp = tempfile::tempdir().unwrap();
        let state_path = daemon_state_path(tmp.path());
        let state_dir = state_path.parent().unwrap();
        std::fs::create_dir_all(state_dir).unwrap();
        std::fs::write(&state_path, r#"{"clean_shutdown":false,"saved_at":1}"#).unwrap();

        let state_path_for_thread = state_path.clone();
        let state_dir_for_thread = state_dir.to_path_buf();
        let writer = std::thread::spawn(move || {
            std::thread::sleep(Duration::from_millis(200));
            std::fs::create_dir_all(&state_dir_for_thread).unwrap();
            std::fs::write(
                &state_path_for_thread,
                r#"{"clean_shutdown":true,"saved_at":2}"#,
            )
            .unwrap();
        });

        assert!(wait_for_graceful_daemon_shutdown(
            tmp.path(),
            std::process::id(),
            Some(1),
            Duration::from_secs(2)
        ));

        writer.join().unwrap();
        assert!(daemon_state_indicates_clean_shutdown(tmp.path(), Some(1)));
    }

    #[cfg(unix)]
    #[test]
    #[serial]
    fn graceful_daemon_shutdown_times_out_before_force_kill_fallback() {
        let tmp = tempfile::tempdir().unwrap();
        let script_path = tmp.path().join("stubborn-daemon.sh");
        write_daemon_script(
            &script_path,
            "#!/bin/sh\ntrap '' TERM\nwhile :; do :; done\n",
        );

        let mut child = std::process::Command::new(&script_path).spawn().unwrap();
        std::fs::create_dir_all(tmp.path().join(".batty")).unwrap();
        std::fs::write(daemon_pid_path(tmp.path()), child.id().to_string()).unwrap();
        std::thread::sleep(Duration::from_millis(200));

        assert!(!request_graceful_daemon_shutdown(
            tmp.path(),
            Duration::from_millis(300)
        ));
        assert!(daemon_process_exists(child.id()));

        force_kill_daemon(tmp.path());
        let _ = child.wait().unwrap();
        assert!(!daemon_pid_path(tmp.path()).exists());
    }

    #[test]
    fn test_rotate_log_shifts_files() {
        let tmp = tempfile::tempdir().unwrap();
        let log_path = daemon_log_path(tmp.path());
        std::fs::create_dir_all(log_path.parent().unwrap()).unwrap();
        std::fs::write(&log_path, b"current").unwrap();
        std::fs::write(rotated_log_path(&log_path, 1), b"older-1").unwrap();
        std::fs::write(rotated_log_path(&log_path, 2), b"older-2").unwrap();
        std::fs::OpenOptions::new()
            .write(true)
            .open(&log_path)
            .unwrap()
            .set_len(LOG_ROTATION_BYTES + 1)
            .unwrap();

        rotate_log_if_needed(&log_path).unwrap();

        assert!(!log_path.exists());
        assert_eq!(
            std::fs::read(rotated_log_path(&log_path, 1)).unwrap().len() as u64,
            LOG_ROTATION_BYTES + 1
        );
        assert_eq!(
            std::fs::read_to_string(rotated_log_path(&log_path, 2)).unwrap(),
            "older-1"
        );
        assert_eq!(
            std::fs::read_to_string(rotated_log_path(&log_path, 3)).unwrap(),
            "older-2"
        );
    }

    #[test]
    fn test_rotate_log_keeps_max_3() {
        let tmp = tempfile::tempdir().unwrap();
        let log_path = orchestrator_log_path(tmp.path());
        std::fs::create_dir_all(log_path.parent().unwrap()).unwrap();
        std::fs::write(&log_path, b"current").unwrap();
        std::fs::write(rotated_log_path(&log_path, 1), b"older-1").unwrap();
        std::fs::write(rotated_log_path(&log_path, 2), b"older-2").unwrap();
        std::fs::write(rotated_log_path(&log_path, 3), b"older-3").unwrap();
        std::fs::OpenOptions::new()
            .write(true)
            .open(&log_path)
            .unwrap()
            .set_len(LOG_ROTATION_BYTES + 1)
            .unwrap();

        rotate_log_if_needed(&log_path).unwrap();

        assert_eq!(
            std::fs::read(rotated_log_path(&log_path, 1)).unwrap().len() as u64,
            LOG_ROTATION_BYTES + 1
        );
        assert_eq!(
            std::fs::read_to_string(rotated_log_path(&log_path, 2)).unwrap(),
            "older-1"
        );
        assert_eq!(
            std::fs::read_to_string(rotated_log_path(&log_path, 3)).unwrap(),
            "older-2"
        );
        assert!(!rotated_log_path(&log_path, 4).exists());
    }

    #[test]
    fn test_rotate_log_noop_under_threshold() {
        let tmp = tempfile::tempdir().unwrap();
        let log_path = daemon_log_path(tmp.path());
        std::fs::create_dir_all(log_path.parent().unwrap()).unwrap();
        std::fs::write(&log_path, b"small-log").unwrap();

        rotate_log_if_needed(&log_path).unwrap();

        assert_eq!(std::fs::read_to_string(&log_path).unwrap(), "small-log");
        assert!(!rotated_log_path(&log_path, 1).exists());
    }

    #[test]
    fn test_daemon_log_append_mode() {
        let tmp = tempfile::tempdir().unwrap();
        let log_path = daemon_log_path(tmp.path());

        {
            let mut file = open_log_for_append(&log_path).unwrap();
            use std::io::Write;
            writeln!(file, "first").unwrap();
        }

        {
            let mut file = open_log_for_append(&log_path).unwrap();
            use std::io::Write;
            writeln!(file, "second").unwrap();
        }

        assert_eq!(
            std::fs::read_to_string(&log_path).unwrap(),
            "first\nsecond\n"
        );
    }

    #[test]
    fn daemon_spawn_args_include_verbose_and_resume() {
        assert_eq!(
            daemon_spawn_args("/tmp/project", false),
            vec![
                "-v".to_string(),
                "daemon".to_string(),
                "--project-root".to_string(),
                "/tmp/project".to_string()
            ]
        );
        assert_eq!(
            daemon_spawn_args("/tmp/project", true),
            vec![
                "-v".to_string(),
                "daemon".to_string(),
                "--project-root".to_string(),
                "/tmp/project".to_string(),
                "--resume".to_string()
            ]
        );
    }

    #[test]
    fn send_message_delivers_to_inbox() {
        let tmp = tempfile::tempdir().unwrap();
        send_message(tmp.path(), "architect", "hello").unwrap();

        let root = inbox::inboxes_root(tmp.path());
        let pending = inbox::pending_messages(&root, "architect").unwrap();
        assert_eq!(pending.len(), 1);
        // detect_sender() returns the tmux pane role if running inside a batty
        // session, or "human" otherwise. Accept either.
        let expected_from = detect_sender().unwrap_or_else(|| "human".to_string());
        assert_eq!(pending[0].from, expected_from);
        assert_eq!(pending[0].to, "architect");
        assert_eq!(pending[0].body, "hello");
    }

    #[test]
    fn send_message_ingests_completion_packet_into_workflow_metadata() {
        let tmp = tempfile::tempdir().unwrap();
        let tasks_dir = team_config_dir(tmp.path()).join("board").join("tasks");
        std::fs::create_dir_all(&tasks_dir).unwrap();
        let task_path = tasks_dir.join("027-completion-packets.md");
        std::fs::write(
            &task_path,
            "---\nid: 27\ntitle: Completion packets\nstatus: review\npriority: medium\nclaimed_by: human\nclass: standard\n---\n\nTask body.\n",
        )
        .unwrap();

        send_message(
            tmp.path(),
            "architect",
            r#"Done.

## Completion Packet

```json
{"task_id":27,"branch":"eng-1-4/task-27","worktree_path":".batty/worktrees/eng-1-4","commit":"abc1234","changed_paths":["src/team/completion.rs"],"tests_run":true,"tests_passed":true,"artifacts":["docs/workflow.md"],"outcome":"ready_for_review"}
```"#,
        )
        .unwrap();

        let metadata = board::read_workflow_metadata(&task_path).unwrap();
        assert_eq!(metadata.branch.as_deref(), Some("eng-1-4/task-27"));
        assert_eq!(
            metadata.worktree_path.as_deref(),
            Some(".batty/worktrees/eng-1-4")
        );
        assert_eq!(metadata.commit.as_deref(), Some("abc1234"));
        assert_eq!(metadata.tests_run, Some(true));
        assert_eq!(metadata.tests_passed, Some(true));
        assert_eq!(metadata.outcome.as_deref(), Some("ready_for_review"));
        assert!(metadata.review_blockers.is_empty());
    }

    #[test]
    fn assign_task_delivers_to_inbox() {
        let tmp = tempfile::tempdir().unwrap();
        let id = assign_task(tmp.path(), "eng-1-1", "fix bug").unwrap();
        assert!(!id.is_empty());

        let root = inbox::inboxes_root(tmp.path());
        let pending = inbox::pending_messages(&root, "eng-1-1").unwrap();
        assert_eq!(pending.len(), 1);
        let expected_from = detect_sender().unwrap_or_else(|| "human".to_string());
        assert_eq!(pending[0].from, expected_from);
        assert_eq!(pending[0].to, "eng-1-1");
        assert_eq!(pending[0].body, "fix bug");
        assert_eq!(pending[0].msg_type, inbox::MessageType::Assign);
    }

    fn write_team_config(project_root: &Path, yaml: &str) {
        std::fs::create_dir_all(team_config_dir(project_root)).unwrap();
        std::fs::write(team_config_path(project_root), yaml).unwrap();
    }

    #[test]
    fn workflow_mode_declared_detects_absent_field() {
        let tmp = tempfile::tempdir().unwrap();
        write_team_config(
            tmp.path(),
            r#"
name: test
roles:
  - name: engineer
    role_type: engineer
    agent: codex
"#,
        );

        assert!(!workflow_mode_declared(&team_config_path(tmp.path())).unwrap());
    }

    #[test]
    fn workflow_mode_declared_detects_present_field() {
        let tmp = tempfile::tempdir().unwrap();
        write_team_config(
            tmp.path(),
            r#"
name: test
workflow_mode: hybrid
roles:
  - name: engineer
    role_type: engineer
    agent: codex
"#,
        );

        assert!(workflow_mode_declared(&team_config_path(tmp.path())).unwrap());
    }

    #[test]
    fn migration_validation_notes_explain_legacy_default_for_older_configs() {
        let config =
            config::TeamConfig::load(Path::new("src/team/templates/team_pair.yaml")).unwrap();
        let notes = migration_validation_notes(&config, false);

        assert_eq!(notes.len(), 1);
        assert!(notes[0].contains("workflow_mode omitted"));
        assert!(notes[0].contains("run unchanged"));
    }

    #[test]
    fn migration_validation_notes_warn_about_workflow_first_partial_rollout() {
        let config: config::TeamConfig = serde_yaml::from_str(
            r#"
name: test
workflow_mode: workflow_first
roles:
  - name: engineer
    role_type: engineer
    agent: codex
"#,
        )
        .unwrap();
        let notes = migration_validation_notes(&config, true);

        assert_eq!(notes.len(), 1);
        assert!(notes[0].contains("workflow_first mode selected"));
        assert!(notes[0].contains("primary truth"));
    }

    #[test]
    fn resolve_member_name_maps_unique_role_alias_to_instance() {
        let tmp = tempfile::tempdir().unwrap();
        write_team_config(
            tmp.path(),
            r#"
name: test
roles:
  - name: human
    role_type: user
    talks_to:
      - sam-designer
  - name: jordan-pm
    role_type: manager
    agent: claude
    instances: 1
  - name: sam-designer
    role_type: engineer
    agent: codex
    instances: 1
    talks_to:
      - jordan-pm
"#,
        );

        assert_eq!(
            resolve_member_name(tmp.path(), "sam-designer").unwrap(),
            "sam-designer-1-1"
        );
        assert_eq!(
            resolve_member_name(tmp.path(), "sam-designer-1-1").unwrap(),
            "sam-designer-1-1"
        );
    }

    #[test]
    fn resolve_member_name_rejects_ambiguous_role_alias() {
        let tmp = tempfile::tempdir().unwrap();
        write_team_config(
            tmp.path(),
            r#"
name: test
roles:
  - name: jordan-pm
    role_type: manager
    agent: claude
    instances: 2
  - name: sam-designer
    role_type: engineer
    agent: codex
    instances: 1
    talks_to:
      - jordan-pm
"#,
        );

        let error = resolve_member_name(tmp.path(), "sam-designer")
            .unwrap_err()
            .to_string();
        assert!(error.contains("matches multiple members"));
        assert!(error.contains("sam-designer-1-1"));
        assert!(error.contains("sam-designer-2-1"));
    }

    #[test]
    #[serial]
    fn send_message_delivers_to_unique_instance_inbox() {
        let tmp = tempfile::tempdir().unwrap();
        let _tmux_pane = EnvVarGuard::unset("TMUX_PANE");
        write_team_config(
            tmp.path(),
            r#"
name: test
roles:
  - name: human
    role_type: user
    talks_to:
      - sam-designer
  - name: jordan-pm
    role_type: manager
    agent: claude
    instances: 1
  - name: sam-designer
    role_type: engineer
    agent: codex
    instances: 1
    talks_to:
      - jordan-pm
"#,
        );

        let original_tmux_pane = std::env::var_os("TMUX_PANE");
        unsafe {
            std::env::remove_var("TMUX_PANE");
        }
        let send_result = send_message(tmp.path(), "sam-designer", "hello");
        match original_tmux_pane {
            Some(value) => unsafe {
                std::env::set_var("TMUX_PANE", value);
            },
            None => unsafe {
                std::env::remove_var("TMUX_PANE");
            },
        }
        send_result.unwrap();

        let root = inbox::inboxes_root(tmp.path());
        assert!(
            inbox::pending_messages(&root, "sam-designer")
                .unwrap()
                .is_empty()
        );

        let pending = inbox::pending_messages(&root, "sam-designer-1-1").unwrap();
        assert_eq!(pending.len(), 1);
        assert_eq!(pending[0].to, "sam-designer-1-1");
        assert_eq!(pending[0].body, "hello");
    }

    #[test]
    fn truncate_chars_handles_unicode_boundaries() {
        let body = "Task #109 confirmed complete on main. I’m available for next assignment.";
        let truncated = truncate_chars(body, 40);
        assert!(truncated.ends_with("..."));
        assert!(truncated.starts_with("Task #109 confirmed complete on main."));
    }

    #[test]
    fn format_inbox_listing_shows_most_recent_messages_by_default_limit() {
        let messages: Vec<_> = (0..25)
            .map(|idx| {
                (
                    inbox::InboxMessage {
                        id: format!("msg{idx:05}"),
                        from: "architect".to_string(),
                        to: "black-lead".to_string(),
                        body: format!("message {idx}"),
                        msg_type: inbox::MessageType::Send,
                        timestamp: idx,
                    },
                    true,
                )
            })
            .collect();

        let rendered = format_inbox_listing("black-lead", &messages, Some(20));
        assert!(rendered.contains("Showing 20 of 25 messages for black-lead."));
        assert!(!rendered.contains("message 0"));
        assert!(rendered.contains("message 5"));
        assert!(rendered.contains("message 24"));
        assert!(!rendered.contains("msg00005"));
        assert!(!rendered.contains("msg00024"));
    }

    #[test]
    fn format_inbox_listing_allows_showing_all_messages() {
        let messages: Vec<_> = (0..3)
            .map(|idx| {
                (
                    inbox::InboxMessage {
                        id: format!("msg{idx:05}"),
                        from: "architect".to_string(),
                        to: "black-lead".to_string(),
                        body: format!("message {idx}"),
                        msg_type: inbox::MessageType::Send,
                        timestamp: idx,
                    },
                    idx % 2 == 0,
                )
            })
            .collect();

        let rendered = format_inbox_listing("black-lead", &messages, None);
        assert!(!rendered.contains("Showing 20"));
        assert!(rendered.contains("REF"));
        assert!(rendered.contains("BODY"));
        assert!(rendered.contains("message 0"));
        assert!(rendered.contains("message 1"));
        assert!(rendered.contains("message 2"));
        assert!(!rendered.contains("msg00000"));
        assert!(!rendered.contains("msg00001"));
        assert!(!rendered.contains("msg00002"));
    }

    #[test]
    fn format_inbox_listing_hides_internal_message_ids() {
        let messages = vec![(
            inbox::InboxMessage {
                id: "1773930387654321.M123456P7890Q42.example".to_string(),
                from: "architect".to_string(),
                to: "black-lead".to_string(),
                body: "message body".to_string(),
                msg_type: inbox::MessageType::Send,
                timestamp: 1_773_930_725,
            },
            true,
        )];

        let rendered = format_inbox_listing("black-lead", &messages, None);
        assert!(rendered.contains("1773930725"));
        assert!(!rendered.contains("1773930387654321.M123456P7890Q42.example"));
        assert!(!rendered.contains("ID BODY"));
    }

    #[test]
    fn inbox_message_refs_use_timestamp_when_unique() {
        let messages = vec![(
            inbox::InboxMessage {
                id: "msg-1".to_string(),
                from: "architect".to_string(),
                to: "black-lead".to_string(),
                body: "message body".to_string(),
                msg_type: inbox::MessageType::Send,
                timestamp: 1_773_930_725,
            },
            true,
        )];

        let refs = inbox_message_refs(&messages);
        assert_eq!(refs, vec!["1773930725".to_string()]);
        assert_eq!(
            resolve_inbox_message_indices(&messages, "1773930725"),
            vec![0]
        );
    }

    #[test]
    fn inbox_message_refs_suffix_same_second_collisions() {
        let messages = vec![
            (
                inbox::InboxMessage {
                    id: "msg-1".to_string(),
                    from: "architect".to_string(),
                    to: "black-lead".to_string(),
                    body: "first".to_string(),
                    msg_type: inbox::MessageType::Send,
                    timestamp: 1_773_930_725,
                },
                true,
            ),
            (
                inbox::InboxMessage {
                    id: "msg-2".to_string(),
                    from: "architect".to_string(),
                    to: "black-lead".to_string(),
                    body: "second".to_string(),
                    msg_type: inbox::MessageType::Send,
                    timestamp: 1_773_930_725,
                },
                true,
            ),
        ];

        let refs = inbox_message_refs(&messages);
        assert_eq!(
            refs,
            vec!["1773930725-1".to_string(), "1773930725-2".to_string()]
        );
        assert!(resolve_inbox_message_indices(&messages, "1773930725").is_empty());
        assert_eq!(
            resolve_inbox_message_indices(&messages, "1773930725-1"),
            vec![0]
        );
        assert_eq!(
            resolve_inbox_message_indices(&messages, "1773930725-2"),
            vec![1]
        );
    }

    #[test]
    fn assignment_result_round_trip_and_format() {
        let tmp = tempfile::tempdir().unwrap();
        let result = AssignmentDeliveryResult {
            message_id: "msg-1".to_string(),
            status: AssignmentResultStatus::Delivered,
            engineer: "eng-1-1".to_string(),
            task_summary: "Say Hello".to_string(),
            branch: Some("eng-1-1/task-1".to_string()),
            work_dir: Some("/tmp/worktree".to_string()),
            detail: "assignment launched".to_string(),
            ts: now_unix(),
        };

        store_assignment_result(tmp.path(), &result).unwrap();
        let loaded = load_assignment_result(tmp.path(), "msg-1")
            .unwrap()
            .unwrap();
        assert_eq!(loaded, result);

        let formatted = format_assignment_result(&loaded);
        assert!(formatted.contains("Assignment delivered: msg-1 -> eng-1-1"));
        assert!(formatted.contains("Branch: eng-1-1/task-1"));
        assert!(formatted.contains("Worktree: /tmp/worktree"));
    }

    #[test]
    fn wait_for_assignment_result_returns_none_when_missing() {
        let tmp = tempfile::tempdir().unwrap();
        let result =
            wait_for_assignment_result(tmp.path(), "missing", Duration::from_millis(10)).unwrap();
        assert!(result.is_none());
    }

    fn make_member(name: &str, role_name: &str, role_type: RoleType) -> hierarchy::MemberInstance {
        hierarchy::MemberInstance {
            name: name.to_string(),
            role_name: role_name.to_string(),
            role_type,
            agent: Some("codex".to_string()),
            prompt: None,
            reports_to: None,
            use_worktrees: false,
        }
    }

    #[test]
    fn strip_tmux_style_removes_formatting_sequences() {
        let raw = "#[fg=yellow]idle#[default] #[fg=magenta]nudge 1:05#[default]";
        assert_eq!(status::strip_tmux_style(raw), "idle nudge 1:05");
    }

    #[test]
    fn summarize_runtime_member_status_extracts_state_and_signal() {
        let summary = status::summarize_runtime_member_status(
            "#[fg=cyan]working#[default] #[fg=blue]standup 4:12#[default]",
            false,
        );

        assert_eq!(summary.state, "working");
        assert_eq!(summary.signal.as_deref(), Some("standup"));
        assert_eq!(summary.label.as_deref(), Some("working standup 4:12"));
    }

    #[test]
    fn summarize_runtime_member_status_marks_nudge_and_standup_together() {
        let summary = status::summarize_runtime_member_status(
            "#[fg=yellow]idle#[default] #[fg=magenta]nudge now#[default] #[fg=blue]standup 0:10#[default]",
            false,
        );

        assert_eq!(summary.state, "idle");
        assert_eq!(
            summary.signal.as_deref(),
            Some("waiting for nudge, standup")
        );
    }

    #[test]
    fn summarize_runtime_member_status_distinguishes_sent_nudge() {
        let summary = status::summarize_runtime_member_status(
            "#[fg=yellow]idle#[default] #[fg=magenta]nudge sent#[default]",
            false,
        );

        assert_eq!(summary.state, "idle");
        assert_eq!(summary.signal.as_deref(), Some("nudged"));
        assert_eq!(summary.label.as_deref(), Some("idle nudge sent"));
    }

    #[test]
    fn summarize_runtime_member_status_tracks_paused_automation() {
        let summary = status::summarize_runtime_member_status(
            "#[fg=cyan]working#[default] #[fg=244]nudge paused#[default] #[fg=244]standup paused#[default]",
            false,
        );

        assert_eq!(summary.state, "working");
        assert_eq!(
            summary.signal.as_deref(),
            Some("nudge paused, standup paused")
        );
        assert_eq!(
            summary.label.as_deref(),
            Some("working nudge paused standup paused")
        );
    }

    #[test]
    fn build_team_status_rows_defaults_by_session_state() {
        let architect = make_member("architect", "architect", RoleType::Architect);
        let human = hierarchy::MemberInstance {
            name: "human".to_string(),
            role_name: "human".to_string(),
            role_type: RoleType::User,
            agent: None,
            prompt: None,
            reports_to: None,
            use_worktrees: false,
        };

        let pending = std::collections::HashMap::from([
            (architect.name.clone(), 3usize),
            (human.name.clone(), 1usize),
        ]);
        let triage = std::collections::HashMap::from([(architect.name.clone(), 2usize)]);
        let owned = std::collections::HashMap::from([(
            architect.name.clone(),
            status::OwnedTaskBuckets {
                active: vec![191u32],
                review: vec![193u32],
            },
        )]);
        let rows = status::build_team_status_rows(
            &[architect.clone(), human.clone()],
            false,
            &Default::default(),
            &pending,
            &triage,
            &owned,
            &Default::default(),
        );
        assert_eq!(rows[0].state, "stopped");
        assert_eq!(rows[0].pending_inbox, 3);
        assert_eq!(rows[0].triage_backlog, 2);
        assert_eq!(rows[0].active_owned_tasks, vec![191]);
        assert_eq!(rows[0].review_owned_tasks, vec![193]);
        assert_eq!(rows[0].health_summary, "-");
        assert_eq!(rows[1].state, "user");
        assert_eq!(rows[1].pending_inbox, 1);
        assert_eq!(rows[1].triage_backlog, 0);
        assert!(rows[1].active_owned_tasks.is_empty());
        assert!(rows[1].review_owned_tasks.is_empty());

        let runtime = std::collections::HashMap::from([(
            architect.name.clone(),
            status::RuntimeMemberStatus {
                state: "idle".to_string(),
                signal: Some("standup".to_string()),
                label: Some("idle standup 2:00".to_string()),
            },
        )]);
        let rows = status::build_team_status_rows(
            &[architect],
            true,
            &runtime,
            &pending,
            &triage,
            &owned,
            &Default::default(),
        );
        assert_eq!(rows[0].state, "reviewing");
        assert_eq!(rows[0].pending_inbox, 3);
        assert_eq!(rows[0].triage_backlog, 2);
        assert_eq!(rows[0].active_owned_tasks, vec![191]);
        assert_eq!(rows[0].review_owned_tasks, vec![193]);
        assert_eq!(
            rows[0].signal.as_deref(),
            Some("standup, needs triage (2), needs review (1)")
        );
        assert_eq!(rows[0].runtime_label.as_deref(), Some("idle standup 2:00"));
    }

    #[test]
    fn delivered_direct_report_triage_count_only_counts_results_newer_than_lead_response() {
        let tmp = tempfile::tempdir().unwrap();
        let root = inbox::inboxes_root(tmp.path());
        inbox::init_inbox(&root, "lead").unwrap();
        inbox::init_inbox(&root, "eng-1").unwrap();
        inbox::init_inbox(&root, "eng-2").unwrap();

        let mut old_result = inbox::InboxMessage::new_send("eng-1", "lead", "old result");
        old_result.timestamp = 10;
        let old_result_id = inbox::deliver_to_inbox(&root, &old_result).unwrap();
        inbox::mark_delivered(&root, "lead", &old_result_id).unwrap();

        let mut lead_reply = inbox::InboxMessage::new_send("lead", "eng-1", "next task");
        lead_reply.timestamp = 20;
        let lead_reply_id = inbox::deliver_to_inbox(&root, &lead_reply).unwrap();
        inbox::mark_delivered(&root, "eng-1", &lead_reply_id).unwrap();

        let mut new_result = inbox::InboxMessage::new_send("eng-1", "lead", "new result");
        new_result.timestamp = 30;
        let new_result_id = inbox::deliver_to_inbox(&root, &new_result).unwrap();
        inbox::mark_delivered(&root, "lead", &new_result_id).unwrap();

        let mut other_result = inbox::InboxMessage::new_send("eng-2", "lead", "parallel result");
        other_result.timestamp = 40;
        let other_result_id = inbox::deliver_to_inbox(&root, &other_result).unwrap();
        inbox::mark_delivered(&root, "lead", &other_result_id).unwrap();

        let triage_state = status::delivered_direct_report_triage_state_at(
            &root,
            "lead",
            &["eng-1".to_string(), "eng-2".to_string()],
            100,
        )
        .unwrap();
        assert_eq!(triage_state.count, 2);
        assert_eq!(triage_state.newest_result_ts, 40);
    }

    #[test]
    fn delivered_direct_report_triage_count_excludes_stale_delivered_results() {
        let tmp = tempfile::tempdir().unwrap();
        let root = inbox::inboxes_root(tmp.path());
        inbox::init_inbox(&root, "lead").unwrap();
        inbox::init_inbox(&root, "eng-1").unwrap();

        let mut stale_result = inbox::InboxMessage::new_send("eng-1", "lead", "stale result");
        stale_result.timestamp = 10;
        let stale_result_id = inbox::deliver_to_inbox(&root, &stale_result).unwrap();
        inbox::mark_delivered(&root, "lead", &stale_result_id).unwrap();

        let triage_state = status::delivered_direct_report_triage_state_at(
            &root,
            "lead",
            &["eng-1".to_string()],
            10 + TRIAGE_RESULT_FRESHNESS_SECONDS + 1,
        )
        .unwrap();

        assert_eq!(triage_state.count, 0);
        assert_eq!(triage_state.newest_result_ts, 0);
    }

    #[test]
    fn delivered_direct_report_triage_count_keeps_fresh_delivered_results() {
        let tmp = tempfile::tempdir().unwrap();
        let root = inbox::inboxes_root(tmp.path());
        inbox::init_inbox(&root, "lead").unwrap();
        inbox::init_inbox(&root, "eng-1").unwrap();

        let mut fresh_result = inbox::InboxMessage::new_send("eng-1", "lead", "fresh result");
        fresh_result.timestamp = 100;
        let fresh_result_id = inbox::deliver_to_inbox(&root, &fresh_result).unwrap();
        inbox::mark_delivered(&root, "lead", &fresh_result_id).unwrap();

        let triage_state = status::delivered_direct_report_triage_state_at(
            &root,
            "lead",
            &["eng-1".to_string()],
            150,
        )
        .unwrap();

        assert_eq!(triage_state.count, 1);
        assert_eq!(triage_state.newest_result_ts, 100);
    }

    #[test]
    fn delivered_direct_report_triage_count_excludes_acked_results() {
        let tmp = tempfile::tempdir().unwrap();
        let root = inbox::inboxes_root(tmp.path());
        inbox::init_inbox(&root, "lead").unwrap();
        inbox::init_inbox(&root, "eng-1").unwrap();

        let mut result = inbox::InboxMessage::new_send("eng-1", "lead", "task complete");
        result.timestamp = 100;
        let result_id = inbox::deliver_to_inbox(&root, &result).unwrap();
        inbox::mark_delivered(&root, "lead", &result_id).unwrap();

        let mut lead_reply = inbox::InboxMessage::new_send("lead", "eng-1", "acknowledged");
        lead_reply.timestamp = 110;
        let lead_reply_id = inbox::deliver_to_inbox(&root, &lead_reply).unwrap();
        inbox::mark_delivered(&root, "eng-1", &lead_reply_id).unwrap();

        let triage_state = status::delivered_direct_report_triage_state_at(
            &root,
            "lead",
            &["eng-1".to_string()],
            150,
        )
        .unwrap();

        assert_eq!(triage_state.count, 0);
        assert_eq!(triage_state.newest_result_ts, 0);
    }

    #[test]
    fn counts_as_active_load_treats_triaging_as_working() {
        let triaging = status::TeamStatusRow {
            name: "lead".to_string(),
            role: "lead".to_string(),
            role_type: "Manager".to_string(),
            agent: Some("codex".to_string()),
            reports_to: Some("architect".to_string()),
            state: "triaging".to_string(),
            pending_inbox: 0,
            triage_backlog: 2,
            active_owned_tasks: vec![191],
            review_owned_tasks: vec![193],
            signal: Some("needs triage (2)".to_string()),
            runtime_label: Some("idle".to_string()),
            health: status::AgentHealthSummary::default(),
            health_summary: "-".to_string(),
            eta: "-".to_string(),
        };
        let reviewing = status::TeamStatusRow {
            state: "reviewing".to_string(),
            triage_backlog: 0,
            signal: Some("needs review (1)".to_string()),
            runtime_label: Some("idle".to_string()),
            ..triaging.clone()
        };
        let idle = status::TeamStatusRow {
            state: "idle".to_string(),
            triage_backlog: 0,
            signal: None,
            runtime_label: Some("idle".to_string()),
            ..triaging.clone()
        };

        assert!(counts_as_active_load(&triaging));
        assert!(counts_as_active_load(&reviewing));
        assert!(!counts_as_active_load(&idle));
    }

    #[test]
    fn format_owned_tasks_summary_compacts_multiple_ids() {
        assert_eq!(status::format_owned_tasks_summary(&[]), "-");
        assert_eq!(status::format_owned_tasks_summary(&[191]), "#191");
        assert_eq!(status::format_owned_tasks_summary(&[191, 192]), "#191,#192");
        assert_eq!(
            status::format_owned_tasks_summary(&[191, 192, 193]),
            "#191,#192,+1"
        );
    }

    #[test]
    fn owned_task_buckets_split_active_and_review_claims() {
        let tmp = tempfile::tempdir().unwrap();
        let members = vec![
            make_member("lead", "lead", RoleType::Manager),
            hierarchy::MemberInstance {
                name: "eng-1".to_string(),
                role_name: "eng".to_string(),
                role_type: RoleType::Engineer,
                agent: Some("codex".to_string()),
                prompt: None,
                reports_to: Some("lead".to_string()),
                use_worktrees: false,
            },
        ];
        std::fs::create_dir_all(
            tmp.path()
                .join(".batty")
                .join("team_config")
                .join("board")
                .join("tasks"),
        )
        .unwrap();
        std::fs::write(
            tmp.path()
                .join(".batty")
                .join("team_config")
                .join("board")
                .join("tasks")
                .join("191-active.md"),
            "---\nid: 191\ntitle: Active\nstatus: in-progress\npriority: high\nclaimed_by: eng-1\nclass: standard\n---\n",
        )
        .unwrap();
        std::fs::write(
            tmp.path()
                .join(".batty")
                .join("team_config")
                .join("board")
                .join("tasks")
                .join("193-review.md"),
            "---\nid: 193\ntitle: Review\nstatus: review\npriority: high\nclaimed_by: eng-1\nclass: standard\n---\n",
        )
        .unwrap();

        let owned = status::owned_task_buckets(tmp.path(), &members);
        let buckets = owned.get("eng-1").unwrap();
        assert_eq!(buckets.active, vec![191]);
        assert!(buckets.review.is_empty());
        let review_buckets = owned.get("lead").unwrap();
        assert!(review_buckets.active.is_empty());
        assert_eq!(review_buckets.review, vec![193]);
    }

    #[test]
    fn workflow_metrics_enabled_detects_supported_modes() {
        let tmp = tempfile::tempdir().unwrap();
        let config_path = tmp.path().join("team.yaml");

        std::fs::write(
            &config_path,
            "name: test\nworkflow_mode: hybrid\nroles: []\n",
        )
        .unwrap();
        assert!(status::workflow_metrics_enabled(&config_path));

        std::fs::write(
            &config_path,
            "name: test\nworkflow_mode: workflow_first\nroles: []\n",
        )
        .unwrap();
        assert!(status::workflow_metrics_enabled(&config_path));

        std::fs::write(&config_path, "name: test\nroles: []\n").unwrap();
        assert!(!status::workflow_metrics_enabled(&config_path));
    }

    #[test]
    fn team_status_metrics_section_renders_when_workflow_mode_enabled() {
        let tmp = tempfile::tempdir().unwrap();
        let team_dir = tmp.path().join(".batty").join("team_config");
        let board_dir = team_dir.join("board");
        let tasks_dir = board_dir.join("tasks");
        std::fs::create_dir_all(&tasks_dir).unwrap();
        std::fs::write(
            team_dir.join("team.yaml"),
            "name: test\nworkflow_mode: hybrid\nroles:\n  - name: engineer\n    role_type: engineer\n    agent: codex\n",
        )
        .unwrap();
        std::fs::write(
            tasks_dir.join("031-runnable.md"),
            "---\nid: 31\ntitle: Runnable\nstatus: todo\npriority: medium\nclass: standard\n---\n\nTask body.\n",
        )
        .unwrap();

        let members = vec![make_member("eng-1-1", "engineer", RoleType::Engineer)];
        let section = status::workflow_metrics_section(tmp.path(), &members).unwrap();

        assert!(section.0.contains("Workflow Metrics"));
        assert_eq!(section.1.runnable_count, 1);
        assert_eq!(section.1.idle_with_runnable, vec!["eng-1-1"]);
    }

    #[test]
    #[serial]
    #[cfg_attr(not(feature = "integration"), ignore)]
    fn list_runtime_member_statuses_reads_tmux_role_and_status_options() {
        let session = "batty-test-team-status-runtime";
        let _ = crate::tmux::kill_session(session);

        crate::tmux::create_session(session, "sleep", &["20".to_string()], "/tmp").unwrap();
        let pane_id = crate::tmux::pane_id(session).unwrap();

        let role_output = std::process::Command::new("tmux")
            .args(["set-option", "-p", "-t", &pane_id, "@batty_role", "eng-1"])
            .output()
            .unwrap();
        assert!(role_output.status.success());

        let status_output = std::process::Command::new("tmux")
            .args([
                "set-option",
                "-p",
                "-t",
                &pane_id,
                "@batty_status",
                "#[fg=yellow]idle#[default] #[fg=magenta]nudge 0:30#[default]",
            ])
            .output()
            .unwrap();
        assert!(status_output.status.success());

        let statuses = status::list_runtime_member_statuses(session).unwrap();
        let eng = statuses.get("eng-1").unwrap();
        assert_eq!(eng.state, "idle");
        assert_eq!(eng.signal.as_deref(), Some("waiting for nudge"));
        assert_eq!(eng.label.as_deref(), Some("idle nudge 0:30"));

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

    #[test]
    fn average_load_ignores_points_older_than_window() {
        let now = 10_000u64;
        let samples = vec![
            TeamLoadSnapshot {
                timestamp: now - 3_000,
                total_members: 10,
                working_members: 0,
                load: 0.8,
                session_running: true,
            },
            TeamLoadSnapshot {
                timestamp: now - 10,
                total_members: 10,
                working_members: 0,
                load: 0.4,
                session_running: true,
            },
            TeamLoadSnapshot {
                timestamp: now - 20,
                total_members: 10,
                working_members: 0,
                load: 0.6,
                session_running: true,
            },
        ];

        let avg_60s = average_load(&samples, now, 60).unwrap();
        assert!((avg_60s - 0.5).abs() < 0.0001);
        assert!(average_load(&samples, now, 5).is_none());
    }

    #[test]
    fn render_load_graph_returns_expected_width() {
        let now = 10_000u64;
        let samples = vec![
            TeamLoadSnapshot {
                timestamp: now - 3_600,
                total_members: 10,
                working_members: 2,
                load: 0.2,
                session_running: true,
            },
            TeamLoadSnapshot {
                timestamp: now - 1_800,
                total_members: 10,
                working_members: 5,
                load: 0.5,
                session_running: true,
            },
            TeamLoadSnapshot {
                timestamp: now - 900,
                total_members: 10,
                working_members: 10,
                load: 1.0,
                session_running: true,
            },
            TeamLoadSnapshot {
                timestamp: now - 600,
                total_members: 10,
                working_members: 0,
                load: 0.0,
                session_running: true,
            },
        ];

        let graph = render_load_graph(&samples, now);
        assert_eq!(graph.len(), LOAD_GRAPH_WIDTH);
        assert!(graph.chars().all(|c| " .:=#@".contains(c)));
    }

    /// Count unwrap()/expect() calls in production code (before `#[cfg(test)] mod tests`).
    fn production_unwrap_expect_count(source: &str) -> usize {
        // Split at the test module boundary, not individual #[cfg(test)] items
        let prod = if let Some(pos) = source.find("\n#[cfg(test)]\nmod tests") {
            &source[..pos]
        } else {
            source
        };
        prod.lines()
            .filter(|line| {
                let trimmed = line.trim();
                // Skip lines that are themselves cfg(test)-gated items
                !trimmed.starts_with("#[cfg(test)]")
                    && (trimmed.contains(".unwrap(") || trimmed.contains(".expect("))
            })
            .count()
    }

    #[test]
    fn production_mod_has_no_unwrap_or_expect_calls() {
        let src = include_str!("mod.rs");
        assert_eq!(
            production_unwrap_expect_count(src),
            0,
            "production mod.rs should avoid unwrap/expect"
        );
    }

    // --- Session summary tests ---

    #[test]
    fn session_summary_counts_completions_correctly() {
        let tmp = tempfile::tempdir().unwrap();
        let events_dir = tmp.path().join(".batty").join("team_config");
        std::fs::create_dir_all(&events_dir).unwrap();

        let now = now_unix();
        let events = [
            format!(r#"{{"event":"daemon_started","ts":{}}}"#, now - 3600),
            format!(
                r#"{{"event":"task_completed","role":"eng-1","task":"10","ts":{}}}"#,
                now - 3000
            ),
            format!(
                r#"{{"event":"task_completed","role":"eng-2","task":"11","ts":{}}}"#,
                now - 2000
            ),
            format!(
                r#"{{"event":"task_auto_merged","role":"eng-1","task":"10","ts":{}}}"#,
                now - 2900
            ),
            format!(
                r#"{{"event":"task_manual_merged","role":"eng-2","task":"11","ts":{}}}"#,
                now - 1900
            ),
            format!(
                r#"{{"event":"task_completed","role":"eng-1","task":"12","ts":{}}}"#,
                now - 1000
            ),
        ];
        std::fs::write(events_dir.join("events.jsonl"), events.join("\n")).unwrap();

        let summary = compute_session_summary(tmp.path()).unwrap();
        assert_eq!(summary.tasks_completed, 3);
        assert_eq!(summary.tasks_merged, 2);
        assert!(summary.runtime_secs >= 3599 && summary.runtime_secs <= 3601);
    }

    #[test]
    fn session_summary_calculates_runtime() {
        let tmp = tempfile::tempdir().unwrap();
        let events_dir = tmp.path().join(".batty").join("team_config");
        std::fs::create_dir_all(&events_dir).unwrap();

        let now = now_unix();
        let events = [format!(
            r#"{{"event":"daemon_started","ts":{}}}"#,
            now - 7200
        )];
        std::fs::write(events_dir.join("events.jsonl"), events.join("\n")).unwrap();

        let summary = compute_session_summary(tmp.path()).unwrap();
        assert_eq!(summary.tasks_completed, 0);
        assert_eq!(summary.tasks_merged, 0);
        assert!(summary.runtime_secs >= 7199 && summary.runtime_secs <= 7201);
    }

    #[test]
    fn session_summary_handles_empty_session() {
        let tmp = tempfile::tempdir().unwrap();
        let events_dir = tmp.path().join(".batty").join("team_config");
        std::fs::create_dir_all(&events_dir).unwrap();

        // No daemon_started event — summary returns None.
        std::fs::write(events_dir.join("events.jsonl"), "").unwrap();
        assert!(compute_session_summary(tmp.path()).is_none());
    }

    #[test]
    fn session_summary_handles_missing_events_file() {
        let tmp = tempfile::tempdir().unwrap();
        // No events.jsonl at all.
        assert!(compute_session_summary(tmp.path()).is_none());
    }

    #[test]
    fn session_summary_display_format() {
        let summary = SessionSummary {
            tasks_completed: 5,
            tasks_merged: 4,
            runtime_secs: 8100, // 2h 15m
        };
        assert_eq!(
            summary.display(),
            "Session summary: 5 tasks completed, 4 merged, runtime 2h 15m"
        );
    }

    #[test]
    fn format_runtime_seconds() {
        assert_eq!(format_runtime(45), "45s");
    }

    #[test]
    fn format_runtime_minutes() {
        assert_eq!(format_runtime(300), "5m");
    }

    #[test]
    fn format_runtime_hours_and_minutes() {
        assert_eq!(format_runtime(5400), "1h 30m");
    }

    #[test]
    fn format_runtime_exact_hours() {
        assert_eq!(format_runtime(7200), "2h");
    }

    #[test]
    fn session_summary_uses_latest_daemon_started() {
        let tmp = tempfile::tempdir().unwrap();
        let events_dir = tmp.path().join(".batty").join("team_config");
        std::fs::create_dir_all(&events_dir).unwrap();

        let now = now_unix();
        // First session had 2 completions, second session has 1.
        let events = [
            format!(r#"{{"event":"daemon_started","ts":{}}}"#, now - 7200),
            format!(
                r#"{{"event":"task_completed","role":"eng-1","task":"1","ts":{}}}"#,
                now - 6000
            ),
            format!(
                r#"{{"event":"task_completed","role":"eng-1","task":"2","ts":{}}}"#,
                now - 5000
            ),
            format!(r#"{{"event":"daemon_started","ts":{}}}"#, now - 1800),
            format!(
                r#"{{"event":"task_completed","role":"eng-1","task":"3","ts":{}}}"#,
                now - 1000
            ),
        ];
        std::fs::write(events_dir.join("events.jsonl"), events.join("\n")).unwrap();

        let summary = compute_session_summary(tmp.path()).unwrap();
        // Should only count events from the latest daemon_started.
        assert_eq!(summary.tasks_completed, 1);
        assert!(summary.runtime_secs >= 1799 && summary.runtime_secs <= 1801);
    }
}