The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat: add ecc2 desktop notifications
Affaan Mustafaa4d0a4fc14b5
diff --git a/ecc2/src/config/mod.rs b/ecc2/src/config/mod.rsindex 165d83632..8259207e6 100644--- a/ecc2/src/config/mod.rs+++ b/ecc2/src/config/mod.rs@@ -3,6 +3,8 @@ use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};use serde::{Deserialize, Serialize};use std::path::PathBuf;+use crate::notifications::DesktopNotificationConfig;+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "snake_case")]pub enum PaneLayout {@@ -45,6 +47,7 @@ pub struct Config {pub auto_dispatch_limit_per_session: usize,pub auto_create_worktrees: bool,pub auto_merge_ready_worktrees: bool,+ pub desktop_notifications: DesktopNotificationConfig,pub cost_budget_usd: f64,pub token_budget: u64,pub budget_alert_thresholds: BudgetAlertThresholds,@@ -107,6 +110,7 @@ impl Default for Config {auto_dispatch_limit_per_session: 5,auto_create_worktrees: true,auto_merge_ready_worktrees: false,+ desktop_notifications: DesktopNotificationConfig::default(),cost_budget_usd: 10.0,token_budget: 500_000,budget_alert_thresholds: Self::BUDGET_ALERT_THRESHOLDS,@@ -431,6 +435,7 @@ theme = "Dark"config.auto_merge_ready_worktrees,defaults.auto_merge_ready_worktrees);+ assert_eq!(config.desktop_notifications, defaults.desktop_notifications);assert_eq!(config.auto_terminate_stale_sessions,defaults.auto_terminate_stale_sessions@@ -582,6 +587,35 @@ critical = 0.85);}+ #[test]+ fn desktop_notifications_deserialize_from_toml() {+ let config: Config = toml::from_str(+ r#"+[desktop_notifications]+enabled = true+session_completed = false+session_failed = true+budget_alerts = true+approval_requests = false++[desktop_notifications.quiet_hours]+enabled = true+start_hour = 21+end_hour = 7+"#,+ )+ .unwrap();++ assert!(config.desktop_notifications.enabled);+ assert!(!config.desktop_notifications.session_completed);+ assert!(config.desktop_notifications.session_failed);+ assert!(config.desktop_notifications.budget_alerts);+ assert!(!config.desktop_notifications.approval_requests);+ assert!(config.desktop_notifications.quiet_hours.enabled);+ assert_eq!(config.desktop_notifications.quiet_hours.start_hour, 21);+ assert_eq!(config.desktop_notifications.quiet_hours.end_hour, 7);+ }+#[test]fn invalid_budget_alert_thresholds_fall_back_to_defaults() {let config: Config = toml::from_str(@@ -608,6 +642,10 @@ critical = 1.10config.auto_dispatch_limit_per_session = 9;config.auto_create_worktrees = false;config.auto_merge_ready_worktrees = true;+ config.desktop_notifications.session_completed = false;+ config.desktop_notifications.quiet_hours.enabled = true;+ config.desktop_notifications.quiet_hours.start_hour = 21;+ config.desktop_notifications.quiet_hours.end_hour = 7;config.worktree_branch_prefix = "bots/ecc".to_string();config.budget_alert_thresholds = BudgetAlertThresholds {advisory: 0.45,@@ -627,6 +665,10 @@ critical = 1.10assert_eq!(loaded.auto_dispatch_limit_per_session, 9);assert!(!loaded.auto_create_worktrees);assert!(loaded.auto_merge_ready_worktrees);+ assert!(!loaded.desktop_notifications.session_completed);+ assert!(loaded.desktop_notifications.quiet_hours.enabled);+ assert_eq!(loaded.desktop_notifications.quiet_hours.start_hour, 21);+ assert_eq!(loaded.desktop_notifications.quiet_hours.end_hour, 7);assert_eq!(loaded.worktree_branch_prefix, "bots/ecc");assert_eq!(loaded.budget_alert_thresholds,diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex 0147942fa..0f0433829 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -1,5 +1,6 @@mod comms;mod config;+mod notifications;mod observability;mod session;mod tui;diff --git a/ecc2/src/notifications.rs b/ecc2/src/notifications.rsnew file mode 100644index 000000000..c4c707110--- /dev/null+++ b/ecc2/src/notifications.rs@@ -0,0 +1,289 @@+use anyhow::Result;+use chrono::{DateTime, Local, Timelike};+use serde::{Deserialize, Serialize};++#[cfg(not(test))]+use anyhow::Context;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum NotificationEvent {+ SessionCompleted,+ SessionFailed,+ BudgetAlert,+ ApprovalRequest,+}++#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+#[serde(default)]+pub struct QuietHoursConfig {+ pub enabled: bool,+ pub start_hour: u8,+ pub end_hour: u8,+}++#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+#[serde(default)]+pub struct DesktopNotificationConfig {+ pub enabled: bool,+ pub session_completed: bool,+ pub session_failed: bool,+ pub budget_alerts: bool,+ pub approval_requests: bool,+ pub quiet_hours: QuietHoursConfig,+}++#[derive(Debug, Clone)]+pub struct DesktopNotifier {+ config: DesktopNotificationConfig,+}++impl Default for QuietHoursConfig {+ fn default() -> Self {+ Self {+ enabled: false,+ start_hour: 22,+ end_hour: 8,+ }+ }+}++impl QuietHoursConfig {+ pub fn sanitized(self) -> Self {+ let valid = self.start_hour <= 23 && self.end_hour <= 23;+ if valid {+ self+ } else {+ Self::default()+ }+ }++ pub fn is_active(&self, now: DateTime<Local>) -> bool {+ if !self.enabled {+ return false;+ }++ let quiet = self.clone().sanitized();+ if quiet.start_hour == quiet.end_hour {+ return false;+ }++ let hour = now.hour() as u8;+ if quiet.start_hour < quiet.end_hour {+ hour >= quiet.start_hour && hour < quiet.end_hour+ } else {+ hour >= quiet.start_hour || hour < quiet.end_hour+ }+ }+}++impl Default for DesktopNotificationConfig {+ fn default() -> Self {+ Self {+ enabled: true,+ session_completed: true,+ session_failed: true,+ budget_alerts: true,+ approval_requests: true,+ quiet_hours: QuietHoursConfig::default(),+ }+ }+}++impl DesktopNotificationConfig {+ pub fn sanitized(self) -> Self {+ Self {+ quiet_hours: self.quiet_hours.sanitized(),+ ..self+ }+ }++ pub fn allows(&self, event: NotificationEvent, now: DateTime<Local>) -> bool {+ let config = self.clone().sanitized();+ if !config.enabled || config.quiet_hours.is_active(now) {+ return false;+ }++ match event {+ NotificationEvent::SessionCompleted => config.session_completed,+ NotificationEvent::SessionFailed => config.session_failed,+ NotificationEvent::BudgetAlert => config.budget_alerts,+ NotificationEvent::ApprovalRequest => config.approval_requests,+ }+ }+}++impl DesktopNotifier {+ pub fn new(config: DesktopNotificationConfig) -> Self {+ Self {+ config: config.sanitized(),+ }+ }++ pub fn notify(&self, event: NotificationEvent, title: &str, body: &str) -> bool {+ match self.try_notify(event, title, body, Local::now()) {+ Ok(sent) => sent,+ Err(error) => {+ tracing::warn!("Failed to send desktop notification: {error}");+ false+ }+ }+ }++ fn try_notify(+ &self,+ event: NotificationEvent,+ title: &str,+ body: &str,+ now: DateTime<Local>,+ ) -> Result<bool> {+ if !self.config.allows(event, now) {+ return Ok(false);+ }++ let Some((program, args)) = notification_command(std::env::consts::OS, title, body) else {+ return Ok(false);+ };++ run_notification_command(&program, &args)?;+ Ok(true)+ }+}++fn notification_command(platform: &str, title: &str, body: &str) -> Option<(String, Vec<String>)> {+ match platform {+ "macos" => Some((+ "osascript".to_string(),+ vec![+ "-e".to_string(),+ format!(+ "display notification \"{}\" with title \"{}\"",+ sanitize_osascript(body),+ sanitize_osascript(title)+ ),+ ],+ )),+ "linux" => Some((+ "notify-send".to_string(),+ vec![+ "--app-name".to_string(),+ "ECC 2.0".to_string(),+ title.trim().to_string(),+ body.trim().to_string(),+ ],+ )),+ _ => None,+ }+}++#[cfg(not(test))]+fn run_notification_command(program: &str, args: &[String]) -> Result<()> {+ let status = std::process::Command::new(program)+ .args(args)+ .status()+ .with_context(|| format!("launch {program}"))?;++ if status.success() {+ Ok(())+ } else {+ anyhow::bail!("{program} exited with {status}");+ }+}++#[cfg(test)]+fn run_notification_command(_program: &str, _args: &[String]) -> Result<()> {+ Ok(())+}++fn sanitize_osascript(value: &str) -> String {+ value+ .replace('\\', "")+ .replace('"', "\u{201C}")+ .replace('\n', " ")+}++#[cfg(test)]+mod tests {+ use super::{+ notification_command, DesktopNotificationConfig, DesktopNotifier, NotificationEvent,+ QuietHoursConfig,+ };+ use chrono::{Local, TimeZone};++ #[test]+ fn quiet_hours_support_cross_midnight_ranges() {+ let quiet_hours = QuietHoursConfig {+ enabled: true,+ start_hour: 22,+ end_hour: 8,+ };++ assert!(quiet_hours.is_active(Local.with_ymd_and_hms(2026, 4, 9, 23, 0, 0).unwrap()));+ assert!(quiet_hours.is_active(Local.with_ymd_and_hms(2026, 4, 9, 7, 0, 0).unwrap()));+ assert!(!quiet_hours.is_active(Local.with_ymd_and_hms(2026, 4, 9, 14, 0, 0).unwrap()));+ }++ #[test]+ fn quiet_hours_support_same_day_ranges() {+ let quiet_hours = QuietHoursConfig {+ enabled: true,+ start_hour: 9,+ end_hour: 17,+ };++ assert!(quiet_hours.is_active(Local.with_ymd_and_hms(2026, 4, 9, 10, 0, 0).unwrap()));+ assert!(!quiet_hours.is_active(Local.with_ymd_and_hms(2026, 4, 9, 18, 0, 0).unwrap()));+ }++ #[test]+ fn notification_preferences_respect_event_flags() {+ let mut config = DesktopNotificationConfig::default();+ config.session_completed = false;+ let now = Local.with_ymd_and_hms(2026, 4, 9, 12, 0, 0).unwrap();++ assert!(!config.allows(NotificationEvent::SessionCompleted, now));+ assert!(config.allows(NotificationEvent::BudgetAlert, now));+ }++ #[test]+ fn notifier_skips_delivery_during_quiet_hours() {+ let mut config = DesktopNotificationConfig::default();+ config.quiet_hours = QuietHoursConfig {+ enabled: true,+ start_hour: 22,+ end_hour: 8,+ };+ let notifier = DesktopNotifier::new(config);++ assert!(!notifier+ .try_notify(+ NotificationEvent::ApprovalRequest,+ "ECC 2.0: Approval needed",+ "worker-123 needs review",+ Local.with_ymd_and_hms(2026, 4, 9, 23, 0, 0).unwrap(),+ )+ .unwrap());+ }++ #[test]+ fn macos_notifications_use_osascript() {+ let (program, args) =+ notification_command("macos", "ECC 2.0: Completed", "Task finished").unwrap();++ assert_eq!(program, "osascript");+ assert_eq!(args[0], "-e");+ assert!(args[1].contains("display notification"));+ assert!(args[1].contains("ECC 2.0: Completed"));+ }++ #[test]+ fn linux_notifications_use_notify_send() {+ let (program, args) =+ notification_command("linux", "ECC 2.0: Approval needed", "worker-123").unwrap();++ assert_eq!(program, "notify-send");+ assert_eq!(args[0], "--app-name");+ assert_eq!(args[1], "ECC 2.0");+ assert_eq!(args[2], "ECC 2.0: Approval needed");+ assert_eq!(args[3], "worker-123");+ }+}diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex 907f2f844..c80929d2b 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -219,7 +219,7 @@ pub async fn drain_inbox(use_worktree,&repo_root,&runner_program,- SessionGrouping::default(),+ SessionGrouping::default(),).await?;@@ -2237,6 +2237,7 @@ mod tests {auto_dispatch_limit_per_session: 5,auto_create_worktrees: true,auto_merge_ready_worktrees: false,+ desktop_notifications: crate::notifications::DesktopNotificationConfig::default(),cost_budget_usd: 10.0,token_budget: 500_000,budget_alert_thresholds: Config::BUDGET_ALERT_THRESHOLDS,@@ -3691,7 +3692,7 @@ mod tests {true,&repo_root,&fake_runner,- SessionGrouping::default(),+ SessionGrouping::default(),).await?;@@ -3763,7 +3764,7 @@ mod tests {true,&repo_root,&fake_runner,- SessionGrouping::default(),+ SessionGrouping::default(),).await?;@@ -3819,7 +3820,7 @@ mod tests {true,&repo_root,&fake_runner,- SessionGrouping::default(),+ SessionGrouping::default(),).await?;diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rsindex ab477bd2b..4f68ad2f7 100644--- a/ecc2/src/session/store.rs+++ b/ecc2/src/session/store.rs@@ -1299,6 +1299,35 @@ impl StateStore {messages.collect::<Result<Vec<_>, _>>().map_err(Into::into)}+ pub fn latest_unread_approval_message(&self) -> Result<Option<SessionMessage>> {+ self.conn+ .query_row(+ "SELECT id, from_session, to_session, content, msg_type, read, timestamp+ FROM messages+ WHERE read = 0 AND msg_type IN ('query', 'conflict')+ ORDER BY id DESC+ LIMIT 1",+ [],+ |row| {+ let timestamp: String = row.get(6)?;++ Ok(SessionMessage {+ id: row.get(0)?,+ from_session: row.get(1)?,+ to_session: row.get(2)?,+ content: row.get(3)?,+ msg_type: row.get(4)?,+ read: row.get::<_, i64>(5)? != 0,+ timestamp: chrono::DateTime::parse_from_rfc3339(×tamp)+ .unwrap_or_default()+ .with_timezone(&chrono::Utc),+ })+ },+ )+ .optional()+ .map_err(Into::into)+ }+pub fn unread_task_handoffs_for_session(&self,session_id: &str,diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex f59607b92..60d86ff6d 100644--- a/ecc2/src/tui/dashboard.rs+++ b/ecc2/src/tui/dashboard.rs@@ -14,6 +14,7 @@ use tokio::sync::broadcast;use super::widgets::{budget_state, format_currency, format_token_count, BudgetState, TokenMeter};use crate::comms;use crate::config::{Config, PaneLayout, PaneNavigationAction, Theme};+use crate::notifications::{DesktopNotifier, NotificationEvent};use crate::observability::ToolLogEntry;use crate::session::manager;use crate::session::output::{@@ -56,6 +57,7 @@ pub struct Dashboard {cfg: Config,output_store: SessionOutputStore,output_rx: broadcast::Receiver<OutputEvent>,+ notifier: DesktopNotifier,sessions: Vec<Session>,session_output_cache: HashMap<String, Vec<OutputLine>>,unread_message_counts: HashMap<String, usize>,@@ -114,6 +116,8 @@ pub struct Dashboard {last_cost_metrics_signature: Option<(u64, u128)>,last_tool_activity_signature: Option<(u64, u128)>,last_budget_alert_state: BudgetState,+ last_session_states: HashMap<String, SessionState>,+ last_seen_approval_message_id: Option<i64>,}#[derive(Debug, Default, PartialEq, Eq)]@@ -314,7 +318,17 @@ impl Dashboard {let _ = db.sync_tool_activity_metrics(&cfg.tool_activity_metrics_path());}let sessions = db.list_sessions().unwrap_or_default();+ let initial_session_states = sessions+ .iter()+ .map(|session| (session.id.clone(), session.state.clone()))+ .collect();+ let initial_approval_message_id = db+ .latest_unread_approval_message()+ .ok()+ .flatten()+ .map(|message| message.id);let output_rx = output_store.subscribe();+ let notifier = DesktopNotifier::new(cfg.desktop_notifications.clone());let mut session_table_state = TableState::default();if !sessions.is_empty() {session_table_state.select(Some(0));@@ -325,6 +339,7 @@ impl Dashboard {cfg,output_store,output_rx,+ notifier,sessions,session_output_cache: HashMap::new(),unread_message_counts: HashMap::new(),@@ -383,6 +398,8 @@ impl Dashboard {last_cost_metrics_signature: initial_cost_metrics_signature,last_tool_activity_signature: initial_tool_activity_signature,last_budget_alert_state: BudgetState::Normal,+ last_session_states: initial_session_states,+ last_seen_approval_message_id: initial_approval_message_id,};sort_sessions_for_display(&mut dashboard.sessions);dashboard.unread_message_counts = dashboard.db.unread_message_counts().unwrap_or_default();@@ -746,9 +763,7 @@ impl Dashboard {} else {self.selected_git_status.min(total.saturating_sub(1)) + 1};- return format!(- " Git status staged:{staged} unstaged:{unstaged} {current}/{total} "- );+ return format!(" Git status staged:{staged} unstaged:{unstaged} {current}/{total} ");}let filter = format!(@@ -1930,7 +1945,10 @@ impl Dashboard {if let Err(error) = worktree::unstage_path(&worktree, &entry.path) {tracing::warn!("Failed to unstage {}: {error}", entry.path);- self.set_operator_note(format!("unstage failed for {}: {error}", entry.display_path));+ self.set_operator_note(format!(+ "unstage failed for {}: {error}",+ entry.display_path+ ));return;}@@ -1963,7 +1981,9 @@ impl Dashboard {pub fn begin_commit_prompt(&mut self) {if self.output_mode != OutputMode::GitStatus {- self.set_operator_note("commit prompt is only available in git status view".to_string());+ self.set_operator_note(+ "commit prompt is only available in git status view".to_string(),+ );return;}@@ -1977,7 +1997,11 @@ impl Dashboard {return;}- if !self.selected_git_status_entries.iter().any(|entry| entry.staged) {+ if !self+ .selected_git_status_entries+ .iter()+ .any(|entry| entry.staged)+ {self.set_operator_note("no staged changes to commit".to_string());return;}@@ -2960,10 +2984,15 @@ impl Dashboard {lines.push("## Session Metrics".to_string());lines.push(format!("- Tokens: {} total (in {} / out {})",- session.metrics.tokens_used, session.metrics.input_tokens, session.metrics.output_tokens+ session.metrics.tokens_used,+ session.metrics.input_tokens,+ session.metrics.output_tokens));lines.push(format!("- Tool calls: {}", session.metrics.tool_calls));- lines.push(format!("- Files changed: {}", session.metrics.files_changed));+ lines.push(format!(+ "- Files changed: {}",+ session.metrics.files_changed+ ));lines.push(format!("- Duration: {}",format_duration(session.metrics.duration_secs)@@ -3372,6 +3401,8 @@ impl Dashboard {HashMap::new()}};+ self.sync_session_state_notifications();+ self.sync_approval_notifications();self.sync_handoff_backlog_counts();self.sync_worktree_health_by_session();self.sync_global_handoff_backlog();@@ -3440,6 +3471,91 @@ impl Dashboard {self.set_operator_note(format!("{summary_suffix} | tokens {token_budget} | cost {cost_budget}"));+ self.notify_desktop(+ NotificationEvent::BudgetAlert,+ "ECC 2.0: Budget alert",+ &format!("{summary_suffix} | tokens {token_budget} | cost {cost_budget}"),+ );+ }++ fn sync_session_state_notifications(&mut self) {+ let mut next_states = HashMap::new();++ for session in &self.sessions {+ let previous_state = self.last_session_states.get(&session.id);+ if let Some(previous_state) = previous_state {+ if previous_state != &session.state {+ match session.state {+ SessionState::Completed => {+ self.notify_desktop(+ NotificationEvent::SessionCompleted,+ "ECC 2.0: Session completed",+ &format!(+ "{} | {}",+ format_session_id(&session.id),+ truncate_for_dashboard(&session.task, 96)+ ),+ );+ }+ SessionState::Failed => {+ self.notify_desktop(+ NotificationEvent::SessionFailed,+ "ECC 2.0: Session failed",+ &format!(+ "{} | {}",+ format_session_id(&session.id),+ truncate_for_dashboard(&session.task, 96)+ ),+ );+ }+ _ => {}+ }+ }+ }++ next_states.insert(session.id.clone(), session.state.clone());+ }++ self.last_session_states = next_states;+ }++ fn sync_approval_notifications(&mut self) {+ let latest_message = match self.db.latest_unread_approval_message() {+ Ok(message) => message,+ Err(error) => {+ tracing::warn!("Failed to refresh latest approval request: {error}");+ return;+ }+ };++ let Some(message) = latest_message else {+ return;+ };++ if self+ .last_seen_approval_message_id+ .is_some_and(|last_seen| message.id <= last_seen)+ {+ return;+ }++ self.last_seen_approval_message_id = Some(message.id);+ let preview =+ truncate_for_dashboard(&comms::preview(&message.msg_type, &message.content), 96);+ self.notify_desktop(+ NotificationEvent::ApprovalRequest,+ "ECC 2.0: Approval needed",+ &format!(+ "{} from {} | {}",+ format_session_id(&message.to_session),+ format_session_id(&message.from_session),+ preview+ ),+ );+ }++ fn notify_desktop(&self, event: NotificationEvent, title: &str, body: &str) {+ let _ = self.notifier.notify(event, title, body);}fn sync_selection(&mut self) {@@ -3688,10 +3804,7 @@ impl Dashboard {.and_then(|worktree| worktree::git_status_entries(worktree).ok()).unwrap_or_default();if self.selected_git_status >= self.selected_git_status_entries.len() {- self.selected_git_status = self- .selected_git_status_entries- .len()- .saturating_sub(1);+ self.selected_git_status = self.selected_git_status_entries.len().saturating_sub(1);}if self.output_mode == OutputMode::GitStatus && worktree.is_none() {self.output_mode = OutputMode::SessionOutput;@@ -4042,7 +4155,11 @@ impl Dashboard {.iter().enumerate().map(|(index, entry)| {- let marker = if index == self.selected_git_status { ">>" } else { "-" };+ let marker = if index == self.selected_git_status {+ ">>"+ } else {+ "-"+ };let mut flags = Vec::new();if entry.conflicted {flags.push("conflict");@@ -6932,6 +7049,42 @@ mod tests {assert!(dashboard.approval_queue_preview.is_empty());}+ #[test]+ fn refresh_tracks_latest_unread_approval_before_selected_messages_mark_read() {+ let sessions = vec![sample_session(+ "worker-123456",+ "reviewer",+ SessionState::Idle,+ Some("ecc/worker"),+ 64,+ 5,+ )];+ let mut dashboard = test_dashboard(sessions, 0);+ for session in &dashboard.sessions {+ dashboard.db.insert_session(session).unwrap();+ }+ dashboard+ .db+ .send_message(+ "lead-12345678",+ "worker-123456",+ "{\"question\":\"Need operator input\"}",+ "query",+ )+ .unwrap();+ let message_id = dashboard+ .db+ .latest_unread_approval_message()+ .unwrap()+ .expect("approval message should exist")+ .id;++ dashboard.refresh();++ assert_eq!(dashboard.last_seen_approval_message_id, Some(message_id));+ assert!(dashboard.approval_queue_preview.is_empty());+ }+#[test]fn focus_next_approval_target_selects_oldest_unread_target() {let sessions = vec![@@ -7199,7 +7352,10 @@ mod tests {dashboard.operator_note.as_deref(),Some("showing selected worktree git status"));- assert_eq!(dashboard.output_title(), " Git status staged:0 unstaged:1 1/1 ");+ assert_eq!(+ dashboard.output_title(),+ " Git status staged:0 unstaged:1 1/1 "+ );let rendered = dashboard.rendered_output_text(180, 20);assert!(rendered.contains("Git status"));assert!(rendered.contains("README.md"));@@ -8959,6 +9115,42 @@ diff --git a/src/lib.rs b/src/lib.rs);}+ #[test]+ fn refresh_updates_session_state_snapshot_after_completion() {+ let db = StateStore::open(Path::new(":memory:")).unwrap();+ let now = Utc::now();+ let session = Session {+ id: "done-1".to_string(),+ task: "complete session".to_string(),+ project: "workspace".to_string(),+ task_group: "general".to_string(),+ agent_type: "claude".to_string(),+ working_dir: PathBuf::from("/tmp"),+ state: SessionState::Running,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now,+ last_heartbeat_at: now,+ metrics: SessionMetrics::default(),+ };+ db.insert_session(&session).unwrap();++ let mut dashboard = Dashboard::new(db, Config::default());+ dashboard+ .db+ .update_state("done-1", &SessionState::Completed)+ .unwrap();++ dashboard.refresh();++ assert_eq!(dashboard.sessions[0].state, SessionState::Completed);+ assert_eq!(+ dashboard.last_session_states.get("done-1"),+ Some(&SessionState::Completed)+ );+ }+#[test]fn refresh_syncs_tool_activity_metrics_from_hook_file() {let tempdir = std::env::temp_dir().join(format!("ecc2-activity-sync-{}", Uuid::new_v4()));@@ -11020,6 +11212,11 @@ diff --git a/src/lib.rs b/src/lib.rsfn test_dashboard(sessions: Vec<Session>, selected_session: usize) -> Dashboard {let selected_session = selected_session.min(sessions.len().saturating_sub(1));let cfg = Config::default();+ let notifier = DesktopNotifier::new(cfg.desktop_notifications.clone());+ let last_session_states = sessions+ .iter()+ .map(|session| (session.id.clone(), session.state.clone()))+ .collect();let output_store = SessionOutputStore::default();let output_rx = output_store.subscribe();let mut session_table_state = TableState::default();@@ -11033,6 +11230,7 @@ diff --git a/src/lib.rs b/src/lib.rscfg,output_store,output_rx,+ notifier,sessions,session_output_cache: HashMap::new(),unread_message_counts: HashMap::new(),@@ -11090,6 +11288,8 @@ diff --git a/src/lib.rs b/src/lib.rslast_cost_metrics_signature: None,last_tool_activity_signature: None,last_budget_alert_state: BudgetState::Normal,+ last_session_states,+ last_seen_approval_message_id: None,}}@@ -11109,6 +11309,7 @@ diff --git a/src/lib.rs b/src/lib.rsauto_dispatch_limit_per_session: 5,auto_create_worktrees: true,auto_merge_ready_worktrees: false,+ desktop_notifications: crate::notifications::DesktopNotificationConfig::default(),cost_budget_usd: 10.0,token_budget: 500_000,budget_alert_thresholds: crate::config::Config::BUDGET_ALERT_THRESHOLDS,