The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat: classify ecc2 remaining coordination pressure
Affaan Mustafaa3f600e25fcc
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex d75344a35..2032ab672 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -392,13 +392,15 @@ async fn main() -> Result<()> {println!("Backlog already clear");} else {println!(- "Coordinated backlog: dispatched {} handoff(s) across {} lead(s); rebalanced {} handoff(s) across {} lead(s); remaining {} handoff(s) across {} session(s)",+ "Coordinated backlog: dispatched {} handoff(s) across {} lead(s); rebalanced {} handoff(s) across {} lead(s); remaining {} handoff(s) across {} session(s) [{} absorbable, {} saturated]",total_routed,outcome.dispatched.len(),total_rerouted,outcome.rebalanced.len(),outcome.remaining_backlog_messages,- outcome.remaining_backlog_sessions+ outcome.remaining_backlog_sessions,+ outcome.remaining_absorbable_sessions,+ outcome.remaining_saturated_sessions);}}diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex 5f0537a13..889e3a876 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -212,6 +212,7 @@ pub async fn coordinate_backlog(let dispatched = auto_dispatch_backlog(db, cfg, agent_type, use_worktree, lead_limit).await?;let rebalanced = rebalance_all_teams(db, cfg, agent_type, use_worktree, lead_limit).await?;let remaining_targets = db.unread_task_handoff_targets(db.list_sessions()?.len().max(1))?;+ let pressure = summarize_backlog_pressure(db, cfg, agent_type, &remaining_targets)?;let remaining_backlog_sessions = remaining_targets.len();let remaining_backlog_messages = remaining_targets.iter()@@ -223,6 +224,8 @@ pub async fn coordinate_backlog(rebalanced,remaining_backlog_sessions,remaining_backlog_messages,+ remaining_absorbable_sessions: pressure.absorbable_sessions,+ remaining_saturated_sessions: pressure.saturated_sessions,})}@@ -811,6 +814,33 @@ fn direct_delegate_sessions(db: &StateStore, lead_id: &str, agent_type: &str) ->Ok(sessions)}+fn summarize_backlog_pressure(+ db: &StateStore,+ cfg: &Config,+ agent_type: &str,+ targets: &[(String, usize)],+) -> Result<BacklogPressureSummary> {+ let unread_counts = db.unread_message_counts()?;+ let mut summary = BacklogPressureSummary::default();++ for (session_id, _) in targets {+ let delegates = direct_delegate_sessions(db, session_id, agent_type)?;+ let has_clear_idle_delegate = delegates.iter().any(|delegate| {+ delegate.state == SessionState::Idle+ && unread_counts.get(&delegate.id).copied().unwrap_or(0) == 0+ });+ let has_capacity = delegates.len() < cfg.max_parallel_sessions;++ if has_clear_idle_delegate || has_capacity {+ summary.absorbable_sessions += 1;+ } else {+ summary.saturated_sessions += 1;+ }+ }++ Ok(summary)+}+fn send_task_handoff(db: &StateStore,from_session: &Session,@@ -1035,6 +1065,8 @@ pub struct CoordinateBacklogOutcome {pub rebalanced: Vec<LeadRebalanceOutcome>,pub remaining_backlog_sessions: usize,pub remaining_backlog_messages: usize,+ pub remaining_absorbable_sessions: usize,+ pub remaining_saturated_sessions: usize,}#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -1044,6 +1076,12 @@ pub enum AssignmentAction {ReusedActive,}+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]+struct BacklogPressureSummary {+ absorbable_sessions: usize,+ saturated_sessions: usize,+}+struct DelegatedSessionSummary {depth: usize,unread_messages: usize,@@ -1975,6 +2013,77 @@ mod tests {assert_eq!(outcome.rebalanced.len(), 0);assert_eq!(outcome.remaining_backlog_sessions, 2);assert_eq!(outcome.remaining_backlog_messages, 2);+ assert_eq!(outcome.remaining_absorbable_sessions, 2);+ assert_eq!(outcome.remaining_saturated_sessions, 0);++ Ok(())+ }++ #[tokio::test(flavor = "current_thread")]+ async fn coordinate_backlog_classifies_remaining_saturated_pressure() -> Result<()> {+ let tempdir = TestDir::new("manager-coordinate-saturated")?;+ let repo_root = tempdir.path().join("repo");+ init_git_repo(&repo_root)?;++ let mut cfg = build_config(tempdir.path());+ cfg.max_parallel_sessions = 1;+ cfg.auto_dispatch_limit_per_session = 1;+ let db = StateStore::open(&cfg.db_path)?;+ let now = Utc::now();++ db.insert_session(&Session {+ id: "worker".to_string(),+ task: "worker task".to_string(),+ agent_type: "claude".to_string(),+ working_dir: repo_root.clone(),+ state: SessionState::Running,+ pid: Some(42),+ worktree: None,+ created_at: now - Duration::minutes(3),+ updated_at: now - Duration::minutes(3),+ metrics: SessionMetrics::default(),+ })?;++ db.insert_session(&Session {+ id: "worker-child".to_string(),+ task: "delegate task".to_string(),+ agent_type: "claude".to_string(),+ working_dir: repo_root.clone(),+ state: SessionState::Running,+ pid: Some(43),+ worktree: None,+ created_at: now - Duration::minutes(2),+ updated_at: now - Duration::minutes(2),+ metrics: SessionMetrics::default(),+ })?;++ db.send_message(+ "worker",+ "worker-child",+ "{\"task\":\"seed delegate\",\"context\":\"Delegated from worker\"}",+ "task_handoff",+ )?;+ let _ = db.mark_messages_read("worker-child")?;++ db.send_message(+ "planner",+ "worker",+ "{\"task\":\"task-a\",\"context\":\"Inbound\"}",+ "task_handoff",+ )?;+ db.send_message(+ "planner",+ "worker",+ "{\"task\":\"task-b\",\"context\":\"Inbound\"}",+ "task_handoff",+ )?;++ let outcome = coordinate_backlog(&db, &cfg, "claude", true, 10).await?;++ assert_eq!(outcome.remaining_backlog_sessions, 1);+ assert_eq!(outcome.remaining_backlog_messages, 2);+ assert_eq!(outcome.remaining_absorbable_sessions, 0);+ assert_eq!(outcome.remaining_saturated_sessions, 1);Ok(())}diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex cdf85cfab..c4bdea08c 100644--- a/ecc2/src/tui/dashboard.rs+++ b/ecc2/src/tui/dashboard.rs@@ -936,13 +936,15 @@ impl Dashboard {self.set_operator_note("backlog already clear".to_string());} else {self.set_operator_note(format!(- "coordinated backlog: dispatched {} across {} lead(s), rebalanced {} across {} lead(s), remaining {} across {} session(s)",+ "coordinated backlog: dispatched {} across {} lead(s), rebalanced {} across {} lead(s), remaining {} across {} session(s) [{} absorbable, {} saturated]",total_routed,outcome.dispatched.len(),total_rerouted,outcome.rebalanced.len(),outcome.remaining_backlog_messages,- outcome.remaining_backlog_sessions+ outcome.remaining_backlog_sessions,+ outcome.remaining_absorbable_sessions,+ outcome.remaining_saturated_sessions));}}