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 coordination status command
Affaan Mustafacd948783749b
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex b931e27b0..70f469b4d 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -102,6 +102,8 @@ enum Commands {#[arg(long, default_value_t = 10)]lead_limit: usize,},+ /// Show global coordination, backlog, and daemon policy status+ CoordinationStatus,/// Rebalance unread handoffs across lead teams with backed-up delegatesRebalanceAll {/// Agent type for routed delegates@@ -458,6 +460,10 @@ async fn main() -> Result<()> {);}}+ Some(Commands::CoordinationStatus) => {+ let status = session::manager::get_coordination_status(&db, &cfg)?;+ println!("{status}");+ }Some(Commands::RebalanceAll {agent,worktree: use_worktree,@@ -953,6 +959,17 @@ mod tests {}}+ #[test]+ fn cli_parses_coordination_status_command() {+ let cli = Cli::try_parse_from(["ecc", "coordination-status"])+ .expect("coordination-status should parse");++ match cli.command {+ Some(Commands::CoordinationStatus) => {}+ _ => panic!("expected coordination-status subcommand"),+ }+ }+#[test]fn cli_parses_rebalance_team_command() {let cli = Cli::try_parse_from([diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex ee210c417..2d214141a 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -1094,6 +1094,16 @@ pub struct CoordinateBacklogOutcome {pub remaining_saturated_sessions: usize,}+pub struct CoordinationStatus {+ pub backlog_leads: usize,+ pub backlog_messages: usize,+ pub absorbable_sessions: usize,+ pub saturated_sessions: usize,+ pub auto_dispatch_enabled: bool,+ pub auto_dispatch_limit_per_session: usize,+ pub daemon_activity: super::store::DaemonActivity,+}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum AssignmentAction {Spawned,@@ -1106,6 +1116,25 @@ pub fn assignment_action_routes_work(action: AssignmentAction) -> bool {!matches!(action, AssignmentAction::DeferredSaturated)}+pub fn get_coordination_status(db: &StateStore, cfg: &Config) -> Result<CoordinationStatus> {+ let targets = db.unread_task_handoff_targets(db.list_sessions()?.len().max(1))?;+ let pressure = summarize_backlog_pressure(db, cfg, &cfg.default_agent, &targets)?;+ let backlog_messages = targets+ .iter()+ .map(|(_, unread_count)| *unread_count)+ .sum::<usize>();++ Ok(CoordinationStatus {+ backlog_leads: targets.len(),+ backlog_messages,+ absorbable_sessions: pressure.absorbable_sessions,+ saturated_sessions: pressure.saturated_sessions,+ auto_dispatch_enabled: cfg.auto_dispatch_unread_handoffs,+ auto_dispatch_limit_per_session: cfg.auto_dispatch_limit_per_session,+ daemon_activity: db.daemon_activity()?,+ })+}+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]struct BacklogPressureSummary {absorbable_sessions: usize,@@ -1201,6 +1230,105 @@ impl fmt::Display for TeamStatus {}}+impl fmt::Display for CoordinationStatus {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ let stabilized = self.daemon_activity.stabilized_after_recovery_at();+ let mode = if self.daemon_activity.dispatch_cooloff_active() {+ "rebalance-cooloff (chronic saturation)"+ } else if self.daemon_activity.prefers_rebalance_first() {+ "rebalance-first (chronic saturation)"+ } else if stabilized.is_some() {+ "dispatch-first (stabilized)"+ } else {+ "dispatch-first"+ };++ writeln!(+ f,+ "Global handoff backlog: {} lead(s) / {} handoff(s) [{} absorbable, {} saturated]",+ self.backlog_leads,+ self.backlog_messages,+ self.absorbable_sessions,+ self.saturated_sessions+ )?;+ writeln!(+ f,+ "Auto-dispatch: {} @ {}/lead",+ if self.auto_dispatch_enabled {+ "on"+ } else {+ "off"+ },+ self.auto_dispatch_limit_per_session+ )?;+ writeln!(f, "Coordination mode: {mode}")?;++ if self.daemon_activity.chronic_saturation_streak > 0 {+ writeln!(+ f,+ "Chronic saturation streak: {} cycle(s)",+ self.daemon_activity.chronic_saturation_streak+ )?;+ }++ if self.daemon_activity.operator_escalation_required() {+ writeln!(+ f,+ "Operator escalation: chronic saturation is not clearing"+ )?;+ }++ if let Some(cleared_at) = self.daemon_activity.chronic_saturation_cleared_at() {+ writeln!(+ f,+ "Chronic saturation cleared: {}",+ cleared_at.to_rfc3339()+ )?;+ }++ if let Some(stabilized_at) = stabilized {+ writeln!(f, "Recovery stabilized: {}", stabilized_at.to_rfc3339())?;+ }++ if let Some(last_dispatch_at) = self.daemon_activity.last_dispatch_at.as_ref() {+ writeln!(+ f,+ "Last daemon dispatch: {} routed / {} deferred across {} lead(s) @ {}",+ self.daemon_activity.last_dispatch_routed,+ self.daemon_activity.last_dispatch_deferred,+ self.daemon_activity.last_dispatch_leads,+ last_dispatch_at.to_rfc3339()+ )?;+ }++ if stabilized.is_none() {+ if let Some(last_recovery_dispatch_at) =+ self.daemon_activity.last_recovery_dispatch_at.as_ref()+ {+ writeln!(+ f,+ "Last daemon recovery dispatch: {} handoff(s) across {} lead(s) @ {}",+ self.daemon_activity.last_recovery_dispatch_routed,+ self.daemon_activity.last_recovery_dispatch_leads,+ last_recovery_dispatch_at.to_rfc3339()+ )?;+ }++ if let Some(last_rebalance_at) = self.daemon_activity.last_rebalance_at.as_ref() {+ writeln!(+ f,+ "Last daemon rebalance: {} handoff(s) across {} lead(s) @ {}",+ self.daemon_activity.last_rebalance_rerouted,+ self.daemon_activity.last_rebalance_leads,+ last_rebalance_at.to_rfc3339()+ )?;+ }+ }++ Ok(())+ }+}+fn session_state_label(state: &SessionState) -> &'static str {match state {SessionState::Pending => "Pending",@@ -1283,6 +1411,23 @@ mod tests {}}+ fn build_daemon_activity() -> super::super::store::DaemonActivity {+ let now = Utc::now();+ super::super::store::DaemonActivity {+ last_dispatch_at: Some(now),+ last_dispatch_routed: 3,+ last_dispatch_deferred: 1,+ last_dispatch_leads: 2,+ chronic_saturation_streak: 2,+ last_recovery_dispatch_at: Some(now - Duration::seconds(5)),+ last_recovery_dispatch_routed: 2,+ last_recovery_dispatch_leads: 1,+ last_rebalance_at: Some(now - Duration::seconds(2)),+ last_rebalance_rerouted: 0,+ last_rebalance_leads: 1,+ }+ }+fn init_git_repo(path: &Path) -> Result<()> {fs::create_dir_all(path)?;run_git(path, ["init", "-q"])?;@@ -2461,4 +2606,84 @@ mod tests {Ok(())}++ #[test]+ fn coordination_status_display_surfaces_mode_and_activity() {+ let status = CoordinationStatus {+ backlog_leads: 2,+ backlog_messages: 5,+ absorbable_sessions: 1,+ saturated_sessions: 1,+ auto_dispatch_enabled: true,+ auto_dispatch_limit_per_session: 4,+ daemon_activity: build_daemon_activity(),+ };++ let rendered = status.to_string();+ assert!(+ rendered.contains(+ "Global handoff backlog: 2 lead(s) / 5 handoff(s) [1 absorbable, 1 saturated]"+ )+ );+ assert!(rendered.contains("Auto-dispatch: on @ 4/lead"));+ assert!(rendered.contains("Coordination mode: rebalance-first (chronic saturation)"));+ assert!(rendered.contains("Chronic saturation streak: 2 cycle(s)"));+ assert!(rendered.contains("Last daemon dispatch: 3 routed / 1 deferred across 2 lead(s)"));+ assert!(rendered.contains("Last daemon recovery dispatch: 2 handoff(s) across 1 lead(s)"));+ assert!(rendered.contains("Last daemon rebalance: 0 handoff(s) across 1 lead(s)"));+ }++ #[test]+ fn coordination_status_summarizes_real_handoff_backlog() -> Result<()> {+ let tempdir = TestDir::new("manager-coordination-status")?;+ let repo_root = tempdir.path().join("repo");+ init_git_repo(&repo_root)?;++ let cfg = Config {+ max_parallel_sessions: 1,+ ..build_config(tempdir.path())+ };+ let db = StateStore::open(&cfg.db_path)?;+ let now = Utc::now();++ db.insert_session(&build_session("source", SessionState::Running, now))?;+ db.insert_session(&build_session("lead-a", SessionState::Running, now))?;+ db.insert_session(&build_session("lead-b", SessionState::Running, now))?;+ db.insert_session(&build_session(+ "delegate-b",+ SessionState::Idle,+ now - Duration::seconds(1),+ ))?;++ db.send_message(+ "source",+ "lead-a",+ "{\"task\":\"clear docs\",\"context\":\"incoming\"}",+ "task_handoff",+ )?;+ db.send_message(+ "source",+ "lead-b",+ "{\"task\":\"review queue\",\"context\":\"incoming\"}",+ "task_handoff",+ )?;+ db.send_message(+ "lead-b",+ "delegate-b",+ "{\"task\":\"delegate queue\",\"context\":\"routed\"}",+ "task_handoff",+ )?;++ db.record_daemon_dispatch_pass(1, 1, 2)?;++ let status = get_coordination_status(&db, &cfg)?;+ assert_eq!(status.backlog_leads, 3);+ assert_eq!(status.backlog_messages, 3);+ assert_eq!(status.absorbable_sessions, 2);+ assert_eq!(status.saturated_sessions, 1);+ assert_eq!(status.daemon_activity.last_dispatch_routed, 1);+ assert_eq!(status.daemon_activity.last_dispatch_deferred, 1);++ Ok(())+ }}