@team-agent/installer 0.5.41 → 0.5.43

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

@@ -12,8 +12,8 @@ use super::helpers::{json_dumps_default, object_fields};
 use super::normalize::normalize_result_status;
 use super::tools::TeamOrchestratorTools;
 use super::types::{
-    McpError, McpTool, RpcError, RpcId, RpcMethod, RpcResponse, Scope, SendOutcome, ServerRunReport,
-    ToolError, ToolErrorReason, ToolOk, ToolResult,
+    McpError, McpTool, RpcError, RpcId, RpcMethod, RpcResponse, Scope, SendOutcome,
+    ServerRunReport, ToolError, ToolErrorReason, ToolOk, ToolResult,
 };
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -38,10 +38,7 @@ pub fn tools_contract() -> Vec<Value> {
         McpTool::StuckList,
         McpTool::StuckCancel,
     ];
-    tools
-        .into_iter()
-        .map(tool_contract)
-        .collect()
+    tools.into_iter().map(tool_contract).collect()
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -58,7 +55,11 @@ pub fn dispatch(tools: &TeamOrchestratorTools, request: &Value) -> ToolResult {
     let tool_value = request
         .get("tool")
         .filter(|v| !v.as_str().is_some_and(str::is_empty))
-        .or_else(|| request.get("name").filter(|v| !v.as_str().is_some_and(str::is_empty)))
+        .or_else(|| {
+            request
+                .get("name")
+                .filter(|v| !v.as_str().is_some_and(str::is_empty))
+        })
         .or_else(|| request.get("method"));
     let name = tool_value.and_then(Value::as_str);
     let args = request
@@ -95,7 +96,10 @@ pub fn dispatch(tools: &TeamOrchestratorTools, request: &Value) -> ToolResult {
 /// frame.
 ///
 /// [`ToolCallResult`]: super::ToolCallResult
-pub fn handle_mcp(tools: &TeamOrchestratorTools, request: &Value) -> Result<Option<RpcResponse>, McpError> {
+pub fn handle_mcp(
+    tools: &TeamOrchestratorTools,
+    request: &Value,
+) -> Result<Option<RpcResponse>, McpError> {
     let id = rpc_id_from_request(request);
     let method = request.get("method").and_then(Value::as_str).unwrap_or("");
     match RpcMethod::classify(method) {
@@ -106,7 +110,10 @@ pub fn handle_mcp(tools: &TeamOrchestratorTools, request: &Value) -> Result<Opti
                 .and_then(Value::as_str)
                 .unwrap_or("2024-11-05");
             let mut result = serde_json::Map::new();
-            result.insert("protocolVersion".to_string(), Value::String(protocol.to_string()));
+            result.insert(
+                "protocolVersion".to_string(),
+                Value::String(protocol.to_string()),
+            );
             result.insert("capabilities".to_string(), serde_json::json!({"tools": {}}));
             result.insert(
                 "serverInfo".to_string(),
@@ -130,7 +137,10 @@ pub fn handle_mcp(tools: &TeamOrchestratorTools, request: &Value) -> Result<Opti
             let body = match dispatch(tools, params) {
                 Ok(ok) => {
                     let value = Value::Object(ok.fields);
-                    tool_call_result_value(value.get("ok").and_then(Value::as_bool) == Some(false), &value)
+                    tool_call_result_value(
+                        value.get("ok").and_then(Value::as_bool) == Some(false),
+                        &value,
+                    )
                 }
                 Err(err) => tool_call_result_value(true, &err.to_envelope()),
             };
@@ -247,7 +257,9 @@ fn handle_stdin_line(
 
 fn rpc_id_from_request(request: &Value) -> RpcId {
     match request.get("id") {
-        Some(Value::Number(n)) => n.as_i64().map_or_else(|| RpcId::Number(n.clone()), RpcId::Int),
+        Some(Value::Number(n)) => n
+            .as_i64()
+            .map_or_else(|| RpcId::Number(n.clone()), RpcId::Int),
         Some(Value::String(s)) => RpcId::Str(s.clone()),
         _ => RpcId::Null,
     }
@@ -385,56 +397,172 @@ 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", object_property("Task object to add or update."));
-            insert_property(&mut properties, "message", string_property("Optional message to deliver with the task."));
+            insert_property(
+                &mut properties,
+                "task",
+                object_property("Task object to add or update."),
+            );
+            insert_property(
+                &mut properties,
+                "message",
+                string_property("Optional message to deliver with the task."),
+            );
         }
         McpTool::SendMessage => {
-            insert_property(&mut properties, "to", string_property("Target agent id, 'leader', or '*' for broadcast."));
+            insert_property(
+                &mut properties,
+                "to",
+                string_property("Target agent id, 'leader', or '*' for broadcast."),
+            );
             insert_property(&mut properties, "content", string_property("Message body."));
-            insert_property(&mut properties, "task_id", string_property("Optional task id to associate with the message."));
-            insert_property(&mut properties, "sender", string_property("Optional sender override."));
-            insert_property(&mut properties, "requires_ack", boolean_property("Whether the recipient should acknowledge delivery."));
+            insert_property(
+                &mut properties,
+                "task_id",
+                string_property("Optional task id to associate with the message."),
+            );
+            insert_property(
+                &mut properties,
+                "sender",
+                string_property("Optional sender override."),
+            );
+            insert_property(
+                &mut properties,
+                "requires_ack",
+                boolean_property("Whether the recipient should acknowledge delivery."),
+            );
         }
         McpTool::ReportResult => {
-            insert_property(&mut properties, "envelope", object_property("Optional full result envelope."));
-            insert_property(&mut properties, "summary", string_property("Short result summary."));
+            insert_property(
+                &mut properties,
+                "envelope",
+                object_property("Optional full result envelope."),
+            );
+            insert_property(
+                &mut properties,
+                "summary",
+                string_property("Short result summary."),
+            );
             insert_property(&mut properties, "status", string_property("Result status."));
-            insert_property(&mut properties, "changes", array_property("Changed files or artifacts."));
-            insert_property(&mut properties, "tests", array_property("Tests or checks performed."));
-            insert_property(&mut properties, "risks", array_property("Risks or blockers."));
-            insert_property(&mut properties, "artifacts", array_property("Artifact references."));
-            insert_property(&mut properties, "next_actions", array_property("Suggested next actions."));
-            insert_property(&mut properties, "task_id", string_property("Optional task id override."));
-            insert_property(&mut properties, "agent_id", string_property("Optional reporting agent id override."));
+            insert_property(
+                &mut properties,
+                "changes",
+                array_property("Changed files or artifacts."),
+            );
+            insert_property(
+                &mut properties,
+                "tests",
+                array_property("Tests or checks performed."),
+            );
+            insert_property(
+                &mut properties,
+                "risks",
+                array_property("Risks or blockers."),
+            );
+            insert_property(
+                &mut properties,
+                "artifacts",
+                array_property("Artifact references."),
+            );
+            insert_property(
+                &mut properties,
+                "next_actions",
+                array_property("Suggested next actions."),
+            );
+            insert_property(
+                &mut properties,
+                "task_id",
+                string_property("Optional task id override."),
+            );
+            insert_property(
+                &mut properties,
+                "agent_id",
+                string_property("Optional reporting agent id override."),
+            );
         }
         McpTool::UpdateState => {
-            insert_property(&mut properties, "note", string_property("Note to append to team state."));
+            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."));
+            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."));
+            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."));
+            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."));
+            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::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."));
+            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."));
+            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."),
+            );
         }
     }
     properties
@@ -460,12 +588,19 @@ fn array_property(description: &str) -> Value {
     serde_json::json!({"type": "array", "description": description, "items": {"type": "object", "additionalProperties": true}})
 }
 
-pub(crate) fn dispatch_tool(tools: &TeamOrchestratorTools, tool: McpTool, args: &Value) -> ToolResult {
+pub(crate) fn dispatch_tool(
+    tools: &TeamOrchestratorTools,
+    tool: McpTool,
+    args: &Value,
+) -> ToolResult {
     if scope_ceiling_tool(tool) {
         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::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("");
@@ -490,36 +625,61 @@ pub(crate) fn dispatch_tool(tools: &TeamOrchestratorTools, tool: McpTool, args:
             // cr verdict (T3-1 refined): an unknown status literal normalizes to
             // Partial and is OBSERVABLE at this ingestion boundary, never silent.
             {
-                let (status, unknown) = crate::mcp_server::normalize::normalize_result_status_observed(
-                    args.get("status").and_then(Value::as_str),
-                );
+                let (status, unknown) =
+                    crate::mcp_server::normalize::normalize_result_status_observed(
+                        args.get("status").and_then(Value::as_str),
+                    );
                 if let Some(raw) = unknown {
                     tools.note_unknown_result_status(&raw);
                 }
                 status
             },
-            args.get("changes").and_then(Value::as_array).map(Vec::as_slice),
-            args.get("tests").and_then(Value::as_array).map(Vec::as_slice),
-            args.get("risks").and_then(Value::as_array).map(Vec::as_slice),
-            args.get("artifacts").and_then(Value::as_array).map(Vec::as_slice),
-            args.get("next_actions").and_then(Value::as_array).map(Vec::as_slice),
+            args.get("changes")
+                .and_then(Value::as_array)
+                .map(Vec::as_slice),
+            args.get("tests")
+                .and_then(Value::as_array)
+                .map(Vec::as_slice),
+            args.get("risks")
+                .and_then(Value::as_array)
+                .map(Vec::as_slice),
+            args.get("artifacts")
+                .and_then(Value::as_array)
+                .map(Vec::as_slice),
+            args.get("next_actions")
+                .and_then(Value::as_array)
+                .map(Vec::as_slice),
             args.get("task_id").and_then(Value::as_str),
             args.get("agent_id").and_then(Value::as_str),
         ),
-        McpTool::UpdateState => tools.update_state(args.get("note").and_then(Value::as_str).unwrap_or("")),
+        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::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),
+            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(""),
+            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("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(
@@ -531,7 +691,9 @@ pub(crate) fn dispatch_tool(tools: &TeamOrchestratorTools, tool: McpTool, args:
         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"),
+            args.get("alert_type")
+                .and_then(Value::as_str)
+                .unwrap_or("stuck"),
         ),
     }
 }
@@ -598,7 +760,10 @@ mod e23_lifecycle_marker_tests {
         assert_eq!(events[0]["event"], serde_json::json!("mcp.server_started"));
         assert_eq!(events[1]["event"], serde_json::json!("mcp.server_exit"));
         assert_eq!(events[1]["reason"], serde_json::json!("stdin_eof"));
-        assert_eq!(events[1]["workspace"], serde_json::json!(ws.display().to_string()));
+        assert_eq!(
+            events[1]["workspace"],
+            serde_json::json!(ws.display().to_string())
+        );
         assert_eq!(events[1]["pid"], serde_json::json!(std::process::id()));
         assert!(events[1].get("ppid").is_some());
         let _ = std::fs::remove_dir_all(&ws);
@@ -618,9 +783,8 @@ mod e23_lifecycle_marker_tests {
         }
 
         let ws = marker_ws("fatal");
-        let input = std::io::Cursor::new(
-            br#"{"jsonrpc":"2.0","id":1,"method":"initialize"}"#.to_vec(),
-        );
+        let input =
+            std::io::Cursor::new(br#"{"jsonrpc":"2.0","id":1,"method":"initialize"}"#.to_vec());
 
         let err = run_stdio_loop(&ws, input, FailingWriter).expect_err("writer failure");
 
@@ -629,12 +793,10 @@ mod e23_lifecycle_marker_tests {
         assert_eq!(events[0]["event"], serde_json::json!("mcp.server_started"));
         assert_eq!(events[1]["event"], serde_json::json!("mcp.server_exit"));
         assert_eq!(events[1]["reason"], serde_json::json!("fatal_error"));
-        assert!(
-            events[1]["error"]
-                .as_str()
-                .unwrap_or_default()
-                .contains("simulated stdout failure")
-        );
+        assert!(events[1]["error"]
+            .as_str()
+            .unwrap_or_default()
+            .contains("simulated stdout failure"));
         let _ = std::fs::remove_dir_all(&ws);
     }
 }

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

@@ -362,7 +362,10 @@ pub fn deliver_pending_message(
     }
     let resolved = resolve_inject_target(state, &message.recipient, transport, &live_targets);
     if let Some(stale) = resolved.stale_binding.as_ref() {
-        event_log.write("worker_pane_binding_stale", stale.as_event_payload(message_id, &message.recipient))?;
+        event_log.write(
+            "worker_pane_binding_stale",
+            stale.as_event_payload(message_id, &message.recipient),
+        )?;
     }
     let target = resolved.target.clone();
     if let Some(outcome) = block_missing_worker_target(
@@ -1232,7 +1235,11 @@ fn resolve_inject_target(
         }) {
             return ResolvedInjectTarget {
                 target: Target::Pane(pane),
-                metadata: Some(target_metadata(transport, live_pane, "validated_cached_pane")),
+                metadata: Some(target_metadata(
+                    transport,
+                    live_pane,
+                    "validated_cached_pane",
+                )),
                 stale_binding: None,
             };
         }
@@ -1259,15 +1266,13 @@ fn live_pane_for_session_window<'a>(
     session: &str,
     window: &str,
 ) -> Option<&'a PaneInfo> {
-    targets
-        .iter()
-        .find(|target| {
-            target.session.as_str() == session
-                && target
-                    .window_name
-                    .as_ref()
-                    .is_some_and(|name| name.as_str() == window)
-        })
+    targets.iter().find(|target| {
+        target.session.as_str() == session
+            && target
+                .window_name
+                .as_ref()
+                .is_some_and(|name| name.as_str() == window)
+    })
 }
 
 fn stale_worker_pane_binding(
@@ -2221,8 +2226,7 @@ fn record_turn_open_if_leader_to_worker_scoped(
     save_scoped_state_reapplying_after_conflict(workspace, &state, owner_team_id, |latest| {
         arm_turn_open(latest, recipient, &delivered.message_id);
     })?;
-    let mut event =
-        serde_json::json!({"agent_id": recipient, "message_id": delivered.message_id});
+    let mut event = serde_json::json!({"agent_id": recipient, "message_id": delivered.message_id});
     if let Some(metadata) = metadata {
         append_target_metadata(&mut event, metadata);
     }
@@ -2256,11 +2260,9 @@ fn arm_turn_open(state: &mut serde_json::Value, recipient: &str, message_id: &Op
         // (whitelisted for the transition) and `mcp_server/helpers.rs`; other
         // messaging/lifecycle/mcp_server code MUST NOT treat this as
         // authoritative task state.
-        let field = message_id
-            .as_ref()
-            .map_or(serde_json::Value::Null, |id| {
-                serde_json::Value::String(id.clone())
-            });
+        let field = message_id.as_ref().map_or(serde_json::Value::Null, |id| {
+            serde_json::Value::String(id.clone())
+        });
         agent.insert("current_turn_message_id".to_string(), field);
     }
 }

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

@@ -122,7 +122,10 @@ pub(crate) fn working_seconds(scrollback: &str) -> Option<u64> {
     // `❯ Run /review`, `Worked for 8m 34s`, or an empty composer prompt,
     // there is no LIVE working indicator and we return None — handing off
     // to the structural latest_prompt_signal / IRON LAW Uncertain path.
-    let last_non_empty = scrollback.lines().rev().find(|line| !line.trim().is_empty())?;
+    let last_non_empty = scrollback
+        .lines()
+        .rev()
+        .find(|line| !line.trim().is_empty())?;
     let lower = last_non_empty.to_ascii_lowercase();
     let start = lower.find("working (")?;
     let rest = last_non_empty.get(start + "Working (".len()..)?;
@@ -193,9 +196,27 @@ pub(crate) fn latest_prompt_signal(scrollback: &str) -> Option<AgentActivity> {
         // and Claude Code tool-progress verbs. We look for STRUCTURAL
         // composer/status signals in the active region only.
         if [
-            "working (", "thinking", "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦",
-            "⠧", "⠇", "⠏", "✶", "✢", "✻", "analyzing", "reading", "writing",
-            "searching", "running", "editing",
+            "working (",
+            "thinking",
+            "⠋",
+            "⠙",
+            "⠹",
+            "⠸",
+            "⠼",
+            "⠴",
+            "⠦",
+            "⠧",
+            "⠇",
+            "⠏",
+            "✶",
+            "✢",
+            "✻",
+            "analyzing",
+            "reading",
+            "writing",
+            "searching",
+            "running",
+            "editing",
         ]
         .iter()
         .any(|needle| lower.contains(needle))

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

@@ -8,7 +8,9 @@ use serde_json::Value;
 use crate::event_log::EventLog;
 use crate::message_store::{MessageStore, NotificationClaimParams};
 use crate::model::ids::TaskId;
-use crate::transport::{InjectPayload, InjectReport, Key, PaneId, Target, Transport, TransportError};
+use crate::transport::{
+    InjectPayload, InjectReport, Key, PaneId, Target, Transport, TransportError,
+};
 
 use super::helpers::MessageStatusShadow;
 use super::{DeliveryOutcome, DeliveryRefusal, DeliveryStage, DeliveryStatus, MessagingError};
@@ -405,10 +407,7 @@ pub fn deliver_to_leader_fallback_pane(
             // Row status is left untouched so status/monitor surfaces the
             // pending notification until the operator rebinds the leader.
             let (status, channel) = if socket_bound {
-                (
-                    DeliveryStatus::Blocked,
-                    "rebind_required".to_string(),
-                )
+                (DeliveryStatus::Blocked, "rebind_required".to_string())
             } else {
                 (DeliveryStatus::Failed, "fallback_pane".to_string())
             };

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

@@ -103,9 +103,8 @@ pub use types::{
     CheckKind, CheckStatus, ContractSuiteCheck, DeliveryOutcome, DeliveryRefusal, DeliveryStage,
     DeliveryStatus, IdleEvaluation, LeaderNotificationKey, LeaderReceiver, PaneWidthQuery,
     ProviderSdkCalls, ReceiverMode, ScheduledKind, SelftestCheck, SelftestReport, SendEventPayload,
-    TrustRetryPayload, WatcherNotice, WorkerRuntimeState,
-    RESULT_DELIVERY_MAX_ATTEMPTS, SEND_RETRY_MAX_ATTEMPTS,
-    TRUST_RETRY_BACKOFF_SECONDS, TRUST_RETRY_MAX_ATTEMPTS,
+    TrustRetryPayload, WatcherNotice, WorkerRuntimeState, RESULT_DELIVERY_MAX_ATTEMPTS,
+    SEND_RETRY_MAX_ATTEMPTS, TRUST_RETRY_BACKOFF_SECONDS, TRUST_RETRY_MAX_ATTEMPTS,
 };
 pub use watchers::{
     delivered_result_message, format_result_watcher_notification, notify_result_watchers,