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 harness metadata detection

Affaan Mustafa29ff44e23eea
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rs
index 273ed1b1a..b5193bd3d 100644
--- a/ecc2/src/main.rs
+++ b/ecc2/src/main.rs
@@ -1150,8 +1150,13 @@ async fn main() -> Result<()> {
Some(Commands::Sessions) => {
sync_runtime_session_metrics(&db, &cfg)?;
let sessions = session::manager::list_sessions(&db)?;
+ let harnesses = db.list_session_harnesses().unwrap_or_default();
for s in sessions {
- println!("{} [{}] {}", s.id, s.state, s.task);
+ let harness = harnesses
+ .get(&s.id)
+ .map(|info| info.primary.to_string())
+ .unwrap_or_else(|| "unknown".to_string());
+ println!("{} [{}] [{}] {}", s.id, s.state, harness, s.task);
}
}
Some(Commands::Status { session_id }) => {
diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rs
index 093d7bf10..2c86e6336 100644
--- a/ecc2/src/session/manager.rs
+++ b/ecc2/src/session/manager.rs
@@ -11,7 +11,7 @@ use super::runtime::capture_command_output;
use super::store::StateStore;
use super::{
default_project_label, default_task_group_label, normalize_group_label, Session,
- SessionAgentProfile, SessionGrouping, SessionMetrics, SessionState,
+ SessionAgentProfile, SessionGrouping, SessionHarnessInfo, SessionMetrics, SessionState,
};
use crate::comms::{self, MessageType};
use crate::config::Config;
@@ -116,6 +116,11 @@ pub fn get_status(db: &StateStore, id: &str) -> Result<SessionStatus> {
let session = resolve_session(db, id)?;
let session_id = session.id.clone();
Ok(SessionStatus {
+ harness: db
+ .get_session_harness_info(&session_id)?
+ .unwrap_or_else(|| {
+ SessionHarnessInfo::detect(&session.agent_type, &session.working_dir)
+ }),
profile: db.get_session_profile(&session_id)?,
session,
parent_session: db.latest_task_handoff_source(&session_id)?,
@@ -2670,6 +2675,7 @@ async fn kill_process(pid: u32) -> Result<()> {
}
pub struct SessionStatus {
+ harness: SessionHarnessInfo,
profile: Option<SessionAgentProfile>,
session: Session,
parent_session: Option<String>,
@@ -2962,6 +2968,8 @@ impl fmt::Display for SessionStatus {
writeln!(f, "Session: {}", s.id)?;
writeln!(f, "Task: {}", s.task)?;
writeln!(f, "Agent: {}", s.agent_type)?;
+ writeln!(f, "Harness: {}", self.harness.primary)?;
+ writeln!(f, "Detected: {}", self.harness.detected_summary())?;
writeln!(f, "State: {}", s.state)?;
if let Some(profile) = self.profile.as_ref() {
writeln!(f, "Profile: {}", profile.profile_name)?;
diff --git a/ecc2/src/session/mod.rs b/ecc2/src/session/mod.rs
index ddde4cd47..0a1aa2924 100644
--- a/ecc2/src/session/mod.rs
+++ b/ecc2/src/session/mod.rs
@@ -13,6 +13,139 @@ use std::path::PathBuf;
pub type SessionAgentProfile = crate::config::ResolvedAgentProfile;
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum HarnessKind {
+ #[default]
+ Unknown,
+ Claude,
+ Codex,
+ OpenCode,
+ Gemini,
+ Cursor,
+ Kiro,
+ Trae,
+ Zed,
+ FactoryDroid,
+ Windsurf,
+}
+
+impl HarnessKind {
+ pub fn from_agent_type(agent_type: &str) -> Self {
+ match agent_type.trim().to_ascii_lowercase().as_str() {
+ "claude" | "claude-code" => Self::Claude,
+ "codex" => Self::Codex,
+ "opencode" => Self::OpenCode,
+ "gemini" | "gemini-cli" => Self::Gemini,
+ "cursor" => Self::Cursor,
+ "kiro" => Self::Kiro,
+ "trae" => Self::Trae,
+ "zed" => Self::Zed,
+ "factory-droid" | "factory_droid" | "factorydroid" => Self::FactoryDroid,
+ "windsurf" => Self::Windsurf,
+ _ => Self::Unknown,
+ }
+ }
+
+ pub fn from_db_value(value: &str) -> Self {
+ match value.trim().to_ascii_lowercase().as_str() {
+ "claude" => Self::Claude,
+ "codex" => Self::Codex,
+ "opencode" => Self::OpenCode,
+ "gemini" => Self::Gemini,
+ "cursor" => Self::Cursor,
+ "kiro" => Self::Kiro,
+ "trae" => Self::Trae,
+ "zed" => Self::Zed,
+ "factory_droid" => Self::FactoryDroid,
+ "windsurf" => Self::Windsurf,
+ _ => Self::Unknown,
+ }
+ }
+
+ pub fn as_str(self) -> &'static str {
+ match self {
+ Self::Unknown => "unknown",
+ Self::Claude => "claude",
+ Self::Codex => "codex",
+ Self::OpenCode => "opencode",
+ Self::Gemini => "gemini",
+ Self::Cursor => "cursor",
+ Self::Kiro => "kiro",
+ Self::Trae => "trae",
+ Self::Zed => "zed",
+ Self::FactoryDroid => "factory_droid",
+ Self::Windsurf => "windsurf",
+ }
+ }
+
+ fn project_markers(self) -> &'static [&'static str] {
+ match self {
+ Self::Claude => &[".claude"],
+ Self::Codex => &[".codex", ".codex-plugin"],
+ Self::OpenCode => &[".opencode"],
+ Self::Gemini => &[".gemini"],
+ Self::Cursor => &[".cursor"],
+ Self::Kiro => &[".kiro"],
+ Self::Trae => &[".trae"],
+ Self::Unknown | Self::Zed | Self::FactoryDroid | Self::Windsurf => &[],
+ }
+ }
+}
+
+impl fmt::Display for HarnessKind {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}", self.as_str())
+ }
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SessionHarnessInfo {
+ pub primary: HarnessKind,
+ pub detected: Vec<HarnessKind>,
+}
+
+impl SessionHarnessInfo {
+ pub fn detect(agent_type: &str, working_dir: &Path) -> Self {
+ let detected = [
+ HarnessKind::Claude,
+ HarnessKind::Codex,
+ HarnessKind::OpenCode,
+ HarnessKind::Gemini,
+ HarnessKind::Cursor,
+ HarnessKind::Kiro,
+ HarnessKind::Trae,
+ ]
+ .into_iter()
+ .filter(|harness| {
+ harness
+ .project_markers()
+ .iter()
+ .any(|marker| working_dir.join(marker).exists())
+ })
+ .collect::<Vec<_>>();
+
+ let primary = match HarnessKind::from_agent_type(agent_type) {
+ HarnessKind::Unknown => detected.first().copied().unwrap_or(HarnessKind::Unknown),
+ harness => harness,
+ };
+
+ Self { primary, detected }
+ }
+
+ pub fn detected_summary(&self) -> String {
+ if self.detected.is_empty() {
+ "none detected".to_string()
+ } else {
+ self.detected
+ .iter()
+ .map(|harness| harness.to_string())
+ .collect::<Vec<_>>()
+ .join(", ")
+ }
+ }
+}
+
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Session {
pub id: String,
@@ -315,3 +448,61 @@ pub struct SessionGrouping {
pub project: Option<String>,
pub task_group: Option<String>,
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::fs;
+
+ struct TestDir {
+ path: PathBuf,
+ }
+
+ impl TestDir {
+ fn new(label: &str) -> Result<Self, Box<dyn std::error::Error>> {
+ let path =
+ std::env::temp_dir().join(format!("ecc2-{}-{}", label, uuid::Uuid::new_v4()));
+ fs::create_dir_all(&path)?;
+ Ok(Self { path })
+ }
+
+ fn path(&self) -> &Path {
+ &self.path
+ }
+ }
+
+ impl Drop for TestDir {
+ fn drop(&mut self) {
+ let _ = fs::remove_dir_all(&self.path);
+ }
+ }
+
+ #[test]
+ fn detect_session_harness_prefers_agent_type_and_collects_project_markers(
+ ) -> Result<(), Box<dyn std::error::Error>> {
+ let repo = TestDir::new("session-harness-detect")?;
+ fs::create_dir_all(repo.path().join(".codex"))?;
+ fs::create_dir_all(repo.path().join(".claude"))?;
+
+ let harness = SessionHarnessInfo::detect("claude", repo.path());
+ assert_eq!(harness.primary, HarnessKind::Claude);
+ assert_eq!(
+ harness.detected,
+ vec![HarnessKind::Claude, HarnessKind::Codex]
+ );
+ assert_eq!(harness.detected_summary(), "claude, codex");
+ Ok(())
+ }
+
+ #[test]
+ fn detect_session_harness_falls_back_to_project_markers_for_unknown_agent(
+ ) -> Result<(), Box<dyn std::error::Error>> {
+ let repo = TestDir::new("session-harness-markers")?;
+ fs::create_dir_all(repo.path().join(".gemini"))?;
+
+ let harness = SessionHarnessInfo::detect("custom-runner", repo.path());
+ assert_eq!(harness.primary, HarnessKind::Gemini);
+ assert_eq!(harness.detected, vec![HarnessKind::Gemini]);
+ Ok(())
+ }
+}
diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rs
index 4ec306be9..5109bef89 100644
--- a/ecc2/src/session/store.rs
+++ b/ecc2/src/session/store.rs
@@ -16,8 +16,9 @@ use super::{
default_project_label, default_task_group_label, normalize_group_label,
ContextGraphCompactionStats, ContextGraphEntity, ContextGraphEntityDetail,
ContextGraphObservation, ContextGraphRecallEntry, ContextGraphRelation, ContextGraphSyncStats,
- ContextObservationPriority, DecisionLogEntry, FileActivityAction, FileActivityEntry, Session,
- SessionAgentProfile, SessionMessage, SessionMetrics, SessionState, WorktreeInfo,
+ ContextObservationPriority, DecisionLogEntry, FileActivityAction, FileActivityEntry,
+ HarnessKind, Session, SessionAgentProfile, SessionHarnessInfo, SessionMessage, SessionMetrics,
+ SessionState, WorktreeInfo,
};
pub struct StateStore {
@@ -171,6 +172,8 @@ impl StateStore {
project TEXT NOT NULL DEFAULT '',
task_group TEXT NOT NULL DEFAULT '',
agent_type TEXT NOT NULL,
+ harness TEXT NOT NULL DEFAULT 'unknown',
+ detected_harnesses_json TEXT NOT NULL DEFAULT '[]',
working_dir TEXT NOT NULL DEFAULT '.',
state TEXT NOT NULL DEFAULT 'pending',
pid INTEGER,
@@ -399,6 +402,24 @@ impl StateStore {
.context("Failed to add task_group column to sessions table")?;
}
+ if !self.has_column("sessions", "harness")? {
+ self.conn
+ .execute(
+ "ALTER TABLE sessions ADD COLUMN harness TEXT NOT NULL DEFAULT 'unknown'",
+ [],
+ )
+ .context("Failed to add harness column to sessions table")?;
+ }
+
+ if !self.has_column("sessions", "detected_harnesses_json")? {
+ self.conn
+ .execute(
+ "ALTER TABLE sessions ADD COLUMN detected_harnesses_json TEXT NOT NULL DEFAULT '[]'",
+ [],
+ )
+ .context("Failed to add detected_harnesses_json column to sessions table")?;
+ }
+
if !self.has_column("sessions", "input_tokens")? {
self.conn
.execute(
@@ -624,6 +645,8 @@ impl StateStore {
WHERE hook_event_id IS NOT NULL;",
)?;
+ self.backfill_session_harnesses()?;
+
Ok(())
}
@@ -637,16 +660,51 @@ impl StateStore {
Ok(columns.iter().any(|existing| existing == column))
}
+ fn backfill_session_harnesses(&self) -> Result<()> {
+ let mut stmt = self
+ .conn
+ .prepare("SELECT id, agent_type, working_dir FROM sessions")?;
+ let updates = stmt
+ .query_map([], |row| {
+ Ok((
+ row.get::<_, String>(0)?,
+ row.get::<_, String>(1)?,
+ row.get::<_, String>(2)?,
+ ))
+ })?
+ .collect::<std::result::Result<Vec<_>, _>>()?;
+
+ for (session_id, agent_type, working_dir) in updates {
+ let harness = SessionHarnessInfo::detect(&agent_type, Path::new(&working_dir));
+ let detected_json =
+ serde_json::to_string(&harness.detected).context("serialize detected harnesses")?;
+ self.conn.execute(
+ "UPDATE sessions
+ SET harness = ?2,
+ detected_harnesses_json = ?3
+ WHERE id = ?1",
+ rusqlite::params![session_id, harness.primary.to_string(), detected_json],
+ )?;
+ }
+
+ Ok(())
+ }
+
pub fn insert_session(&self, session: &Session) -> Result<()> {
+ let harness = SessionHarnessInfo::detect(&session.agent_type, &session.working_dir);
+ let detected_json =
+ serde_json::to_string(&harness.detected).context("serialize detected harnesses")?;
self.conn.execute(
- "INSERT INTO sessions (id, task, project, task_group, agent_type, working_dir, state, pid, worktree_path, worktree_branch, worktree_base, created_at, updated_at, last_heartbeat_at)
- VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)",
+ "INSERT INTO sessions (id, task, project, task_group, agent_type, harness, detected_harnesses_json, working_dir, state, pid, worktree_path, worktree_branch, worktree_base, created_at, updated_at, last_heartbeat_at)
+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16)",
rusqlite::params![
session.id,
session.task,
session.project,
session.task_group,
session.agent_type,
+ harness.primary.to_string(),
+ detected_json,
session.working_dir.to_string_lossy().to_string(),
session.state.to_string(),
session.pid.map(i64::from),
@@ -1553,6 +1611,55 @@ impl StateStore {
Ok(sessions)
}
+ pub fn list_session_harnesses(&self) -> Result<HashMap<String, SessionHarnessInfo>> {
+ let mut stmt = self.conn.prepare(
+ "SELECT id, harness, detected_harnesses_json, agent_type, working_dir FROM sessions",
+ )?;
+
+ let harnesses = stmt
+ .query_map([], |row| {
+ let session_id: String = row.get(0)?;
+ let primary = HarnessKind::from_db_value(&row.get::<_, String>(1)?);
+ let detected = serde_json::from_str::<Vec<HarnessKind>>(&row.get::<_, String>(2)?)
+ .unwrap_or_default();
+ let agent_type: String = row.get(3)?;
+ let working_dir = PathBuf::from(row.get::<_, String>(4)?);
+ let info = if primary == HarnessKind::Unknown && detected.is_empty() {
+ SessionHarnessInfo::detect(&agent_type, &working_dir)
+ } else {
+ SessionHarnessInfo { primary, detected }
+ };
+ Ok((session_id, info))
+ })?
+ .collect::<std::result::Result<HashMap<_, _>, _>>()?;
+
+ Ok(harnesses)
+ }
+
+ pub fn get_session_harness_info(&self, session_id: &str) -> Result<Option<SessionHarnessInfo>> {
+ let mut stmt = self.conn.prepare(
+ "SELECT harness, detected_harnesses_json, agent_type, working_dir
+ FROM sessions
+ WHERE id = ?1",
+ )?;
+
+ stmt.query_row([session_id], |row| {
+ let primary = HarnessKind::from_db_value(&row.get::<_, String>(0)?);
+ let detected = serde_json::from_str::<Vec<HarnessKind>>(&row.get::<_, String>(1)?)
+ .unwrap_or_default();
+ let agent_type: String = row.get(2)?;
+ let working_dir = PathBuf::from(row.get::<_, String>(3)?);
+ let info = if primary == HarnessKind::Unknown && detected.is_empty() {
+ SessionHarnessInfo::detect(&agent_type, &working_dir)
+ } else {
+ SessionHarnessInfo { primary, detected }
+ };
+ Ok(info)
+ })
+ .optional()
+ .map_err(Into::into)
+ }
+
pub fn get_latest_session(&self) -> Result<Option<Session>> {
Ok(self.list_sessions()?.into_iter().next())
}
@@ -3800,12 +3907,83 @@ mod tests {
assert!(column_names.iter().any(|column| column == "pid"));
assert!(column_names.iter().any(|column| column == "input_tokens"));
assert!(column_names.iter().any(|column| column == "output_tokens"));
+ assert!(column_names.iter().any(|column| column == "harness"));
+ assert!(column_names
+ .iter()
+ .any(|column| column == "detected_harnesses_json"));
assert!(column_names
.iter()
.any(|column| column == "last_heartbeat_at"));
Ok(())
}
+ #[test]
+ fn open_backfills_session_harness_metadata_for_legacy_rows() -> Result<()> {
+ let tempdir = TestDir::new("store-harness-backfill")?;
+ let repo_root = tempdir.path().join("repo");
+ fs::create_dir_all(repo_root.join(".codex"))?;
+ let db_path = tempdir.path().join("state.db");
+
+ let conn = Connection::open(&db_path)?;
+ conn.execute_batch(
+ "
+ CREATE TABLE sessions (
+ id TEXT PRIMARY KEY,
+ task TEXT NOT NULL,
+ project TEXT NOT NULL DEFAULT '',
+ task_group TEXT NOT NULL DEFAULT '',
+ agent_type TEXT NOT NULL,
+ working_dir TEXT NOT NULL DEFAULT '.',
+ state TEXT NOT NULL DEFAULT 'pending',
+ pid INTEGER,
+ worktree_path TEXT,
+ worktree_branch TEXT,
+ worktree_base TEXT,
+ input_tokens INTEGER DEFAULT 0,
+ output_tokens INTEGER DEFAULT 0,
+ tokens_used INTEGER DEFAULT 0,
+ tool_calls INTEGER DEFAULT 0,
+ files_changed INTEGER DEFAULT 0,
+ duration_secs INTEGER DEFAULT 0,
+ cost_usd REAL DEFAULT 0.0,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ last_heartbeat_at TEXT NOT NULL
+ );
+ ",
+ )?;
+ let now = Utc::now().to_rfc3339();
+ conn.execute(
+ "INSERT INTO sessions (
+ id, task, project, task_group, agent_type, working_dir, state, pid,
+ worktree_path, worktree_branch, worktree_base, input_tokens, output_tokens,
+ tokens_used, tool_calls, files_changed, duration_secs, cost_usd, created_at,
+ updated_at, last_heartbeat_at
+ ) VALUES (
+ ?1, ?2, ?3, ?4, ?5, ?6, 'pending', NULL,
+ NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0.0, ?7, ?7, ?7
+ )",
+ rusqlite::params![
+ "sess-legacy",
+ "Backfill harness metadata",
+ "ecc",
+ "legacy",
+ "claude",
+ repo_root.display().to_string(),
+ now,
+ ],
+ )?;
+ drop(conn);
+
+ let db = StateStore::open(&db_path)?;
+ let harness = db
+ .get_session_harness_info("sess-legacy")?
+ .expect("legacy row should be backfilled");
+ assert_eq!(harness.primary, HarnessKind::Claude);
+ assert_eq!(harness.detected, vec![HarnessKind::Codex]);
+ Ok(())
+ }
+
#[test]
fn session_profile_round_trips_with_launch_settings() -> Result<()> {
let tempdir = TestDir::new("store-session-profile")?;
diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rs
index c2e3712b5..eeb5dfec2 100644
--- a/ecc2/src/tui/dashboard.rs
+++ b/ecc2/src/tui/dashboard.rs
@@ -24,7 +24,7 @@ use crate::session::output::{
use crate::session::store::{DaemonActivity, FileActivityOverlap, StateStore};
use crate::session::{
ContextObservationPriority, DecisionLogEntry, FileActivityEntry, Session, SessionGrouping,
- SessionMessage, SessionState,
+ SessionHarnessInfo, SessionMessage, SessionState,
};
use crate::worktree;
@@ -87,6 +87,7 @@ pub struct Dashboard {
notifier: DesktopNotifier,
webhook_notifier: WebhookNotifier,
sessions: Vec<Session>,
+ session_harnesses: HashMap<String, SessionHarnessInfo>,
session_output_cache: HashMap<String, Vec<OutputLine>>,
unread_message_counts: HashMap<String, usize>,
approval_queue_counts: HashMap<String, usize>,
@@ -497,6 +498,7 @@ impl Dashboard {
let _ = db.sync_tool_activity_metrics(&cfg.tool_activity_metrics_path());
}
let sessions = db.list_sessions().unwrap_or_default();
+ let session_harnesses = db.list_session_harnesses().unwrap_or_default();
let initial_session_states = sessions
.iter()
.map(|session| (session.id.clone(), session.state.clone()))
@@ -522,6 +524,7 @@ impl Dashboard {
notifier,
webhook_notifier,
sessions,
+ session_harnesses,
session_output_cache: HashMap::new(),
unread_message_counts: HashMap::new(),
approval_queue_counts: HashMap::new(),
@@ -4035,6 +4038,13 @@ impl Dashboard {
Vec::new()
}
};
+ self.session_harnesses = match self.db.list_session_harnesses() {
+ Ok(harnesses) => harnesses,
+ Err(error) => {
+ tracing::warn!("Failed to refresh session harnesses: {error}");
+ HashMap::new()
+ }
+ };
self.unread_message_counts = match self.db.unread_message_counts() {
Ok(counts) => counts,
Err(error) => {
@@ -6332,6 +6342,14 @@ impl Dashboard {
}
}
+ if let Some(harness) = self.session_harnesses.get(&session.id) {
+ lines.push(format!(
+ "Harness {} | Detected {}",
+ harness.primary,
+ harness.detected_summary()
+ ));
+ }
+
lines.push(format!(
"Tokens {} total | In {} | Out {}",
format_token_count(metrics.tokens_used),
@@ -12281,6 +12299,40 @@ diff --git a/src/lib.rs b/src/lib.rs
Ok(())
}
+ #[test]
+ fn selected_session_metrics_text_includes_harness_summary() -> Result<()> {
+ let tempdir = std::env::temp_dir().join(format!(
+ "ecc2-dashboard-harness-metrics-{}",
+ uuid::Uuid::new_v4()
+ ));
+ fs::create_dir_all(tempdir.join(".claude"))?;
+ fs::create_dir_all(tempdir.join(".codex"))?;
+
+ let now = Utc::now();
+ let session = Session {
+ id: "sess-harness".to_string(),
+ task: "Map harness metadata".to_string(),
+ project: "ecc".to_string(),
+ task_group: "compat".to_string(),
+ agent_type: "claude".to_string(),
+ working_dir: tempdir.clone(),
+ state: SessionState::Running,
+ pid: Some(4242),
+ worktree: None,
+ created_at: now - Duration::minutes(3),
+ updated_at: now - Duration::minutes(1),
+ last_heartbeat_at: now - Duration::minutes(1),
+ metrics: SessionMetrics::default(),
+ };
+
+ let dashboard = test_dashboard(vec![session], 0);
+ let metrics_text = dashboard.selected_session_metrics_text();
+ assert!(metrics_text.contains("Harness claude | Detected claude, codex"));
+
+ let _ = fs::remove_dir_all(tempdir);
+ Ok(())
+ }
+
#[test]
fn new_session_task_uses_selected_session_context() {
let dashboard = test_dashboard(
@@ -14429,6 +14481,15 @@ diff --git a/src/lib.rs b/src/lib.rs
.iter()
.map(|session| (session.id.clone(), session.state.clone()))
.collect();
+ let session_harnesses = sessions
+ .iter()
+ .map(|session| {
+ (
+ session.id.clone(),
+ SessionHarnessInfo::detect(&session.agent_type, &session.working_dir),
+ )
+ })
+ .collect();
let output_store = SessionOutputStore::default();
let output_rx = output_store.subscribe();
let mut session_table_state = TableState::default();
@@ -14445,6 +14506,7 @@ diff --git a/src/lib.rs b/src/lib.rs
notifier,
webhook_notifier,
sessions,
+ session_harnesses,
session_output_cache: HashMap::new(),
unread_message_counts: HashMap::new(),
approval_queue_counts: HashMap::new(),