Function bodies 848 total

    fn test_debounce_resets_on_different_state() {
        let mut debounce = DetectionDebounce::new();
        let current = AgentState::Running { since: Utc::now() };

        // First tick: detected WaitingForInput
        debounce.process(
            AgentState::WaitingForInput {
                prompt_type: PromptType::InputPrompt,
                since: Utc::now(),
            },
            &current,
        );

        // Second tick: detected Idle instead — debounce resets
        let result = debounce.process(AgentState::Idle { since: Utc::now() }, &current);
        assert!(result.is_none()); // Reset, not enough ticks for Idle
    }

    fn test_debounce_terminal_state_immediate() {
        let mut debounce = DetectionDebounce::new();
        let current = AgentState::Running { since: Utc::now() };
        let completed = AgentState::Completed {
            at: Utc::now(),
            exit_code: Some(0),
        };

        // Terminal states bypass debounce
        let result = debounce.process(completed, &current);
        assert!(result.is_some());
    }

    fn test_debounce_same_as_current_no_transition() {
        let mut debounce = DetectionDebounce::new();
        let current = AgentState::Running { since: Utc::now() };

        // Detecting same state as current — no transition needed
        let result = debounce.process(AgentState::Running { since: Utc::now() }, &current);
        assert!(result.is_none());
    }

    fn test_debounce_custom_threshold() {
        let mut debounce = DetectionDebounce::with_threshold(3);
        let current = AgentState::Running { since: Utc::now() };
        let idle = AgentState::Idle { since: Utc::now() };

        assert!(debounce.process(idle.clone(), &current).is_none()); // tick 1
        assert!(debounce.process(idle.clone(), &current).is_none()); // tick 2
        assert!(debounce.process(idle, &current).is_some()); // tick 3 — transition
    }

    fn test_debounce_default_impl() {
        let debounce = DetectionDebounce::default();
        assert_eq!(debounce.threshold, 2);
        assert_eq!(debounce.count, 0);
        assert!(debounce.pending.is_none());
    }

    pub fn new(
        id: AgentId,
        name: String,
        project_name: String,
        pty: PtyController,
        parser: vt100::Parser,
        child: Box<dyn Child + Send + Sync>,
        spawn_command: String,
        spawn_args: Vec<String>,
        spawn_cwd: PathBuf,
        spawn_env: HashMap<String, String>,
        session_id: Option<String>,
    ) -> Self {
        Self {
            id,
            name,
            project_name,
            state: AgentState::Spawning { since: Utc::now() },
            pty,
            parser,
            child,
            spawned_at: Utc::now(),
            last_output_at: None,
            debounce: DetectionDebounce::new(),
            dirty: true,
            spawn_command,
            spawn_args,
            spawn_cwd,
            spawn_env,
            scrollback: ScrollbackBuffer::new(10 * 1024 * 1024), // 10MB default
            session_id,
            resume_retry_attempted: false,
            has_unread_result: false,

    pub fn id(&self) -> AgentId {
        self.id
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn set_name(&mut self, new_name: String) {
        self.name = new_name;
        self.dirty = true;
    }

    pub fn project_name(&self) -> &str {
        &self.project_name
    }

    pub fn set_project_name(&mut self, new_name: String) {
        self.project_name = new_name;
        self.dirty = true;
    }

    pub fn session_id(&self) -> Option<&str> {
        self.session_id.as_deref()
    }

    pub fn resume_retry_attempted(&self) -> bool {
        self.resume_retry_attempted
    }

    pub fn set_resume_retry_attempted(&mut self, val: bool) {
        self.resume_retry_attempted = val;
    }

    pub fn has_unread_result(&self) -> bool {
        self.has_unread_result
    }

    pub fn mark_result_read(&mut self) {
        self.has_unread_result = false;
    }

    pub fn is_stale_resume_failure(&self, max_secs: u64) -> bool {
        if self.resume_retry_attempted {
            return false;
        }
        if !matches!(self.state, AgentState::Errored { .. }) {
            return false;
        }
        let age = (Utc::now() - self.spawned_at).num_seconds();
        if age > max_secs as i64 {
            return false;
        }
        self.spawn_args.iter().any(|a| a == "--resume" || a == "-r")
    }

    pub fn state(&self) -> &AgentState {
        &self.state
    }

    pub fn spawned_at(&self) -> DateTime<Utc> {
        self.spawned_at
    }

    pub fn is_dirty(&self) -> bool {
        self.dirty
    }

    pub fn screen(&self) -> &vt100::Screen {
        self.parser.screen()
    }

    pub fn mark_clean(&mut self) {
        self.dirty = false;
    }

    pub fn uptime(&self) -> String {
        let elapsed = Utc::now() - self.spawned_at;
        let secs = elapsed.num_seconds();
        if secs < 60 {
            format!("{secs}s")
        } else if secs < 3600 {
            format!("{}m {}s", secs / 60, secs % 60)
        } else {
            format!("{}h {}m", secs / 3600, (secs % 3600) / 60)
        }
    }

    pub fn process_output(&mut self, data: &[u8]) {
        self.parser.process(data);
        self.scrollback.append(data);

        // Auto-scroll to bottom when new output arrives (if already at bottom)
        if !self.scrollback.is_scrolled() {
            self.scrollback.scroll_to_bottom();
        }

        self.last_output_at = Some(Utc::now());
        self.dirty = true;
    }

    pub fn write_input(&self, data: &[u8]) -> Result<()> {
        self.pty.write(data)
    }

    pub fn resize(&mut self, size: PtySize) {
        if let Err(e) = self.pty.resize(size) {
            tracing::warn!("Failed to resize PTY for agent {}: {}", self.name, e);
        }
        self.parser.screen_mut().set_size(size.rows, size.cols);
        self.dirty = true;
    }

    pub fn scrollback(&self) -> &ScrollbackBuffer {
        &self.scrollback
    }

    pub fn scrollback_mut(&mut self) -> &mut ScrollbackBuffer {
        &mut self.scrollback
    }

    pub fn scroll_up(&mut self, page_height: usize) {
        self.scrollback.scroll_up(page_height);
        // Discover actual max scrollback: set_scrollback(usize::MAX) clamps
        // to the real scrollback length, then we read it back and reset.
        self.parser.screen_mut().set_scrollback(usize::MAX);
        let max_scrollback = self.parser.screen().scrollback();
        self.parser.screen_mut().set_scrollback(0);
        self.scrollback.clamp_scroll(max_scrollback);
        self.dirty = true;
    }

    pub fn set_scrollback_view(&mut self, offset: usize) {
        self.parser.screen_mut().set_scrollback(offset);
    }

    pub fn scroll_down(&mut self, page_height: usize) {
        self.scrollback.scroll_down(page_height);
        self.dirty = true;
    }

    pub fn mouse_scroll_up(&mut self, lines: usize) {
        self.scrollback.mouse_scroll_up(lines);
        self.parser.screen_mut().set_scrollback(usize::MAX);
        let max_scrollback = self.parser.screen().scrollback();
        self.parser.screen_mut().set_scrollback(0);
        self.scrollback.clamp_scroll(max_scrollback);
        self.dirty = true;
    }

    pub fn mouse_scroll_down(&mut self, lines: usize) {
        self.scrollback.mouse_scroll_down(lines);
        self.dirty = true;
    }

    pub fn scroll_offset(&self) -> usize {
        self.scrollback.scroll_offset()
    }

    pub fn is_scrolled(&self) -> bool {
        self.scrollback.is_scrolled()
    }

    pub fn start_search(&mut self, query: &str) {
        self.scrollback.start_search(query);
        if let Some(search) = self.scrollback.search_mut() {
            search.search(self.parser.screen());
        }
        self.dirty = true;
    }

    pub fn clear_search(&mut self) {
        self.scrollback.clear_search();
        self.dirty = true;
    }

    pub fn search_next(&mut self) -> Option<usize> {
        let line = self
            .scrollback
            .search_mut()
            .and_then(|s| s.next_match().map(|m| m.line));
        if line.is_some() {
            self.dirty = true;
        }
        line
    }

    pub fn search_prev(&mut self) -> Option<usize> {
        let line = self
            .scrollback
            .search_mut()
            .and_then(|s| s.prev_match().map(|m| m.line));
        if line.is_some() {
            self.dirty = true;
        }
        line
    }

    pub fn detect_and_update(
        &mut self,
        patterns: &DetectionPatterns,
        idle_timeout_secs: u64,
    ) -> Option<AgentState> {
        // Check process exit
        let process_exited = match self.child.try_wait() {
            Ok(Some(status)) => Some(ProcessExit {
                exit_code: Some(status.exit_code() as i32),
                signal: status.signal().is_some(),
            }),
            Ok(None) => None,
            Err(e) => {
                tracing::warn!("try_wait failed for agent {}: {}", self.name, e);
                None
            }
        };

        // Calculate seconds since last output
        let seconds_since_output = match self.last_output_at {
            Some(last) => (Utc::now() - last).num_milliseconds() as f64 / 1000.0,
            None => 0.0,
        };

        // Extract screen lines
        let screen_lines = extract_screen_lines(self.parser.screen(), patterns.scan_lines());

        let signals = DetectionSignals {
    

    pub fn kill(&mut self) {
        // Step 1: Try graceful shutdown by sending Ctrl-C through the PTY.
        // This is how a terminal user would interrupt a process.
        let _ = self.pty.write(b"\x03");

        // Step 2: Send SIGTERM to the process group for a clean exit.
        // The child was spawned with setsid(), so its PID == PGID.
        // Using negative PID sends the signal to the entire process group,
        // ensuring Electron's child processes also receive it.
        if let Some(pid) = self.child.process_id() {
            unsafe {
                libc::kill(-(pid as i32), libc::SIGTERM);
            }
        }

        // Step 3: Give the process a generous grace period to exit cleanly.
        // Electron needs more time than the 250ms that portable-pty allows.
        for _ in 0..20 {
            match self.child.try_wait() {
                Ok(Some(_)) => {
                    self.pty.shutdown();
                    self.state = AgentState::Errored {
 

    pub fn scrollback_raw_bytes(&self) -> &[u8] {
        self.scrollback.raw_bytes()
    }

    pub fn load_scrollback_history(&mut self, data: &[u8]) {
        self.scrollback.append(data);
        self.dirty = true;
    }

    pub fn restart_params(&self) -> RestartParams {
        RestartParams {
            name: self.name.clone(),
            project_name: self.project_name.clone(),
            command: self.spawn_command.clone(),
            args: self.spawn_args.clone(),
            cwd: self.spawn_cwd.clone(),
            env: self.spawn_env.clone(),
            session_id: self.session_id.clone(),
        }
    }

    fn test_uptime_formatting_seconds() {
        // Test seconds-only range
        let fmt = format_duration(30);
        assert_eq!(fmt, "30s");
    }

    fn test_uptime_formatting_minutes() {
        let fmt = format_duration(125);
        assert_eq!(fmt, "2m 5s");
    }

    fn test_uptime_formatting_hours() {
        let fmt = format_duration(3661);
        assert_eq!(fmt, "1h 1m");
    }

    fn format_duration(secs: i64) -> String {
        if secs < 60 {
            format!("{secs}s")
        } else if secs < 3600 {
            format!("{}m {}s", secs / 60, secs % 60)
        } else {
            format!("{}h {}m", secs / 3600, (secs % 3600) / 60)
        }
    }

    pub fn new(config: &MaestroConfig, event_tx: mpsc::UnboundedSender<AppEvent>) -> Self {
        let detection_patterns = DetectionPatterns::from_config(&config.detection);

        Self {
            agents: HashMap::new(),
            display_order: Vec::new(),
            event_tx,
            detection_patterns,
            max_agents: config.global.max_agents,
            config: config.clone(),
        }
    }

    pub fn spawn(
        &mut self,
        name: String,
        project_name: String,
        command: String,
        args: Vec<String>,
        cwd: std::path::PathBuf,
        env: HashMap<String, String>,
        pty_size: PtySize,
    ) -> Result<AgentId> {
        // Check agent limit
        let alive_count = self
            .agents
            .values()
            .filter(|a| a.state().is_alive())
            .count();
        if alive_count >= self.max_agents {
            bail!(
                "Agent limit reached ({}/{}). Kill an agent first.",
                alive_count,
                self.max_agents,
            );
        }

        // Check for duplicate name within same project
        if self.find_by_name(&project_name, &name).is_some() {
            bail!(
                "Agent '{}' already exists in project '{}'",
                name,
                project_name
            );
        }

        // For Claude commands, generate a session ID and inject --s