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(ecc2): surface overlapping file activity

Affaan Mustafaf28f55c41eb8
diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rs
index b6de51b7e..1fa31298a 100644
--- a/ecc2/src/session/store.rs
+++ b/ecc2/src/session/store.rs
@@ -1,6 +1,7 @@
use anyhow::{Context, Result};
use rusqlite::{Connection, OptionalExtension};
use serde::Serialize;
+use std::cmp::Reverse;
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::{BufRead, BufReader};
@@ -19,6 +20,16 @@ pub struct StateStore {
conn: Connection,
}
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct FileActivityOverlap {
+ pub path: String,
+ pub current_action: FileActivityAction,
+ pub other_action: FileActivityAction,
+ pub other_session_id: String,
+ pub other_session_state: SessionState,
+ pub timestamp: chrono::DateTime<chrono::Utc>,
+}
+
#[derive(Debug, Clone, Default, Serialize)]
pub struct DaemonActivity {
pub last_dispatch_at: Option<chrono::DateTime<chrono::Utc>>,
@@ -1627,6 +1638,67 @@ impl StateStore {
Ok(events)
}
+
+ pub fn list_file_overlaps(
+ &self,
+ session_id: &str,
+ limit: usize,
+ ) -> Result<Vec<FileActivityOverlap>> {
+ if limit == 0 {
+ return Ok(Vec::new());
+ }
+
+ let current_activity = self.list_file_activity(session_id, 64)?;
+ if current_activity.is_empty() {
+ return Ok(Vec::new());
+ }
+
+ let mut current_by_path = HashMap::new();
+ for entry in current_activity {
+ current_by_path.entry(entry.path.clone()).or_insert(entry);
+ }
+
+ let mut overlaps = Vec::new();
+ let mut seen = HashSet::new();
+
+ for session in self.list_sessions()? {
+ if session.id == session_id || !session_state_supports_overlap(&session.state) {
+ continue;
+ }
+
+ for entry in self.list_file_activity(&session.id, 32)? {
+ let Some(current) = current_by_path.get(&entry.path) else {
+ continue;
+ };
+ if !file_overlap_is_relevant(current, &entry) {
+ continue;
+ }
+ if !seen.insert((session.id.clone(), entry.path.clone())) {
+ continue;
+ }
+
+ overlaps.push(FileActivityOverlap {
+ path: entry.path.clone(),
+ current_action: current.action.clone(),
+ other_action: entry.action.clone(),
+ other_session_id: session.id.clone(),
+ other_session_state: session.state.clone(),
+ timestamp: entry.timestamp,
+ });
+ }
+ }
+
+ overlaps.sort_by_key(|entry| {
+ (
+ overlap_state_priority(&entry.other_session_state),
+ Reverse(entry.timestamp),
+ entry.other_session_id.clone(),
+ entry.path.clone(),
+ )
+ });
+ overlaps.truncate(limit);
+ Ok(overlaps)
+ }
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -1702,6 +1774,31 @@ fn infer_file_activity_action(tool_name: &str) -> FileActivityAction {
}
}
+fn session_state_supports_overlap(state: &SessionState) -> bool {
+ matches!(
+ state,
+ SessionState::Pending | SessionState::Running | SessionState::Idle | SessionState::Stale
+ )
+}
+
+fn file_overlap_is_relevant(current: &FileActivityEntry, other: &FileActivityEntry) -> bool {
+ current.path == other.path
+ && !(matches!(current.action, FileActivityAction::Read)
+ && matches!(other.action, FileActivityAction::Read))
+}
+
+fn overlap_state_priority(state: &SessionState) -> u8 {
+ match state {
+ SessionState::Running => 0,
+ SessionState::Idle => 1,
+ SessionState::Pending => 2,
+ SessionState::Stale => 3,
+ SessionState::Completed => 4,
+ SessionState::Failed => 5,
+ SessionState::Stopped => 6,
+ }
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -2015,6 +2112,77 @@ mod tests {
Ok(())
}
+ #[test]
+ fn list_file_overlaps_reports_other_active_sessions_sharing_paths() -> Result<()> {
+ let tempdir = TestDir::new("store-file-overlaps")?;
+ let db = StateStore::open(&tempdir.path().join("state.db"))?;
+ let now = Utc::now();
+
+ db.insert_session(&Session {
+ id: "session-1".to_string(),
+ task: "focus".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 {
+ id: "session-2".to_string(),
+ task: "delegate".to_string(),
+ agent_type: "claude".to_string(),
+ working_dir: PathBuf::from("/tmp"),
+ state: SessionState::Idle,
+ pid: None,
+ worktree: None,
+ created_at: now,
+ updated_at: now,
+ last_heartbeat_at: now,
+ metrics: SessionMetrics::default(),
+ })?;
+ db.insert_session(&Session {
+ id: "session-3".to_string(),
+ task: "done".to_string(),
+ agent_type: "claude".to_string(),
+ working_dir: PathBuf::from("/tmp"),
+ state: SessionState::Completed,
+ pid: None,
+ worktree: None,
+ created_at: now,
+ updated_at: now,
+ last_heartbeat_at: now,
+ metrics: SessionMetrics::default(),
+ })?;
+
+ let metrics_dir = tempdir.path().join("metrics");
+ fs::create_dir_all(&metrics_dir)?;
+ let metrics_path = metrics_dir.join("tool-usage.jsonl");
+ fs::write(
+ &metrics_path,
+ concat!(
+ "{\"id\":\"evt-1\",\"session_id\":\"session-1\",\"tool_name\":\"Edit\",\"input_summary\":\"Edit src/lib.rs\",\"output_summary\":\"updated lib\",\"file_events\":[{\"path\":\"src/lib.rs\",\"action\":\"modify\"}],\"timestamp\":\"2026-04-09T00:02:00Z\"}\n",
+ "{\"id\":\"evt-2\",\"session_id\":\"session-2\",\"tool_name\":\"Write\",\"input_summary\":\"Write src/lib.rs\",\"output_summary\":\"touched lib\",\"file_events\":[{\"path\":\"src/lib.rs\",\"action\":\"modify\"}],\"timestamp\":\"2026-04-09T00:03:00Z\"}\n",
+ "{\"id\":\"evt-3\",\"session_id\":\"session-3\",\"tool_name\":\"Write\",\"input_summary\":\"Write src/lib.rs\",\"output_summary\":\"completed overlap\",\"file_events\":[{\"path\":\"src/lib.rs\",\"action\":\"modify\"}],\"timestamp\":\"2026-04-09T00:04:00Z\"}\n"
+ ),
+ )?;
+
+ db.sync_tool_activity_metrics(&metrics_path)?;
+
+ let overlaps = db.list_file_overlaps("session-1", 10)?;
+ assert_eq!(overlaps.len(), 1);
+ assert_eq!(overlaps[0].path, "src/lib.rs");
+ assert_eq!(overlaps[0].current_action, FileActivityAction::Modify);
+ assert_eq!(overlaps[0].other_action, FileActivityAction::Modify);
+ assert_eq!(overlaps[0].other_session_id, "session-2");
+ assert_eq!(overlaps[0].other_session_state, SessionState::Idle);
+
+ Ok(())
+ }
+
#[test]
fn refresh_session_durations_updates_running_and_terminal_sessions() -> Result<()> {
let tempdir = TestDir::new("store-duration-metrics")?;
diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rs
index cdb2271b9..53d8c23ac 100644
--- a/ecc2/src/tui/dashboard.rs
+++ b/ecc2/src/tui/dashboard.rs
@@ -19,7 +19,7 @@ use crate::session::manager;
use crate::session::output::{
OutputEvent, OutputLine, OutputStream, SessionOutputStore, OUTPUT_BUFFER_LIMIT,
};
-use crate::session::store::{DaemonActivity, StateStore};
+use crate::session::store::{DaemonActivity, FileActivityOverlap, StateStore};
use crate::session::{FileActivityEntry, Session, SessionMessage, SessionState};
use crate::worktree;
@@ -4169,6 +4169,22 @@ impl Dashboard {
}
}
}
+ let file_overlaps = self
+ .db
+ .list_file_overlaps(&session.id, 3)
+ .unwrap_or_default();
+ if !file_overlaps.is_empty() {
+ lines.push("Potential overlaps".to_string());
+ for overlap in file_overlaps {
+ lines.push(format!(
+ "- {}",
+ file_overlap_summary(
+ &overlap,
+ &self.short_timestamp(&overlap.timestamp.to_rfc3339())
+ )
+ ));
+ }
+ }
lines.push(format!(
"Cost ${:.4} | Duration {}s",
metrics.cost_usd, metrics.duration_secs
@@ -5447,6 +5463,18 @@ fn file_activity_patch_lines(entry: &FileActivityEntry, max_lines: usize) -> Vec
.unwrap_or_default()
}
+fn file_overlap_summary(entry: &FileActivityOverlap, timestamp: &str) -> String {
+ format!(
+ "{} {} | {} {} as {} | {}",
+ file_activity_verb(entry.current_action.clone()),
+ truncate_for_dashboard(&entry.path, 48),
+ entry.other_session_state,
+ format_session_id(&entry.other_session_id),
+ file_activity_verb(entry.other_action.clone()),
+ timestamp
+ )
+}
+
fn file_activity_verb(action: crate::session::FileActivityAction) -> &'static str {
match action {
crate::session::FileActivityAction::Read => "read",
@@ -6152,6 +6180,58 @@ mod tests {
Ok(())
}
+ #[test]
+ fn metrics_text_surfaces_file_activity_overlaps() -> Result<()> {
+ let root = std::env::temp_dir().join(format!("ecc2-file-overlaps-{}", Uuid::new_v4()));
+ fs::create_dir_all(&root)?;
+ let now = Utc::now();
+ let mut focus = sample_session(
+ "focus-12345678",
+ "planner",
+ SessionState::Running,
+ Some("ecc/focus"),
+ 512,
+ 42,
+ );
+ focus.created_at = now - chrono::Duration::hours(1);
+ focus.updated_at = now - chrono::Duration::minutes(3);
+
+ let mut delegate = sample_session(
+ "delegate-87654321",
+ "coder",
+ SessionState::Idle,
+ Some("ecc/delegate"),
+ 256,
+ 12,
+ );
+ delegate.created_at = now - chrono::Duration::minutes(50);
+ delegate.updated_at = now - chrono::Duration::minutes(2);
+
+ let mut dashboard = test_dashboard(vec![focus.clone(), delegate.clone()], 0);
+ dashboard.db.insert_session(&focus)?;
+ dashboard.db.insert_session(&delegate)?;
+
+ let metrics_path = root.join("tool-usage.jsonl");
+ fs::write(
+ &metrics_path,
+ concat!(
+ "{\"id\":\"evt-1\",\"session_id\":\"focus-12345678\",\"tool_name\":\"Edit\",\"input_summary\":\"Edit src/lib.rs\",\"output_summary\":\"updated lib\",\"file_events\":[{\"path\":\"src/lib.rs\",\"action\":\"modify\"}],\"timestamp\":\"2026-04-09T00:00:00Z\"}\n",
+ "{\"id\":\"evt-2\",\"session_id\":\"delegate-87654321\",\"tool_name\":\"Write\",\"input_summary\":\"Write src/lib.rs\",\"output_summary\":\"touched lib\",\"file_events\":[{\"path\":\"src/lib.rs\",\"action\":\"modify\"}],\"timestamp\":\"2026-04-09T00:01:00Z\"}\n"
+ ),
+ )?;
+ dashboard.db.sync_tool_activity_metrics(&metrics_path)?;
+ dashboard.sync_from_store();
+
+ let metrics_text = dashboard.selected_session_metrics_text();
+ assert!(metrics_text.contains("Potential overlaps"));
+ assert!(metrics_text.contains("modify src/lib.rs"));
+ assert!(metrics_text.contains("idle delegate"));
+ assert!(metrics_text.contains("as modify"));
+
+ let _ = fs::remove_dir_all(root);
+ Ok(())
+ }
+
#[test]
fn timeline_time_filter_hides_old_events() {
let now = Utc::now();
diff --git a/tests/hooks/session-activity-tracker.test.js b/tests/hooks/session-activity-tracker.test.js
index 0b15c2fdc..da56c677c 100644
--- a/tests/hooks/session-activity-tracker.test.js
+++ b/tests/hooks/session-activity-tracker.test.js
@@ -260,6 +260,54 @@ function runTests() {
fs.rmSync(repoDir, { recursive: true, force: true });
}) ? passed++ : failed++);
+ (test('captures tracked Delete activity using git diff context', () => {
+ const tmpHome = makeTempDir();
+ const repoDir = fs.mkdtempSync(path.join(os.tmpdir(), 'session-activity-tracker-delete-repo-'));
+
+ spawnSync('git', ['init'], { cwd: repoDir, encoding: 'utf8' });
+ spawnSync('git', ['config', 'user.email', '[email protected]'], { cwd: repoDir, encoding: 'utf8' });
+ spawnSync('git', ['config', 'user.name', 'ECC Tests'], { cwd: repoDir, encoding: 'utf8' });
+
+ const srcDir = path.join(repoDir, 'src');
+ fs.mkdirSync(srcDir, { recursive: true });
+ const trackedFile = path.join(srcDir, 'obsolete.ts');
+ fs.writeFileSync(trackedFile, 'export const obsolete = true;\n', 'utf8');
+ spawnSync('git', ['add', 'src/obsolete.ts'], { cwd: repoDir, encoding: 'utf8' });
+ spawnSync('git', ['commit', '-m', 'init'], { cwd: repoDir, encoding: 'utf8' });
+
+ fs.rmSync(trackedFile, { force: true });
+
+ const input = {
+ tool_name: 'Delete',
+ tool_input: {
+ file_path: 'src/obsolete.ts',
+ },
+ tool_output: { output: 'deleted src/obsolete.ts' },
+ };
+ const result = runScript(input, {
+ ...withTempHome(tmpHome),
+ CLAUDE_HOOK_EVENT_NAME: 'PostToolUse',
+ ECC_SESSION_ID: 'ecc-session-delete',
+ }, {
+ cwd: repoDir,
+ });
+ assert.strictEqual(result.code, 0);
+
+ const metricsFile = path.join(tmpHome, '.claude', 'metrics', 'tool-usage.jsonl');
+ const row = JSON.parse(fs.readFileSync(metricsFile, 'utf8').trim());
+ assert.deepStrictEqual(row.file_events, [
+ {
+ path: 'src/obsolete.ts',
+ action: 'delete',
+ diff_preview: 'export const obsolete = true; ->',
+ patch_preview: '@@ -1 +0,0 @@\n-export const obsolete = true;',
+ },
+ ]);
+
+ fs.rmSync(tmpHome, { recursive: true, force: true });
+ fs.rmSync(repoDir, { recursive: true, force: true });
+ }) ? passed++ : failed++);
+
(test('prefers ECC_SESSION_ID over CLAUDE_SESSION_ID and redacts bash summaries', () => {
const tmpHome = makeTempDir();
const input = {