@team-agent/installer 0.5.101 → 0.5.103

package/crates/team-agent/src/mcp_server/types.rs

@@ -48,48 +48,25 @@ pub enum McpError {
 // WIRE ENUMS (§19) —散字符串 → 穷尽 enum;契约字节级真相由这些派生。
 // ═══════════════════════════════════════════════════════════════════════════
 
-/// The 12 MCP tool names (`server.py:19-43` if-chain = 字符串打地鼠). Exhaustive
-/// match; unknown → [`ToolErrorReason::UnknownTool`]. [`tools_contract`] (the
-/// `TOOLS` wire list returned by `tools/list`) MUST be derived from this enum so
-/// name/inputSchema stay byte-identical to `contracts.py`.
+/// The three MCP tool names. Unknown names map to [`ToolErrorReason::UnknownTool`].
+/// [`tools_contract`] (the `tools/list` payload) is derived from this enum.
 ///
 /// [`tools_contract`]: super::tools_contract
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum McpTool {
-    AssignTask,
     SendMessage,
     ReportResult,
-    UpdateState,
     GetTeamStatus,
-    StopAgent,
-    ResetAgent,
-    AddAgent,
-    CloneAgent,
-    ForkAgent,
-    RequestHuman,
-    StuckList,
-    StuckCancel,
 }
 
 impl McpTool {
-    /// Wire name (`assign_task` … `stuck_cancel`) — the byte-stable string used in
-    /// `tools/list` and `tools/call`. Parse failure ⇒ [`ToolErrorReason::UnknownTool`].
+    /// Wire name used in `tools/list` and `tools/call`.
     pub fn wire_name(self) -> &'static str {
         match self {
-            McpTool::AssignTask => "assign_task",
             McpTool::SendMessage => "send_message",
             McpTool::ReportResult => "report_result",
-            McpTool::UpdateState => "update_state",
             McpTool::GetTeamStatus => "get_team_status",
-            McpTool::StopAgent => "stop_agent",
-            McpTool::ResetAgent => "reset_agent",
-            McpTool::AddAgent => "add_agent",
-            McpTool::CloneAgent => "clone_agent",
-            McpTool::ForkAgent => "fork_agent",
-            McpTool::RequestHuman => "request_human",
-            McpTool::StuckList => "stuck_list",
-            McpTool::StuckCancel => "stuck_cancel",
         }
     }
 
@@ -97,19 +74,9 @@ impl McpTool {
     /// to [`ToolErrorReason::UnknownTool`], matching `server.py:43`).
     pub fn parse(name: &str) -> Option<Self> {
         match name {
-            "assign_task" => Some(McpTool::AssignTask),
             "send_message" => Some(McpTool::SendMessage),
             "report_result" => Some(McpTool::ReportResult),
-            "update_state" => Some(McpTool::UpdateState),
             "get_team_status" => Some(McpTool::GetTeamStatus),
-            "stop_agent" => Some(McpTool::StopAgent),
-            "reset_agent" => Some(McpTool::ResetAgent),
-            "add_agent" => Some(McpTool::AddAgent),
-            "clone_agent" => Some(McpTool::CloneAgent),
-            "fork_agent" => Some(McpTool::ForkAgent),
-            "request_human" => Some(McpTool::RequestHuman),
-            "stuck_list" => Some(McpTool::StuckList),
-            "stuck_cancel" => Some(McpTool::StuckCancel),
             _ => None,
         }
     }

package/crates/team-agent/src/mcp_server/wire.rs

@@ -25,19 +25,9 @@ use super::types::{
 /// schema cannot drift from the enum. Returned verbatim by `tools/list`.
 pub fn tools_contract() -> Vec<Value> {
     let tools = [
-        McpTool::AssignTask,
         McpTool::SendMessage,
         McpTool::ReportResult,
-        McpTool::UpdateState,
         McpTool::GetTeamStatus,
-        McpTool::StopAgent,
-        McpTool::ResetAgent,
-        McpTool::AddAgent,
-        McpTool::CloneAgent,
-        McpTool::ForkAgent,
-        McpTool::RequestHuman,
-        McpTool::StuckList,
-        McpTool::StuckCancel,
     ];
     tools.into_iter().map(tool_contract).collect()
 }
@@ -397,21 +387,11 @@ fn tool_contract(tool: McpTool) -> Value {
             "Send a message to a teammate, the leader, or '*' for all other team members. mailbox=true stores durably without live injection; the default is live delivery.",
             vec!["to", "content"],
         ),
-        McpTool::AssignTask => ("Assign or update a task in the team graph and deliver it to its assignee.", vec!["task"]),
         McpTool::ReportResult => (
             "Report task completion with a durable result envelope. Optional presentation routing controls live leader display, not persistence.",
             Vec::new(),
         ),
-        McpTool::UpdateState => ("Append a note to team state and rewrite team_state.md.", vec!["note"]),
         McpTool::GetTeamStatus => ("Return machine-readable team status.", Vec::new()),
-        McpTool::StopAgent => ("Stop a running worker.", vec!["agent_id"]),
-        McpTool::ResetAgent => ("Reset one worker to a fresh session.", vec!["agent_id", "discard_session"]),
-        McpTool::AddAgent => ("Add a first-class worker from a role file.", vec!["new_agent_id", "role_file_path"]),
-        McpTool::CloneAgent => ("Clone a worker role into a fresh provider session.", vec!["source_agent_id", "as_agent_id"]),
-        McpTool::ForkAgent => ("Fork a running worker.", vec!["source_agent_id", "as_agent_id"]),
-        McpTool::RequestHuman => ("Ask the leader or user for human input.", vec!["question"]),
-        McpTool::StuckList => ("List manually suppressed idle alerts.", Vec::new()),
-        McpTool::StuckCancel => ("Suppress repeated stuck or idle alerts.", vec!["agent_id"]),
     };
     serde_json::json!({
         "name": tool.wire_name(),
@@ -428,14 +408,6 @@ fn tool_contract(tool: McpTool) -> Value {
 fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
     let mut properties = serde_json::Map::new();
     match tool {
-        McpTool::AssignTask => {
-            insert_property(&mut properties, "task", task_property());
-            insert_property(
-                &mut properties,
-                "message",
-                string_property("Optional message to deliver with the task."),
-            );
-        }
         McpTool::SendMessage => {
             insert_property(
                 &mut properties,
@@ -506,108 +478,7 @@ fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
                 presentation_property("Optional durable presentation routing."),
             );
         }
-        McpTool::UpdateState => {
-            insert_property(
-                &mut properties,
-                "note",
-                string_property("Note to append to team state."),
-            );
-        }
-        McpTool::GetTeamStatus | McpTool::StuckList => {}
-        McpTool::StopAgent => {
-            insert_property(
-                &mut properties,
-                "agent_id",
-                string_property("Agent id to stop."),
-            );
-        }
-        McpTool::ResetAgent => {
-            insert_property(
-                &mut properties,
-                "agent_id",
-                string_property("Agent id to reset."),
-            );
-            insert_property(
-                &mut properties,
-                "discard_session",
-                boolean_property("Whether to discard the existing provider session."),
-            );
-        }
-        McpTool::AddAgent => {
-            insert_property(
-                &mut properties,
-                "new_agent_id",
-                string_property("New agent id."),
-            );
-            insert_property(
-                &mut properties,
-                "role_file_path",
-                string_property("Workspace-relative role file path."),
-            );
-        }
-        McpTool::ForkAgent => {
-            insert_property(
-                &mut properties,
-                "source_agent_id",
-                string_property("Agent id to fork from."),
-            );
-            insert_property(
-                &mut properties,
-                "as_agent_id",
-                string_property("Agent id for the forked worker."),
-            );
-            insert_property(
-                &mut properties,
-                "label",
-                string_property("Optional display label."),
-            );
-        }
-        McpTool::CloneAgent => {
-            insert_property(
-                &mut properties,
-                "source_agent_id",
-                string_property("Agent id to clone from."),
-            );
-            insert_property(
-                &mut properties,
-                "as_agent_id",
-                string_property("Agent id for the cloned worker."),
-            );
-            insert_property(
-                &mut properties,
-                "label",
-                string_property("Optional display label."),
-            );
-        }
-        McpTool::RequestHuman => {
-            insert_property(
-                &mut properties,
-                "question",
-                string_property("Question to ask the human."),
-            );
-            insert_property(
-                &mut properties,
-                "task_id",
-                string_property("Optional related task id."),
-            );
-            insert_property(
-                &mut properties,
-                "agent_id",
-                string_property("Optional requesting agent id."),
-            );
-        }
-        McpTool::StuckCancel => {
-            insert_property(
-                &mut properties,
-                "agent_id",
-                string_property("Agent id whose stuck alerts should be suppressed."),
-            );
-            insert_property(
-                &mut properties,
-                "alert_type",
-                string_property("Alert type to suppress, or all."),
-            );
-        }
+        McpTool::GetTeamStatus => {}
     }
     properties
 }
@@ -628,25 +499,6 @@ fn object_property(description: &str) -> Value {
     serde_json::json!({"type": "object", "description": description, "additionalProperties": true})
 }
 
-fn task_property() -> Value {
-    serde_json::json!({
-        "type": "object",
-        "description": "Task object to add or update.",
-        "properties": {
-            "result_route": {
-                "type": "string",
-                "enum": crate::messaging::results::ResultRoute::ALL
-                    .iter()
-                    .map(|route| route.as_str())
-                    .collect::<Vec<_>>(),
-                "default": crate::messaging::results::ResultRoute::default().as_str(),
-                "description": "Result destination chosen by the task assigner."
-            }
-        },
-        "additionalProperties": true
-    })
-}
-
 fn presentation_property(description: &str) -> Value {
     serde_json::json!({
         "type": "object",
@@ -690,14 +542,8 @@ pub(crate) fn dispatch_tool(
         }
         _ => {}
     }
-    if scope_ceiling_tool(tool) {
-        tools.validate_rpc_scope_args(tool.wire_name(), args)?;
-    }
+    tools.validate_rpc_scope_args(tool.wire_name(), args)?;
     match tool {
-        McpTool::AssignTask => tools.assign_task(
-            args.get("task").unwrap_or(args),
-            args.get("message").and_then(Value::as_str),
-        ),
         McpTool::SendMessage => {
             let target = message_target_from_value(args.get("to"));
             let content = args.get("content").and_then(Value::as_str).unwrap_or("");
@@ -740,77 +586,10 @@ pub(crate) fn dispatch_tool(
             args.get("agent_id").and_then(Value::as_str),
             args.get("presentation"),
         ),
-        McpTool::UpdateState => {
-            tools.update_state(args.get("note").and_then(Value::as_str).unwrap_or(""))
-        }
         McpTool::GetTeamStatus => tools.get_team_status(),
-        McpTool::StopAgent => {
-            tools.stop_agent(args.get("agent_id").and_then(Value::as_str).unwrap_or(""))
-        }
-        McpTool::ResetAgent => tools.reset_agent(
-            args.get("agent_id").and_then(Value::as_str).unwrap_or(""),
-            args.get("discard_session")
-                .and_then(Value::as_bool)
-                .unwrap_or(false),
-        ),
-        McpTool::AddAgent => tools.add_agent(
-            args.get("new_agent_id")
-                .and_then(Value::as_str)
-                .unwrap_or(""),
-            args.get("role_file_path")
-                .and_then(Value::as_str)
-                .unwrap_or(""),
-        ),
-        McpTool::ForkAgent => tools.fork_agent(
-            args.get("source_agent_id")
-                .and_then(Value::as_str)
-                .unwrap_or(""),
-            args.get("as_agent_id")
-                .and_then(Value::as_str)
-                .unwrap_or(""),
-            args.get("label").and_then(Value::as_str),
-        ),
-        McpTool::CloneAgent => tools.clone_agent(
-            args.get("source_agent_id")
-                .and_then(Value::as_str)
-                .unwrap_or(""),
-            args.get("as_agent_id")
-                .and_then(Value::as_str)
-                .unwrap_or(""),
-            args.get("label").and_then(Value::as_str),
-        ),
-        McpTool::RequestHuman => tools.request_human(
-            args.get("question").and_then(Value::as_str).unwrap_or(""),
-            args.get("task_id").and_then(Value::as_str),
-            args.get("agent_id").and_then(Value::as_str),
-        ),
-        McpTool::StuckList => tools.stuck_list(),
-        McpTool::StuckCancel => tools.stuck_cancel(
-            args.get("agent_id").and_then(Value::as_str).unwrap_or(""),
-            // tools.py:351 — the MCP default alert_type is "stuck", not "all".
-            args.get("alert_type")
-                .and_then(Value::as_str)
-                .unwrap_or("stuck"),
-        ),
     }
 }
 
-fn scope_ceiling_tool(tool: McpTool) -> bool {
-    matches!(
-        tool,
-        McpTool::SendMessage
-            | McpTool::ReportResult
-            | McpTool::RequestHuman
-            | McpTool::AssignTask
-            | McpTool::UpdateState
-            | McpTool::GetTeamStatus
-            | McpTool::StopAgent
-            | McpTool::ResetAgent
-            | McpTool::CloneAgent
-            | McpTool::ForkAgent
-    )
-}
-
 fn message_target_from_value(value: Option<&Value>) -> MessageTarget {
     match value {
         Some(Value::String(s)) if s == "*" => MessageTarget::Broadcast,

package/crates/team-agent/src/messaging/leader_receiver.rs

@@ -22,7 +22,7 @@ use super::{
 };
 
 /// `_send_to_leader_receiver` (`leader.py:69`) — **N31/N32 funnel primitive**:所有 leader-bound
-/// caller(send_message(to=leader) / report_result / request_human / idle reminder /
+/// caller(send_message(to=leader) / report_result / idle reminder /
 /// broadcast-to-leader / peer-mirror / worker.abnormal_exit)统一经过这里。
 ///
 /// 职责 = create_message + leader_notification_log dedup(result_id 时)+ audit + emit

package/crates/team-agent/src/messaging/mod.rs

@@ -105,14 +105,14 @@ pub use results::{
     collect, collect_for_team, report_result, report_result_for_owner_team,
     report_result_for_owner_team_with_primary_error,
 };
-pub use scheduler::{detect_stuck_agents, fire_due_scheduled_events, stuck_cancel, stuck_list};
+pub use scheduler::{detect_stuck_agents, fire_due_scheduled_events};
 pub use selftest::{run_comms_selftest, CommsSelftestDriver};
 pub use send::{
     apply_worker_sender_bypass, send_message, MessageTarget, SendOptions, TrustedSender,
 };
 pub use trust::{attempt_trust_auto_answer, TrustAnswerOutcome};
 pub use types::{
-    ActivityStatus, AgentActivity, AlertType, CheckEvidence, CheckKind, CheckStatus,
+    ActivityStatus, AgentActivity, CheckEvidence, CheckKind, CheckStatus,
     ContractSuiteCheck, DeliveryOutcome, DeliveryRefusal, DeliveryStage, DeliveryStatus,
     IdleEvaluation, LeaderNotificationKey, LeaderReceiver, PaneWidthQuery,
     ProviderSdkCalls, ReceiverMode, ScheduledKind, SelftestCheck, SelftestReport, SendEventPayload,

package/crates/team-agent/src/messaging/results.rs

@@ -1046,25 +1046,6 @@ fn leader_result_presentation(task_id: &str) -> super::presentation::Presentatio
     )
 }
 
-const LEADER_NOTIFICATION_LIMIT_BYTES: usize = 160;
-
-fn truncate_utf8(text: &str, max_bytes: usize) -> String {
-    if text.len() <= max_bytes {
-        return text.to_string();
-    }
-    let suffix = "...";
-    let budget = max_bytes.saturating_sub(suffix.len());
-    let mut end = 0;
-    for (index, ch) in text.char_indices() {
-        let next = index + ch.len_utf8();
-        if next > budget {
-            break;
-        }
-        end = next;
-    }
-    format!("{}{}", &text[..end], suffix)
-}
-
 fn format_report_result_leader_summary(
     result_id: &str,
     task_id: &str,
@@ -1075,19 +1056,8 @@ fn format_report_result_leader_summary(
     let summary = envelope
         .get("summary")
         .and_then(serde_json::Value::as_str)
-        .unwrap_or("")
-        .lines()
-        .next()
-        .unwrap_or("")
-        .chars()
-        .filter(|ch| !ch.is_control())
-        .collect::<String>();
-    truncate_utf8(
-        &format!(
-            "Task {task_id} reported {status} from {agent_id}: {summary}; Result id: {result_id}"
-        ),
-        LEADER_NOTIFICATION_LIMIT_BYTES,
-    )
+        .unwrap_or("");
+    format!("Task {task_id} reported {status} from {agent_id}: {summary}; Result id: {result_id}")
 }
 
 fn auto_finalize_result(
@@ -1441,18 +1411,17 @@ mod tests {
     }
 
     #[test]
-    fn leader_result_summary_is_single_line_and_byte_bounded() {
-        let envelope = serde_json::json!({"summary": "中".repeat(4096)});
+    fn leader_result_summary_preserves_long_multiline_text_verbatim() {
+        let source = format!("首行\nbranch: fix/keyboard-receive-and-compose\ncommit: {}", "a1b2c3d4e5f67890".repeat(24));
+        let envelope = serde_json::json!({"summary": source});
         let summary = super::format_report_result_leader_summary(
-            "res-1",
-            "task-1",
-            "worker",
-            "success",
-            &envelope,
+            "res-1", "task-1", "worker", "success", &envelope,
         );
-        assert!(summary.len() <= 160);
-        assert!(!summary.contains('\n'));
-        assert!(summary.ends_with("..."));
+        let source = envelope["summary"].as_str().unwrap();
+        assert_eq!(summary, format!("Task task-1 reported success from worker: {source}; Result id: res-1"));
+        assert!(summary.len() > 160);
+        assert!(summary.contains("\nbranch: fix/keyboard-receive-and-compose\ncommit: "));
+        assert!(summary.contains("a1b2c3d4e5f67890".repeat(24).as_str()));
     }
 
     #[test]

package/crates/team-agent/src/messaging/scheduler.rs

@@ -1,5 +1,5 @@
 //!
-//! scheduler.py — 调度器心脏 + stuck 检测 + 告警抑制 (card §18/§68/§73)。
+//! Scheduled-event dispatch and coordinator stuck detection (card §18/§68/§73).
 
 use std::path::Path;
 
@@ -11,9 +11,7 @@ use crate::transport::{PaneId, Transport};
 
 use super::delivery::{deliver_stored_message, handle_trust_retry_needed};
 use super::helpers::{parse_scheduled_kind, status_wire};
-use super::{
-    AlertType, MessagingError, ScheduledKind, TrustRetryPayload, TRUST_RETRY_MAX_ATTEMPTS,
-};
+use super::{MessagingError, ScheduledKind, TrustRetryPayload, TRUST_RETRY_MAX_ATTEMPTS};
 
 /// `_fire_due_scheduled_events` (`scheduler.py:41`):coordinator tick 的调度器心脏 —— 分派到期
 /// `send`/`health_ping`/`trust_retry` ([`ScheduledKind`] 穷尽 match),send 失败有界重试。
@@ -209,204 +207,3 @@ fn output_is_stale(last_output_at: &str, timeout_seconds: i64) -> bool {
         .num_seconds()
         >= timeout_seconds
 }
-
-/// stuck/idle 告警列表 (`scheduler.py:222`)。team-scoped 抑制查询。CLI 调。
-pub fn stuck_list(workspace: &Path) -> Result<serde_json::Value, MessagingError> {
-    let state = crate::state::persist::load_runtime_state(workspace)?;
-    let team = active_team_key(workspace, &state);
-    let suppressed = state
-        .get("coordinator")
-        .and_then(|v| v.get("suppressed_idle_alerts"))
-        .and_then(|v| v.get(&team))
-        .cloned()
-        .unwrap_or_else(|| serde_json::json!({}));
-    Ok(serde_json::json!({"ok": true, "suppressed_idle_alerts": suppressed}))
-}
-
-/// 取消 idle 告警抑制 (`scheduler.py:262`)。`alert_type` 为 [`AlertType`] 或 `all` (展开全集);
-/// owner-gate 校验 (check_team_owner)。CLI 调。
-pub fn stuck_cancel(
-    workspace: &Path,
-    agent_id: &str,
-    alert_type: Option<AlertType>,
-    suppressed_by: &str,
-) -> Result<serde_json::Value, MessagingError> {
-    let alert_types: Vec<&str> = match alert_type {
-        Some(AlertType::Stuck) => vec!["stuck"],
-        Some(AlertType::IdleFallback) => vec!["idle_fallback"],
-        Some(AlertType::CrossWorkerDeadlock) => vec!["cross_worker_deadlock"],
-        None => vec!["cross_worker_deadlock", "idle_fallback", "stuck"],
-    };
-    let mut state = crate::state::persist::load_runtime_state(workspace)?;
-    let team = active_team_key(workspace, &state);
-    let now = chrono::Utc::now().to_rfc3339();
-    let assigned = assigned_task_ids(&state, agent_id);
-    let store = MessageStore::open(workspace)?;
-    let delivered = delivered_message_ids(&store, &team, agent_id)?;
-    for kind in &alert_types {
-        upsert_suppression(
-            &mut state,
-            SuppressionRecord {
-                team: &team,
-                agent_id,
-                alert_type: kind,
-                suppressed_by,
-                suppressed_at: &now,
-                assigned_task_ids: assigned.clone(),
-                delivered_message_ids: delivered.clone(),
-            },
-        );
-    }
-    crate::state::repository::StateRepository::new(workspace).save_reapplying(
-        crate::state::repository::StateWriteIntent::SchedulerSuppression {
-            owner_team_id: Some(&team),
-        },
-        &state,
-        |latest| {
-            for kind in &alert_types {
-                upsert_suppression(
-                    latest,
-                    SuppressionRecord {
-                        team: &team,
-                        agent_id,
-                        alert_type: kind,
-                        suppressed_by,
-                        suppressed_at: &now,
-                        assigned_task_ids: assigned.clone(),
-                        delivered_message_ids: delivered.clone(),
-                    },
-                );
-            }
-        },
-    )?;
-    crate::event_log::EventLog::new(workspace).write(
-        "coordinator.idle_alert_suppressed",
-        serde_json::json!({
-            "agent_id": agent_id,
-            "team": team,
-            "alert_types": alert_types,
-            "suppressed_by": suppressed_by,
-        }),
-    )?;
-    let suppressed = state
-        .get("coordinator")
-        .and_then(|v| v.get("suppressed_idle_alerts"))
-        .and_then(|v| v.get(&team))
-        .and_then(|v| v.get(agent_id))
-        .cloned()
-        .unwrap_or_else(|| serde_json::json!({}));
-    Ok(serde_json::json!({
-        "ok": true,
-        "agent_id": agent_id,
-        "alert_types": alert_types,
-        "suppressed": suppressed
-    }))
-}
-
-fn active_team_key(workspace: &Path, state: &serde_json::Value) -> String {
-    state
-        .get("active_team_key")
-        .and_then(serde_json::Value::as_str)
-        .filter(|team| !team.is_empty())
-        .map(ToString::to_string)
-        .or_else(|| {
-            workspace
-                .file_name()
-                .map(|name| name.to_string_lossy().to_string())
-        })
-        .unwrap_or_else(|| "current".to_string())
-}
-
-fn assigned_task_ids(state: &serde_json::Value, agent_id: &str) -> Vec<String> {
-    let mut ids: Vec<String> = state
-        .get("tasks")
-        .and_then(serde_json::Value::as_array)
-        .map(|tasks| {
-            tasks
-                .iter()
-                .filter(|task| {
-                    task.get("assignee").and_then(serde_json::Value::as_str) == Some(agent_id)
-                })
-                .filter_map(|task| {
-                    task.get("id")
-                        .and_then(serde_json::Value::as_str)
-                        .map(ToString::to_string)
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-    ids.sort();
-    ids
-}
-
-fn delivered_message_ids(
-    store: &MessageStore,
-    team: &str,
-    agent_id: &str,
-) -> Result<Vec<String>, MessagingError> {
-    let conn = crate::db::schema::open_db(store.db_path())?;
-    let mut stmt = conn.prepare(
-        "select message_id from messages
-         where (owner_team_id = ?1 or owner_team_id is null)
-           and recipient = ?2
-           and status in ('visible', 'submitted', 'delivered', 'acknowledged')
-         order by message_id",
-    )?;
-    let rows = stmt.query_map(params![team, agent_id], |row| row.get::<_, String>(0))?;
-    Ok(rows.collect::<Result<Vec<_>, _>>()?)
-}
-
-struct SuppressionRecord<'a> {
-    team: &'a str,
-    agent_id: &'a str,
-    alert_type: &'a str,
-    suppressed_by: &'a str,
-    suppressed_at: &'a str,
-    assigned_task_ids: Vec<String>,
-    delivered_message_ids: Vec<String>,
-}
-
-fn upsert_suppression(state: &mut serde_json::Value, record: SuppressionRecord<'_>) {
-    let Some(root) = state.as_object_mut() else {
-        return;
-    };
-    let Some(coordinator) = root
-        .entry("coordinator")
-        .or_insert_with(|| serde_json::json!({}))
-        .as_object_mut()
-    else {
-        return;
-    };
-    let Some(all) = coordinator
-        .entry("suppressed_idle_alerts")
-        .or_insert_with(|| serde_json::json!({}))
-        .as_object_mut()
-    else {
-        return;
-    };
-    let Some(team_map) = all
-        .entry(record.team.to_string())
-        .or_insert_with(|| serde_json::json!({}))
-        .as_object_mut()
-    else {
-        return;
-    };
-    let Some(agent_map) = team_map
-        .entry(record.agent_id.to_string())
-        .or_insert_with(|| serde_json::json!({}))
-        .as_object_mut()
-    else {
-        return;
-    };
-    agent_map.insert(
-        record.alert_type.to_string(),
-        serde_json::json!({
-            "suppressed_at": record.suppressed_at,
-            "suppressed_by": record.suppressed_by,
-            "snapshot": {
-                "assigned_task_ids": record.assigned_task_ids,
-                "delivered_message_ids": record.delivered_message_ids
-            },
-        }),
-    );
-}