@team-agent/installer 0.5.100 → 0.5.102

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/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
-            },
-        }),
-    );
-}

package/crates/team-agent/src/messaging/tests/basic.rs

@@ -140,23 +140,6 @@ fn activity_status_serde_byte_locked() {
     );
 }
 
-#[test]
-fn alert_type_serde_byte_locked() {
-    // scheduler.py:38 _ALERT_TYPES set members.
-    assert_eq!(
-        serde_json::to_string(&AlertType::Stuck).unwrap(),
-        "\"stuck\""
-    );
-    assert_eq!(
-        serde_json::to_string(&AlertType::IdleFallback).unwrap(),
-        "\"idle_fallback\""
-    );
-    assert_eq!(
-        serde_json::to_string(&AlertType::CrossWorkerDeadlock).unwrap(),
-        "\"cross_worker_deadlock\""
-    );
-}
-
 #[test]
 fn check_status_serde_byte_locked() {
     assert_eq!(
@@ -266,20 +249,6 @@ fn provider_sdk_calls_is_zero_only_when_all_three_zero() {
     .is_zero());
 }
 
-#[test]
-fn alert_type_all_is_sorted_full_set() {
-    // scheduler.py:269 sorted(_ALERT_TYPES) =
-    //   ['cross_worker_deadlock','idle_fallback','stuck'].
-    assert_eq!(
-        AlertType::all(),
-        [
-            AlertType::CrossWorkerDeadlock,
-            AlertType::IdleFallback,
-            AlertType::Stuck
-        ]
-    );
-}
-
 #[test]
 fn activity_status_idle_takeover_gate_uncertain_never_idle() {
     // THE IRON LAW (bug-071/077/085): only Idle passes; Uncertain/Working/Stuck

package/crates/team-agent/src/messaging/tests/main_preserved.rs

@@ -1,78 +1,5 @@
 use super::*;
 
-// ── F1 [P1 byte-shape] — stuck_cancel suppression snapshot.delivered_message_ids must use golden's
-// _DELIVERED_MESSAGE_STATUSES = {visible, submitted, delivered, acknowledged} (scheduler.py:27,376-383),
-// sorted. The Rust delivered_message_ids (scheduler.rs:243) used {injected, visible, submitted,
-// submitted_unverified, delivered} — the WRONG set (reviewer's explicit warning: don't copy the
-// activity.rs deadlock query set): it EXCLUDES 'acknowledged' and INCLUDES 'injected'/'submitted_unverified'.
-// (The snapshot also must carry BOTH assigned_task_ids AND delivered_message_ids — that structural half
-// is already present; this pins the STATUS SET.)
-#[test]
-fn stuck_cancel_snapshot_delivered_message_ids_uses_golden_status_set() {
-    let ws = tmp_ws("f1_delivered");
-    crate::state::persist::save_runtime_state(
-        &ws,
-        &serde_json::json!({
-            "active_team_key": "teamX",
-            "agents": {"w1": {"status": "running", "provider": "codex"}}
-        }),
-    )
-    .unwrap();
-    let store = crate::message_store::MessageStore::open(&ws).unwrap();
-    // golden-delivered (must be IN delivered_message_ids): acknowledged + visible.
-    let m_ack = store
-        .create_message(None, "leader", "w1", "ack-me", None, true, Some("teamX"))
-        .unwrap();
-    store.mark(&m_ack, "delivered", None).unwrap();
-    store.mark(&m_ack, "acknowledged", None).unwrap();
-    let m_vis = store
-        .create_message(None, "leader", "w1", "vis", None, true, Some("teamX"))
-        .unwrap();
-    store.mark(&m_vis, "visible", None).unwrap();
-    // NOT golden-delivered (must be EXCLUDED): injected.
-    let m_inj = store
-        .create_message(None, "leader", "w1", "inj", None, true, Some("teamX"))
-        .unwrap();
-    store.mark(&m_inj, "injected", None).unwrap();
-    drop(store);
-    let _ = stuck_cancel(&ws, "w1", None, "leader").unwrap();
-    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    let snapshot =
-        &state["coordinator"]["suppressed_idle_alerts"]["teamX"]["w1"]["stuck"]["snapshot"];
-    assert!(
-        snapshot.get("assigned_task_ids").is_some(),
-        "F1: snapshot must carry assigned_task_ids; got {snapshot}"
-    );
-    let delivered = snapshot
-        .get("delivered_message_ids")
-        .and_then(serde_json::Value::as_array)
-        .map(|a| {
-            a.iter()
-                .filter_map(|v| v.as_str().map(str::to_string))
-                .collect::<Vec<_>>()
-        })
-        .unwrap_or_else(|| panic!("F1: snapshot must carry delivered_message_ids; got {snapshot}"));
-    assert!(
-        delivered.contains(&m_ack),
-        "F1: golden _DELIVERED_MESSAGE_STATUSES includes 'acknowledged' — the acknowledged message must be \
-         in delivered_message_ids; the Rust set omits it. got {delivered:?}"
-    );
-    assert!(
-        delivered.contains(&m_vis),
-        "F1: 'visible' is delivered (golden); got {delivered:?}"
-    );
-    assert!(
-        !delivered.contains(&m_inj),
-        "F1: 'injected' is NOT in golden _DELIVERED_MESSAGE_STATUSES — it must be EXCLUDED; the Rust set \
-         wrongly includes it. got {delivered:?}"
-    );
-    let mut sorted = delivered.clone();
-    sorted.sort();
-    assert_eq!(
-        delivered, sorted,
-        "F1: delivered_message_ids must be sorted (golden sorts); got {delivered:?}"
-    );
-}
 // ── collect --result-file INGEST SEMANTIC (golden results.py:58-73) ──────────────────────────────
 // Golden `collect(result_file=…)` INDEPENDENTLY INGESTS a standalone result: a valid result_envelope_v1
 // is `store.add_result(envelope)`'d (results.py:73) regardless of any in-flight delivery, then the