diff options
Diffstat (limited to 'src')
30 files changed, 2042 insertions, 898 deletions
diff --git a/src/agent_detection_policy.rs b/src/agent_detection_policy.rs new file mode 100644 index 00000000..a0d7ba4c --- /dev/null +++ b/src/agent_detection_policy.rs @@ -0,0 +1,288 @@ +use crate::detect::{Agent, AgentDetection, AgentState}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) struct PtySignal { + pub active: bool, + pub tainted: bool, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) struct DetectionPolicyInput { + pub agent: Option<Agent>, + pub screen_detection: AgentDetection, + pub process_exited: bool, + pub startup_grace_active: bool, + pub pty_signal: Option<PtySignal>, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum DetectionPolicyDecision { + Publish(AgentDetection), + Freeze, +} + +fn screen_blocked_or_idle_fallback(detection: AgentDetection) -> AgentDetection { + if detection.visible_blocker { + return AgentDetection { + state: AgentState::Blocked, + skip_state_update: false, + visible_blocker: true, + visible_working: false, + }; + } + + AgentDetection { + state: AgentState::Idle, + skip_state_update: false, + visible_blocker: false, + visible_working: false, + } +} + +#[cfg(test)] +pub(crate) fn full_lifecycle_detected_agent(agent: Agent) -> bool { + matches!( + agent, + Agent::Pi | Agent::GithubCopilot | Agent::Kimi | Agent::Hermes | Agent::Qodercli + ) +} + +pub(crate) fn full_lifecycle_hook_authority(source: &str, agent_label: &str) -> bool { + matches!( + (source, agent_label), + ("herdr:pi", "pi") + | ("herdr:omp", "omp") + | ("herdr:kimi", "kimi") + | ("herdr:copilot", "copilot") + | ("herdr:hermes", "hermes") + | ("herdr:qodercli", "qodercli") + ) +} + +pub(crate) fn apply_detection_policy(input: DetectionPolicyInput) -> DetectionPolicyDecision { + if input.process_exited { + return DetectionPolicyDecision::Publish(input.screen_detection); + } + + if input.startup_grace_active { + return DetectionPolicyDecision::Freeze; + } + + if input.agent.is_none() { + return DetectionPolicyDecision::Publish(input.screen_detection); + }; + + let Some(pty_signal) = input.pty_signal else { + return DetectionPolicyDecision::Publish(input.screen_detection); + }; + + if pty_signal.tainted { + return DetectionPolicyDecision::Freeze; + } + + if pty_signal.active { + return DetectionPolicyDecision::Publish(AgentDetection { + state: AgentState::Working, + skip_state_update: false, + visible_blocker: false, + visible_working: false, + }); + } + + DetectionPolicyDecision::Publish(screen_blocked_or_idle_fallback(input.screen_detection)) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn detection(state: AgentState) -> AgentDetection { + AgentDetection { + state, + skip_state_update: false, + visible_blocker: false, + visible_working: state == AgentState::Working, + } + } + + fn input(screen_detection: AgentDetection) -> DetectionPolicyInput { + DetectionPolicyInput { + agent: Some(Agent::Codex), + screen_detection, + process_exited: false, + startup_grace_active: false, + pty_signal: Some(PtySignal { + active: false, + tainted: false, + }), + } + } + + #[test] + fn classifies_full_lifecycle_hook_sources() { + assert!(full_lifecycle_hook_authority("herdr:pi", "pi")); + assert!(full_lifecycle_hook_authority("herdr:omp", "omp")); + assert!(full_lifecycle_hook_authority("herdr:kimi", "kimi")); + assert!(full_lifecycle_hook_authority("herdr:copilot", "copilot")); + assert!(full_lifecycle_hook_authority("herdr:hermes", "hermes")); + assert!(full_lifecycle_hook_authority("herdr:qodercli", "qodercli")); + assert!(!full_lifecycle_hook_authority("herdr:codex", "codex")); + assert!(!full_lifecycle_hook_authority("herdr:claude", "claude")); + assert!(!full_lifecycle_hook_authority("herdr:opencode", "opencode")); + assert!(!full_lifecycle_hook_authority("custom", "pi")); + } + + #[test] + fn classifies_full_lifecycle_detected_agents_without_omp_variant() { + assert!(full_lifecycle_detected_agent(Agent::Pi)); + assert!(full_lifecycle_detected_agent(Agent::Kimi)); + assert!(full_lifecycle_detected_agent(Agent::GithubCopilot)); + assert!(full_lifecycle_detected_agent(Agent::Hermes)); + assert!(full_lifecycle_detected_agent(Agent::Qodercli)); + assert!(!full_lifecycle_detected_agent(Agent::Codex)); + assert!(!full_lifecycle_detected_agent(Agent::Claude)); + } + + #[test] + fn startup_grace_freezes_publish() { + let mut input = input(detection(AgentState::Working)); + input.startup_grace_active = true; + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Freeze + ); + } + + #[test] + fn taint_freezes_weak_publish() { + let mut input = input(detection(AgentState::Idle)); + input.pty_signal = Some(PtySignal { + active: false, + tainted: true, + }); + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Freeze + ); + } + + #[test] + fn taint_freezes_visible_blocker_until_pty_is_quiet() { + let mut blocker = detection(AgentState::Blocked); + blocker.visible_blocker = true; + let mut input = input(blocker); + input.pty_signal = Some(PtySignal { + active: false, + tainted: true, + }); + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Freeze + ); + } + + #[test] + fn process_exit_publishes_even_during_taint() { + let mut input = input(detection(AgentState::Idle)); + input.process_exited = true; + input.pty_signal = Some(PtySignal { + active: true, + tainted: true, + }); + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Publish(detection(AgentState::Idle)) + ); + } + + #[test] + fn pty_activity_publishes_working_without_inventing_visible_working() { + let mut input = input(detection(AgentState::Idle)); + input.pty_signal = Some(PtySignal { + active: true, + tainted: false, + }); + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Publish(AgentDetection { + state: AgentState::Working, + skip_state_update: false, + visible_blocker: false, + visible_working: false, + }) + ); + } + + #[test] + fn active_pty_wins_over_visible_blocker() { + let mut blocker = detection(AgentState::Blocked); + blocker.visible_blocker = true; + let mut input = input(blocker); + input.pty_signal = Some(PtySignal { + active: true, + tainted: false, + }); + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Publish(AgentDetection { + state: AgentState::Working, + skip_state_update: false, + visible_blocker: false, + visible_working: false, + }) + ); + } + + #[test] + fn silent_pty_with_visible_blocker_publishes_blocked() { + let mut screen = detection(AgentState::Blocked); + screen.visible_blocker = true; + let input = input(screen); + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Publish(AgentDetection { + state: AgentState::Blocked, + skip_state_update: false, + visible_blocker: true, + visible_working: false, + }) + ); + } + + #[test] + fn silent_pty_downgrades_screen_working_to_idle() { + let input = input(detection(AgentState::Working)); + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Publish(AgentDetection { + state: AgentState::Idle, + skip_state_update: false, + visible_blocker: false, + visible_working: false, + }) + ); + } + + #[test] + fn silent_pty_downgrades_weak_screen_blocked_to_idle() { + let input = input(detection(AgentState::Blocked)); + + assert_eq!( + apply_detection_policy(input), + DetectionPolicyDecision::Publish(AgentDetection { + state: AgentState::Idle, + skip_state_update: false, + visible_blocker: false, + visible_working: false, + }) + ); + } +} diff --git a/src/app/actions.rs b/src/app/actions.rs index 371457a8..249d0e64 100644 --- a/src/app/actions.rs +++ b/src/app/actions.rs @@ -22,6 +22,28 @@ fn is_background_completion_transition(prev_state: AgentState, new_state: AgentS && matches!(prev_state, AgentState::Working | AgentState::Blocked) } +fn is_completion_transition(change: &EffectiveStateChange) -> bool { + is_completion_transition_parts( + change.previous_state, + change.state, + change.previous_agent_label.as_deref(), + change.agent_label.as_deref(), + ) +} + +pub fn is_completion_transition_parts( + previous_state: AgentState, + state: AgentState, + previous_agent_label: Option<&str>, + agent_label: Option<&str>, +) -> bool { + is_background_completion_transition(previous_state, state) + || (previous_state == AgentState::Unknown + && state == AgentState::Idle + && previous_agent_label.is_some() + && previous_agent_label == agent_label) +} + pub fn active_tab_suppresses_notifications( is_active_tab: bool, outer_terminal_focus: Option<bool>, @@ -29,6 +51,7 @@ pub fn active_tab_suppresses_notifications( is_active_tab && outer_terminal_focus != Some(false) } +#[cfg(test)] pub fn notification_sound_for_state_change( suppress_active_tab_notifications: bool, prev_state: AgentState, @@ -50,10 +73,58 @@ pub fn notification_sound_for_state_change( } } -pub fn notification_toast_for_state_change( +pub fn notification_sound_for_state_change_with_agent_labels( suppress_active_tab_notifications: bool, prev_state: AgentState, new_state: AgentState, + previous_agent_label: Option<&str>, + agent_label: Option<&str>, +) -> Option<crate::sound::Sound> { + if new_state == prev_state { + return None; + } + + match new_state { + AgentState::Blocked => Some(crate::sound::Sound::Request), + AgentState::Idle + if is_completion_transition_parts( + prev_state, + new_state, + previous_agent_label, + agent_label, + ) && !suppress_active_tab_notifications => + { + Some(crate::sound::Sound::Done) + } + _ => None, + } +} + +fn notification_sound_for_effective_state_change( + suppress_active_tab_notifications: bool, + change: &EffectiveStateChange, +) -> Option<crate::sound::Sound> { + if change.state == change.previous_state { + return None; + } + + match change.state { + AgentState::Blocked => Some(crate::sound::Sound::Request), + AgentState::Idle + if is_completion_transition(change) && !suppress_active_tab_notifications => + { + Some(crate::sound::Sound::Done) + } + _ => None, + } +} + +pub fn notification_toast_for_state_change_with_agent_labels( + suppress_active_tab_notifications: bool, + prev_state: AgentState, + new_state: AgentState, + previous_agent_label: Option<&str>, + agent_label: Option<&str>, ) -> Option<ToastKind> { if suppress_active_tab_notifications || new_state == prev_state { return None; @@ -61,13 +132,52 @@ pub fn notification_toast_for_state_change( match new_state { AgentState::Blocked => Some(ToastKind::NeedsAttention), - AgentState::Idle if is_background_completion_transition(prev_state, new_state) => { + AgentState::Idle + if is_completion_transition_parts( + prev_state, + new_state, + previous_agent_label, + agent_label, + ) => + { Some(ToastKind::Finished) } _ => None, } } +fn notification_toast_for_effective_state_change( + suppress_active_tab_notifications: bool, + change: &EffectiveStateChange, +) -> Option<ToastKind> { + if suppress_active_tab_notifications || change.state == change.previous_state { + return None; + } + + match change.state { + AgentState::Blocked => Some(ToastKind::NeedsAttention), + AgentState::Idle if is_completion_transition(change) => Some(ToastKind::Finished), + _ => None, + } +} + +pub fn notification_toast_for_pane_state_update( + suppress_active_tab_notifications: bool, + update: &PaneStateUpdate, +) -> Option<ToastKind> { + if suppress_active_tab_notifications || update.state == update.previous_state { + return None; + } + + notification_toast_for_state_change_with_agent_labels( + suppress_active_tab_notifications, + update.previous_state, + update.state, + update.previous_agent_label.as_deref(), + update.agent_label.as_deref(), + ) +} + fn toast_agent_label(agent_label: &str) -> &str { agent_label } @@ -2207,7 +2317,6 @@ impl AppState { agent, state, visible_blocker, - visible_idle, visible_working, process_exited, observed_at, @@ -2217,7 +2326,7 @@ impl AppState { agent, state, visible_blocker, - visible_idle, + false, visible_working, process_exited, observed_at, @@ -2405,6 +2514,27 @@ impl AppState { Some(update) } + pub(crate) fn publish_pane_process_exit_if_agent( + &mut self, + pane_id: PaneId, + ) -> Option<PaneStateUpdate> { + let observed_at = std::time::Instant::now(); + self.update_terminal_state(pane_id, |terminal| { + let agent = terminal + .effective_known_agent() + .or(terminal.detected_agent)?; + Some(terminal.set_detected_state_with_screen_signals_at( + Some(agent), + AgentState::Idle, + false, + false, + false, + true, + observed_at, + )) + }) + } + fn apply_pane_state_change( &mut self, ws_idx: usize, @@ -2421,7 +2551,7 @@ impl AppState { if change.state != AgentState::Idle { pane.seen = true; - } else if is_background_completion_transition(change.previous_state, change.state) { + } else if is_completion_transition(change) { pane.seen = suppress_active_tab_notifications; } let seen = pane.seen; @@ -2445,15 +2575,13 @@ impl AppState { let suppress_active_tab_notifications = active_tab_suppresses_notifications(is_active_tab, self.outer_terminal_focus); - let client_notification_kind = notification_toast_for_state_change( + let client_notification_kind = notification_toast_for_effective_state_change( suppress_active_tab_notifications, - change.previous_state, - change.state, + change, ); - let sound = notification_sound_for_state_change( + let sound = notification_sound_for_effective_state_change( suppress_active_tab_notifications, - change.previous_state, - change.state, + change, ); if client_notification_kind.is_none() && sound.is_none() { return None; @@ -3834,7 +3962,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -3854,6 +3981,7 @@ mod tests { #[test] fn state_changed_idle_in_background_marks_unseen() { let mut state = app_with_workspaces(&["active", "background"]); + state.toast_config.delivery = crate::config::ToastDelivery::Herdr; state.active = Some(0); let bg_pane_id = *state.workspaces[1].panes.keys().next().unwrap(); @@ -3872,7 +4000,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -3880,6 +4007,10 @@ mod tests { let pane = state.workspaces[1].panes.get(&bg_pane_id).unwrap(); assert!(!pane.seen); + assert!(matches!( + state.toast.as_ref().map(|toast| toast.kind), + Some(ToastKind::Finished) + )); } #[test] @@ -3902,7 +4033,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -3925,7 +4055,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -3936,6 +4065,36 @@ mod tests { } #[test] + fn idle_after_known_unknown_agent_in_background_marks_done() { + let mut state = app_with_workspaces(&["active", "background"]); + state.toast_config.delivery = crate::config::ToastDelivery::Herdr; + state.active = Some(0); + let bg_pane_id = *state.workspaces[1].panes.keys().next().unwrap(); + + state.handle_app_event(AppEvent::StateChanged { + pane_id: bg_pane_id, + agent: Some(Agent::Pi), + state: AgentState::Unknown, + visible_blocker: false, + visible_working: false, + process_exited: false, + observed_at: std::time::Instant::now(), + }); + state.handle_app_event(AppEvent::StateChanged { + pane_id: bg_pane_id, + agent: Some(Agent::Pi), + state: AgentState::Idle, + visible_blocker: false, + visible_working: false, + process_exited: false, + observed_at: std::time::Instant::now(), + }); + + let pane = state.workspaces[1].panes.get(&bg_pane_id).unwrap(); + assert!(!pane.seen); + } + + #[test] fn waiting_sound_plays_even_in_active_workspace() { assert_eq!( notification_sound_for_state_change(true, AgentState::Working, AgentState::Blocked), @@ -3971,7 +4130,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -3996,7 +4154,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4029,7 +4186,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4041,7 +4197,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: true, process_exited: false, observed_at: std::time::Instant::now(), @@ -4065,7 +4220,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4091,7 +4245,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4119,7 +4272,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4176,7 +4328,6 @@ mod tests { agent: Some(Agent::Codex), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4196,7 +4347,6 @@ mod tests { agent: Some(Agent::Codex), state: AgentState::Blocked, visible_blocker: true, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4227,7 +4377,6 @@ mod tests { agent: Some(Agent::Claude), state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4252,7 +4401,6 @@ mod tests { agent: Some(Agent::Claude), state: AgentState::Idle, visible_blocker: false, - visible_idle: true, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4279,7 +4427,6 @@ mod tests { agent: Some(Agent::Claude), state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: true, process_exited: false, observed_at: std::time::Instant::now(), @@ -4298,7 +4445,7 @@ mod tests { } #[test] - fn hidden_session_ref_only_update_marks_session_dirty_without_visible_update() { + fn hidden_custom_session_ref_only_update_marks_session_dirty_without_visible_update() { let mut state = app_with_workspaces(&["active"]); let pane_id = *state.workspaces[0].panes.keys().next().unwrap(); let test_dir = std::env::current_dir().unwrap(); @@ -4307,7 +4454,7 @@ mod tests { let first_updates = state.handle_app_event(AppEvent::HookStateReported { pane_id, - source: "herdr:pi".into(), + source: "custom:pi".into(), agent_label: "pi".into(), state: AgentState::Working, message: None, @@ -4320,7 +4467,7 @@ mod tests { let second_updates = state.handle_app_event(AppEvent::HookStateReported { pane_id, - source: "herdr:pi".into(), + source: "custom:pi".into(), agent_label: "pi".into(), state: AgentState::Working, message: None, @@ -4377,7 +4524,6 @@ mod tests { agent: Some(Agent::Droid), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4407,7 +4553,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4434,7 +4579,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4458,7 +4602,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4480,7 +4623,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -4678,6 +4820,39 @@ mod tests { } #[test] + fn pane_process_exit_publish_marks_agent_idle_before_pane_removal() { + let mut state = app_with_workspaces(&["active", "background"]); + state.toast_config.delivery = crate::config::ToastDelivery::Herdr; + state.active = Some(1); + state.ensure_test_terminals(); + let pane_id = state.workspaces[0].tabs[0].root_pane; + let terminal_id = state.terminal_id_for_pane(0, pane_id).unwrap(); + state + .terminals + .get_mut(&terminal_id) + .unwrap() + .set_detected_state(Some(Agent::Pi), AgentState::Working); + assert_eq!( + state.terminals.get(&terminal_id).unwrap().state, + AgentState::Working + ); + + let update = state + .publish_pane_process_exit_if_agent(pane_id) + .expect("process exit update"); + + assert!(!state.pane_is_in_active_tab(update.ws_idx, pane_id)); + assert_eq!(update.previous_state, AgentState::Working); + assert_eq!(update.state, AgentState::Idle); + assert_eq!(update.agent_label.as_deref(), Some("pi")); + assert_eq!(update.known_agent, Some(Agent::Pi)); + assert!(matches!( + state.toast.as_ref().map(|toast| toast.kind), + Some(ToastKind::Finished) + )); + } + + #[test] fn close_pane_removes_unattached_terminal_state() { let mut state = app_with_workspaces(&["test"]); let pane_id = state.workspaces[0].test_split(Direction::Horizontal); diff --git a/src/app/api.rs b/src/app/api.rs index 166ea789..76d9c537 100644 --- a/src/app/api.rs +++ b/src/app/api.rs @@ -67,6 +67,12 @@ impl App { } if let AppEvent::PaneDied { pane_id } = &ev { + let previous_toast = self.state.toast.clone(); + if let Some(update) = self.state.publish_pane_process_exit_if_agent(*pane_id) { + self.refresh_new_herdr_toast_context_for_update(&update, &previous_toast); + self.emit_pane_state_update(&update); + self.emit_terminal_or_system_agent_notifications(std::slice::from_ref(&update)); + } if self.runtime_exit_action(*pane_id) == RuntimeExitAction::RespawnShell && self.respawn_shell_for_launch_pane(*pane_id) { @@ -161,57 +167,7 @@ impl App { let instruction = crate::update::update_install_instruction(&install_command); let _ = notify(&format!("v{version} available"), Some(&instruction)); } else if self.state.toast_config.delay_seconds == 0 { - for update in &pane_updates { - let is_active_tab = self - .state - .pane_is_in_active_tab(update.ws_idx, update.pane_id); - let suppress_active_tab_notifications = - crate::app::actions::active_tab_suppresses_notifications( - is_active_tab, - self.state.outer_terminal_focus, - ); - let Some(kind) = crate::app::actions::notification_toast_for_state_change( - suppress_active_tab_notifications, - update.previous_state, - update.state, - ) else { - continue; - }; - let Some(ws) = self.state.workspaces.get(update.ws_idx) else { - continue; - }; - let Some(pane) = ws - .tabs - .iter() - .find_map(|tab| tab.panes.get(&update.pane_id)) - else { - continue; - }; - let Some(agent_label) = self - .state - .terminals - .get(&pane.attached_terminal_id) - .and_then(|terminal| terminal.effective_agent_label()) - else { - continue; - }; - let event_text = match kind { - ToastKind::NeedsAttention => "needs attention", - ToastKind::Finished => "finished", - ToastKind::UpdateInstalled => "updated", - }; - let workspace_label = - ws.display_name_from(&self.state.terminals, &self.terminal_runtimes); - let _ = notify( - &format!("{} {}", agent_label, event_text), - Some(&crate::app::actions::notification_context( - ws, - &workspace_label, - update.ws_idx, - update.pane_id, - )), - ); - } + self.emit_terminal_or_system_agent_notifications(&pane_updates); } } @@ -407,6 +363,78 @@ impl App { } } + fn emit_terminal_or_system_agent_notifications( + &self, + pane_updates: &[crate::app::actions::PaneStateUpdate], + ) { + if !self.local_terminal_notifications + || self.state.toast_config.delay_seconds != 0 + || !matches!( + self.state.toast_config.delivery, + crate::config::ToastDelivery::Terminal | crate::config::ToastDelivery::System + ) + { + return; + } + + let notify = match self.state.toast_config.delivery { + crate::config::ToastDelivery::Terminal => crate::terminal_notify::show_notification, + crate::config::ToastDelivery::System => crate::platform::show_desktop_notification, + _ => return, + }; + + for update in pane_updates { + let is_active_tab = self + .state + .pane_is_in_active_tab(update.ws_idx, update.pane_id); + let suppress_active_tab_notifications = + crate::app::actions::active_tab_suppresses_notifications( + is_active_tab, + self.state.outer_terminal_focus, + ); + let Some(kind) = crate::app::actions::notification_toast_for_pane_state_update( + suppress_active_tab_notifications, + update, + ) else { + continue; + }; + let Some(ws) = self.state.workspaces.get(update.ws_idx) else { + continue; + }; + let Some(pane) = ws + .tabs + .iter() + .find_map(|tab| tab.panes.get(&update.pane_id)) + else { + continue; + }; + let Some(agent_label) = self + .state + .terminals + .get(&pane.attached_terminal_id) + .and_then(|terminal| terminal.effective_agent_label()) + else { + continue; + }; + let event_text = match kind { + ToastKind::NeedsAttention => "needs attention", + ToastKind::Finished => "finished", + ToastKind::UpdateInstalled => "updated", + }; + let workspace_label = + ws.display_name_from(&self.state.terminals, &self.terminal_runtimes); + let _ = notify( + &format!("{} {}", agent_label, event_text), + Some(&crate::app::actions::notification_context( + ws, + &workspace_label, + update.ws_idx, + update.pane_id, + )), + ); + } + } + pub(crate) fn sync_toast_deadline( &mut self, previous_toast: Option<crate::app::state::ToastNotification>, @@ -891,7 +919,6 @@ mod tests { agent: Some(Agent::Codex), state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -901,7 +928,6 @@ mod tests { agent: Some(Agent::Codex), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -984,7 +1010,6 @@ mod tests { agent: Some(Agent::Codex), state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -994,7 +1019,6 @@ mod tests { agent: Some(Agent::Codex), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -1096,7 +1120,6 @@ mod tests { agent: Some(Agent::Codex), state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -1117,7 +1140,6 @@ mod tests { agent: Some(Agent::Codex), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), diff --git a/src/app/input/mouse.rs b/src/app/input/mouse.rs index a682d7ac..a241dadb 100644 --- a/src/app/input/mouse.rs +++ b/src/app/input/mouse.rs @@ -2260,7 +2260,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), diff --git a/src/app/mod.rs b/src/app/mod.rs index 3a038dee..936b082f 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -3621,7 +3621,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), @@ -3646,7 +3645,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: std::time::Instant::now(), diff --git a/src/detect/agents/amp.rs b/src/detect/agents/amp.rs index ad76ca27..b1fcba4d 100644 --- a/src/detect/agents/amp.rs +++ b/src/detect/agents/amp.rs @@ -17,6 +17,19 @@ use super::super::AgentState; pub(super) fn detect(content: &str) -> AgentState { let lower = content.to_lowercase(); + if has_visible_blocker(content) { + return AgentState::Blocked; + } + + if lower.contains("esc to cancel") { + return AgentState::Working; + } + + AgentState::Idle +} + +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); let has_waiting_for_approval = lower.contains("waiting for approval"); let has_approval_header = lower.contains("invoke tool") || lower.contains("run this command?") @@ -29,13 +42,5 @@ pub(super) fn detect(content: &str) -> AgentState { || lower.contains("allow file for every session") || lower.contains("deny with feedback")); - if has_approval_actions && (has_waiting_for_approval || has_approval_header) { - return AgentState::Blocked; - } - - if lower.contains("esc to cancel") { - return AgentState::Working; - } - - AgentState::Idle + has_approval_actions && (has_waiting_for_approval || has_approval_header) } diff --git a/src/detect/agents/antigravity.rs b/src/detect/agents/antigravity.rs index b504a96a..9790c5a4 100644 --- a/src/detect/agents/antigravity.rs +++ b/src/detect/agents/antigravity.rs @@ -1,12 +1,7 @@ use super::super::AgentState; pub(super) fn detect(content: &str) -> AgentState { - let lower = content.to_lowercase(); - - let has_permission_request = lower.contains("requesting permission for:"); - let has_permission_question = lower.contains("do you want to proceed?"); - let has_permission_controls = lower.contains("tab amend") && lower.contains("edit command"); - if has_permission_request && (has_permission_question || has_permission_controls) { + if has_visible_blocker(content) { return AgentState::Blocked; } @@ -17,6 +12,14 @@ pub(super) fn detect(content: &str) -> AgentState { AgentState::Idle } +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); + let has_permission_request = lower.contains("requesting permission for:"); + let has_permission_question = lower.contains("do you want to proceed?"); + let has_permission_controls = lower.contains("tab amend") && lower.contains("edit command"); + has_permission_request && (has_permission_question || has_permission_controls) +} + fn has_antigravity_spinner(content: &str) -> bool { content.lines().any(|line| { let trimmed = line.trim_start(); diff --git a/src/detect/agents/claude_code.rs b/src/detect/agents/claude_code.rs index 910eb679..a13019a4 100644 --- a/src/detect/agents/claude_code.rs +++ b/src/detect/agents/claude_code.rs @@ -27,6 +27,10 @@ pub(super) fn detect(content: &str) -> AgentState { return AgentState::Blocked; } + if has_dynamic_workflow_prompt(&lower) { + return AgentState::Blocked; + } + if has_working_chrome(content) { return AgentState::Working; } @@ -45,6 +49,7 @@ pub(super) fn detect(content: &str) -> AgentState { pub(super) fn has_visible_blocker(content: &str) -> bool { let lower = content.to_lowercase(); has_live_blocked_form(content) + || has_dynamic_workflow_prompt(&lower) || lower.contains("do you want to proceed?") && has_claude_yes_no_choice(content) && (lower.contains("bash command") @@ -96,6 +101,7 @@ fn has_claude_blocked_prompt(content: &str, lower_content: &str) -> bool { has_confirmation_prompt(lower_content) || lower_content.contains("do you want to proceed?") || lower_content.contains("would you like to proceed?") + || has_dynamic_workflow_prompt(lower_content) || lower_content.contains("waiting for permission") || lower_content.contains("do you want to allow this connection?") || lower_content.contains("tab to amend") @@ -105,6 +111,10 @@ fn has_claude_blocked_prompt(content: &str, lower_content: &str) -> bool { || (has_selection_prompt(content) && has_claude_yes_no_choice(content)) } +fn has_dynamic_workflow_prompt(lower_content: &str) -> bool { + lower_content.contains("run a dynamic workflow?") && lower_content.contains("esc to cancel") +} + fn has_live_blocked_form(content: &str) -> bool { let region = content_after_last_horizontal_rule(content); region.lines().any(|line| { diff --git a/src/detect/agents/cline.rs b/src/detect/agents/cline.rs index 86b5ce01..13509606 100644 --- a/src/detect/agents/cline.rs +++ b/src/detect/agents/cline.rs @@ -4,11 +4,7 @@ pub(super) fn detect(content: &str) -> AgentState { let lower = content.to_lowercase(); // Blocked - if lower.contains("let cline use this tool") { - return AgentState::Blocked; - } - // [act mode] or [plan mode] followed by "yes" - if (lower.contains("[act mode]") || lower.contains("[plan mode]")) && lower.contains("yes") { + if has_visible_blocker(content) { return AgentState::Blocked; } @@ -20,3 +16,11 @@ pub(super) fn detect(content: &str) -> AgentState { // Cline defaults to working (unlike most agents that default to idle) AgentState::Working } + +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); + lower.contains("let cline use this tool") + || ((lower.contains("[act mode]") || lower.contains("[plan mode]")) + && (lower.contains("execute command?") || lower.contains("use this tool?")) + && lower.contains("yes")) +} diff --git a/src/detect/agents/codex.rs b/src/detect/agents/codex.rs index 0a9bdadb..b77b7d25 100644 --- a/src/detect/agents/codex.rs +++ b/src/detect/agents/codex.rs @@ -38,10 +38,6 @@ pub(super) fn has_visible_blocker(content: &str) -> bool { has_codex_strong_blocked_prompt(content) } -pub(super) fn has_prompt(content: &str) -> bool { - has_codex_current_prompt(content) || content.lines().any(codex_prompt_line) -} - pub(super) fn has_visible_working(content: &str) -> bool { has_codex_live_working_at_current_prompt(content) || (!has_codex_current_prompt(content) && has_codex_visible_working_without_prompt(content)) diff --git a/src/detect/agents/cursor.rs b/src/detect/agents/cursor.rs index a62e9382..f0f00b9b 100644 --- a/src/detect/agents/cursor.rs +++ b/src/detect/agents/cursor.rs @@ -4,7 +4,7 @@ pub(super) fn detect(content: &str) -> AgentState { let lower = content.to_lowercase(); // Blocked - if has_cursor_blocked_prompt(content, &lower) { + if has_visible_blocker(content) { return AgentState::Blocked; } @@ -19,8 +19,12 @@ pub(super) fn detect(content: &str) -> AgentState { AgentState::Idle } -fn has_cursor_blocked_prompt(content: &str, lower: &str) -> bool { - if lower.contains("waiting for approval") || lower.contains("run this command?") { +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); + if lower.contains("waiting for approval") + && lower.contains("run this command?") + && (lower.contains("run (once) (y)") || lower.contains("skip (esc or n)")) + { return true; } diff --git a/src/detect/agents/droid.rs b/src/detect/agents/droid.rs index ea19da3f..52c5e087 100644 --- a/src/detect/agents/droid.rs +++ b/src/detect/agents/droid.rs @@ -9,19 +9,7 @@ use super::super::{has_braille_spinner, AgentState}; pub(super) fn detect(content: &str) -> AgentState { let lower = content.to_lowercase(); - // Blocked: EXECUTE approval prompt with selection UI chrome - // Primary (AND): structural keyword + chrome text = certain - let has_execute = content.contains("EXECUTE"); - let has_selection_chrome = lower.contains("enter to select") - || lower.contains("↑↓ to navigate") - || lower.contains("esc to cancel"); - let has_selection_options = lower.contains("> yes, allow") || lower.contains("> no, cancel"); - - if has_execute && (has_selection_chrome || has_selection_options) { - return AgentState::Blocked; - } - // Secondary: selection chrome + options together (no EXECUTE needed) - if has_selection_chrome && has_selection_options { + if has_visible_blocker(content) { return AgentState::Blocked; } @@ -37,3 +25,16 @@ pub(super) fn detect(content: &str) -> AgentState { AgentState::Idle } + +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); + // Primary (AND): structural keyword + chrome text = certain + let has_execute = content.contains("EXECUTE"); + let has_selection_chrome = lower.contains("enter to select") + || lower.contains("↑↓ to navigate") + || lower.contains("esc to cancel"); + let has_selection_options = lower.contains("> yes, allow") || lower.contains("> no, cancel"); + + (has_execute && (has_selection_chrome || has_selection_options)) + || (has_selection_chrome && has_selection_options) +} diff --git a/src/detect/agents/gemini.rs b/src/detect/agents/gemini.rs index c47355c0..86cf3bca 100644 --- a/src/detect/agents/gemini.rs +++ b/src/detect/agents/gemini.rs @@ -1,24 +1,11 @@ -use super::super::{has_confirmation_prompt, AgentState}; +use super::super::AgentState; pub(super) fn detect(content: &str) -> AgentState { - let lower = content.to_lowercase(); - - // Blocked — explicit confirmation - if lower.contains("waiting for user confirmation") { - return AgentState::Blocked; - } - - // Blocked — box-drawing confirmation prompts - if content.contains("│ Apply this change") - || content.contains("│ Allow execution") - || content.contains("│ Do you want to proceed") - { - return AgentState::Blocked; - } - if has_confirmation_prompt(&lower) { + if has_visible_blocker(content) { return AgentState::Blocked; } + let lower = content.to_lowercase(); // Working if lower.contains("esc to cancel") { return AgentState::Working; @@ -26,3 +13,19 @@ pub(super) fn detect(content: &str) -> AgentState { AgentState::Idle } + +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); + let has_choice = lower.contains("yes") || lower.contains("no"); + + content.contains("│ Apply this change") + || content.contains("│ Allow execution") + || (has_choice + && (lower.contains("waiting for user confirmation") + || content.contains("│ Do you want to proceed") + || lower.contains("do you want to proceed?"))) + || content.lines().any(|line| { + let line = line.trim().to_ascii_lowercase(); + line.starts_with("❯") && (line.contains("yes") || line.contains("allow")) + }) +} diff --git a/src/detect/agents/github_copilot.rs b/src/detect/agents/github_copilot.rs index eed03011..0eece95b 100644 --- a/src/detect/agents/github_copilot.rs +++ b/src/detect/agents/github_copilot.rs @@ -4,11 +4,7 @@ pub(super) fn detect(content: &str) -> AgentState { let lower = content.to_lowercase(); // Blocked - if lower.contains("esc to cancel") - && (lower.contains("enter to select") - || lower.contains("enter to confirm") - || lower.contains("enter to submit")) - { + if has_visible_blocker(content) { return AgentState::Blocked; } @@ -22,3 +18,11 @@ pub(super) fn detect(content: &str) -> AgentState { AgentState::Idle } + +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); + lower.contains("esc to cancel") + && (lower.contains("enter to select") + || lower.contains("enter to confirm") + || lower.contains("enter to submit")) +} diff --git a/src/detect/agents/grok.rs b/src/detect/agents/grok.rs index 75b5cd35..8a5834a2 100644 --- a/src/detect/agents/grok.rs +++ b/src/detect/agents/grok.rs @@ -7,17 +7,11 @@ use super::super::{has_braille_spinner, AgentState}; /// status line such as "⠋ Waiting… 1.8s" plus live controls like /// "Ctrl+c:cancel" and "Ctrl+Enter:interject". pub(super) fn detect(content: &str) -> AgentState { - let lower = content.to_lowercase(); - - if lower.contains("use ← → to choose permission whitelist scope") - || lower.contains("yes, proceed") - || lower.contains("no, reject") - || lower.contains("ctrl+o:yolo") - || lower.contains(":scope") - { + if has_visible_blocker(content) { return AgentState::Blocked; } + let lower = content.to_lowercase(); if has_braille_spinner(content) && (lower.contains("waiting") || lower.contains("run ") @@ -34,3 +28,10 @@ pub(super) fn detect(content: &str) -> AgentState { AgentState::Idle } + +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); + let has_scope_selector = lower.contains("use ← → to choose permission whitelist scope") + || lower.contains("←/→:scope"); + has_scope_selector && lower.contains("yes, proceed") && lower.contains("no, reject") +} diff --git a/src/detect/agents/hermes.rs b/src/detect/agents/hermes.rs index d6c4c97e..474dda5c 100644 --- a/src/detect/agents/hermes.rs +++ b/src/detect/agents/hermes.rs @@ -6,21 +6,25 @@ use super::super::AgentState; /// dialogs for dangerous terminal commands. Prefer the modal controls for /// blocked detection, then the live interrupt/status controls for working. pub(super) fn detect(content: &str) -> AgentState { - let lower = content.to_lowercase(); - - let has_approval_options = lower.contains("allow once") - && lower.contains("allow for this session") - && lower.contains("deny"); - let has_approval_controls = lower.contains("enter to confirm") - || lower.contains("↑/↓ to select") - || lower.contains("show full command"); - if (lower.contains("dangerous command") || has_approval_options) && has_approval_controls { + if has_visible_blocker(content) { return AgentState::Blocked; } + let lower = content.to_lowercase(); if lower.contains("msg=interrupt") || lower.contains("ctrl+c cancel") { return AgentState::Working; } AgentState::Idle } + +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower = content.to_lowercase(); + let has_approval_options = lower.contains("allow once") + && lower.contains("allow for this session") + && lower.contains("deny"); + let has_approval_controls = lower.contains("enter to confirm") + || lower.contains("↑/↓ to select") + || lower.contains("show full command"); + (lower.contains("dangerous command") || has_approval_options) && has_approval_controls +} diff --git a/src/detect/agents/kilo.rs b/src/detect/agents/kilo.rs index 1ab3651a..46a5601a 100644 --- a/src/detect/agents/kilo.rs +++ b/src/detect/agents/kilo.rs @@ -7,3 +7,7 @@ pub(super) fn detect(content: &str) -> AgentState { super::opencode::detect(content) } + +pub(super) fn has_visible_blocker(content: &str) -> bool { + super::opencode::has_visible_blocker(content) +} diff --git a/src/detect/agents/kimi.rs b/src/detect/agents/kimi.rs index b42bf885..9d3821ed 100644 --- a/src/detect/agents/kimi.rs +++ b/src/detect/agents/kimi.rs @@ -16,10 +16,6 @@ pub(super) fn has_visible_blocker(content: &str) -> bool { has_current_approval_panel(content) || has_question_panel(content) } -pub(super) fn has_prompt_box(content: &str) -> bool { - has_editor_prompt_box(content) && has_footer_context(content) -} - pub(super) fn has_visible_working(content: &str) -> bool { has_kimi_working_status(content) } @@ -99,49 +95,3 @@ fn has_question_panel(content: &str) -> bool { fn has_numeric_choose_hint(lower_content: &str) -> bool { lower_content.contains(" choose") && lower_content.contains('1') && lower_content.contains('2') } - -fn has_editor_prompt_box(content: &str) -> bool { - let lines: Vec<&str> = content.lines().collect(); - - for top_index in 0..lines.len() { - if !is_editor_top_border(lines[top_index]) { - continue; - } - - let mut saw_prompt = false; - for line in lines.iter().skip(top_index + 1) { - if is_editor_bottom_border(line) { - if saw_prompt { - return true; - } - break; - } - - saw_prompt |= is_editor_prompt_line(line); - } - } - - false -} - -fn is_editor_top_border(line: &str) -> bool { - let trimmed = line.trim(); - ((trimmed.starts_with('╭') && trimmed.ends_with('╮')) - || (trimmed.starts_with('├') && trimmed.ends_with('┤'))) - && trimmed.contains('─') -} - -fn is_editor_bottom_border(line: &str) -> bool { - let trimmed = line.trim(); - trimmed.starts_with('╰') && trimmed.ends_with('╯') && trimmed.contains('─') -} - -fn is_editor_prompt_line(line: &str) -> bool { - let trimmed = line.trim_start(); - let inner = trimmed.strip_prefix('│').unwrap_or(trimmed).trim_start(); - inner.starts_with('>') -} - -fn has_footer_context(content: &str) -> bool { - content.to_lowercase().contains("context: ") -} diff --git a/src/detect/agents/kiro.rs b/src/detect/agents/kiro.rs index f40b9bcb..889f5315 100644 --- a/src/detect/agents/kiro.rs +++ b/src/detect/agents/kiro.rs @@ -7,7 +7,7 @@ use super::super::AgentState; pub(super) fn detect(content: &str) -> AgentState { let lower = content.to_lowercase(); - if has_kiro_blocked_prompt(&lower) { + if has_visible_blocker(content) { return AgentState::Blocked; } @@ -20,8 +20,9 @@ pub(super) fn detect(content: &str) -> AgentState { AgentState::Idle } -fn has_kiro_blocked_prompt(lower_content: &str) -> bool { - has_tool_approval_prompt(lower_content) || has_subagent_approval_prompt(lower_content) +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower_content = content.to_lowercase(); + has_tool_approval_prompt(&lower_content) || has_subagent_approval_prompt(&lower_content) } fn has_tool_approval_prompt(lower_content: &str) -> bool { diff --git a/src/detect/agents/mod.rs b/src/detect/agents/mod.rs index 46a25f66..704350df 100644 --- a/src/detect/agents/mod.rs +++ b/src/detect/agents/mod.rs @@ -45,7 +45,6 @@ pub(super) fn detect(agent: Agent, screen_content: &str) -> AgentDetection { state, skip_state_update: true, visible_blocker: false, - visible_idle: false, visible_working: false, }; } @@ -54,7 +53,6 @@ pub(super) fn detect(agent: Agent, screen_content: &str) -> AgentDetection { state, skip_state_update: false, visible_blocker: has_visible_blocker(agent, screen_content, state), - visible_idle: has_visible_idle(agent, screen_content, state), visible_working: has_visible_working(agent, screen_content, state), } } @@ -79,20 +77,20 @@ fn has_visible_blocker(agent: Agent, content: &str, state: AgentState) -> bool { // is known to be structural and live. Agent::Claude => claude_code::has_visible_blocker(content), Agent::Codex => codex::has_visible_blocker(content), + Agent::Gemini => gemini::has_visible_blocker(content), + Agent::Cursor => cursor::has_visible_blocker(content), + Agent::Antigravity => antigravity::has_visible_blocker(content), + Agent::Cline => cline::has_visible_blocker(content), + Agent::OpenCode => opencode::has_visible_blocker(content), + Agent::GithubCopilot => github_copilot::has_visible_blocker(content), Agent::Kimi => kimi::has_visible_blocker(content), - _ => false, - } -} - -fn has_visible_idle(agent: Agent, content: &str, state: AgentState) -> bool { - if state != AgentState::Idle { - return false; - } - - match agent { - Agent::Claude => claude_code::has_prompt_box(content), - Agent::Codex => codex::has_prompt(content), - Agent::Kimi => kimi::has_prompt_box(content), + Agent::Kiro => kiro::has_visible_blocker(content), + Agent::Droid => droid::has_visible_blocker(content), + Agent::Amp => amp::has_visible_blocker(content), + Agent::Grok => grok::has_visible_blocker(content), + Agent::Hermes => hermes::has_visible_blocker(content), + Agent::Kilo => kilo::has_visible_blocker(content), + Agent::Qodercli => qodercli::has_visible_blocker(content), _ => false, } } diff --git a/src/detect/agents/opencode.rs b/src/detect/agents/opencode.rs index 219f69ed..ab8a424f 100644 --- a/src/detect/agents/opencode.rs +++ b/src/detect/agents/opencode.rs @@ -2,7 +2,7 @@ use super::super::{has_interrupt_pattern, AgentState}; pub(super) fn detect(content: &str) -> AgentState { // Blocked - if content.contains("△ Permission required") || has_opencode_question_prompt(content) { + if has_visible_blocker(content) { return AgentState::Blocked; } @@ -17,6 +17,10 @@ pub(super) fn detect(content: &str) -> AgentState { AgentState::Idle } +pub(super) fn has_visible_blocker(content: &str) -> bool { + content.contains("△ Permission required") || has_opencode_question_prompt(content) +} + fn has_opencode_question_prompt(content: &str) -> bool { let lower = content.to_lowercase(); let has_enter_action = lower.contains("enter confirm") diff --git a/src/detect/agents/qodercli.rs b/src/detect/agents/qodercli.rs index b7da356b..0a4372df 100644 --- a/src/detect/agents/qodercli.rs +++ b/src/detect/agents/qodercli.rs @@ -15,7 +15,7 @@ pub(super) fn detect(content: &str) -> AgentState { return AgentState::Idle; } - if has_qodercli_blocked_prompt(&lower) { + if has_visible_blocker(content) { return AgentState::Blocked; } @@ -87,9 +87,15 @@ fn has_qodercli_spinner_row(content: &str) -> bool { /// defensive fallbacks in case the title row scrolls off-screen. /// * The interactive shell waiting hint emitted by qodercli when an agent /// spawns a shell that is now parked for user keystrokes. -fn has_qodercli_blocked_prompt(lower_content: &str) -> bool { - lower_content.contains("waiting for user confirmation") - || lower_content.contains("awaiting approval") +pub(super) fn has_visible_blocker(content: &str) -> bool { + let lower_content = content.to_lowercase(); + (lower_content.contains("waiting for user confirmation") + && (lower_content.contains("yes") + || lower_content.contains("no") + || lower_content.contains("allow") + || lower_content.contains("reject"))) + || (lower_content.contains("awaiting approval") + && (lower_content.contains("allow") || lower_content.contains("reject"))) || lower_content.contains("permission required") || lower_content.contains("allow once or always?") || lower_content.contains("asking user") diff --git a/src/detect/mod.rs b/src/detect/mod.rs index 529574f9..24393c59 100644 --- a/src/detect/mod.rs +++ b/src/detect/mod.rs @@ -29,13 +29,9 @@ pub struct AgentDetection { /// human input. This is stronger than arbitrary prompt-like text in the /// scrollback and may override a non-blocked integration state. pub visible_blocker: bool, - /// True when the current screen visibly shows the agent's idle input UI. - /// This lets Herdr recover from integrations that miss an interrupt/stop - /// event without treating an empty or ambiguous screen as idle authority. - pub visible_idle: bool, - /// True when the current screen visibly shows live working chrome. This is - /// narrower than a fallback `Working` heuristic and may guard against stale - /// hook idle reports. + /// True when the current screen visibly shows live working chrome. PTY + /// activity is the normal working authority; this remains diagnostic + /// metadata and for non-PTY fallback paths. pub visible_working: bool, } @@ -178,7 +174,6 @@ pub fn detect_agent(agent: Option<Agent>, screen_content: &str) -> AgentDetectio state: AgentState::Unknown, skip_state_update: false, visible_blocker: false, - visible_idle: false, visible_working: false, }; }; @@ -1135,7 +1130,6 @@ mod tests { let detection = detect_agent(Some(Agent::Claude), screen); assert!(detection.skip_state_update); - assert!(!detection.visible_idle); assert!(!detection.visible_working); assert!(!detection.visible_blocker); } @@ -1162,7 +1156,6 @@ mod tests { let detection = detect_agent(Some(Agent::Claude), screen); assert!(!detection.skip_state_update); - assert!(detection.visible_idle); } #[test] @@ -1196,7 +1189,6 @@ mod tests { assert_eq!(detection.state, AgentState::Blocked); assert!(detection.visible_blocker); - assert!(!detection.visible_idle); } #[test] @@ -1216,13 +1208,31 @@ mod tests { } #[test] + fn claude_dynamic_workflow_prompt_is_visible_blocker() { + let screen = "● Workflow(Review the current worktree diff and verify the resulting findings)\n\n─────────────────────────────────────────────────────────────────────────────────────────\n Run a dynamic workflow?\n\n Review the current worktree diff and verify the resulting findings\n\n This dynamic workflow will spin up multiple subagents across the following phases:\n 1. Overview — map the diff and identify coupled subsystems\n 2. Review — review each changed file in parallel\n 3. Verify — adversarially verify each finding\n 4. Synthesize — summarize confirmed issues and residual risk\n\n Dynamic workflows can use a lot of tokens quickly by running many subagents in parallel — which counts against your usage limit. Stop a running workflow at any time with\n /workflows, or disable dynamic workflows in /config.\n\n ❯ 1. Yes, run it\n 2. View raw script\n 3. No\n\n Esc to cancel · Tab to amend\n ctrl+g to edit script in $EDITOR"; + let detection = detect_agent(Some(Agent::Claude), screen); + + assert_eq!(detection.state, AgentState::Blocked); + assert!(detection.visible_blocker); + assert!(!detection.visible_working); + } + + #[test] + fn claude_dynamic_workflow_prompt_uses_stable_modal_gate() { + let screen = "● Workflow(Evaluate changes)\n\n─────────────────────────────────────────────────────────────────────────────────────────\n Run a dynamic workflow?\n\n 1. Scope\n 2. Review\n 3. Synthesize\n\n Esc to cancel · Tab to amend"; + let detection = detect_agent(Some(Agent::Claude), screen); + + assert_eq!(detection.state, AgentState::Blocked); + assert!(detection.visible_blocker); + } + + #[test] fn claude_question_form_selected_top_is_visible_blocker() { let screen = "❯ ask again\n─────────────────────────────────────────────────────────────────────────────────────────\n← ☐ Subject ☐ Tone ✔ Submit →\n\nWhat should I ask you about?\n\n❯ 1. Today\n Your current plan or priority.\n 2. Project\n A codebase, feature, bug, or PR.\n 3. Preference\n How you want me to work with you.\n 4. Random\n A casual question with no work context.\n 5. Type something.\n─────────────────────────────────────────────────────────────────────────────────────────\n 6. Chat about this\n\nEnter to select · Tab/Arrow keys to navigate · Esc to cancel"; let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Blocked); assert!(detection.visible_blocker); - assert!(!detection.visible_idle); } #[test] @@ -1232,7 +1242,6 @@ mod tests { assert_eq!(detection.state, AgentState::Blocked); assert!(detection.visible_blocker); - assert!(!detection.visible_idle); } #[test] @@ -1242,7 +1251,6 @@ mod tests { assert_eq!(detection.state, AgentState::Blocked); assert!(detection.visible_blocker); - assert!(!detection.visible_idle); } #[test] @@ -1264,31 +1272,28 @@ mod tests { } #[test] - fn claude_prompt_box_is_visible_idle() { + fn claude_prompt_box_does_not_set_screen_idle_signal() { let screen = "Interrupted.\n─────────────\n❯ \n─────────────"; let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); } #[test] - fn claude_prompt_box_with_status_text_and_custom_status_is_visible_idle() { + fn claude_prompt_box_with_status_text_and_custom_status_does_not_set_screen_idle_signal() { let screen = "──────────────────────────────────────────── ◐ medium · /effort\n❯ \n────────────────────────────────────────────\n thommie-backend | refactor/cleanup-codebase | Opus 4.8 (1M context)\nIppy Tippy\n/coach-dive to chat about this\n▸▸ auto mode on (shift+tab to cycle) · ← for agents"; let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_blocker); } #[test] - fn claude_interrupted_permission_prompt_box_is_visible_idle() { + fn claude_interrupted_permission_prompt_box_does_not_set_screen_idle_signal() { let screen = "❯ this is a test, create some dummy files on /tmp and -rm rf them i wanna test\n permissions\n\n Thought for 7s (ctrl+o to expand)\n\n● Bash(tmpdir=$(mktemp -d /tmp/claude-perm-test.XXXXXX) && touch \"$tmpdir/file1.txt\"\n \"$tmpdir/file2.log\" && mkdir \"$tmpdir/subdir\" && touch\n \"$tmpdir/subdir/nested.txt\"…)\n ⎿ Interrupted · What should Claude do instead?\n\n─────────────────────────────────────────────────────────────────────────────────────────\n❯ \n─────────────────────────────────────────────────────────────────────────────────────────\n ~/P/herdr ⎇ master ▱▱▱▱▱ 0%"; let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); assert!(!detection.visible_blocker); } @@ -1299,7 +1304,6 @@ mod tests { let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); assert!(!detection.visible_blocker); } @@ -1310,7 +1314,6 @@ mod tests { let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); assert!(!detection.visible_blocker); } @@ -1322,17 +1325,15 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); assert!(!detection.visible_blocker); } #[test] - fn claude_separators_without_prompt_are_not_visible_idle() { + fn claude_separators_without_prompt_do_not_set_screen_idle_signal() { let screen = "Task complete.\n─────────────\nplain text\n─────────────"; let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(!detection.visible_idle); } #[test] @@ -1342,7 +1343,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1352,7 +1352,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); assert!(!detection.visible_blocker); } @@ -1363,7 +1362,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1372,7 +1370,6 @@ mod tests { let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); assert!(!detection.visible_blocker); } @@ -1383,7 +1380,6 @@ mod tests { let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); assert!(!detection.visible_blocker); } @@ -1394,7 +1390,6 @@ mod tests { let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); } @@ -1404,7 +1399,6 @@ mod tests { let detection = detect_agent(Some(Agent::Claude), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); } @@ -1467,7 +1461,6 @@ mod tests { let detection = detect_agent(Some(Agent::Codex), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_blocker); } @@ -1477,7 +1470,6 @@ mod tests { let detection = detect_agent(Some(Agent::Codex), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_blocker); } @@ -1493,11 +1485,11 @@ mod tests { } #[test] - fn non_codex_blocked_heuristics_are_not_strong_visible_blockers_by_default() { + fn gemini_confirmation_prompt_is_visible_blocker() { let detection = detect_agent(Some(Agent::Gemini), "Do you want to proceed?\n\nYes No"); assert_eq!(detection.state, AgentState::Blocked); - assert!(!detection.visible_blocker); + assert!(detection.visible_blocker); } #[test] @@ -1517,16 +1509,14 @@ mod tests { assert_eq!(detection.state, AgentState::Blocked); assert!(detection.visible_blocker); - assert!(!detection.visible_idle); } #[test] - fn codex_interrupted_prompt_is_visible_idle() { + fn codex_interrupted_prompt_does_not_set_screen_idle_signal() { let screen = "■ Conversation interrupted - tell the model what to do differently. Something went\nwrong? Hit `/feedback` to report the issue.\n\n\n› Run /review on my current changes\n\n gpt-5.5 high · ~/Projects/herdr-worktrees/issue-249-state-arbitration"; let detection = detect_agent(Some(Agent::Codex), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); } #[test] @@ -1551,7 +1541,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1563,7 +1552,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1575,7 +1563,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1587,7 +1574,7 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); + assert!(!detection.visible_blocker); } #[test] @@ -1606,7 +1593,7 @@ mod tests { ); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); + assert!(!detection.visible_blocker); assert!(!detection.visible_working); } @@ -1619,7 +1606,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1631,7 +1617,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1643,7 +1628,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1655,7 +1639,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1667,7 +1650,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1678,7 +1660,6 @@ mod tests { ); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); } @@ -1690,7 +1671,6 @@ mod tests { ); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); } @@ -1703,7 +1683,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -1726,7 +1705,6 @@ mod tests { assert_eq!(detection.state, AgentState::Idle); assert!(!detection.visible_working); - assert!(detection.visible_idle); } #[test] @@ -1738,7 +1716,6 @@ mod tests { assert_eq!(detection.state, AgentState::Idle); assert!(!detection.visible_working); - assert!(detection.visible_idle); } #[test] @@ -1755,7 +1732,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } } @@ -1770,7 +1746,6 @@ mod tests { let detection = detect_agent(Some(Agent::Codex), screen); assert!(detection.skip_state_update); - assert!(!detection.visible_idle); assert!(!detection.visible_working); assert!(!detection.visible_blocker); } @@ -1781,7 +1756,6 @@ mod tests { let detection = detect_agent(Some(Agent::Codex), screen); assert!(detection.skip_state_update); - assert!(!detection.visible_idle); } #[test] @@ -1790,7 +1764,6 @@ mod tests { let detection = detect_agent(Some(Agent::Codex), screen); assert!(detection.skip_state_update); - assert!(!detection.visible_idle); } #[test] @@ -1799,7 +1772,6 @@ mod tests { let detection = detect_agent(Some(Agent::Codex), screen); assert!(!detection.skip_state_update); - assert!(detection.visible_idle); } #[test] @@ -1815,12 +1787,20 @@ mod tests { #[test] fn gemini_waiting_confirmation() { assert_eq!( - detect_gemini("waiting for user confirmation"), + detect_gemini("waiting for user confirmation\nYes No"), AgentState::Blocked ); } #[test] + fn gemini_waiting_text_without_choices_is_idle() { + assert_eq!( + detect_gemini("waiting for user confirmation"), + AgentState::Idle + ); + } + + #[test] fn gemini_waiting_apply() { assert_eq!( detect_gemini("│ Apply this change\n│ Yes │ No"), @@ -1893,6 +1873,14 @@ mod tests { } #[test] + fn cursor_approval_words_without_visible_controls_are_idle() { + assert_eq!( + detect_cursor("previous output: waiting for approval"), + AgentState::Idle + ); + } + + #[test] fn cursor_running_text_with_unrelated_yes_is_not_blocked() { let screen = "previous answer mentioned (y)\n⠠⠜ Running 5.52k tokens"; assert_eq!(detect_cursor(screen), AgentState::Working); @@ -1992,6 +1980,14 @@ mod tests { } #[test] + fn cline_mode_text_with_unrelated_yes_is_not_blocked() { + assert_eq!( + detect_cline("[act mode]\nPrevious answer was yes."), + AgentState::Working + ); + } + + #[test] fn cline_idle_ready() { assert_eq!( detect_cline("cline is ready for your message"), @@ -2322,7 +2318,6 @@ mod tests { assert_eq!(detection.state, AgentState::Blocked); assert!(detection.visible_blocker); - assert!(!detection.visible_idle); } #[test] @@ -2332,7 +2327,6 @@ mod tests { assert_eq!(detection.state, AgentState::Blocked); assert!(detection.visible_blocker); - assert!(!detection.visible_idle); } #[test] @@ -2363,7 +2357,6 @@ mod tests { assert_eq!(detection.state, AgentState::Working); assert!(detection.visible_working); - assert!(!detection.visible_idle); } #[test] @@ -2397,12 +2390,11 @@ mod tests { } #[test] - fn kimi_current_editor_box_is_visible_idle() { + fn kimi_current_editor_box_does_not_set_screen_idle_signal() { let screen = "╭──────────────────────────────────────────────────╮\n│ > │\n╰──────────────────────────────────────────────────╯\nk2 ~/Projects/herdr /help: show commands\n context: 0.0%"; let detection = detect_agent(Some(Agent::Kimi), screen); assert_eq!(detection.state, AgentState::Idle); - assert!(detection.visible_idle); assert!(!detection.visible_working); assert!(!detection.visible_blocker); } @@ -2587,11 +2579,17 @@ mod tests { #[test] fn grok_blocked_wins_over_spinner() { - let screen = "⠹ Run git 30s\nYes, proceed\nNo, reject (type to add feedback)"; + let screen = "⠹ Run git 30s\nUse ← → to choose permission whitelist scope\nYes, proceed\nNo, reject (type to add feedback)"; assert_eq!(detect_state(Some(Agent::Grok), screen), AgentState::Blocked); } #[test] + fn grok_choice_words_without_scope_selector_are_not_blocked() { + let screen = "Yes, proceed\nNo, reject (type to add feedback)"; + assert_eq!(detect_state(Some(Agent::Grok), screen), AgentState::Idle); + } + + #[test] fn grok_working_on_waiting_spinner() { let screen = "⠋ Waiting… 1.8s\nCtrl+c:cancel │ Ctrl+Enter:interject"; assert_eq!(detect_state(Some(Agent::Grok), screen), AgentState::Working); @@ -2666,12 +2664,20 @@ mod tests { #[test] fn qodercli_blocked_on_confirmation() { assert_eq!( - detect_qodercli("Waiting for user confirmation..."), + detect_qodercli("Waiting for user confirmation...\nAllow\nReject"), AgentState::Blocked, ); } #[test] + fn qodercli_waiting_confirmation_without_choices_is_idle() { + assert_eq!( + detect_qodercli("Waiting for user confirmation..."), + AgentState::Idle, + ); + } + + #[test] fn qodercli_working_on_spinner() { assert_eq!(detect_qodercli("\u{280B} Thinking..."), AgentState::Working); } diff --git a/src/events.rs b/src/events.rs index b4d49d10..cf6a208e 100644 --- a/src/events.rs +++ b/src/events.rs @@ -33,7 +33,6 @@ pub enum AppEvent { agent: Option<Agent>, state: AgentState, visible_blocker: bool, - visible_idle: bool, visible_working: bool, process_exited: bool, observed_at: Instant, diff --git a/src/main.rs b/src/main.rs index d2beb114..d2a1767b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -42,6 +42,7 @@ fn pop_keyboard_enhancement_flags() -> io::Result<()> { Ok(()) } +mod agent_detection_policy; mod agent_resume; mod api; mod app; diff --git a/src/pane.rs b/src/pane.rs index 34775f00..1d9dd7d4 100644 --- a/src/pane.rs +++ b/src/pane.rs @@ -2,7 +2,7 @@ use std::cell::Cell; use std::io; use std::path::Path; use std::sync::{ - atomic::{AtomicBool, AtomicU16, AtomicU32, Ordering}, + atomic::{AtomicBool, AtomicU16, AtomicU32, AtomicU64, Ordering}, Arc, Mutex, }; @@ -81,7 +81,6 @@ async fn publish_state_changed_event( agent: Option<Agent>, state: AgentState, visible_blocker: bool, - visible_idle: bool, visible_working: bool, process_exited: bool, observed_at: std::time::Instant, @@ -95,7 +94,6 @@ async fn publish_state_changed_event( agent, state, visible_blocker, - visible_idle, visible_working, process_exited, observed_at, @@ -120,6 +118,9 @@ const PROCESS_ACQUISITION_FAST_RECHECK: std::time::Duration = std::time::Duratio const PROCESS_ACQUISITION_SLOW_RECHECK: std::time::Duration = std::time::Duration::from_secs(2); const PROCESS_ACQUISITION_IDLE_RESET: std::time::Duration = std::time::Duration::from_secs(2); const STABLE_VISIBLE_SIGNAL_REFRESH: std::time::Duration = std::time::Duration::from_millis(800); +const AGENT_PTY_ACTIVITY_WINDOW: std::time::Duration = std::time::Duration::from_secs(1); +const AGENT_INPUT_TAINT_WINDOW: std::time::Duration = std::time::Duration::from_millis(1200); +const AGENT_STARTUP_GRACE_WINDOW: std::time::Duration = std::time::Duration::from_secs(3); #[derive(Debug, Clone, Copy)] struct AgentDetectionPresence { @@ -328,7 +329,6 @@ fn probe_foreground_process(pid: u32, foreground_pgid: Option<u32>) -> ProcessPr struct DetectionPublishState { state: AgentState, visible_blocker: bool, - visible_idle: bool, visible_working: bool, } @@ -341,14 +341,10 @@ fn should_publish_detection_update( ) -> bool { next.state != previous.state || next.visible_blocker != previous.visible_blocker - || next.visible_idle != previous.visible_idle || next.visible_working != previous.visible_working || agent_changed || process_exited - || (stable_visible_signal_refresh_due - && ((next.visible_blocker && previous.visible_blocker) - || (next.visible_idle && previous.visible_idle) - || (next.visible_working && previous.visible_working))) + || (stable_visible_signal_refresh_due && next.visible_blocker && previous.visible_blocker) } fn stable_visible_signal_refresh_due( @@ -357,11 +353,7 @@ fn stable_visible_signal_refresh_due( last_refresh: Option<std::time::Instant>, now: std::time::Instant, ) -> bool { - // TODO: Evaluate expanding agent-specific visible_* predicates so more - // detectors can use screen-authoritative refreshes safely. - let stable_visible_signal = (next.visible_blocker && previous.visible_blocker) - || (next.visible_idle && previous.visible_idle) - || (next.visible_working && previous.visible_working); + let stable_visible_signal = next.visible_blocker && previous.visible_blocker; stable_visible_signal && last_refresh.is_none_or(|last_refresh| { @@ -383,7 +375,6 @@ fn detection_update_for_publish( state: AgentState::Idle, skip_state_update: false, visible_blocker: false, - visible_idle: false, visible_working: false, }); } @@ -392,11 +383,71 @@ fn detection_update_for_publish( (!detection.skip_state_update).then_some(detection) } +#[derive(Debug, Default)] +struct PtyCausalityTracker { + last_pty_render_seq: u64, + last_input_seq: u64, + input_tainted_until: Option<std::time::Instant>, + last_agent_pty_at: Option<std::time::Instant>, +} + +#[derive(Debug, Clone, Copy)] +struct PtyActivitySignal { + active: bool, + tainted: bool, +} + +fn baseline_pty_causality(tracker: &mut PtyCausalityTracker, pty_render_seq: u64, input_seq: u64) { + tracker.last_pty_render_seq = pty_render_seq; + tracker.last_input_seq = input_seq; + tracker.input_tainted_until = None; + tracker.last_agent_pty_at = None; +} + +fn agent_caused_pty_activity_active( + pty_render_seq: u64, + input_seq: u64, + tracker: &mut PtyCausalityTracker, + now: std::time::Instant, +) -> PtyActivitySignal { + if input_seq != tracker.last_input_seq { + tracker.last_input_seq = input_seq; + tracker.input_tainted_until = Some(now + AGENT_INPUT_TAINT_WINDOW); + tracker.last_agent_pty_at = None; + } + + let tainted = tracker.input_tainted_until.is_some_and(|until| now < until); + + if pty_render_seq != tracker.last_pty_render_seq { + tracker.last_pty_render_seq = pty_render_seq; + if !tainted { + tracker.last_agent_pty_at = Some(now); + } + } + + if tainted { + return PtyActivitySignal { + active: false, + tainted: true, + }; + } + + let active = tracker + .last_agent_pty_at + .is_some_and(|last| now.duration_since(last) < AGENT_PTY_ACTIVITY_WINDOW); + PtyActivitySignal { + active, + tainted: false, + } +} + #[cfg(unix)] fn spawn_basic_detection_task( pane_id: PaneId, child_pid: Arc<AtomicU32>, terminal: Arc<PaneTerminal>, + pty_render_seq: Arc<AtomicU64>, + input_write_seq: Arc<AtomicU64>, state_events: mpsc::Sender<AppEvent>, ) -> ( tokio::task::AbortHandle, @@ -412,17 +463,19 @@ fn spawn_basic_detection_task( let mut agent_presence = AgentDetectionPresence::from_agent(None); let mut state = AgentState::Unknown; let mut last_visible_blocker = false; - let mut last_visible_idle = false; let mut last_visible_working = false; let mut last_visible_signal_refresh = None; - let mut last_screen_working_at = None; let mut last_process_check = std::time::Instant::now(); let mut last_foreground_pgid = None; let mut has_process_probe = false; let mut acquisition_started_at = None; let mut last_content_change_at = None; + let mut pending_foreground_shell_clear = false; + let mut foreground_shell_exit_reported = false; let mut release_was_active = false; let mut last_detection_text = String::new(); + let mut pty_causality = PtyCausalityTracker::default(); + let mut agent_startup_grace_until = None; loop { tokio::select! { @@ -431,17 +484,19 @@ fn spawn_basic_detection_task( agent_presence = AgentDetectionPresence::from_agent(None); state = AgentState::Unknown; last_visible_blocker = false; - last_visible_idle = false; last_visible_working = false; last_visible_signal_refresh = None; - last_screen_working_at = None; last_process_check = std::time::Instant::now(); last_foreground_pgid = None; has_process_probe = false; acquisition_started_at = None; last_content_change_at = None; + pending_foreground_shell_clear = false; + foreground_shell_exit_reported = false; release_was_active = false; last_detection_text.clear(); + pty_causality = PtyCausalityTracker::default(); + agent_startup_grace_until = None; } } @@ -456,27 +511,11 @@ fn spawn_basic_detection_task( let pid = child_pid.load(Ordering::Acquire); let mut agent_changed = false; let mut agent = agent_presence.current_agent(); - let content = terminal.detection_text(); - let content_changed = content != last_detection_text; - last_detection_text.clone_from(&content); - if crate::detect::should_skip_state_update(agent, &content) { - continue; - } - let foreground_pgid = (pid > 0) .then(|| crate::detect::foreground_process_group_id(pid)) .flatten(); let process_group_changed = foreground_group_changed(foreground_pgid, last_foreground_pgid); - sync_content_change_acquisition( - agent_presence.current_agent(), - suppressed_agent, - process_group_changed, - content_changed, - now, - &mut acquisition_started_at, - &mut last_content_change_at, - ); let should_check_process = pid > 0 && should_probe_foreground_job(ProcessProbeInput { current_agent: agent_presence.current_agent(), @@ -486,7 +525,7 @@ fn spawn_basic_detection_task( has_process_probe, acquisition_age: acquisition_started_at .map(|started| now.duration_since(started)), - pending_foreground_shell_clear: false, + pending_foreground_shell_clear, pending_restore_probe: false, elapsed_since_process_check: now.duration_since(last_process_check), }); @@ -496,6 +535,8 @@ fn spawn_basic_detection_task( let had_process_probe = has_process_probe; has_process_probe = true; let probe = probe_foreground_process(pid, foreground_pgid); + let process_group_id = probe.process_group_id; + let foreground_is_pane_shell = probe.foreground_is_pane_shell; let mut new_agent = probe.agent; if let Some(suppressed_agent) = suppressed_agent { if new_agent == Some(suppressed_agent) { @@ -504,51 +545,157 @@ fn spawn_basic_detection_task( *pending_release = None; } } - if new_agent.is_none() { - last_foreground_pgid = probe.process_group_id.or(foreground_pgid); + let previous_agent = agent_presence.current_agent(); + let changed = match foreground_shell_agent_action( + previous_agent, + new_agent, + foreground_is_pane_shell, + foreground_shell_exit_reported, + ) { + ForegroundShellAgentAction::ReportProcessExit => { + pending_foreground_shell_clear = true; + false + } + ForegroundShellAgentAction::ClearAgent => { + pending_foreground_shell_clear = false; + foreground_shell_exit_reported = false; + agent_presence.clear_current_agent() + } + ForegroundShellAgentAction::ObserveProbe => { + pending_foreground_shell_clear = false; + foreground_shell_exit_reported = false; + agent_presence.observe_process_probe(new_agent) + } + }; + if new_agent.is_some() { + last_foreground_pgid = process_group_id.or(foreground_pgid); + acquisition_started_at = None; + last_content_change_at = None; + } else if agent_presence.current_agent().is_none() { + last_foreground_pgid = process_group_id.or(foreground_pgid); if had_process_probe && process_group_changed { acquisition_started_at = Some(now); } } else { - last_foreground_pgid = probe.process_group_id.or(foreground_pgid); - acquisition_started_at = None; - last_content_change_at = None; + last_foreground_pgid = process_group_id.or(foreground_pgid); } - let previous_agent = agent_presence.current_agent(); - if agent_presence.observe_process_probe(new_agent) { + if changed { agent = agent_presence.current_agent(); agent_changed = previous_agent != agent; if agent_changed { - last_screen_working_at = None; + if agent.is_some() { + agent_startup_grace_until = Some(now + AGENT_STARTUP_GRACE_WINDOW); + baseline_pty_causality( + &mut pty_causality, + pty_render_seq.load(Ordering::Relaxed), + input_write_seq.load(Ordering::Relaxed), + ); + state = AgentState::Idle; + last_visible_blocker = false; + last_visible_working = false; + last_visible_signal_refresh = None; + publish_state_changed_event( + state_events.clone(), + pane_id, + agent, + AgentState::Idle, + false, + false, + false, + now, + ) + .await; + } else { + agent_startup_grace_until = None; + } + } + } + } + + let process_exited = pending_foreground_shell_clear + && agent.is_some() + && !foreground_shell_exit_reported; + + if let Some(until) = agent_startup_grace_until { + if process_exited { + agent_startup_grace_until = None; + } else { + if now < until { + continue; } + baseline_pty_causality( + &mut pty_causality, + pty_render_seq.load(Ordering::Relaxed), + input_write_seq.load(Ordering::Relaxed), + ); + agent_startup_grace_until = None; + continue; } } - let Some(detection) = detection_update_for_publish(agent, &content, false) else { + let content = terminal.detection_text(); + let content_changed = content != last_detection_text; + last_detection_text.clone_from(&content); + if !process_exited && crate::detect::should_skip_state_update(agent, &content) { continue; - }; - let new_state = crate::terminal::state::stabilize_agent_detection( - agent, - state, - detection, - false, + } + sync_content_change_acquisition( + agent_presence.current_agent(), + suppressed_agent, + process_group_changed, + content_changed, now, - &mut last_screen_working_at, + &mut acquisition_started_at, + &mut last_content_change_at, ); + + let Some(screen_detection) = + detection_update_for_publish(agent, &content, process_exited) + else { + continue; + }; + let pty_signal = if agent.is_some() { + let signal = agent_caused_pty_activity_active( + pty_render_seq.load(Ordering::Relaxed), + input_write_seq.load(Ordering::Relaxed), + &mut pty_causality, + now, + ); + Some(crate::agent_detection_policy::PtySignal { + active: signal.active, + tainted: signal.tainted, + }) + } else { + None + }; + let detection = match crate::agent_detection_policy::apply_detection_policy( + crate::agent_detection_policy::DetectionPolicyInput { + agent, + screen_detection, + process_exited, + startup_grace_active: false, + pty_signal, + }, + ) { + crate::agent_detection_policy::DetectionPolicyDecision::Publish(detection) => { + detection + } + crate::agent_detection_policy::DetectionPolicyDecision::Freeze => { + continue; + } + }; + let new_state = crate::terminal::state::stabilize_agent_detection(detection); let visible_blocker = detection.visible_blocker && new_state == AgentState::Blocked; - let visible_idle = detection.visible_idle && new_state == AgentState::Idle; let visible_working = detection.visible_working && new_state == AgentState::Working; let previous_publish = DetectionPublishState { state, visible_blocker: last_visible_blocker, - visible_idle: last_visible_idle, visible_working: last_visible_working, }; let next_publish = DetectionPublishState { state: new_state, visible_blocker, - visible_idle, visible_working, }; let stable_refresh_due = stable_visible_signal_refresh_due( @@ -562,14 +709,13 @@ fn spawn_basic_detection_task( previous_publish, next_publish, agent_changed, - false, + process_exited, stable_refresh_due, ) { state = new_state; last_visible_blocker = visible_blocker; - last_visible_idle = visible_idle; last_visible_working = visible_working; - if visible_blocker || visible_idle || visible_working { + if visible_blocker || visible_working { last_visible_signal_refresh = Some(now); } else { last_visible_signal_refresh = None; @@ -580,12 +726,14 @@ fn spawn_basic_detection_task( agent, new_state, visible_blocker, - visible_idle, visible_working, - false, + process_exited, now, ) .await; + if process_exited { + foreground_shell_exit_reported = true; + } } } }); @@ -657,6 +805,7 @@ pub struct PaneRuntime { reported_cwd: Arc<Mutex<Option<std::path::PathBuf>>>, child_wait_completed: Option<Arc<AtomicBool>>, kitty_keyboard_flags: Arc<AtomicU16>, + input_write_seq: Arc<AtomicU64>, detect_reset_notify: Arc<Notify>, pending_release: Arc<Mutex<Option<PendingAgentRelease>>>, preserve_processes_on_drop: bool, @@ -1399,12 +1548,15 @@ impl PaneRuntime { let child_pid = Arc::new(AtomicU32::new(child_pid)); let reported_cwd = Arc::new(Mutex::new(None)); let kitty_keyboard_flags = Arc::new(AtomicU16::new(keyboard_protocol_flags)); + let input_write_seq = Arc::new(AtomicU64::new(0)); + let pty_render_seq = Arc::new(AtomicU64::new(0)); let io = { let terminal = terminal.clone(); let response_writer = response_tx.clone(); let render_notify = render_notify.clone(); let render_dirty = render_dirty.clone(); + let pty_render_seq = pty_render_seq.clone(); let child_pid = child_pid.clone(); let read_events = events.clone(); let reported_cwd = reported_cwd.clone(); @@ -1414,8 +1566,11 @@ impl PaneRuntime { let shell_pid = child_pid.load(Ordering::Acquire); let result = terminal.process_pty_bytes(pane_id, shell_pid, bytes, &response_writer); - if result.request_render && !render_dirty.swap(true, Ordering::AcqRel) { - render_notify.notify_one(); + if result.request_render { + pty_render_seq.fetch_add(1, Ordering::Relaxed); + if !render_dirty.swap(true, Ordering::AcqRel) { + render_notify.notify_one(); + } } if let Some(delay) = result.render_delay { let render_notify = render_notify.clone(); @@ -1457,8 +1612,14 @@ impl PaneRuntime { })?) }; - let (detect_handle, detect_reset_notify, pending_release) = - spawn_basic_detection_task(pane_id, child_pid.clone(), terminal.clone(), events); + let (detect_handle, detect_reset_notify, pending_release) = spawn_basic_detection_task( + pane_id, + child_pid.clone(), + terminal.clone(), + pty_render_seq, + input_write_seq.clone(), + events, + ); Ok(Self { pane_id, @@ -1469,6 +1630,7 @@ impl PaneRuntime { reported_cwd, child_wait_completed: None, kitty_keyboard_flags, + input_write_seq, detect_reset_notify, pending_release, preserve_processes_on_drop: true, @@ -1517,6 +1679,8 @@ impl PaneRuntime { let child_pid = Arc::new(AtomicU32::new(0)); let reported_cwd = Arc::new(Mutex::new(None)); let child_wait_completed = Arc::new(AtomicBool::new(false)); + let input_write_seq = Arc::new(AtomicU64::new(0)); + let pty_render_seq = Arc::new(AtomicU64::new(0)); { let child_pid = child_pid.clone(); let child_wait_completed = child_wait_completed.clone(); @@ -1548,6 +1712,7 @@ impl PaneRuntime { let response_writer = response_tx.clone(); let render_notify = render_notify.clone(); let render_dirty = render_dirty.clone(); + let pty_render_seq = pty_render_seq.clone(); let child_pid = child_pid.clone(); let events = events.clone(); let reported_cwd = reported_cwd.clone(); @@ -1556,8 +1721,11 @@ impl PaneRuntime { let shell_pid = child_pid.load(Ordering::Acquire); let result = terminal.process_pty_bytes(pane_id, shell_pid, bytes, &response_writer); - if result.request_render && !render_dirty.swap(true, Ordering::AcqRel) { - render_notify.notify_one(); + if result.request_render { + pty_render_seq.fetch_add(1, Ordering::Relaxed); + if !render_dirty.swap(true, Ordering::AcqRel) { + render_notify.notify_one(); + } } if let Some(delay) = result.render_delay { let render_notify = render_notify.clone(); @@ -1609,6 +1777,8 @@ impl PaneRuntime { let child_pid = child_pid.clone(); let terminal = terminal.clone(); let state_events = events.clone(); + let pty_render_seq = pty_render_seq.clone(); + let input_write_seq_for_task = input_write_seq.clone(); let render_notify = render_notify.clone(); let render_dirty = render_dirty.clone(); let detect_reset_notify = Arc::new(Notify::new()); @@ -1619,11 +1789,7 @@ impl PaneRuntime { let handle = tokio::spawn(async move { let mut agent_presence = AgentDetectionPresence::from_agent(initial_state.detected_agent); - let mut state = if initial_state.detected_agent.is_some() { - AgentState::Idle - } else { - AgentState::Unknown - }; + let mut state = AgentState::Idle; let mut last_process_check = Instant::now(); let mut last_foreground_pgid = None; let mut has_process_probe = false; @@ -1633,12 +1799,12 @@ impl PaneRuntime { let mut foreground_shell_exit_reported = false; let mut release_was_active = false; let mut pending_restore_probe = initial_state.detected_agent.is_some(); - let mut last_screen_working_at = None; let mut last_visible_blocker = false; - let mut last_visible_idle = false; let mut last_visible_working = false; let mut last_visible_signal_refresh = None; let mut last_detection_text = String::new(); + let mut pty_causality = PtyCausalityTracker::default(); + let mut agent_startup_grace_until = None; tokio::time::sleep(Duration::from_millis(50)).await; @@ -1666,12 +1832,12 @@ impl PaneRuntime { foreground_shell_exit_reported = false; release_was_active = false; pending_restore_probe = false; - last_screen_working_at = None; last_visible_blocker = false; - last_visible_idle = false; last_visible_working = false; last_visible_signal_refresh = None; last_detection_text.clear(); + pty_causality = PtyCausalityTracker::default(); + agent_startup_grace_until = None; } } @@ -1684,26 +1850,11 @@ impl PaneRuntime { } release_was_active = suppressed_agent.is_some(); let pid = child_pid.load(Ordering::Acquire); - let content = terminal.detection_text(); - let content_changed = content != last_detection_text; - last_detection_text.clone_from(&content); - if detect::should_skip_state_update(agent_presence.current_agent(), &content) { - continue; - } let foreground_pgid = (pid > 0) .then(|| detect::foreground_process_group_id(pid)) .flatten(); let process_group_changed = foreground_group_changed(foreground_pgid, last_foreground_pgid); - sync_content_change_acquisition( - agent_presence.current_agent(), - suppressed_agent, - process_group_changed, - content_changed, - now, - &mut acquisition_started_at, - &mut last_content_change_at, - ); let should_check_process = pid > 0 && should_probe_foreground_job(ProcessProbeInput { current_agent: agent_presence.current_agent(), @@ -1780,7 +1931,32 @@ impl PaneRuntime { if changed { agent = agent_presence.current_agent(); if agent != previous_agent { - last_screen_working_at = None; + if agent.is_some() { + agent_startup_grace_until = + Some(now + AGENT_STARTUP_GRACE_WINDOW); + baseline_pty_causality( + &mut pty_causality, + pty_render_seq.load(Ordering::Relaxed), + input_write_seq_for_task.load(Ordering::Relaxed), + ); + state = AgentState::Idle; + last_visible_blocker = false; + last_visible_working = false; + last_visible_signal_refresh = None; + publish_state_changed_event( + state_events.clone(), + pane_id, + agent, + AgentState::Idle, + false, + false, + false, + now, + ) + .await; + } else { + agent_startup_grace_until = None; + } } if let Some(process_name) = process_name { info!( @@ -1817,36 +1993,89 @@ impl PaneRuntime { let process_exited = pending_foreground_shell_clear && agent.is_some() && !foreground_shell_exit_reported; - let Some(detection) = + + if let Some(until) = agent_startup_grace_until { + if process_exited { + agent_startup_grace_until = None; + } else { + if now < until { + continue; + } + baseline_pty_causality( + &mut pty_causality, + pty_render_seq.load(Ordering::Relaxed), + input_write_seq_for_task.load(Ordering::Relaxed), + ); + agent_startup_grace_until = None; + continue; + } + } + + let content = terminal.detection_text(); + let content_changed = content != last_detection_text; + last_detection_text.clone_from(&content); + if detect::should_skip_state_update(agent, &content) { + continue; + } + sync_content_change_acquisition( + agent_presence.current_agent(), + suppressed_agent, + process_group_changed, + content_changed, + now, + &mut acquisition_started_at, + &mut last_content_change_at, + ); + + let Some(screen_detection) = detection_update_for_publish(agent, &content, process_exited) else { continue; }; - let raw_state = detection.state; - let new_state = crate::terminal::state::stabilize_agent_detection( - agent, - state, - detection, - process_exited, - now, - &mut last_screen_working_at, - ); + let pty_signal = if agent.is_some() { + let signal = agent_caused_pty_activity_active( + pty_render_seq.load(Ordering::Relaxed), + input_write_seq_for_task.load(Ordering::Relaxed), + &mut pty_causality, + now, + ); + Some(crate::agent_detection_policy::PtySignal { + active: signal.active, + tainted: signal.tainted, + }) + } else { + None + }; + let detection = match crate::agent_detection_policy::apply_detection_policy( + crate::agent_detection_policy::DetectionPolicyInput { + agent, + screen_detection, + process_exited, + startup_grace_active: false, + pty_signal, + }, + ) { + crate::agent_detection_policy::DetectionPolicyDecision::Publish( + detection, + ) => detection, + crate::agent_detection_policy::DetectionPolicyDecision::Freeze => { + continue; + } + }; + let new_state = crate::terminal::state::stabilize_agent_detection(detection); let visible_blocker = detection.visible_blocker && new_state == AgentState::Blocked; - let visible_idle = detection.visible_idle && new_state == AgentState::Idle; let visible_working = detection.visible_working && new_state == AgentState::Working; let previous_publish = DetectionPublishState { state, visible_blocker: last_visible_blocker, - visible_idle: last_visible_idle, visible_working: last_visible_working, }; let next_publish = DetectionPublishState { state: new_state, visible_blocker, - visible_idle, visible_working, }; let stable_refresh_due = stable_visible_signal_refresh_due( @@ -1863,19 +2092,10 @@ impl PaneRuntime { process_exited, stable_refresh_due, ) { - debug!( - pane = pane_id.raw(), - ?state, - ?raw_state, - ?new_state, - ?agent, - "state changed" - ); state = new_state; last_visible_blocker = visible_blocker; - last_visible_idle = visible_idle; last_visible_working = visible_working; - if visible_blocker || visible_idle || visible_working { + if visible_blocker || visible_working { last_visible_signal_refresh = Some(now); } else { last_visible_signal_refresh = None; @@ -1886,7 +2106,6 @@ impl PaneRuntime { agent, new_state, visible_blocker, - visible_idle, visible_working, process_exited, now, @@ -1910,6 +2129,7 @@ impl PaneRuntime { reported_cwd, child_wait_completed: Some(child_wait_completed), kitty_keyboard_flags, + input_write_seq, detect_reset_notify, pending_release, preserve_processes_on_drop: false, @@ -1940,6 +2160,7 @@ impl PaneRuntime { if self.current_size.get() == size { return; } + self.input_write_seq.fetch_add(1, Ordering::Relaxed); self.current_size.set(size); let terminal_responses = self .terminal @@ -1955,6 +2176,7 @@ impl PaneRuntime { #[cfg(unix)] pub fn nudge_child_redraw_after_handoff(&self) { + self.input_write_seq.fetch_add(1, Ordering::Relaxed); let (rows, cols, cell_width_px, cell_height_px) = self.current_size.get(); self.io .nudge_child_redraw_after_handoff(rows, cols, cell_width_px, cell_height_px); @@ -2081,11 +2303,19 @@ impl PaneRuntime { } pub async fn send_bytes(&self, bytes: Bytes) -> Result<(), mpsc::error::SendError<Bytes>> { - self.io.send_bytes(bytes).await + let result = self.io.send_bytes(bytes).await; + if result.is_ok() { + self.input_write_seq.fetch_add(1, Ordering::Relaxed); + } + result } pub fn try_send_bytes(&self, bytes: Bytes) -> Result<(), mpsc::error::TrySendError<Bytes>> { - self.io.try_send_bytes(bytes) + let result = self.io.try_send_bytes(bytes); + if result.is_ok() { + self.input_write_seq.fetch_add(1, Ordering::Relaxed); + } + result } pub async fn send_paste(&self, text: String) -> Result<(), mpsc::error::SendError<Bytes>> { @@ -2283,6 +2513,7 @@ impl PaneRuntime { reported_cwd: Arc::new(Mutex::new(None)), child_wait_completed: None, kitty_keyboard_flags: Arc::new(AtomicU16::new(0)), + input_write_seq: Arc::new(AtomicU64::new(0)), detect_reset_notify: Arc::new(Notify::new()), pending_release: Arc::new(Mutex::new(None)), preserve_processes_on_drop: true, @@ -2655,6 +2886,7 @@ mod tests { reported_cwd: Arc::new(Mutex::new(None)), child_wait_completed: None, kitty_keyboard_flags: Arc::new(AtomicU16::new(0)), + input_write_seq: Arc::new(AtomicU64::new(0)), detect_reset_notify: Arc::new(Notify::new()), pending_release: Arc::new(Mutex::new(None)), preserve_processes_on_drop: true, @@ -2684,6 +2916,7 @@ mod tests { reported_cwd: Arc::new(Mutex::new(None)), child_wait_completed: None, kitty_keyboard_flags: Arc::new(AtomicU16::new(0)), + input_write_seq: Arc::new(AtomicU64::new(0)), detect_reset_notify: Arc::new(Notify::new()), pending_release: Arc::new(Mutex::new(None)), preserve_processes_on_drop: true, @@ -2744,37 +2977,11 @@ mod tests { } #[test] - fn stable_visible_idle_republishes_for_stale_hook_deadline() { - let now = std::time::Instant::now(); - let previous = DetectionPublishState { - state: AgentState::Idle, - visible_blocker: false, - visible_idle: true, - visible_working: false, - }; - let refresh_due = stable_visible_signal_refresh_due( - previous, - previous, - Some(now - STABLE_VISIBLE_SIGNAL_REFRESH), - now, - ); - - assert!(should_publish_detection_update( - previous, - previous, - false, - false, - refresh_due - )); - } - - #[test] fn stable_plain_idle_does_not_republish() { let now = std::time::Instant::now(); let previous = DetectionPublishState { state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, }; let refresh_due = stable_visible_signal_refresh_due( @@ -2794,12 +3001,11 @@ mod tests { } #[test] - fn stable_visible_working_republishes_for_hook_override_refresh() { + fn stable_visible_working_does_not_republish() { let now = std::time::Instant::now(); let previous = DetectionPublishState { state: AgentState::Working, visible_blocker: false, - visible_idle: false, visible_working: true, }; let refresh_due = stable_visible_signal_refresh_due( @@ -2809,7 +3015,7 @@ mod tests { now, ); - assert!(should_publish_detection_update( + assert!(!should_publish_detection_update( previous, previous, false, @@ -2824,7 +3030,6 @@ mod tests { let previous = DetectionPublishState { state: AgentState::Blocked, visible_blocker: true, - visible_idle: false, visible_working: false, }; let refresh_due = stable_visible_signal_refresh_due( @@ -3220,6 +3425,81 @@ mod tests { assert_eq!(presence.current_agent(), None); } + #[test] + fn pty_activity_outside_taint_reports_active_until_hold_expires() { + let now = std::time::Instant::now(); + let mut tracker = PtyCausalityTracker::default(); + baseline_pty_causality(&mut tracker, 1, 1); + + let active = agent_caused_pty_activity_active(2, 1, &mut tracker, now); + assert!(active.active); + assert!(!active.tainted); + + let held = agent_caused_pty_activity_active( + 2, + 1, + &mut tracker, + now + AGENT_PTY_ACTIVITY_WINDOW - std::time::Duration::from_millis(1), + ); + assert!(held.active); + assert!(!held.tainted); + + let expired = agent_caused_pty_activity_active( + 2, + 1, + &mut tracker, + now + AGENT_PTY_ACTIVITY_WINDOW + std::time::Duration::from_millis(1), + ); + assert!(!expired.active); + assert!(!expired.tainted); + } + + #[test] + fn input_taint_discards_pty_activity_until_fresh_post_taint_render() { + let now = std::time::Instant::now(); + let mut tracker = PtyCausalityTracker::default(); + baseline_pty_causality(&mut tracker, 1, 1); + + let tainted = agent_caused_pty_activity_active(2, 2, &mut tracker, now); + assert!(!tainted.active); + assert!(tainted.tainted); + + let after_taint = agent_caused_pty_activity_active( + 2, + 2, + &mut tracker, + now + AGENT_INPUT_TAINT_WINDOW + std::time::Duration::from_millis(1), + ); + assert!(!after_taint.active); + assert!(!after_taint.tainted); + + let fresh_render = agent_caused_pty_activity_active( + 3, + 2, + &mut tracker, + now + AGENT_INPUT_TAINT_WINDOW + std::time::Duration::from_millis(2), + ); + assert!(fresh_render.active); + assert!(!fresh_render.tainted); + } + + #[test] + fn startup_grace_rebaseline_discards_accumulated_pty_activity() { + let now = std::time::Instant::now(); + let mut tracker = PtyCausalityTracker::default(); + baseline_pty_causality(&mut tracker, 1, 1); + + let startup_render = agent_caused_pty_activity_active(2, 1, &mut tracker, now); + assert!(startup_render.active); + + baseline_pty_causality(&mut tracker, 2, 1); + let after_grace = + agent_caused_pty_activity_active(2, 1, &mut tracker, now + AGENT_STARTUP_GRACE_WINDOW); + + assert!(!after_grace.active); + assert!(!after_grace.tainted); + } + #[tokio::test] async fn state_changed_event_waits_for_queue_space_instead_of_dropping() { let (tx, mut rx) = mpsc::channel(1); @@ -3239,7 +3519,6 @@ mod tests { false, false, false, - false, std::time::Instant::now(), ); tokio::pin!(publish); @@ -3276,7 +3555,6 @@ mod tests { agent: Some(Agent::Pi), state: AgentState::Idle, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: _, diff --git a/src/server/headless.rs b/src/server/headless.rs index edd1a388..806cce4b 100644 --- a/src/server/headless.rs +++ b/src/server/headless.rs @@ -1395,6 +1395,89 @@ impl HeadlessServer { .unwrap_or(crate::detect::AgentState::Unknown) } + fn pane_effective_agent_label(&self, pane_id: crate::layout::PaneId) -> Option<String> { + self.app.state.workspaces.iter().find_map(|ws| { + ws.tabs.iter().find_map(|tab| { + let pane = tab.panes.get(&pane_id)?; + self.app + .state + .terminals + .get(&pane.attached_terminal_id) + .and_then(|terminal| terminal.effective_agent_label()) + .map(str::to_string) + }) + }) + } + + fn forward_pane_state_update_notifications_to_clients( + &mut self, + update: &crate::app::actions::PaneStateUpdate, + ) { + if self.app.state.toast_config.delay_seconds != 0 { + return; + } + + let is_active_tab = self + .app + .state + .pane_is_in_active_tab(update.ws_idx, update.pane_id); + let suppress_active_tab_notifications = + self.active_tab_suppresses_notifications(is_active_tab); + + if self.app.state.sound.allows(update.known_agent) { + if let Some(sound) = + crate::app::actions::notification_sound_for_state_change_with_agent_labels( + suppress_active_tab_notifications, + update.previous_state, + update.state, + update.previous_agent_label.as_deref(), + update.agent_label.as_deref(), + ) + { + self.send_notify_to_foreground_client( + protocol::NotifyKind::Sound, + sound_notify_message(sound), + None, + ); + } + } + + if !should_forward_toast_to_clients(self.app.state.toast_config.delivery) { + return; + } + let Some(kind) = crate::app::actions::notification_toast_for_pane_state_update( + suppress_active_tab_notifications, + update, + ) else { + return; + }; + let Some(ws) = self.app.state.workspaces.get(update.ws_idx) else { + return; + }; + let Some(agent_label) = update.agent_label.as_deref() else { + return; + }; + let event_text = match kind { + crate::app::state::ToastKind::NeedsAttention => "needs attention", + crate::app::state::ToastKind::Finished => "finished", + crate::app::state::ToastKind::UpdateInstalled => "updated", + }; + let workspace_label = + ws.display_name_from(&self.app.state.terminals, &self.app.terminal_runtimes); + let context = crate::app::actions::notification_context( + ws, + &workspace_label, + update.ws_idx, + update.pane_id, + ); + self.send_notify_to_foreground_client( + toast_notify_kind(self.app.state.toast_config.delivery) + .expect("toast forwarding requires a client notification kind"), + format!("{agent_label} {event_text}"), + non_empty_body(&context), + ); + } + fn forward_agent_notification_delivery( &mut self, delivery: &crate::app::state::AgentNotificationDelivery, @@ -1561,6 +1644,7 @@ impl HeadlessServer { // is processed. Notifications must follow effective state changes, // not raw fallback reports that may be masked by hook authority. let prev_state = self.pane_effective_state(pane_id_val); + let prev_agent_label = self.pane_effective_agent_label(pane_id_val); // Handle the state change (updates pane state, sets toast on AppState). // Headless mode disables local sound playback separately from the @@ -1583,15 +1667,20 @@ impl HeadlessServer { self.active_tab_suppresses_notifications(is_active_tab); let next_state = self.pane_effective_state(pane_id_val); + let next_agent_label = self.pane_effective_agent_label(pane_id_val); if self.app.state.toast_config.delay_seconds == 0 && self.app.state.sound.allows(agent_val) { - if let Some(sound) = crate::app::actions::notification_sound_for_state_change( - suppress_active_tab_notifications, - prev_state, - next_state, - ) { + if let Some(sound) = + crate::app::actions::notification_sound_for_state_change_with_agent_labels( + suppress_active_tab_notifications, + prev_state, + next_state, + prev_agent_label.as_deref(), + next_agent_label.as_deref(), + ) + { self.send_notify_to_foreground_client( protocol::NotifyKind::Sound, sound_notify_message(sound), @@ -1617,6 +1706,7 @@ impl HeadlessServer { suppress_active_tab_notifications, prev_state, next_state, + prev_agent_label.as_deref(), ) } } else { @@ -1648,6 +1738,7 @@ impl HeadlessServer { // are already folded into pane.state; raw hook transitions must not // produce a second notification path. let prev_state = self.pane_effective_state(pane_id_val); + let prev_agent_label = self.pane_effective_agent_label(pane_id_val); self.sync_foreground_client_state(); self.app.handle_internal_event(ev); @@ -1668,15 +1759,20 @@ impl HeadlessServer { self.active_tab_suppresses_notifications(is_active_tab); let next_state = self.pane_effective_state(pane_id_val); + let next_agent_label = self.pane_effective_agent_label(pane_id_val); if self.app.state.toast_config.delay_seconds == 0 && self.app.state.sound.allows(agent_val) { - if let Some(sound) = crate::app::actions::notification_sound_for_state_change( - suppress_active_tab_notifications, - prev_state, - next_state, - ) { + if let Some(sound) = + crate::app::actions::notification_sound_for_state_change_with_agent_labels( + suppress_active_tab_notifications, + prev_state, + next_state, + prev_agent_label.as_deref(), + next_agent_label.as_deref(), + ) + { self.send_notify_to_foreground_client( protocol::NotifyKind::Sound, sound_notify_message(sound), @@ -1702,6 +1798,7 @@ impl HeadlessServer { suppress_active_tab_notifications, prev_state, next_state, + prev_agent_label.as_deref(), ) } } else { @@ -1765,6 +1862,14 @@ impl HeadlessServer { .map(|pane| pane.attached_terminal_id.to_string()) }) }); + if let Some(update) = self + .app + .state + .publish_pane_process_exit_if_agent(pane_id_val) + { + self.app.emit_pane_state_update(&update); + self.forward_pane_state_update_notifications_to_clients(&update); + } self.app.handle_internal_event(ev); @@ -2419,7 +2524,12 @@ impl HeadlessServer { // bypasses drain_internal_events_with_forwarding. Headless mode disables // local sound playback, so sound notifications need to be forwarded here. let toast_before = self.app.state.toast.clone(); - let pane_states_before: Vec<(usize, crate::layout::PaneId, crate::detect::AgentState)> = { + let pane_states_before: Vec<( + usize, + crate::layout::PaneId, + crate::detect::AgentState, + Option<String>, + )> = { let terminals = &self.app.state.terminals; self.app .state @@ -2429,9 +2539,14 @@ impl HeadlessServer { .flat_map(|(ws_idx, ws)| { ws.tabs.iter().flat_map(move |tab| { tab.panes.iter().filter_map(move |(&pane_id, pane)| { - terminals - .get(&pane.attached_terminal_id) - .map(|terminal| (ws_idx, pane_id, terminal.state)) + terminals.get(&pane.attached_terminal_id).map(|terminal| { + ( + ws_idx, + pane_id, + terminal.state, + terminal.effective_agent_label().map(str::to_string), + ) + }) }) }) }) @@ -2495,7 +2610,7 @@ impl HeadlessServer { // Forward notifications for effective pane state changes that occurred // during the API request. Hook authority is already folded into // pane.state, so raw hook transitions must not produce separate sounds. - for (ws_idx, pane_id, prev_state) in &pane_states_before { + for (ws_idx, pane_id, prev_state, prev_agent_label) in &pane_states_before { let pane_after = self .app .state @@ -2526,6 +2641,7 @@ impl HeadlessServer { self.active_tab_suppresses_notifications(is_active_tab); let agent = terminal_after.effective_known_agent(); + let agent_label = terminal_after.effective_agent_label().map(str::to_string); debug!( ws_idx, @@ -2540,11 +2656,15 @@ impl HeadlessServer { && self.app.state.toast_config.delay_seconds == 0 && should_forward_toast_to_clients(self.app.state.toast_config.delivery) { - if let Some(kind) = crate::app::actions::notification_toast_for_state_change( - suppress_active_tab_notifications, - *prev_state, - new_state, - ) { + if let Some(kind) = + crate::app::actions::notification_toast_for_state_change_with_agent_labels( + suppress_active_tab_notifications, + *prev_state, + new_state, + prev_agent_label.as_deref(), + agent_label.as_deref(), + ) + { if let Some(agent_label) = self .app .state @@ -2581,11 +2701,15 @@ impl HeadlessServer { // Clients still decide locally whether they can execute the side effect. if self.app.state.toast_config.delay_seconds == 0 && self.app.state.sound.allows(agent) { - if let Some(sound) = crate::app::actions::notification_sound_for_state_change( - suppress_active_tab_notifications, - *prev_state, - new_state, - ) { + if let Some(sound) = + crate::app::actions::notification_sound_for_state_change_with_agent_labels( + suppress_active_tab_notifications, + *prev_state, + new_state, + prev_agent_label.as_deref(), + agent_label.as_deref(), + ) + { debug!(sound = ?sound, "forwarding sound notification from API request"); self.send_notify_to_foreground_client( protocol::NotifyKind::Sound, @@ -7207,7 +7331,6 @@ next_tab = "" agent: Some(crate::detect::Agent::Pi), state: crate::detect::AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: Instant::now(), @@ -7297,7 +7420,6 @@ next_tab = "" agent: Some(crate::detect::Agent::Pi), state: crate::detect::AgentState::Blocked, visible_blocker: false, - visible_idle: false, visible_working: false, process_exited: false, observed_at: Instant::now(), diff --git a/src/server/notifications.rs b/src/server/notifications.rs index 711087f5..ed8fcb6c 100644 --- a/src/server/notifications.rs +++ b/src/server/notifications.rs @@ -25,13 +25,8 @@ pub(crate) fn toast_message_from_state_change( suppress_active_tab_notifications: bool, prev_state: AgentState, new_state: AgentState, + previous_agent_label: Option<&str>, ) -> Option<String> { - let kind = app::actions::notification_toast_for_state_change( - suppress_active_tab_notifications, - prev_state, - new_state, - )?; - state .workspaces .iter() @@ -43,6 +38,13 @@ pub(crate) fn toast_message_from_state_change( .terminals .get(&pane.attached_terminal_id) .and_then(|terminal| terminal.effective_agent_label())?; + let kind = app::actions::notification_toast_for_state_change_with_agent_labels( + suppress_active_tab_notifications, + prev_state, + new_state, + previous_agent_label, + Some(agent_label), + )?; let workspace_label = ws.display_name_from(&state.terminals, terminal_runtimes); Some(format!( "{} {}: {}", @@ -138,6 +140,7 @@ mod tests { false, AgentState::Working, AgentState::Idle, + Some("codex"), ); assert_eq!( diff --git a/src/terminal/metadata.rs b/src/terminal/metadata.rs index 1dcb80c0..2666b32f 100644 --- a/src/terminal/metadata.rs +++ b/src/terminal/metadata.rs @@ -352,7 +352,7 @@ impl TerminalState { fn effective_custom_status_for_state_at_with_ttl( &self, - state: AgentState, + _state: AgentState, now: Instant, enforce_ttl: bool, ) -> Option<String> { @@ -360,10 +360,7 @@ impl TerminalState { return Some(custom_status); } - if self.visible_blocker_overrides_hook() - || self.visible_working_overrides_hook() - || self.visible_idle_masks_hook_custom_status(state, now) - { + if self.visible_blocker_overrides_hook() { return None; } diff --git a/src/terminal/state.rs b/src/terminal/state.rs index eeff4c49..afd94ecf 100644 --- a/src/terminal/state.rs +++ b/src/terminal/state.rs @@ -1,11 +1,12 @@ use std::collections::HashMap; use std::path::PathBuf; -use std::time::{Duration, Instant}; +#[cfg(test)] +use std::time::Duration; +use std::time::Instant; -// Effective state arbitration is intentionally centralized here. Hooks are the -// default authority for agent-owned internal state, but a narrow set of strong -// visible screen signals can veto stale hook reports. Precedence is: -// strong visible blocker > visible working/idle recovery > hook > fallback. +// Effective state arbitration is intentionally centralized here. Full lifecycle +// Herdr hook integrations are hook-authoritative while live; screen recovery +// remains only for session-only/custom hook paths and fallback detection. // Process-exit updates clear matching hook authority before recomputing state. use crate::detect::{Agent, AgentState}; @@ -15,9 +16,6 @@ use crate::terminal::TerminalId; mod metadata; pub use metadata::{AgentMetadata, AgentMetadataReport, EffectivePresentation}; -const SCREEN_WORKING_HOLD: Duration = Duration::from_millis(1200); -const STALE_HOOK_IDLE_GRACE: Duration = Duration::from_secs(2); - #[derive(Debug, Clone, PartialEq, Eq)] pub struct HookAuthority { pub source: String, @@ -30,6 +28,12 @@ pub struct HookAuthority { } #[derive(Debug, Clone, PartialEq, Eq)] +struct SuppressedFullLifecycleHookReport { + agent_label: String, + session_ref: Option<crate::agent_resume::AgentSessionRef>, +} + +#[derive(Debug, Clone, PartialEq, Eq)] pub struct EffectiveStateChange { pub previous_agent_label: Option<String>, pub previous_known_agent: Option<Agent>, @@ -58,16 +62,14 @@ pub struct TerminalState { pub detected_agent: Option<Agent>, pub fallback_state: AgentState, fallback_visible_blocker: bool, - fallback_visible_idle: bool, - fallback_visible_working: bool, fallback_observed_at: Option<Instant>, - stale_hook_idle_since: Option<Instant>, pub hook_authority: Option<HookAuthority>, pub agent_metadata: HashMap<String, AgentMetadata>, pub persisted_agent_session: Option<crate::agent_resume::PersistedAgentSession>, pub manual_label: Option<String>, pub agent_name: Option<String>, hook_report_sequences: HashMap<String, u64>, + suppressed_full_lifecycle_hook_reports: HashMap<String, SuppressedFullLifecycleHookReport>, metadata_report_sequences: HashMap<String, u64>, pub state: AgentState, pub revision: u64, @@ -84,16 +86,14 @@ impl TerminalState { detected_agent: None, fallback_state: AgentState::Unknown, fallback_visible_blocker: false, - fallback_visible_idle: false, - fallback_visible_working: false, fallback_observed_at: None, - stale_hook_idle_since: None, hook_authority: None, agent_metadata: HashMap::new(), persisted_agent_session: None, manual_label: None, agent_name: None, hook_report_sequences: HashMap::new(), + suppressed_full_lifecycle_hook_reports: HashMap::new(), metadata_report_sequences: HashMap::new(), state: AgentState::Unknown, revision: 0, @@ -153,14 +153,14 @@ impl TerminalState { agent: Option<Agent>, fallback_state: AgentState, visible_blocker: bool, - visible_idle: bool, + _ignored_screen_idle: bool, process_exited: bool, ) -> Option<EffectiveStateChange> { self.set_detected_state_with_screen_signals_at( agent, fallback_state, visible_blocker, - visible_idle, + false, false, process_exited, Instant::now(), @@ -173,8 +173,8 @@ impl TerminalState { agent: Option<Agent>, fallback_state: AgentState, visible_blocker: bool, - visible_idle: bool, - visible_working: bool, + _ignored_screen_idle: bool, + _visible_working: bool, process_exited: bool, now: Instant, ) -> TerminalStateMutation { @@ -184,11 +184,36 @@ impl TerminalState { let previous_presentation = self.effective_presentation_for_state_at(previous_state, now); let previous_detected_agent = self.detected_agent; let previous_session = self.current_session_identity_for_persistence(); + if self.should_ignore_detected_state_under_full_lifecycle_hook(agent, process_exited) { + if self + .hook_authority + .as_ref() + .and_then(|authority| crate::detect::parse_agent_label(&authority.agent_label)) + == agent + { + self.detected_agent = agent; + } + return TerminalStateMutation { + effective_state_change: self.recompute_effective_state( + previous_agent_label, + previous_known_agent, + previous_state, + previous_presentation, + now, + ), + session_ref_changed: previous_session + != self.current_session_identity_for_persistence(), + }; + } self.detected_agent = agent; + if !process_exited { + self.clear_full_lifecycle_hook_suppression_for_detected_agent( + previous_detected_agent, + agent, + ); + } self.fallback_state = fallback_state; self.fallback_visible_blocker = visible_blocker && fallback_state == AgentState::Blocked; - self.fallback_visible_idle = visible_idle && fallback_state == AgentState::Idle; - self.fallback_visible_working = visible_working && fallback_state == AgentState::Working; self.fallback_observed_at = Some(now); if process_exited && self.hook_authority_not_newer_than(now) @@ -196,8 +221,8 @@ impl TerminalState { crate::detect::parse_agent_label(&authority.agent_label) == agent }) { + self.suppress_current_full_lifecycle_hook_authority(); self.hook_authority = None; - self.stale_hook_idle_since = None; } if self.hook_authority_not_newer_than(now) && (self.hook_authority_conflicts_with_detected_agent(agent) @@ -208,8 +233,8 @@ impl TerminalState { == previous_detected_agent }))) { + self.suppress_current_full_lifecycle_hook_authority(); self.hook_authority = None; - self.stale_hook_idle_since = None; } let detected_agent_changed_or_disappeared = previous_detected_agent.is_some() && agent != previous_detected_agent; @@ -220,7 +245,6 @@ impl TerminalState { { self.persisted_agent_session = None; } - self.update_stale_hook_idle_window(now); TerminalStateMutation { effective_state_change: self.recompute_effective_state( previous_agent_label, @@ -302,6 +326,9 @@ impl TerminalState { seq: Option<u64>, now: Instant, ) -> Option<TerminalStateMutation> { + if self.full_lifecycle_hook_report_is_suppressed(&source, &agent_label, &session_ref) { + return None; + } if !self.accept_hook_report(&source, seq) { return None; } @@ -318,6 +345,16 @@ impl TerminalState { self.conflicting_current_session_ref(&source, &agent_label, &session_ref) .unwrap_or(session_ref) }); + if self.live_full_lifecycle_hook_authority_conflicts_with_session( + &source, + &agent_label, + &session_ref, + ) { + return None; + } + if session_ref.is_some() { + self.suppressed_full_lifecycle_hook_reports.remove(&source); + } self.persisted_agent_session = None; self.hook_authority = Some(HookAuthority { source, @@ -328,7 +365,6 @@ impl TerminalState { reported_at: now, session_ref, }); - self.stale_hook_idle_since = None; let current_session = self.current_session_identity_for_persistence(); Some(TerminalStateMutation { effective_state_change: self.recompute_effective_state( @@ -365,6 +401,16 @@ impl TerminalState { }) } + fn should_ignore_detected_state_under_full_lifecycle_hook( + &self, + detected_agent: Option<Agent>, + process_exited: bool, + ) -> bool { + self.live_full_lifecycle_hook_authority() + && !process_exited + && !self.hook_authority_conflicts_with_detected_agent(detected_agent) + } + fn persisted_agent_session_conflicts_with_detected_agent( &self, detected_agent: Option<Agent>, @@ -397,6 +443,113 @@ impl TerminalState { .is_some_and(|session| session.source == source && session.agent == agent) } + fn suppress_current_full_lifecycle_hook_authority(&mut self) { + if let Some((source, agent_label)) = self + .hook_authority + .as_ref() + .filter(|authority| { + crate::agent_detection_policy::full_lifecycle_hook_authority( + &authority.source, + &authority.agent_label, + ) + }) + .map(|authority| (authority.source.clone(), authority.agent_label.clone())) + { + let session_ref = self + .hook_authority + .as_ref() + .and_then(|authority| authority.session_ref.clone()); + self.suppressed_full_lifecycle_hook_reports.insert( + source, + SuppressedFullLifecycleHookReport { + agent_label, + session_ref, + }, + ); + } + } + + fn suppress_full_lifecycle_hook_report(&mut self, source: &str, agent_label: &str) { + if crate::agent_detection_policy::full_lifecycle_hook_authority(source, agent_label) { + self.suppressed_full_lifecycle_hook_reports.insert( + source.to_string(), + SuppressedFullLifecycleHookReport { + agent_label: agent_label.to_string(), + session_ref: self + .hook_authority + .as_ref() + .and_then(|authority| authority.session_ref.clone()), + }, + ); + } + } + + fn full_lifecycle_hook_report_is_suppressed( + &self, + source: &str, + agent_label: &str, + session_ref: &Option<crate::agent_resume::AgentSessionRef>, + ) -> bool { + if !crate::agent_detection_policy::full_lifecycle_hook_authority(source, agent_label) { + return false; + } + self.suppressed_full_lifecycle_hook_reports + .get(source) + .is_some_and(|suppressed| { + if suppressed.agent_label != agent_label { + return false; + } + match (&suppressed.session_ref, session_ref) { + (Some(suppressed_ref), Some(incoming_ref)) => incoming_ref == suppressed_ref, + (Some(_), None) => true, + (None, Some(_)) => false, + (None, None) => true, + } + }) + } + + fn live_full_lifecycle_hook_authority_conflicts_with_session( + &self, + source: &str, + agent_label: &str, + session_ref: &Option<crate::agent_resume::AgentSessionRef>, + ) -> bool { + let Some(authority) = self.hook_authority.as_ref() else { + return false; + }; + if !crate::agent_detection_policy::full_lifecycle_hook_authority( + &authority.source, + &authority.agent_label, + ) { + return false; + } + if authority.source != source || authority.agent_label != agent_label { + return false; + } + authority + .session_ref + .as_ref() + .zip(session_ref.as_ref()) + .is_some_and(|(current, incoming)| current != incoming) + } + + fn clear_full_lifecycle_hook_suppression_for_detected_agent( + &mut self, + previous_detected_agent: Option<Agent>, + detected_agent: Option<Agent>, + ) { + let Some(detected_agent) = detected_agent else { + return; + }; + if previous_detected_agent == Some(detected_agent) { + return; + } + self.suppressed_full_lifecycle_hook_reports + .retain(|_, agent_label| { + crate::detect::parse_agent_label(&agent_label.agent_label) != Some(detected_agent) + }); + } + fn current_session_identity_for_persistence( &self, ) -> Option<( @@ -551,8 +704,8 @@ impl TerminalState { if !should_clear { return None; } + self.suppress_current_full_lifecycle_hook_authority(); self.hook_authority = None; - self.stale_hook_idle_since = None; self.persisted_agent_session = None; Some(TerminalStateMutation { effective_state_change: self.recompute_effective_state( @@ -605,14 +758,12 @@ impl TerminalState { let previous_state = self.state; let previous_presentation = self.effective_presentation_for_state_at(previous_state, now); let previous_session = self.current_session_identity_for_persistence(); + self.suppress_full_lifecycle_hook_report(source, agent_label); self.detected_agent = None; self.fallback_state = AgentState::Unknown; self.fallback_visible_blocker = false; - self.fallback_visible_idle = false; - self.fallback_visible_working = false; self.fallback_observed_at = None; self.hook_authority = None; - self.stale_hook_idle_since = None; self.persisted_agent_session = None; Some(TerminalStateMutation { effective_state_change: self.recompute_effective_state( @@ -641,6 +792,9 @@ impl TerminalState { } fn visible_blocker_overrides_hook(&self) -> bool { + if self.live_full_lifecycle_hook_authority() { + return false; + } self.fallback_visible_blocker && self.fallback_not_older_than_hook() && self.hook_authority.as_ref().is_some_and(|authority| { @@ -650,61 +804,13 @@ impl TerminalState { }) } - fn visible_working_overrides_hook(&self) -> bool { - self.fallback_visible_working - && self.visible_working_is_fresh_enough_for_hook() - && self.hook_authority.as_ref().is_some_and(|authority| { - (authority.state == AgentState::Idle || authority.state == AgentState::Blocked) - && crate::detect::parse_agent_label(&authority.agent_label) - == self.detected_agent - }) - } - - fn visible_working_is_fresh_enough_for_hook(&self) -> bool { - self.fallback_not_older_than_hook() - || self - .fallback_observed_at - .zip( - self.hook_authority - .as_ref() - .map(|authority| authority.reported_at), - ) - .is_some_and(|(observed_at, reported_at)| { - reported_at >= observed_at - && reported_at.duration_since(observed_at) < SCREEN_WORKING_HOLD - }) - } - - fn visible_idle_stales_hook(&self, now: Instant) -> bool { - self.stale_hook_idle_since - .is_some_and(|since| now.duration_since(since) >= STALE_HOOK_IDLE_GRACE) - } - - fn visible_idle_masks_hook_custom_status(&self, state: AgentState, now: Instant) -> bool { - self.fallback_visible_idle - && self.fallback_not_older_than_hook() - && self.hook_authority.as_ref().is_some_and(|authority| { - (authority.state == AgentState::Working || authority.state == AgentState::Blocked) - && crate::detect::parse_agent_label(&authority.agent_label) - == self.detected_agent - }) - && (state == AgentState::Idle || self.visible_idle_stales_hook(now)) - } - - fn update_stale_hook_idle_window(&mut self, now: Instant) { - let visible_idle_stales_hook = self.fallback_visible_idle - && self.fallback_not_older_than_hook() - && self.hook_authority.as_ref().is_some_and(|authority| { - (authority.state == AgentState::Working || authority.state == AgentState::Blocked) - && crate::detect::parse_agent_label(&authority.agent_label) - == self.detected_agent - }); - - if visible_idle_stales_hook { - self.stale_hook_idle_since.get_or_insert(now); - } else { - self.stale_hook_idle_since = None; - } + fn live_full_lifecycle_hook_authority(&self) -> bool { + self.hook_authority.as_ref().is_some_and(|authority| { + crate::agent_detection_policy::full_lifecycle_hook_authority( + &authority.source, + &authority.agent_label, + ) + }) } pub fn set_manual_label(&mut self, label: String) { @@ -729,13 +835,11 @@ impl TerminalState { self.detected_agent = None; self.fallback_state = AgentState::Unknown; self.fallback_visible_blocker = false; - self.fallback_visible_idle = false; - self.fallback_visible_working = false; self.fallback_observed_at = None; - self.stale_hook_idle_since = None; self.hook_authority = None; self.persisted_agent_session = None; self.agent_metadata.clear(); + self.suppressed_full_lifecycle_hook_reports.clear(); self.state = AgentState::Unknown; self.launch_argv = None; self.respawn_shell_on_exit = false; @@ -772,10 +876,6 @@ impl TerminalState { ) -> Option<EffectiveStateChange> { let state = if self.visible_blocker_overrides_hook() { AgentState::Blocked - } else if self.visible_working_overrides_hook() { - AgentState::Working - } else if self.visible_idle_stales_hook(now) { - AgentState::Idle } else { self.hook_authority .as_ref() @@ -809,55 +909,8 @@ impl TerminalState { } } -pub(crate) fn stabilize_agent_state( - agent: Option<Agent>, - previous: AgentState, - raw: AgentState, - now: std::time::Instant, - last_screen_working_at: &mut Option<std::time::Instant>, -) -> AgentState { - if !matches!(agent, Some(Agent::Claude | Agent::Droid)) { - return raw; - } - - match raw { - AgentState::Working => { - *last_screen_working_at = Some(now); - AgentState::Working - } - AgentState::Blocked => AgentState::Blocked, - AgentState::Idle if previous == AgentState::Working => { - if last_screen_working_at - .is_some_and(|last_working| now.duration_since(last_working) < SCREEN_WORKING_HOLD) - { - AgentState::Working - } else { - AgentState::Idle - } - } - _ => raw, - } -} - -pub(crate) fn stabilize_agent_detection( - agent: Option<Agent>, - previous: AgentState, - detection: crate::detect::AgentDetection, - process_exited: bool, - now: std::time::Instant, - last_screen_working_at: &mut Option<std::time::Instant>, -) -> AgentState { - if process_exited { - return detection.state; - } - - stabilize_agent_state( - agent, - previous, - detection.state, - now, - last_screen_working_at, - ) +pub(crate) fn stabilize_agent_detection(detection: crate::detect::AgentDetection) -> AgentState { + detection.state } #[cfg(test)] @@ -878,184 +931,367 @@ mod tests { } #[test] - fn claude_working_is_sticky_for_short_gap() { - let now = std::time::Instant::now(); - let mut last_working = None; + fn stabilization_uses_raw_policy_state() { + let detection = AgentDetection { + state: AgentState::Idle, + skip_state_update: false, + visible_blocker: false, + visible_working: false, + }; - let working = stabilize_agent_state( - Some(Agent::Claude), - AgentState::Idle, - AgentState::Working, - now, - &mut last_working, - ); - assert_eq!(working, AgentState::Working); + assert_eq!(stabilize_agent_detection(detection), AgentState::Idle); + } - let still_working = stabilize_agent_state( - Some(Agent::Claude), + #[test] + fn hook_authority_overrides_fallback_for_same_agent() { + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); + terminal.set_hook_authority( + "herdr:pi".into(), + "pi".into(), AgentState::Working, - AgentState::Idle, - now + std::time::Duration::from_millis(400), - &mut last_working, + None, + None, ); - assert_eq!(still_working, AgentState::Working); + + assert_eq!(terminal.detected_agent, Some(Agent::Pi)); + assert_eq!(terminal.fallback_state, AgentState::Idle); + assert_eq!(terminal.effective_agent_label(), Some("pi")); + assert_eq!(terminal.state, AgentState::Working); } #[test] - fn claude_transitions_to_idle_after_hold_expires() { - let now = std::time::Instant::now(); - let mut last_working = Some(now); - - let state = stabilize_agent_state( - Some(Agent::Claude), + fn hook_authority_can_override_with_unknown_agent_label() { + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); + terminal.set_hook_authority( + "herdr:custom".into(), + "custom-agent".into(), AgentState::Working, - AgentState::Idle, - now + SCREEN_WORKING_HOLD + std::time::Duration::from_millis(1), - &mut last_working, + None, + None, ); - assert_eq!(state, AgentState::Idle); + + assert_eq!(terminal.detected_agent, Some(Agent::Pi)); + assert_eq!(terminal.effective_agent_label(), Some("custom-agent")); + assert_eq!(terminal.effective_known_agent(), None); + assert_eq!(terminal.state, AgentState::Working); } #[test] - fn process_exit_idle_bypasses_claude_working_hold() { - let now = std::time::Instant::now(); - let mut last_working = Some(now); - - let state = stabilize_agent_detection( - Some(Agent::Claude), + fn omp_hook_authority_works_without_detected_agent_variant() { + let mut terminal = test_terminal(); + terminal.set_hook_authority( + "herdr:omp".into(), + "omp".into(), AgentState::Working, - AgentDetection { - state: AgentState::Idle, - skip_state_update: false, - visible_blocker: false, - visible_idle: false, - visible_working: false, - }, + None, + None, + ); + + assert_eq!(terminal.detected_agent, None); + assert_eq!(terminal.effective_agent_label(), Some("omp")); + assert_eq!(terminal.effective_known_agent(), None); + assert_eq!(terminal.state, AgentState::Working); + + let change = terminal.set_detected_state_with_visible_blocker( + None, + AgentState::Blocked, true, - now + std::time::Duration::from_millis(100), - &mut last_working, + false, + false, ); - assert_eq!(state, AgentState::Idle); + assert_eq!(terminal.fallback_state, AgentState::Unknown); + assert_eq!(terminal.state, AgentState::Working); + assert!(change.is_none()); } #[test] - fn visible_idle_does_not_bypass_claude_working_hold() { - let now = std::time::Instant::now(); - let mut last_working = Some(now); + fn session_only_report_does_not_create_hook_authority() { + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Codex), AgentState::Idle); - let state = stabilize_agent_detection( - Some(Agent::Claude), + let mutation = terminal.set_agent_session_ref( + "herdr:codex".into(), + "codex".into(), + crate::agent_resume::AgentSessionRef::id("codex-session"), + Some(1), + ); + + assert!(mutation.is_some()); + assert!(terminal.hook_authority.is_none()); + assert_eq!(terminal.state, AgentState::Idle); + + terminal.set_detected_state_with_screen_signals_at( + Some(Agent::Codex), AgentState::Working, - AgentDetection { - state: AgentState::Idle, - skip_state_update: false, - visible_blocker: false, - visible_idle: true, - visible_working: false, - }, false, - now + std::time::Duration::from_millis(100), - &mut last_working, + false, + false, + false, + Instant::now(), ); - assert_eq!(state, AgentState::Working); + assert_eq!(terminal.state, AgentState::Working); } #[test] - fn droid_working_is_sticky_for_short_gap() { - let now = std::time::Instant::now(); - let mut last_working = None; + fn process_exit_clears_matching_full_lifecycle_hook_authority() { + let now = Instant::now(); + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Working); + terminal.set_hook_authority_with_custom_status_at( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + None, + None, + Some(10), + now, + ); - let working = stabilize_agent_state( - Some(Agent::Droid), + let change = terminal.set_detected_state_with_screen_signals_at( + Some(Agent::Pi), AgentState::Idle, + false, + true, + false, + true, + now + Duration::from_millis(1), + ); + + assert!(terminal.hook_authority.is_none()); + assert_eq!(terminal.state, AgentState::Idle); + assert_eq!( + change.effective_state_change.unwrap().previous_state, + AgentState::Working + ); + + let stale = terminal.set_hook_authority_with_custom_status_at( + "herdr:pi".into(), + "pi".into(), AgentState::Working, - now, - &mut last_working, + None, + None, + None, + Some(9), + now + Duration::from_millis(2), ); - assert_eq!(working, AgentState::Working); - let still_working = stabilize_agent_state( - Some(Agent::Droid), + assert!(stale.is_none()); + assert_eq!(terminal.state, AgentState::Idle); + } + + #[test] + fn late_full_lifecycle_hook_after_process_exit_does_not_reacquire_authority() { + let now = Instant::now(); + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Working); + terminal.set_hook_authority_with_custom_status_at( + "herdr:pi".into(), + "pi".into(), AgentState::Working, + None, + None, + None, + Some(20), + now, + ); + + terminal.set_detected_state_with_screen_signals_at( + Some(Agent::Pi), AgentState::Idle, - now + std::time::Duration::from_millis(400), - &mut last_working, + false, + true, + false, + true, + now + Duration::from_millis(1), ); - assert_eq!(still_working, AgentState::Working); + let late = terminal.set_hook_authority_with_custom_status_at( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + Some("late".into()), + None, + Some(21), + now + Duration::from_millis(2), + ); + + assert!(late.is_none()); + assert!(terminal.hook_authority.is_none()); + assert_eq!(terminal.state, AgentState::Idle); } #[test] - fn droid_transitions_to_idle_after_hold_expires() { - let now = std::time::Instant::now(); - let mut last_working = Some(now); - - let state = stabilize_agent_state( - Some(Agent::Droid), + fn late_full_lifecycle_hook_with_same_session_after_process_exit_does_not_reacquire_authority() + { + let now = Instant::now(); + let mut terminal = test_terminal(); + let session_path = test_session_path("pi.jsonl"); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Working); + terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), AgentState::Working, + None, + None, + crate::agent_resume::AgentSessionRef::path(session_path.clone()), + Some(20), + ); + + terminal.set_detected_state_with_screen_signals_at( + Some(Agent::Pi), AgentState::Idle, - now + SCREEN_WORKING_HOLD + std::time::Duration::from_millis(1), - &mut last_working, + false, + true, + false, + true, + now + Duration::from_millis(1), ); - assert_eq!(state, AgentState::Idle); + let late = terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + Some("late".into()), + crate::agent_resume::AgentSessionRef::path(session_path), + Some(21), + ); + + assert!(late.is_none()); + assert!(terminal.hook_authority.is_none()); + assert_eq!(terminal.state, AgentState::Idle); } #[test] - fn process_exit_idle_bypasses_droid_working_hold() { - let now = std::time::Instant::now(); - let mut last_working = Some(now); + fn late_full_lifecycle_hook_after_release_does_not_reacquire_authority() { + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); + terminal.set_hook_authority( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + Some(20), + ); - let state = stabilize_agent_detection( - Some(Agent::Droid), + terminal.release_agent("herdr:pi", "pi", Some(21)); + let late = terminal.set_hook_authority( + "herdr:pi".into(), + "pi".into(), AgentState::Working, - AgentDetection { - state: AgentState::Idle, - skip_state_update: false, - visible_blocker: false, - visible_idle: false, - visible_working: false, - }, - true, - now + std::time::Duration::from_millis(100), - &mut last_working, + None, + Some(22), ); - assert_eq!(state, AgentState::Idle); + assert!(late.is_none()); + assert!(terminal.hook_authority.is_none()); + assert_eq!(terminal.state, AgentState::Unknown); } #[test] - fn droid_blocked_bypasses_working_hold() { - let now = std::time::Instant::now(); - let mut last_working = Some(now); + fn late_full_lifecycle_hook_with_same_session_after_release_does_not_reacquire_authority() { + let mut terminal = test_terminal(); + let session_path = test_session_path("pi.jsonl"); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); + terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + None, + crate::agent_resume::AgentSessionRef::path(session_path.clone()), + Some(20), + ); - let state = stabilize_agent_state( - Some(Agent::Droid), + terminal.release_agent("herdr:pi", "pi", Some(21)); + let late = terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), AgentState::Working, - AgentState::Blocked, - now + std::time::Duration::from_millis(100), - &mut last_working, + None, + None, + crate::agent_resume::AgentSessionRef::path(session_path), + Some(22), ); - assert_eq!(state, AgentState::Blocked); + + assert!(late.is_none()); + assert!(terminal.hook_authority.is_none()); + assert_eq!(terminal.state, AgentState::Unknown); } #[test] - fn codex_states_are_unchanged_by_screen_working_hold() { - let now = std::time::Instant::now(); - let mut last_working = None; + fn changed_session_ref_allows_full_lifecycle_hook_after_suppression() { + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); + terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + None, + crate::agent_resume::AgentSessionRef::path(test_session_path("old.jsonl")), + Some(20), + ); + terminal.release_agent("herdr:pi", "pi", Some(21)); - let state = stabilize_agent_state( - Some(Agent::Codex), + let fresh = terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), AgentState::Working, + None, + None, + crate::agent_resume::AgentSessionRef::path(test_session_path("new.jsonl")), + Some(22), + ); + + assert!(fresh.is_some()); + assert!(terminal.hook_authority.is_some()); + assert_eq!(terminal.state, AgentState::Working); + } + + #[test] + fn live_full_lifecycle_hook_rejects_different_session_ref_for_same_source() { + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); + terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + None, + crate::agent_resume::AgentSessionRef::path(test_session_path("one.jsonl")), + Some(20), + ); + + let mutation = terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), AgentState::Idle, - now, - &mut last_working, + None, + None, + crate::agent_resume::AgentSessionRef::path(test_session_path("two.jsonl")), + Some(21), + ); + + assert!(mutation.is_none()); + assert_eq!(terminal.state, AgentState::Working); + assert_eq!( + terminal + .hook_authority + .as_ref() + .and_then(|authority| authority.session_ref.as_ref()) + .map(|session_ref| session_ref.value.as_str()), + Some(test_session_path("one.jsonl").as_str()) ); - assert_eq!(state, AgentState::Idle); } #[test] - fn hook_authority_overrides_fallback_for_same_agent() { + fn fresh_detected_process_allows_full_lifecycle_hook_after_suppression() { + let now = Instant::now(); let mut terminal = test_terminal(); terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); terminal.set_hook_authority( @@ -1063,30 +1299,57 @@ mod tests { "pi".into(), AgentState::Working, None, + Some(20), + ); + terminal.release_agent("herdr:pi", "pi", Some(21)); + + terminal.set_detected_state_with_screen_signals_at( + Some(Agent::Pi), + AgentState::Unknown, + false, + false, + false, + false, + now, + ); + let fresh = terminal.set_hook_authority( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, None, + Some(22), ); - assert_eq!(terminal.detected_agent, Some(Agent::Pi)); - assert_eq!(terminal.fallback_state, AgentState::Idle); - assert_eq!(terminal.effective_agent_label(), Some("pi")); + assert!(fresh.is_some()); + assert!(terminal.hook_authority.is_some()); assert_eq!(terminal.state, AgentState::Working); } #[test] - fn hook_authority_can_override_with_unknown_agent_label() { + fn fresh_session_ref_allows_full_lifecycle_hook_after_suppression() { let mut terminal = test_terminal(); terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); terminal.set_hook_authority( - "herdr:custom".into(), - "custom-agent".into(), + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + Some(20), + ); + terminal.release_agent("herdr:pi", "pi", Some(21)); + + let fresh = terminal.set_hook_authority_with_session_ref( + "herdr:pi".into(), + "pi".into(), AgentState::Working, None, None, + crate::agent_resume::AgentSessionRef::id("fresh-session"), + Some(22), ); - assert_eq!(terminal.detected_agent, Some(Agent::Pi)); - assert_eq!(terminal.effective_agent_label(), Some("custom-agent")); - assert_eq!(terminal.effective_known_agent(), None); + assert!(fresh.is_some()); + assert!(terminal.hook_authority.is_some()); assert_eq!(terminal.state, AgentState::Working); } @@ -1116,6 +1379,31 @@ mod tests { } #[test] + fn visible_blocker_does_not_override_full_lifecycle_hook_authority() { + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); + terminal.set_hook_authority( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + None, + ); + + let change = terminal.set_detected_state_with_visible_blocker( + Some(Agent::Pi), + AgentState::Blocked, + true, + false, + false, + ); + + assert_eq!(terminal.fallback_state, AgentState::Idle); + assert_eq!(terminal.state, AgentState::Working); + assert!(change.is_none()); + } + + #[test] fn weak_blocked_fallback_does_not_override_hook_authority() { let mut terminal = test_terminal(); terminal.set_detected_state(Some(Agent::Codex), AgentState::Idle); @@ -1214,18 +1502,10 @@ mod tests { } #[test] - fn visible_idle_waits_before_overriding_claude_hook_working() { + fn fallback_idle_does_not_override_hook_working() { let now = Instant::now(); let mut terminal = test_terminal(); - terminal.set_detected_state_with_screen_signals_at( - Some(Agent::Claude), - AgentState::Working, - false, - false, - true, - false, - now, - ); + terminal.set_detected_state(Some(Agent::Claude), AgentState::Working); terminal.set_hook_authority_with_custom_status_at( "herdr:claude".into(), "claude".into(), @@ -1237,50 +1517,32 @@ mod tests { now, ); - let waiting = terminal.set_detected_state_with_screen_signals_at( + terminal.set_detected_state_with_screen_signals_at( Some(Agent::Claude), AgentState::Idle, false, true, false, false, - now + Duration::from_millis(500), + now + Duration::from_secs(10), ); - assert!(waiting.effective_state_change.is_none()); assert_eq!(terminal.fallback_state, AgentState::Idle); assert_eq!(terminal.state, AgentState::Working); assert_eq!( terminal.effective_custom_status().as_deref(), Some("thinking") ); - - let change = terminal.set_detected_state_with_screen_signals_at( - Some(Agent::Claude), - AgentState::Idle, - false, - true, - false, - false, - now + Duration::from_millis(500) + STALE_HOOK_IDLE_GRACE + Duration::from_millis(1), - ); - - assert_eq!(terminal.state, AgentState::Idle); - assert_eq!(terminal.effective_custom_status(), None); - assert_eq!( - change.effective_state_change.unwrap().previous_state, - AgentState::Working - ); } #[test] - fn fresh_hook_working_resets_visible_idle_stale_window() { + fn fallback_idle_does_not_override_full_lifecycle_hook_working() { let now = Instant::now(); let mut terminal = test_terminal(); - terminal.set_detected_state(Some(Agent::Claude), AgentState::Working); + terminal.set_detected_state(Some(Agent::Kimi), AgentState::Working); terminal.set_hook_authority_with_custom_status_at( - "herdr:claude".into(), - "claude".into(), + "herdr:kimi".into(), + "kimi".into(), AgentState::Working, None, Some("thinking".into()), @@ -1289,47 +1551,62 @@ mod tests { now, ); terminal.set_detected_state_with_screen_signals_at( - Some(Agent::Claude), + Some(Agent::Kimi), AgentState::Idle, false, true, false, false, - now + Duration::from_millis(500), + now + Duration::from_secs(10), + ); + + assert_eq!(terminal.fallback_state, AgentState::Working); + assert_eq!(terminal.state, AgentState::Working); + assert_eq!( + terminal.effective_custom_status().as_deref(), + Some("thinking") ); + } + #[test] + fn visible_working_does_not_override_hook_idle_for_same_agent() { + let now = Instant::now(); + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Claude), AgentState::Idle); terminal.set_hook_authority_with_custom_status_at( "herdr:claude".into(), "claude".into(), - AgentState::Working, + AgentState::Idle, None, - Some("thinking".into()), None, - Some(1), - now + Duration::from_millis(800), + None, + None, + now, ); + let change = terminal.set_detected_state_with_screen_signals_at( Some(Agent::Claude), - AgentState::Idle, + AgentState::Working, false, - true, false, + true, false, - now + STALE_HOOK_IDLE_GRACE + Duration::from_millis(1), + now + Duration::from_millis(1), ); + assert_eq!(terminal.fallback_state, AgentState::Working); + assert_eq!(terminal.state, AgentState::Idle); assert!(change.effective_state_change.is_none()); - assert_eq!(terminal.state, AgentState::Working); } #[test] - fn visible_working_overrides_hook_idle_for_same_agent() { + fn visible_working_does_not_override_full_lifecycle_hook_idle() { let now = Instant::now(); let mut terminal = test_terminal(); - terminal.set_detected_state(Some(Agent::Claude), AgentState::Idle); + terminal.set_detected_state(Some(Agent::Hermes), AgentState::Idle); terminal.set_hook_authority_with_custom_status_at( - "herdr:claude".into(), - "claude".into(), + "herdr:hermes".into(), + "hermes".into(), AgentState::Idle, None, None, @@ -1339,7 +1616,7 @@ mod tests { ); let change = terminal.set_detected_state_with_screen_signals_at( - Some(Agent::Claude), + Some(Agent::Hermes), AgentState::Working, false, false, @@ -1348,44 +1625,44 @@ mod tests { now + Duration::from_millis(1), ); - assert_eq!(terminal.state, AgentState::Working); - assert_eq!( - change.effective_state_change.unwrap().previous_state, - AgentState::Idle - ); + assert_eq!(terminal.fallback_state, AgentState::Idle); + assert_eq!(terminal.state, AgentState::Idle); + assert!(change.effective_state_change.is_none()); } #[test] - fn recent_visible_working_holds_against_newer_claude_hook_idle() { + fn pty_working_fallback_is_ignored_under_full_lifecycle_hook_authority() { let now = Instant::now(); let mut terminal = test_terminal(); - terminal.set_detected_state_with_screen_signals_at( - Some(Agent::Claude), - AgentState::Working, - false, - false, - true, - false, - now, - ); - - let change = terminal.set_hook_authority_with_custom_status_at( - "herdr:claude".into(), - "claude".into(), + terminal.set_detected_state(Some(Agent::Qodercli), AgentState::Idle); + terminal.set_hook_authority_with_custom_status_at( + "herdr:qodercli".into(), + "qodercli".into(), AgentState::Idle, None, None, None, None, - now + Duration::from_millis(100), + now, ); - assert!(change.unwrap().effective_state_change.is_none()); - assert_eq!(terminal.state, AgentState::Working); + let change = terminal.set_detected_state_with_screen_signals_at( + Some(Agent::Qodercli), + AgentState::Working, + false, + false, + false, + false, + now + Duration::from_millis(1), + ); + + assert_eq!(terminal.fallback_state, AgentState::Idle); + assert_eq!(terminal.state, AgentState::Idle); + assert!(change.effective_state_change.is_none()); } #[test] - fn old_visible_working_does_not_hold_against_newer_claude_hook_idle() { + fn visible_working_does_not_hold_against_newer_claude_hook_idle() { let now = Instant::now(); let mut terminal = test_terminal(); terminal.set_detected_state_with_screen_signals_at( @@ -1406,7 +1683,7 @@ mod tests { None, None, None, - now + SCREEN_WORKING_HOLD + Duration::from_millis(1), + now + Duration::from_millis(100), ); assert_eq!(terminal.state, AgentState::Idle); @@ -1421,7 +1698,7 @@ mod tests { } #[test] - fn refreshed_visible_working_overrides_newer_hook_blocked() { + fn refreshed_visible_working_does_not_override_newer_hook_blocked() { let now = Instant::now(); let mut terminal = test_terminal(); terminal.set_detected_state_with_screen_signals_at( @@ -1441,7 +1718,7 @@ mod tests { Some("permission".into()), None, None, - now + SCREEN_WORKING_HOLD + Duration::from_millis(1), + now + Duration::from_millis(1201), ); assert_eq!(terminal.state, AgentState::Blocked); @@ -1453,71 +1730,20 @@ mod tests { false, true, false, - now + SCREEN_WORKING_HOLD + Duration::from_millis(800), - ); - - assert_eq!(terminal.state, AgentState::Working); - assert_eq!(terminal.effective_custom_status(), None); - assert_eq!( - change.effective_state_change.unwrap().previous_state, - AgentState::Blocked - ); - } - - #[test] - fn visible_idle_waits_before_overriding_claude_hook_blocked() { - let now = Instant::now(); - let mut terminal = test_terminal(); - terminal.set_detected_state(Some(Agent::Claude), AgentState::Working); - terminal.set_hook_authority_with_custom_status_at( - "herdr:claude".into(), - "claude".into(), - AgentState::Blocked, - None, - Some("permission".into()), - None, - None, - now, - ); - - let waiting = terminal.set_detected_state_with_screen_signals_at( - Some(Agent::Claude), - AgentState::Idle, - false, - true, - false, - false, - now + Duration::from_millis(500), + now + Duration::from_millis(2000), ); - assert!(waiting.effective_state_change.is_none()); - assert_eq!(terminal.fallback_state, AgentState::Idle); + assert_eq!(terminal.fallback_state, AgentState::Working); assert_eq!(terminal.state, AgentState::Blocked); assert_eq!( terminal.effective_custom_status().as_deref(), Some("permission") ); - - let change = terminal.set_detected_state_with_screen_signals_at( - Some(Agent::Claude), - AgentState::Idle, - false, - true, - false, - false, - now + Duration::from_millis(500) + STALE_HOOK_IDLE_GRACE + Duration::from_millis(1), - ); - - assert_eq!(terminal.state, AgentState::Idle); - assert_eq!(terminal.effective_custom_status(), None); - assert_eq!( - change.effective_state_change.unwrap().previous_state, - AgentState::Blocked - ); + assert!(change.effective_state_change.is_none()); } #[test] - fn visible_idle_does_not_override_other_agent_hook_working() { + fn fallback_idle_does_not_override_other_agent_hook_working() { let mut terminal = test_terminal(); terminal.set_detected_state(Some(Agent::Codex), AgentState::Working); terminal.set_hook_authority( @@ -1620,6 +1846,39 @@ mod tests { } #[test] + fn full_lifecycle_hook_authority_ignores_detected_agent_clear_without_process_exit() { + let now = Instant::now(); + let mut terminal = test_terminal(); + terminal.set_detected_state(Some(Agent::Pi), AgentState::Idle); + terminal.set_hook_authority_with_custom_status_at( + "herdr:pi".into(), + "pi".into(), + AgentState::Working, + None, + None, + None, + None, + now, + ); + + let change = terminal.set_detected_state_with_screen_signals_at( + None, + AgentState::Unknown, + false, + false, + false, + false, + now + Duration::from_millis(1), + ); + + assert!(terminal.hook_authority.is_some()); + assert_eq!(terminal.detected_agent, Some(Agent::Pi)); + assert_eq!(terminal.fallback_state, AgentState::Idle); + assert_eq!(terminal.state, AgentState::Working); + assert!(change.effective_state_change.is_none()); + } + + #[test] fn detected_agent_clear_clears_matching_hook_authority() { let mut terminal = test_terminal(); terminal.set_detected_state(Some(Agent::OpenCode), AgentState::Idle); @@ -1721,7 +1980,6 @@ mod tests { ); assert_eq!(terminal.state, AgentState::Working); - assert!(terminal.stale_hook_idle_since.is_none()); } #[test] @@ -2202,7 +2460,7 @@ mod tests { } #[test] - fn detected_agent_disappearance_clears_matching_hook_session_ref() { + fn detected_agent_disappearance_does_not_clear_full_lifecycle_hook_session_ref() { let mut terminal = test_terminal(); terminal.set_detected_state(Some(Agent::Hermes), AgentState::Idle); terminal.set_hook_authority_with_session_ref( @@ -2217,10 +2475,10 @@ mod tests { let mutation = terminal.set_detected_state_with_mutation(None, AgentState::Unknown); - assert!(mutation.session_ref_changed); - assert!(terminal.hook_authority.is_none()); + assert!(!mutation.session_ref_changed); + assert!(terminal.hook_authority.is_some()); assert!(terminal.persisted_agent_session.is_none()); - assert_eq!(terminal.effective_agent_label(), None); + assert_eq!(terminal.effective_agent_label(), Some("hermes")); } #[test] |