The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
fix(ecc2): bound output cursor recovery
wellkilo8cd852136f30
diff --git a/ecc2/README.md b/ecc2/README.mdindex 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 previousdashboard tick.## What This Is Fordiff --git a/ecc2/src/session/output.rs b/ecc2/src/session/output.rsindex 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.rsindex 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<SessionOutputRecord>,}+/// Converts one persisted output row into the dashboard's typed record.fn output_record_from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<SessionOutputRecord> {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<SessionOutputBatch> {+ /// Returns at most `limit` output rows newer than `cursor` in insertion order.+ pub(crate) fn get_output_since(+ &self,+ cursor: i64,+ limit: usize,+ ) -> Result<SessionOutputBatch> {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, timestampFROM session_outputWHERE 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::<Result<Vec<_>, _>>()?;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 = dbdiff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex 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<String, Vec<OutputLine>>,+ mut cache: HashMap<String, Vec<OutputLine>>,records: Vec<SessionOutputRecord>,-) {+) -> HashMap<String, Vec<OutputLine>> {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>,session_harnesses: HashMap<String, SessionHarnessInfo>,session_output_cache: HashMap<String, Vec<OutputLine>>,+ session_output_generations: HashMap<String, chrono::DateTime<Utc>>,output_cursor: Option<i64>,unread_message_counts: HashMap<String, usize>,approval_queue_counts: HashMap<String, usize>,@@ -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.rsexternal.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.rssessions,session_harnesses,session_output_cache: HashMap::new(),+ session_output_generations,output_cursor: None,unread_message_counts: HashMap::new(),approval_queue_counts: HashMap::new(),