diff --git a/ecc2/README.md b/ecc2/README.md index 8f9cc6d80..2ea06c961 100644 --- a/ecc2/README.md +++ b/ecc2/README.md @@ -14,10 +14,10 @@ It is usable as an alpha for local experimentation, but it is **not** the finish - worktree-aware session scaffolding - basic multi-session state and output tracking -Dashboard output is hydrated from SQLite at startup, explicit refresh, and -recovery, then synchronized with a monotonic database cursor. Because session -runners are separate processes, the database remains the cross-process source -of truth while steady-state refreshes read only rows appended since the previous +Dashboard output is hydrated from SQLite at startup and after recovery, then +synchronized with a monotonic database cursor. Because session runners are +separate processes, the database remains the cross-process source of truth +while steady-state refreshes read only the rows appended since the previous dashboard tick. ## What This Is For diff --git a/ecc2/src/session/output.rs b/ecc2/src/session/output.rs index 07aadf9d5..1edd3f800 100644 --- a/ecc2/src/session/output.rs +++ b/ecc2/src/session/output.rs @@ -5,6 +5,8 @@ use serde::{Deserialize, Serialize}; use tokio::sync::broadcast; pub const OUTPUT_BUFFER_LIMIT: usize = 1000; +/// Maximum number of cross-process output rows applied during one dashboard refresh. +pub const OUTPUT_DELTA_BATCH_LIMIT: usize = 4096; #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] pub enum OutputStream { diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rs index 3e77184a9..de1af81fc 100644 --- a/ecc2/src/session/store.rs +++ b/ecc2/src/session/store.rs @@ -41,6 +41,7 @@ pub(crate) struct SessionOutputBatch { pub records: Vec, } +/// Converts one persisted output row into the dashboard's typed record. fn output_record_from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { let stream: String = row.get(2)?; let text: String = row.get(3)?; @@ -4024,6 +4025,7 @@ impl StateStore { Ok(lines) } + /// Returns a bounded recent-output snapshot and its highest persisted row ID. pub(crate) fn get_output_snapshot( &self, limit_per_session: usize, @@ -4047,16 +4049,23 @@ impl StateStore { Ok(SessionOutputBatch { cursor, records }) } - pub(crate) fn get_output_since(&self, cursor: i64) -> Result { + /// Returns at most `limit` output rows newer than `cursor` in insertion order. + pub(crate) fn get_output_since( + &self, + cursor: i64, + limit: usize, + ) -> Result { let cursor = cursor.max(0); + let limit = i64::try_from(limit.max(1)).unwrap_or(i64::MAX); let mut stmt = self.conn.prepare( "SELECT id, session_id, stream, line, timestamp FROM session_output WHERE id > ?1 - ORDER BY id ASC", + ORDER BY id ASC + LIMIT ?2", )?; let records = stmt - .query_map(rusqlite::params![cursor], output_record_from_row)? + .query_map(rusqlite::params![cursor, limit], output_record_from_row)? .collect::, _>>()?; let cursor = records.last().map(|record| record.id).unwrap_or(cursor); @@ -7475,14 +7484,21 @@ mod tests { ); db.append_output_line("session-2", OutputStream::Stderr, "two-c")?; - let delta = db.get_output_since(snapshot.cursor)?; + db.append_output_line("session-1", OutputStream::Stdout, "one-d")?; + let delta = db.get_output_since(snapshot.cursor, 1)?; assert_eq!(delta.cursor, 6); assert_eq!(delta.records.len(), 1); assert_eq!(delta.records[0].session_id, "session-2"); assert_eq!(delta.records[0].line.text, "two-c"); - let empty = db.get_output_since(delta.cursor)?; - assert_eq!(empty.cursor, delta.cursor); + let next = db.get_output_since(delta.cursor, 1)?; + assert_eq!(next.cursor, 7); + assert_eq!(next.records.len(), 1); + assert_eq!(next.records[0].session_id, "session-1"); + assert_eq!(next.records[0].line.text, "one-d"); + + let empty = db.get_output_since(next.cursor, 1)?; + assert_eq!(empty.cursor, next.cursor); assert!(empty.records.is_empty()); let query_plan = db diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rs index 1a75f799a..deb34605a 100644 --- a/ecc2/src/tui/dashboard.rs +++ b/ecc2/src/tui/dashboard.rs @@ -17,7 +17,9 @@ use crate::config::{Config, PaneLayout, PaneNavigationAction, Theme}; use crate::notifications::{DesktopNotifier, NotificationEvent, WebhookNotifier}; use crate::observability::ToolLogEntry; use crate::session::manager; -use crate::session::output::{OutputLine, OutputStream, OUTPUT_BUFFER_LIMIT}; +use crate::session::output::{ + OutputLine, OutputStream, OUTPUT_BUFFER_LIMIT, OUTPUT_DELTA_BATCH_LIMIT, +}; use crate::session::store::{DaemonActivity, FileActivityOverlap, SessionOutputRecord, StateStore}; use crate::session::{ ContextObservationPriority, DecisionLogEntry, FileActivityEntry, Session, SessionBoardMeta, @@ -76,10 +78,11 @@ struct TestRunSummary { passed: usize, } +/// Consumes an output cache and returns a new bounded cache with `records` appended. fn append_output_records( - cache: &mut HashMap>, + mut cache: HashMap>, records: Vec, -) { +) -> HashMap> { let mut touched_sessions = HashSet::new(); for record in records { cache @@ -97,6 +100,8 @@ fn append_output_records( } } } + + cache } pub struct Dashboard { @@ -107,6 +112,7 @@ pub struct Dashboard { sessions: Vec, session_harnesses: HashMap, session_output_cache: HashMap>, + session_output_generations: HashMap>, output_cursor: Option, unread_message_counts: HashMap, approval_queue_counts: HashMap, @@ -521,6 +527,7 @@ fn load_session_harnesses( } impl Dashboard { + /// Builds the dashboard and hydrates its initial bounded output snapshot. pub fn new(db: StateStore, cfg: Config) -> Self { let pane_size_percent = configured_pane_size(&cfg, cfg.pane_layout); let initial_cost_metrics_signature = metrics_file_signature(&cfg.cost_metrics_path()); @@ -539,6 +546,10 @@ impl Dashboard { .iter() .map(|session| (session.id.clone(), session.state.clone())) .collect(); + let session_output_generations = sessions + .iter() + .map(|session| (session.id.clone(), session.created_at)) + .collect(); let initial_approval_message_id = db .latest_unread_approval_message() .ok() @@ -559,6 +570,7 @@ impl Dashboard { sessions, session_harnesses, session_output_cache: HashMap::new(), + session_output_generations, output_cursor: None, unread_message_counts: HashMap::new(), approval_queue_counts: HashMap::new(), @@ -3221,8 +3233,8 @@ impl Dashboard { )); } + /// Refreshes persisted dashboard state while preserving the output cursor. pub fn refresh(&mut self) { - self.output_cursor = None; self.sync_from_store(); } @@ -4075,6 +4087,7 @@ impl Dashboard { ) } + /// Synchronizes dashboard state, deferring output recovery until sessions load. fn sync_from_store(&mut self) { let (heartbeat_enforcement, budget_enforcement, conflict_enforcement) = self.sync_runtime_metrics(); @@ -4488,16 +4501,24 @@ impl Dashboard { } fn sync_output_cache(&mut self) { - let active_session_ids: HashSet<_> = self + let active_session_generations: HashMap<_, _> = self .sessions .iter() - .map(|session| session.id.as_str()) + .map(|session| (session.id.clone(), session.created_at)) .collect(); - self.session_output_cache - .retain(|session_id, _| active_session_ids.contains(session_id.as_str())); + let cached_generations = &self.session_output_generations; + self.session_output_cache = std::mem::take(&mut self.session_output_cache) + .into_iter() + .filter(|(session_id, _)| { + active_session_generations.get(session_id) == cached_generations.get(session_id) + }) + .collect(); + self.session_output_generations = active_session_generations; let batch = match self.output_cursor { - Some(cursor) => self.db.get_output_since(cursor), + Some(cursor) => self + .db + .get_output_since(cursor, OUTPUT_DELTA_BATCH_LIMIT), None => self.db.get_output_snapshot(OUTPUT_BUFFER_LIMIT), }; let batch = match batch { @@ -4509,11 +4530,14 @@ impl Dashboard { }; if self.output_cursor.is_none() { - self.session_output_cache.clear(); + self.session_output_cache = HashMap::new(); } self.output_cursor = Some(batch.cursor); - append_output_records(&mut self.session_output_cache, batch.records); + self.session_output_cache = append_output_records( + std::mem::take(&mut self.session_output_cache), + batch.records, + ); } fn ensure_selected_pane_visible(&mut self) { @@ -5226,6 +5250,7 @@ impl Dashboard { .map(|session| session.id.as_str()) } + /// Returns the selected session's currently cached output window. fn selected_output_lines(&self) -> &[OutputLine] { self.selected_session_id() .and_then(|session_id| self.session_output_cache.get(session_id)) @@ -13190,7 +13215,7 @@ diff --git a/src/lib.rs b/src/lib.rs .env("ECC2_OUTPUT_CURSOR_CHILD_DB", &db_path) .status()?; assert!(child.success(), "child output writer should succeed"); - dashboard.sync_output_cache(); + dashboard.refresh(); let text = dashboard.selected_output_text(); assert!(text.contains("persisted-before-open")); @@ -13299,21 +13324,23 @@ diff --git a/src/lib.rs b/src/lib.rs external.append_output_line("session-2", OutputStream::Stderr, "new-session")?; dashboard.sync_from_store(); - assert!(dashboard.sessions.iter().any(|session| session.id == "session-2")); - assert_eq!(dashboard.session_output_cache["session-2"][0].text, "new-session"); + assert!(dashboard + .sessions + .iter() + .any(|session| session.id == "session-2")); + assert_eq!( + dashboard.session_output_cache["session-2"][0].text, + "new-session" + ); external.delete_session("session-2")?; - dashboard.sync_from_store(); - assert!(!dashboard.session_output_cache.contains_key("session-2")); - - external.insert_session(&sample_session( - "session-2", - "codex", - SessionState::Running, - None, - 0, - 0, - ))?; + let replacement_time = Utc::now() + chrono::Duration::seconds(1); + external.insert_session(&Session { + created_at: replacement_time, + updated_at: replacement_time, + last_heartbeat_at: replacement_time, + ..sample_session("session-2", "codex", SessionState::Running, None, 0, 0) + })?; external.append_output_line("session-2", OutputStream::Stdout, "replacement-session")?; dashboard.sync_from_store(); @@ -13398,7 +13425,7 @@ diff --git a/src/lib.rs b/src/lib.rs }) .collect(); - append_output_records(&mut cache, records); + cache = append_output_records(cache, records); let session_lines = cache.get("session-1").expect("session output"); assert_eq!(session_lines.len(), OUTPUT_BUFFER_LIMIT); @@ -15183,6 +15210,10 @@ diff --git a/src/lib.rs b/src/lib.rs ) }) .collect(); + let session_output_generations = sessions + .iter() + .map(|session| (session.id.clone(), session.created_at)) + .collect(); let mut session_table_state = TableState::default(); if !sessions.is_empty() { session_table_state.select(Some(selected_session)); @@ -15197,6 +15228,7 @@ diff --git a/src/lib.rs b/src/lib.rs sessions, session_harnesses, session_output_cache: HashMap::new(), + session_output_generations, output_cursor: None, unread_message_counts: HashMap::new(), approval_queue_counts: HashMap::new(),