Skip to content

armgit / ECC

Public Imported from GitHub
0

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 graph compaction

Affaan Mustafa8cc92c59a64d
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rs
index 226730f8b..9329af088 100644
--- a/ecc2/src/main.rs
+++ b/ecc2/src/main.rs
@@ -490,6 +490,18 @@ enum GraphCommands {
#[arg(long)]
json: bool,
},
+ /// Compact stored observations in the shared context graph
+ Compact {
+ /// Filter by source session ID or alias
+ #[arg(long)]
+ session_id: Option<String>,
+ /// Maximum observations to retain per entity after compaction
+ #[arg(long, default_value_t = 12)]
+ keep_observations_per_entity: usize,
+ /// Emit machine-readable JSON instead of the human summary
+ #[arg(long)]
+ json: bool,
+ },
/// Recall relevant context graph entities for a query
Recall {
/// Filter by source session ID or alias
@@ -1314,6 +1326,32 @@ async fn main() -> Result<()> {
println!("{}", format_graph_observations_human(&observations));
}
}
+ GraphCommands::Compact {
+ session_id,
+ keep_observations_per_entity,
+ json,
+ } => {
+ let resolved_session_id = session_id
+ .as_deref()
+ .map(|value| resolve_session_id(&db, value))
+ .transpose()?;
+ let stats = db.compact_context_graph(
+ resolved_session_id.as_deref(),
+ keep_observations_per_entity,
+ )?;
+ if json {
+ println!("{}", serde_json::to_string_pretty(&stats)?);
+ } else {
+ println!(
+ "{}",
+ format_graph_compaction_stats_human(
+ &stats,
+ resolved_session_id.as_deref(),
+ keep_observations_per_entity,
+ )
+ );
+ }
+ }
GraphCommands::Recall {
session_id,
query,
@@ -2416,6 +2454,32 @@ fn format_graph_recall_human(
lines.join("\n")
}
+fn format_graph_compaction_stats_human(
+ stats: &session::ContextGraphCompactionStats,
+ session_id: Option<&str>,
+ keep_observations_per_entity: usize,
+) -> String {
+ let scope = session_id
+ .map(short_session)
+ .unwrap_or_else(|| "all sessions".to_string());
+ [
+ format!(
+ "Context graph compaction complete for {scope} (keep {keep_observations_per_entity} observations per entity)"
+ ),
+ format!("- entities scanned {}", stats.entities_scanned),
+ format!(
+ "- duplicate observations deleted {}",
+ stats.duplicate_observations_deleted
+ ),
+ format!(
+ "- overflow observations deleted {}",
+ stats.overflow_observations_deleted
+ ),
+ format!("- observations retained {}", stats.observations_retained),
+ ]
+ .join("\n")
+}
+
fn format_graph_entity_detail_human(detail: &session::ContextGraphEntityDetail) -> String {
let mut lines = vec![format_graph_entity_human(&detail.entity)];
lines.push(String::new());
@@ -4393,6 +4457,37 @@ mod tests {
}
}
+ #[test]
+ fn cli_parses_graph_compact_command() {
+ let cli = Cli::try_parse_from([
+ "ecc",
+ "graph",
+ "compact",
+ "--session-id",
+ "latest",
+ "--keep-observations-per-entity",
+ "6",
+ "--json",
+ ])
+ .expect("graph compact should parse");
+
+ match cli.command {
+ Some(Commands::Graph {
+ command:
+ GraphCommands::Compact {
+ session_id,
+ keep_observations_per_entity,
+ json,
+ },
+ }) => {
+ assert_eq!(session_id.as_deref(), Some("latest"));
+ assert_eq!(keep_observations_per_entity, 6);
+ assert!(json);
+ }
+ _ => panic!("expected graph compact subcommand"),
+ }
+ }
+
#[test]
fn format_decisions_human_renders_details() {
let text = format_decisions_human(
@@ -4534,6 +4629,27 @@ mod tests {
assert!(text.contains("summary Finished auth callback recovery with 2 tests"));
}
+ #[test]
+ fn format_graph_compaction_stats_human_renders_counts() {
+ let text = format_graph_compaction_stats_human(
+ &session::ContextGraphCompactionStats {
+ entities_scanned: 3,
+ duplicate_observations_deleted: 2,
+ overflow_observations_deleted: 4,
+ observations_retained: 9,
+ },
+ Some("sess-12345678"),
+ 6,
+ );
+
+ assert!(text.contains("Context graph compaction complete for sess-123"));
+ assert!(text.contains("keep 6 observations per entity"));
+ assert!(text.contains("- entities scanned 3"));
+ assert!(text.contains("- duplicate observations deleted 2"));
+ assert!(text.contains("- overflow observations deleted 4"));
+ assert!(text.contains("- observations retained 9"));
+ }
+
#[test]
fn format_graph_sync_stats_human_renders_counts() {
let text = format_graph_sync_stats_human(
diff --git a/ecc2/src/session/mod.rs b/ecc2/src/session/mod.rs
index 40e15ea75..727a7c9f1 100644
--- a/ecc2/src/session/mod.rs
+++ b/ecc2/src/session/mod.rs
@@ -220,6 +220,14 @@ pub struct ContextGraphSyncStats {
pub messages_processed: usize,
}
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ContextGraphCompactionStats {
+ pub entities_scanned: usize,
+ pub duplicate_observations_deleted: usize,
+ pub overflow_observations_deleted: usize,
+ pub observations_retained: usize,
+}
+
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum FileActivityAction {
diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rs
index 01b1fa062..31d93ce65 100644
--- a/ecc2/src/session/store.rs
+++ b/ecc2/src/session/store.rs
@@ -13,17 +13,19 @@ use crate::observability::{ToolCallEvent, ToolLogEntry, ToolLogPage};
use super::output::{OutputLine, OutputStream, OUTPUT_BUFFER_LIMIT};
use super::{
- default_project_label, default_task_group_label, normalize_group_label, ContextGraphEntity,
- ContextGraphEntityDetail, ContextGraphObservation, ContextGraphRecallEntry,
- ContextGraphRelation, ContextGraphSyncStats, DecisionLogEntry, FileActivityAction,
- FileActivityEntry, Session, SessionAgentProfile, SessionMessage, SessionMetrics, SessionState,
- WorktreeInfo,
+ default_project_label, default_task_group_label, normalize_group_label,
+ ContextGraphCompactionStats, ContextGraphEntity, ContextGraphEntityDetail,
+ ContextGraphObservation, ContextGraphRecallEntry, ContextGraphRelation, ContextGraphSyncStats,
+ DecisionLogEntry, FileActivityAction, FileActivityEntry, Session, SessionAgentProfile,
+ SessionMessage, SessionMetrics, SessionState, WorktreeInfo,
};
pub struct StateStore {
conn: Connection,
}
+const DEFAULT_CONTEXT_GRAPH_OBSERVATION_RETENTION: usize = 12;
+
#[derive(Debug, Clone)]
pub struct PendingWorktreeRequest {
pub session_id: String,
@@ -2235,6 +2237,11 @@ impl StateStore {
],
)?;
let observation_id = self.conn.last_insert_rowid();
+ self.compact_context_graph_observations(
+ None,
+ Some(entity_id),
+ DEFAULT_CONTEXT_GRAPH_OBSERVATION_RETENTION,
+ )?;
self.conn
.query_row(
"SELECT o.id, o.session_id, o.entity_id, e.entity_type, e.name,
@@ -2248,6 +2255,14 @@ impl StateStore {
.map_err(Into::into)
}
+ pub fn compact_context_graph(
+ &self,
+ session_id: Option<&str>,
+ keep_observations_per_entity: usize,
+ ) -> Result<ContextGraphCompactionStats> {
+ self.compact_context_graph_observations(session_id, None, keep_observations_per_entity)
+ }
+
pub fn add_session_observation(
&self,
session_id: &str,
@@ -2289,6 +2304,94 @@ impl StateStore {
Ok(entries)
}
+ fn compact_context_graph_observations(
+ &self,
+ session_id: Option<&str>,
+ entity_id: Option<i64>,
+ keep_observations_per_entity: usize,
+ ) -> Result<ContextGraphCompactionStats> {
+ let entities_scanned = self.conn.query_row(
+ "SELECT COUNT(DISTINCT o.entity_id)
+ FROM context_graph_observations o
+ JOIN context_graph_entities e ON e.id = o.entity_id
+ WHERE (?1 IS NULL OR e.session_id = ?1)
+ AND (?2 IS NULL OR o.entity_id = ?2)",
+ rusqlite::params![session_id, entity_id],
+ |row| row.get::<_, i64>(0),
+ )? as usize;
+
+ let duplicate_observations_deleted = self.conn.execute(
+ "DELETE FROM context_graph_observations
+ WHERE id IN (
+ SELECT id
+ FROM (
+ SELECT o.id,
+ ROW_NUMBER() OVER (
+ PARTITION BY o.entity_id, o.observation_type, o.summary
+ ORDER BY o.created_at DESC, o.id DESC
+ ) AS rn
+ FROM context_graph_observations o
+ JOIN context_graph_entities e ON e.id = o.entity_id
+ WHERE (?1 IS NULL OR e.session_id = ?1)
+ AND (?2 IS NULL OR o.entity_id = ?2)
+ ) ranked
+ WHERE ranked.rn > 1
+ )",
+ rusqlite::params![session_id, entity_id],
+ )?;
+
+ let overflow_observations_deleted = if keep_observations_per_entity == 0 {
+ self.conn.execute(
+ "DELETE FROM context_graph_observations
+ WHERE id IN (
+ SELECT o.id
+ FROM context_graph_observations o
+ JOIN context_graph_entities e ON e.id = o.entity_id
+ WHERE (?1 IS NULL OR e.session_id = ?1)
+ AND (?2 IS NULL OR o.entity_id = ?2)
+ )",
+ rusqlite::params![session_id, entity_id],
+ )?
+ } else {
+ self.conn.execute(
+ "DELETE FROM context_graph_observations
+ WHERE id IN (
+ SELECT id
+ FROM (
+ SELECT o.id,
+ ROW_NUMBER() OVER (
+ PARTITION BY o.entity_id
+ ORDER BY o.created_at DESC, o.id DESC
+ ) AS rn
+ FROM context_graph_observations o
+ JOIN context_graph_entities e ON e.id = o.entity_id
+ WHERE (?1 IS NULL OR e.session_id = ?1)
+ AND (?2 IS NULL OR o.entity_id = ?2)
+ ) ranked
+ WHERE ranked.rn > ?3
+ )",
+ rusqlite::params![session_id, entity_id, keep_observations_per_entity as i64],
+ )?
+ };
+
+ let observations_retained = self.conn.query_row(
+ "SELECT COUNT(*)
+ FROM context_graph_observations o
+ JOIN context_graph_entities e ON e.id = o.entity_id
+ WHERE (?1 IS NULL OR e.session_id = ?1)
+ AND (?2 IS NULL OR o.entity_id = ?2)",
+ rusqlite::params![session_id, entity_id],
+ |row| row.get::<_, i64>(0),
+ )? as usize;
+
+ Ok(ContextGraphCompactionStats {
+ entities_scanned,
+ duplicate_observations_deleted,
+ overflow_observations_deleted,
+ observations_retained,
+ })
+ }
+
pub fn upsert_context_relation(
&self,
session_id: Option<&str>,
@@ -4200,6 +4303,130 @@ mod tests {
Ok(())
}
+ #[test]
+ fn compact_context_graph_prunes_duplicate_and_overflow_observations() -> Result<()> {
+ let tempdir = TestDir::new("store-context-compaction")?;
+ let db = StateStore::open(&tempdir.path().join("state.db"))?;
+ let now = Utc::now();
+
+ db.insert_session(&Session {
+ id: "session-1".to_string(),
+ task: "deep memory".to_string(),
+ project: "workspace".to_string(),
+ task_group: "knowledge".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(),
+ })?;
+
+ let entity = db.upsert_context_entity(
+ Some("session-1"),
+ "decision",
+ "Prefer recovery-first routing",
+ None,
+ "Recovered installs should go through the portal first",
+ &BTreeMap::new(),
+ )?;
+
+ for summary in [
+ "old duplicate",
+ "keep me",
+ "old duplicate",
+ "recent",
+ "latest",
+ ] {
+ db.conn.execute(
+ "INSERT INTO context_graph_observations (
+ session_id, entity_id, observation_type, summary, details_json, created_at
+ ) VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
+ rusqlite::params![
+ "session-1",
+ entity.id,
+ "note",
+ summary,
+ "{}",
+ chrono::Utc::now().to_rfc3339(),
+ ],
+ )?;
+ std::thread::sleep(std::time::Duration::from_millis(2));
+ }
+
+ let stats = db.compact_context_graph(None, 3)?;
+ assert_eq!(stats.entities_scanned, 1);
+ assert_eq!(stats.duplicate_observations_deleted, 1);
+ assert_eq!(stats.overflow_observations_deleted, 1);
+ assert_eq!(stats.observations_retained, 3);
+
+ let observations = db.list_context_observations(Some(entity.id), 10)?;
+ let summaries = observations
+ .iter()
+ .map(|observation| observation.summary.as_str())
+ .collect::<Vec<_>>();
+ assert_eq!(summaries, vec!["latest", "recent", "old duplicate"]);
+
+ Ok(())
+ }
+
+ #[test]
+ fn add_context_observation_auto_compacts_entity_history() -> Result<()> {
+ let tempdir = TestDir::new("store-context-auto-compaction")?;
+ let db = StateStore::open(&tempdir.path().join("state.db"))?;
+ let now = Utc::now();
+
+ db.insert_session(&Session {
+ id: "session-1".to_string(),
+ task: "deep memory".to_string(),
+ project: "workspace".to_string(),
+ task_group: "knowledge".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(),
+ })?;
+
+ let entity = db.upsert_context_entity(
+ Some("session-1"),
+ "session",
+ "session-1",
+ None,
+ "Deep-memory worker",
+ &BTreeMap::new(),
+ )?;
+
+ for index in 0..(DEFAULT_CONTEXT_GRAPH_OBSERVATION_RETENTION + 2) {
+ let summary = format!("completion summary {}", index);
+ db.add_context_observation(
+ Some("session-1"),
+ entity.id,
+ "completion_summary",
+ &summary,
+ &BTreeMap::new(),
+ )?;
+ std::thread::sleep(std::time::Duration::from_millis(2));
+ }
+
+ let observations = db.list_context_observations(Some(entity.id), 20)?;
+ assert_eq!(
+ observations.len(),
+ DEFAULT_CONTEXT_GRAPH_OBSERVATION_RETENTION
+ );
+ assert_eq!(observations[0].summary, "completion summary 13");
+ assert_eq!(observations.last().unwrap().summary, "completion summary 2");
+
+ Ok(())
+ }
+
#[test]
fn recall_context_entities_ranks_matching_entities() -> Result<()> {
let tempdir = TestDir::new("store-context-recall")?;