The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat(ecc2): add tool call logging and history
Affaan Mustafa6c2a3a2baeaa
diff --git a/ecc2/src/observability/mod.rs b/ecc2/src/observability/mod.rsindex 5f7a9645d..39128e2ed 100644--- a/ecc2/src/observability/mod.rs+++ b/ecc2/src/observability/mod.rs@@ -1,4 +1,4 @@-use anyhow::Result;+use anyhow::{bail, Result};use serde::{Deserialize, Serialize};use crate::session::store::StateStore;@@ -14,6 +14,26 @@ pub struct ToolCallEvent {}impl ToolCallEvent {+ pub fn new(+ session_id: impl Into<String>,+ tool_name: impl Into<String>,+ input_summary: impl Into<String>,+ output_summary: impl Into<String>,+ duration_ms: u64,+ ) -> Self {+ let tool_name = tool_name.into();+ let input_summary = input_summary.into();++ Self {+ session_id: session_id.into(),+ risk_score: Self::compute_risk(&tool_name, &input_summary),+ tool_name,+ input_summary,+ output_summary: output_summary.into(),+ duration_ms,+ }+ }+/// Compute risk score based on tool type and input patterns.pub fn compute_risk(tool_name: &str, input: &str) -> f64 {let mut score: f64 = 0.0;@@ -43,12 +63,120 @@ impl ToolCallEvent {}}-pub fn log_tool_call(db: &StateStore, event: &ToolCallEvent) -> Result<()> {- db.send_message(- &event.session_id,- "observability",- &serde_json::to_string(event)?,- "tool_call",- )?;- Ok(())+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]+pub struct ToolLogEntry {+ pub id: i64,+ pub session_id: String,+ pub tool_name: String,+ pub input_summary: String,+ pub output_summary: String,+ pub duration_ms: u64,+ pub risk_score: f64,+ pub timestamp: String,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]+pub struct ToolLogPage {+ pub entries: Vec<ToolLogEntry>,+ pub page: u64,+ pub page_size: u64,+ pub total: u64,+}++pub struct ToolLogger<'a> {+ db: &'a StateStore,+}++impl<'a> ToolLogger<'a> {+ pub fn new(db: &'a StateStore) -> Self {+ Self { db }+ }++ pub fn log(&self, event: &ToolCallEvent) -> Result<ToolLogEntry> {+ let timestamp = chrono::Utc::now().to_rfc3339();++ self.db.insert_tool_log(+ &event.session_id,+ &event.tool_name,+ &event.input_summary,+ &event.output_summary,+ event.duration_ms,+ event.risk_score,+ ×tamp,+ )+ }++ pub fn query(&self, session_id: &str, page: u64, page_size: u64) -> Result<ToolLogPage> {+ if page_size == 0 {+ bail!("page_size must be greater than 0");+ }++ self.db.query_tool_logs(session_id, page.max(1), page_size)+ }+}++pub fn log_tool_call(db: &StateStore, event: &ToolCallEvent) -> Result<ToolLogEntry> {+ ToolLogger::new(db).log(event)+}++#[cfg(test)]+mod tests {+ use super::{ToolCallEvent, ToolLogger};+ use crate::session::store::StateStore;+ use crate::session::{Session, SessionMetrics, SessionState};+ use std::path::PathBuf;++ fn test_db_path() -> PathBuf {+ std::env::temp_dir().join(format!("ecc2-observability-{}.db", uuid::Uuid::new_v4()))+ }++ fn test_session(id: &str) -> Session {+ let now = chrono::Utc::now();++ Session {+ id: id.to_string(),+ task: "test task".to_string(),+ agent_type: "claude".to_string(),+ state: SessionState::Pending,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now,+ metrics: SessionMetrics::default(),+ }+ }++ #[test]+ fn compute_risk_caps_high_risk_bash_commands() {+ let score = ToolCallEvent::compute_risk("Bash", "sudo rm -rf /tmp --force");+ assert_eq!(score, 1.0);+ }++ #[test]+ fn logger_persists_entries_and_paginates() -> anyhow::Result<()> {+ let db_path = test_db_path();+ let db = StateStore::open(&db_path)?;+ db.insert_session(&test_session("sess-1"))?;++ let logger = ToolLogger::new(&db);++ logger.log(&ToolCallEvent::new("sess-1", "Read", "first", "ok", 5))?;+ logger.log(&ToolCallEvent::new("sess-1", "Write", "second", "ok", 15))?;+ logger.log(&ToolCallEvent::new("sess-1", "Bash", "third", "ok", 25))?;++ let first_page = logger.query("sess-1", 1, 2)?;+ assert_eq!(first_page.total, 3);+ assert_eq!(first_page.entries.len(), 2);+ assert_eq!(first_page.entries[0].tool_name, "Bash");+ assert_eq!(first_page.entries[1].tool_name, "Write");++ let second_page = logger.query("sess-1", 2, 2)?;+ assert_eq!(second_page.total, 3);+ assert_eq!(second_page.entries.len(), 1);+ assert_eq!(second_page.entries[0].tool_name, "Read");++ std::fs::remove_file(&db_path).ok();++ Ok(())+ }}diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex 07538d8ee..670997801 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -9,6 +9,7 @@ use super::runtime::capture_command_output;use super::store::StateStore;use super::{Session, SessionMetrics, SessionState};use crate::config::Config;+use crate::observability::{log_tool_call, ToolCallEvent, ToolLogEntry, ToolLogPage, ToolLogger};use crate::worktree;pub async fn create_session(@@ -36,6 +37,44 @@ pub async fn stop_session(db: &StateStore, id: &str) -> Result<()> {stop_session_with_options(db, id, true).await}+pub fn record_tool_call(+ db: &StateStore,+ session_id: &str,+ tool_name: &str,+ input_summary: &str,+ output_summary: &str,+ duration_ms: u64,+) -> Result<ToolLogEntry> {+ let session = db+ .get_session(session_id)?+ .ok_or_else(|| anyhow::anyhow!("Session not found: {session_id}"))?;++ let event = ToolCallEvent::new(+ session.id.clone(),+ tool_name,+ input_summary,+ output_summary,+ duration_ms,+ );+ let entry = log_tool_call(db, &event)?;+ db.increment_tool_calls(&session.id)?;++ Ok(entry)+}++pub fn query_tool_calls(+ db: &StateStore,+ session_id: &str,+ page: u64,+ page_size: u64,+) -> Result<ToolLogPage> {+ let session = db+ .get_session(session_id)?+ .ok_or_else(|| anyhow::anyhow!("Session not found: {session_id}"))?;++ ToolLogger::new(db).query(&session.id, page, page_size)+}+pub async fn resume_session(db: &StateStore, id: &str) -> Result<String> {let session = resolve_session(db, id)?;diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rsindex bb6af18e6..a547ac2ae 100644--- a/ecc2/src/session/store.rs+++ b/ecc2/src/session/store.rs@@ -3,6 +3,8 @@ use rusqlite::{Connection, OptionalExtension};use std::path::{Path, PathBuf};use std::time::Duration;+use crate::observability::{ToolLogEntry, ToolLogPage};+use super::output::{OutputLine, OutputStream, OUTPUT_BUFFER_LIMIT};use super::{Session, SessionMetrics, SessionState};@@ -216,6 +218,14 @@ impl StateStore {Ok(())}+ pub fn increment_tool_calls(&self, session_id: &str) -> Result<()> {+ self.conn.execute(+ "UPDATE sessions SET tool_calls = tool_calls + 1, updated_at = ?1 WHERE id = ?2",+ rusqlite::params![chrono::Utc::now().to_rfc3339(), session_id],+ )?;+ Ok(())+ }+pub fn list_sessions(&self) -> Result<Vec<Session>> {let mut stmt = self.conn.prepare("SELECT id, task, agent_type, state, pid, worktree_path, worktree_branch, worktree_base,@@ -348,6 +358,88 @@ impl StateStore {Ok(lines)}++ pub fn insert_tool_log(+ &self,+ session_id: &str,+ tool_name: &str,+ input_summary: &str,+ output_summary: &str,+ duration_ms: u64,+ risk_score: f64,+ timestamp: &str,+ ) -> Result<ToolLogEntry> {+ self.conn.execute(+ "INSERT INTO tool_log (session_id, tool_name, input_summary, output_summary, duration_ms, risk_score, timestamp)+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",+ rusqlite::params![+ session_id,+ tool_name,+ input_summary,+ output_summary,+ duration_ms,+ risk_score,+ timestamp,+ ],+ )?;++ Ok(ToolLogEntry {+ id: self.conn.last_insert_rowid(),+ session_id: session_id.to_string(),+ tool_name: tool_name.to_string(),+ input_summary: input_summary.to_string(),+ output_summary: output_summary.to_string(),+ duration_ms,+ risk_score,+ timestamp: timestamp.to_string(),+ })+ }++ pub fn query_tool_logs(+ &self,+ session_id: &str,+ page: u64,+ page_size: u64,+ ) -> Result<ToolLogPage> {+ let page = page.max(1);+ let offset = (page - 1) * page_size;++ let total: u64 = self.conn.query_row(+ "SELECT COUNT(*) FROM tool_log WHERE session_id = ?1",+ rusqlite::params![session_id],+ |row| row.get(0),+ )?;++ let mut stmt = self.conn.prepare(+ "SELECT id, session_id, tool_name, input_summary, output_summary, duration_ms, risk_score, timestamp+ FROM tool_log+ WHERE session_id = ?1+ ORDER BY timestamp DESC, id DESC+ LIMIT ?2 OFFSET ?3",+ )?;++ let entries = stmt+ .query_map(rusqlite::params![session_id, page_size, offset], |row| {+ Ok(ToolLogEntry {+ id: row.get(0)?,+ session_id: row.get(1)?,+ tool_name: row.get(2)?,+ input_summary: row.get::<_, Option<String>>(3)?.unwrap_or_default(),+ output_summary: row.get::<_, Option<String>>(4)?.unwrap_or_default(),+ duration_ms: row.get::<_, Option<u64>>(5)?.unwrap_or_default(),+ risk_score: row.get::<_, Option<f64>>(6)?.unwrap_or_default(),+ timestamp: row.get(7)?,+ })+ })?+ .collect::<Result<Vec<_>, _>>()?;++ Ok(ToolLogPage {+ entries,+ page,+ page_size,+ total,+ })+ }}#[cfg(test)]diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex 38efd539a..a86f052f8 100644--- a/ecc2/src/tui/dashboard.rs+++ b/ecc2/src/tui/dashboard.rs@@ -11,6 +11,7 @@ use tokio::sync::broadcast;use super::widgets::{budget_state, format_currency, format_token_count, BudgetState, TokenMeter};use crate::config::{Config, PaneLayout};+use crate::observability::ToolLogEntry;use crate::session::output::{OutputEvent, OutputLine, SessionOutputStore, OutputStream, OUTPUT_BUFFER_LIMIT};use crate::session::store::StateStore;use crate::session::{Session, SessionMetrics, SessionState, WorktreeInfo};@@ -21,6 +22,7 @@ const OUTPUT_PANE_PERCENT: u16 = 70;const MIN_PANE_SIZE_PERCENT: u16 = 20;const MAX_PANE_SIZE_PERCENT: u16 = 80;const PANE_RESIZE_STEP_PERCENT: u16 = 5;+const MAX_LOG_ENTRIES: u64 = 12;pub struct Dashboard {db: StateStore,@@ -29,6 +31,7 @@ pub struct Dashboard {output_rx: broadcast::Receiver<OutputEvent>,sessions: Vec<Session>,session_output_cache: HashMap<String, Vec<OutputLine>>,+ logs: Vec<ToolLogEntry>,selected_pane: Pane,selected_session: usize,show_help: bool,@@ -99,6 +102,7 @@ impl Dashboard {output_rx,sessions,session_output_cache: HashMap::new(),+ logs: Vec::new(),selected_pane: Pane::Sessions,selected_session: 0,show_help: false,@@ -109,6 +113,7 @@ impl Dashboard {session_table_state,};dashboard.sync_selected_output();+ dashboard.refresh_logs();dashboard}@@ -300,15 +305,26 @@ impl Dashboard {}fn render_log(&self, frame: &mut Frame, area: Rect) {- let content = if let Some(session) = self.sessions.get(self.selected_session) {- format!(- "Split-pane grid layout reserved this pane for observability.\n\nSelected session: {}\nState: {}\n\nTool call history lands in the follow-on logging PR.",- &session.id[..8.min(session.id.len())],- session.state- )+ let content = if self.sessions.get(self.selected_session).is_none() {+ "No session selected.".to_string()+ } else if self.logs.is_empty() {+ "No tool logs available for this session yet.".to_string()} else {- "Split-pane grid layout reserved this pane for observability.\n\nNo session selected."- .to_string()+ self.logs+ .iter()+ .map(|entry| {+ format!(+ "[{}] {} | {}ms | risk {:.0}%\ninput: {}\noutput: {}",+ self.short_timestamp(&entry.timestamp),+ entry.tool_name,+ entry.duration_ms,+ entry.risk_score * 100.0,+ self.log_field(&entry.input_summary),+ self.log_field(&entry.output_summary)+ )+ })+ .collect::<Vec<_>>()+ .join("\n\n")};let paragraph = Paragraph::new(content)@@ -318,6 +334,7 @@ impl Dashboard {.title(" Log ").border_style(self.pane_border_style(Pane::Log)),)+ .scroll((self.output_scroll_offset as u16, 0)).wrap(Wrap { trim: false });frame.render_widget(paragraph, area);}@@ -426,6 +443,7 @@ impl Dashboard {self.sync_selection();self.reset_output_view();self.sync_selected_output();+ self.refresh_logs();}Pane::Output => {let max_scroll = self.max_output_scroll();@@ -441,7 +459,10 @@ impl Dashboard {}}Pane::Metrics => {}- Pane::Log => {}+ Pane::Log => {+ self.output_follow = false;+ self.output_scroll_offset = self.output_scroll_offset.saturating_add(1);+ }Pane::Sessions => {}}}@@ -453,6 +474,7 @@ impl Dashboard {self.sync_selection();self.reset_output_view();self.sync_selected_output();+ self.refresh_logs();}Pane::Output => {if self.output_follow {@@ -463,7 +485,10 @@ impl Dashboard {self.output_scroll_offset = self.output_scroll_offset.saturating_sub(1);}Pane::Metrics => {}- Pane::Log => {}+ Pane::Log => {+ self.output_follow = false;+ self.output_scroll_offset = self.output_scroll_offset.saturating_sub(1);+ }}}@@ -517,6 +542,7 @@ impl Dashboard {self.sync_selection_by_id(selected_id.as_deref());self.ensure_selected_pane_visible();self.sync_selected_output();+ self.refresh_logs();}fn sync_selection(&mut self) {@@ -597,6 +623,21 @@ impl Dashboard {self.output_scroll_offset = 0;}+ fn refresh_logs(&mut self) {+ let Some(session_id) = self.selected_session_id().map(ToOwned::to_owned) else {+ self.logs.clear();+ return;+ };++ match self.db.query_tool_logs(&session_id, 1, MAX_LOG_ENTRIES) {+ Ok(page) => self.logs = page.entries,+ Err(error) => {+ tracing::warn!("Failed to load tool logs: {error}");+ self.logs.clear();+ }+ }+ }+fn aggregate_usage(&self) -> AggregateUsage {let total_tokens = self.sessions@@ -767,6 +808,21 @@ impl Dashboard {}}+ fn log_field<'a>(&self, value: &'a str) -> &'a str {+ let trimmed = value.trim();+ if trimmed.is_empty() {+ "n/a"+ } else {+ trimmed+ }+ }++ fn short_timestamp(&self, timestamp: &str) -> String {+ chrono::DateTime::parse_from_rfc3339(timestamp)+ .map(|value| value.format("%H:%M:%S").to_string())+ .unwrap_or_else(|_| timestamp.to_string())+ }+#[cfg(test)]fn aggregate_cost_summary_text(&self) -> String {self.aggregate_cost_summary().0@@ -1135,6 +1191,7 @@ mod tests {output_rx,sessions,session_output_cache: HashMap::new(),+ logs: Vec::new(),selected_pane: Pane::Sessions,selected_session,show_help: false,