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 health metadata
Affaan Mustafabcf8d0617e55
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex 2f17ea271..aef8bd094 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -692,12 +692,11 @@ fn format_coordination_status(}fn coordination_status_exit_code(status: &session::manager::CoordinationStatus) -> i32 {- if status.daemon_activity.operator_escalation_required() || status.saturated_sessions > 0 {- 2- } else if status.backlog_messages > 0 {- 1- } else {- 0+ match status.health {+ session::manager::CoordinationHealth::Healthy => 0,+ session::manager::CoordinationHealth::BacklogAbsorbable => 1,+ session::manager::CoordinationHealth::Saturated+ | session::manager::CoordinationHealth::EscalationRequired => 2,}}@@ -1039,6 +1038,9 @@ mod tests {backlog_messages: 5,absorbable_sessions: 1,saturated_sessions: 1,+ mode: session::manager::CoordinationMode::RebalanceFirstChronicSaturation,+ health: session::manager::CoordinationHealth::Saturated,+ operator_escalation_required: false,auto_dispatch_enabled: true,auto_dispatch_limit_per_session: 4,daemon_activity: session::store::DaemonActivity {@@ -1065,6 +1067,9 @@ mod tests {backlog_messages: 0,absorbable_sessions: 0,saturated_sessions: 0,+ mode: session::manager::CoordinationMode::DispatchFirst,+ health: session::manager::CoordinationHealth::Healthy,+ operator_escalation_required: false,auto_dispatch_enabled: false,auto_dispatch_limit_per_session: 5,daemon_activity: Default::default(),@@ -1075,12 +1080,14 @@ mod tests {backlog_messages: 2,backlog_leads: 1,absorbable_sessions: 1,+ health: session::manager::CoordinationHealth::BacklogAbsorbable,..clear.clone()};assert_eq!(coordination_status_exit_code(&absorbable), 1);let saturated = session::manager::CoordinationStatus {saturated_sessions: 1,+ health: session::manager::CoordinationHealth::Saturated,..absorbable};assert_eq!(coordination_status_exit_code(&saturated), 2);diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex 90f924e70..f8e621316 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -1101,11 +1101,32 @@ pub struct CoordinationStatus {pub backlog_messages: usize,pub absorbable_sessions: usize,pub saturated_sessions: usize,+ pub mode: CoordinationMode,+ pub health: CoordinationHealth,+ pub operator_escalation_required: bool,pub auto_dispatch_enabled: bool,pub auto_dispatch_limit_per_session: usize,pub daemon_activity: super::store::DaemonActivity,}+#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum CoordinationMode {+ DispatchFirst,+ DispatchFirstStabilized,+ RebalanceFirstChronicSaturation,+ RebalanceCooloffChronicSaturation,+}++#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum CoordinationHealth {+ Healthy,+ BacklogAbsorbable,+ Saturated,+ EscalationRequired,+}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum AssignmentAction {Spawned,@@ -1118,6 +1139,34 @@ pub fn assignment_action_routes_work(action: AssignmentAction) -> bool {!matches!(action, AssignmentAction::DeferredSaturated)}+fn coordination_mode(activity: &super::store::DaemonActivity) -> CoordinationMode {+ if activity.dispatch_cooloff_active() {+ CoordinationMode::RebalanceCooloffChronicSaturation+ } else if activity.prefers_rebalance_first() {+ CoordinationMode::RebalanceFirstChronicSaturation+ } else if activity.stabilized_after_recovery_at().is_some() {+ CoordinationMode::DispatchFirstStabilized+ } else {+ CoordinationMode::DispatchFirst+ }+}++fn coordination_health(+ backlog_messages: usize,+ saturated_sessions: usize,+ activity: &super::store::DaemonActivity,+) -> CoordinationHealth {+ if activity.operator_escalation_required() {+ CoordinationHealth::EscalationRequired+ } else if saturated_sessions > 0 {+ CoordinationHealth::Saturated+ } else if backlog_messages > 0 {+ CoordinationHealth::BacklogAbsorbable+ } else {+ CoordinationHealth::Healthy+ }+}+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)?;@@ -1125,15 +1174,23 @@ pub fn get_coordination_status(db: &StateStore, cfg: &Config) -> Result<Coordina.iter().map(|(_, unread_count)| *unread_count).sum::<usize>();+ let daemon_activity = db.daemon_activity()?;Ok(CoordinationStatus {backlog_leads: targets.len(),backlog_messages,absorbable_sessions: pressure.absorbable_sessions,saturated_sessions: pressure.saturated_sessions,+ mode: coordination_mode(&daemon_activity),+ health: coordination_health(+ backlog_messages,+ pressure.saturated_sessions,+ &daemon_activity,+ ),+ operator_escalation_required: daemon_activity.operator_escalation_required(),auto_dispatch_enabled: cfg.auto_dispatch_unread_handoffs,auto_dispatch_limit_per_session: cfg.auto_dispatch_limit_per_session,- daemon_activity: db.daemon_activity()?,+ daemon_activity,})}@@ -1235,14 +1292,15 @@ 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"+ let mode = match self.mode {+ CoordinationMode::DispatchFirst => "dispatch-first",+ CoordinationMode::DispatchFirstStabilized => "dispatch-first (stabilized)",+ CoordinationMode::RebalanceFirstChronicSaturation => {+ "rebalance-first (chronic saturation)"+ }+ CoordinationMode::RebalanceCooloffChronicSaturation => {+ "rebalance-cooloff (chronic saturation)"+ }};writeln!(@@ -1273,7 +1331,7 @@ impl fmt::Display for CoordinationStatus {)?;}- if self.daemon_activity.operator_escalation_required() {+ if self.operator_escalation_required {writeln!(f,"Operator escalation: chronic saturation is not clearing"@@ -2616,6 +2674,9 @@ mod tests {backlog_messages: 5,absorbable_sessions: 1,saturated_sessions: 1,+ mode: CoordinationMode::RebalanceFirstChronicSaturation,+ health: CoordinationHealth::Saturated,+ operator_escalation_required: false,auto_dispatch_enabled: true,auto_dispatch_limit_per_session: 4,daemon_activity: build_daemon_activity(),@@ -2683,6 +2744,9 @@ mod tests {assert_eq!(status.backlog_messages, 3);assert_eq!(status.absorbable_sessions, 2);assert_eq!(status.saturated_sessions, 1);+ assert_eq!(status.mode, CoordinationMode::RebalanceFirstChronicSaturation);+ assert_eq!(status.health, CoordinationHealth::Saturated);+ assert!(!status.operator_escalation_required);assert_eq!(status.daemon_activity.last_dispatch_routed, 1);assert_eq!(status.daemon_activity.last_dispatch_deferred, 1);