@team-agent/installer 0.5.60 → 0.5.62

package/crates/team-agent/src/lifecycle/tests.rs

@@ -2,6 +2,7 @@
 use super::*;
 use serde_json::json;
 use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::OnceLock;
 
 static SEQ: AtomicU32 = AtomicU32::new(0);
 
@@ -20,6 +21,24 @@ fn sess(s: &str) -> SessionName {
     SessionName(s.to_string())
 }
 
+pub(crate) fn test_binary_path() -> &'static str {
+    static PATH: OnceLock<String> = OnceLock::new();
+    PATH.get_or_init(|| {
+        if let Ok(path) = std::env::var("CARGO_BIN_EXE_team-agent") {
+            return path;
+        }
+        let current = std::env::current_exe().expect("test executable path");
+        current
+            .parent()
+            .and_then(|deps| deps.parent())
+            .map(|target| target.join("team-agent"))
+            .expect("team-agent test binary path")
+            .to_string_lossy()
+            .into_owned()
+    })
+    .as_str()
+}
+
 mod agent_ops;
 mod core;
 mod lane_ops;
@@ -29,3 +48,43 @@ mod main_preserved;
 mod phase_b_contracts;
 mod phase_golden;
 mod restart;
+mod b0_legacy_snapshot_nonauthority_contract;
+mod b0_reader_hideone_audit_contract;
+mod behavioral_diff_264_red;
+mod claude_profile_launch_red;
+mod codex_mcp_approval_inheritance_red;
+mod codex_weak_window_attribution_red;
+mod copilot_provider_red;
+mod display_adaptive_red;
+mod core_034_real_red;
+mod f032_startup_prompt_best_effort_red;
+mod harvest2_a_batch_red;
+mod host_cotenant_death_p0_contract;
+mod lifecycle_rollback_red;
+mod quick_start_worker_readiness_red;
+mod realmachine_clusters_1_6_red;
+mod realmachine_residual_g1_g4_red;
+mod restart_build_before_destroy_0540_contract;
+mod restart_liveness_red;
+mod restart_rebind_hotfix_252_red;
+mod restart_session_capture_red;
+mod resume_recover_red;
+mod stale_team_saveconflict_contract;
+mod startup_latency_contract;
+mod status_credential_redaction_contract;
+mod subprep_codex_trust_roundtrip_red;
+mod swallow_batch4_semantics_red;
+mod team_in_team_identity_scope_red;
+mod team_in_team_sibling_quick_start_red;
+mod team_in_team_state_scope_red;
+mod team_key_retirement_roster_red;
+mod team_key_retirement_txn_red;
+mod test_isolation_escape_contract;
+mod upgrade_compat_0211_red;
+mod verify_rs031_window_consistency_red;
+mod worker_dangerous_bypass_argv_red;
+mod worker_spawn_env_red;
+mod acceptance_b_batch_red;
+mod claude_compatible_config_red;
+mod communication_mode_runtime_contract_red;
+mod clone_fork_copilot_perms_red;

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

@@ -16,15 +16,6 @@ use super::DisplayBackend;
 // CROSS-LANE PLACEHOLDERS(13/14/15 兄弟 lane 尚未交付;leader 集成时 reconcile)
 // ===========================================================================
 
-/// step8 provider 还未暴露的 launch/resume/fork 命令构造门面。lifecycle 经它构造
-/// provider 命令字符串(`shell_command_for_agent`/`shell_resume_command_for_agent`/
-/// `shell_fork_command_for_agent`,`runtime` 自由函数)—— provider lane 落地后替换为
-/// 真实 `provider::shell_*` API。**PLACEHOLDER**:仅占位 argv,字段映射由 provider lane 定。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ShellCommand {
-    pub argv: Vec<String>,
-}
-
 /// `EventLog` 已在 step4 落地,但 lifecycle 发射的 typed `EventKind` 名集(`lifecycle.*`/
 /// `restart.*`/`display.*`)是 step4 owned 的稳定事件名(JSON 名与 Python 一致)。
 /// **PLACEHOLDER**:此处仅命名 lifecycle 关心的事件名常量集,leader 集成时映射到

package/crates/team-agent/src/lifecycle/worker_command_context.rs

@@ -1,5 +1,6 @@
 use std::path::Path;
 
+use crate::communication_mode::CommunicationMode;
 use crate::lifecycle::types::{DangerousApproval, LifecycleError};
 use crate::model::enums::{Enforcement, Provider};
 use crate::model::ids::AgentId;
@@ -12,15 +13,10 @@ output. All communication must go through Team Agent MCP tools.
 
 ## Communication (mandatory)
 
-- Progress, blockers, questions: team_orchestrator.send_message(to='leader', content='...')
 - Coordinate with teammate: team_orchestrator.send_message(to='<agent_id>', content='...')
 - Broadcast to all teammates: team_orchestrator.send_message(to='*', content='...')
 - Task complete: team_orchestrator.report_result(summary='...') — call exactly once
 
-When you receive a message from the leader or a teammate, you MUST respond
-through MCP tools. Writing a reply in your terminal does nothing — the sender
-will never see it.
-
 ## Rules
 
 - Do not pass sender, task_id, or schema_version — the MCP runtime fills them.
@@ -45,6 +41,7 @@ pub(crate) struct WorkerCommandAgent {
     system_prompt_inline: Option<String>,
     system_prompt_file: Option<String>,
     output_contract_format: Option<String>,
+    communication_mode: CommunicationMode,
 }
 
 impl WorkerCommandAgent {
@@ -52,9 +49,9 @@ impl WorkerCommandAgent {
         agent: &crate::model::yaml::Value,
         fallback_id: Option<&str>,
         provider: Provider,
-    ) -> Self {
+    ) -> Result<Self, LifecycleError> {
         let system_prompt = agent.get("system_prompt");
-        Self {
+        Ok(Self {
             id: agent
                 .get("id")
                 .and_then(crate::model::yaml::Value::as_str)
@@ -90,16 +87,21 @@ impl WorkerCommandAgent {
                 .and_then(|contract| contract.get("format"))
                 .and_then(crate::model::yaml::Value::as_str)
                 .map(str::to_string),
-        }
+            communication_mode: communication_mode(
+                agent
+                    .get("communication_mode")
+                    .and_then(crate::model::yaml::Value::as_str),
+            )?,
+        })
     }
 
     pub(crate) fn from_json(
         agent: &serde_json::Value,
         fallback_id: Option<&str>,
         provider: Provider,
-    ) -> Self {
+    ) -> Result<Self, LifecycleError> {
         let system_prompt = agent.get("system_prompt");
-        Self {
+        Ok(Self {
             id: agent
                 .get("id")
                 .and_then(serde_json::Value::as_str)
@@ -135,7 +137,12 @@ impl WorkerCommandAgent {
                 .and_then(|contract| contract.get("format"))
                 .and_then(serde_json::Value::as_str)
                 .map(str::to_string),
-        }
+            communication_mode: communication_mode(
+                agent
+                    .get("communication_mode")
+                    .and_then(serde_json::Value::as_str),
+            )?,
+        })
     }
 }
 
@@ -149,6 +156,7 @@ pub(crate) fn compile_worker_system_prompt(
     let mut chunks = vec![
         identity_section(agent),
         runtime_contract_section(),
+        agent.communication_mode.runtime_contract().to_string(),
         role_body(agent)?,
     ];
     if let Some(contract) = output_contract(agent) {
@@ -197,6 +205,14 @@ fn runtime_contract_section() -> String {
     RUNTIME_CONTRACT_SECTION.to_string()
 }
 
+fn communication_mode(value: Option<&str>) -> Result<CommunicationMode, LifecycleError> {
+    let Some(value) = value else {
+        return Ok(CommunicationMode::default());
+    };
+    CommunicationMode::parse(value)
+        .ok_or_else(|| LifecycleError::Compile(format!("unknown communication_mode {value:?}")))
+}
+
 fn identity_section(agent: &WorkerCommandAgent) -> String {
     format!(
         "You are Team Agent worker `{}` with role `{}`. When asked about your role or identity, answer with this Team Agent worker identity first, not only the generic provider product identity.",
@@ -291,6 +307,7 @@ mod tests {
             system_prompt_inline: None,
             system_prompt_file: None,
             output_contract_format: None,
+            communication_mode: CommunicationMode::default(),
         };
         let tools =
             resolved_tool_strings_for_command(&agent, Provider::ClaudeCode, &disabled_safety())
@@ -335,6 +352,7 @@ mod tests {
             system_prompt_inline: Some("Implement the assigned slice.".to_string()),
             system_prompt_file: None,
             output_contract_format: Some("result_envelope_v1".to_string()),
+            communication_mode: CommunicationMode::default(),
         };
         let prompt = compile_worker_system_prompt(&agent).unwrap();
         assert!(

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

@@ -1,3 +1,4 @@
+//!
 //! step 14a · mcp_server::helpers — pure regularization + shared free helpers.
 
 use std::io::Write as _;

package/crates/team-agent/src/mcp_server/lifecycle_tools/mod.rs

@@ -1,3 +1,4 @@
+//!
 //! MCP lifecycle tool facades.
 //!
 //! S0 keeps the old placeholder behavior behind stable module boundaries so

package/crates/team-agent/src/mcp_server/lifecycle_tools/state_status.rs

@@ -1,3 +1,4 @@
+//!
 use std::path::Path;
 
 use serde_json::Value;

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

@@ -1,3 +1,4 @@
+//!
 //! step 14a · mcp_server — stdio MCP server (`team_orchestrator`) over JSON-RPC 2.0.
 //!
 //! Card: `docs/phase0/subsystems/14-mcp_cli.md` (MCP half).

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

@@ -1,3 +1,4 @@
+//!
 //! step 14a · mcp_server::normalize — string-alias regularization + result compaction.
 
 use serde_json::Value;
@@ -28,9 +29,9 @@ pub fn normalize_result_status(value: Option<&str>) -> ResultStatus {
     normalize_result_status_observed(value).0
 }
 
-/// The observed variant: `.1` carries the raw unrecognized literal so ingestion
-/// boundaries (wire report_result) can emit `provider.result.unknown_status_normalized`.
-pub fn normalize_result_status_observed(value: Option<&str>) -> (ResultStatus, Option<String>) {
+/// The internal observed variant: `.1` carries the raw unrecognized literal for
+/// callers that need to retain it.
+fn normalize_result_status_observed(value: Option<&str>) -> (ResultStatus, Option<String>) {
     let token = normalize_token(value);
     if token.is_empty() {
         return (ResultStatus::Success, None);
@@ -260,6 +261,7 @@ pub fn compact_tool_result(result: &Value) -> ToolResult {
             "notification_channel",
             "notification_event_id",
             "warnings",
+            "warning",
         ]
     };
     for key in keys {

package/crates/team-agent/src/mcp_server/tests/send.rs

@@ -78,6 +78,7 @@ fn send_outcome_worker_accepted_envelope_byte_stable() {
     let outcome = SendOutcome::WorkerAccepted {
         message_id: "42".to_string(),
         poll_via: "team-agent inbox 42".to_string(),
+        warning: None,
     };
     let v = outcome.to_value();
     assert_eq!(
@@ -160,6 +161,7 @@ fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
         Ok(SendOutcome::WorkerAccepted {
             message_id,
             poll_via,
+            ..
         }) => {
             assert!(!message_id.is_empty());
             assert_eq!(poll_via, format!("team-agent inbox {message_id}"));
@@ -353,6 +355,30 @@ fn send_message_leader_recipient_is_direct_not_accepted() {
     );
 }
 
+#[test]
+fn send_message_mailbox_is_durable_without_live_injection() {
+    let tools = TeamOrchestratorTools::with_identity(
+        &unique_ws("send-leader-mailbox"),
+        Some(AgentId::new("worker-1")),
+        Some(TeamKey::new("teamA")),
+    );
+    let mailbox = json!(true);
+    let outcome = tools
+        .send_message_with_presentation(
+            &MessageTarget::Single("leader".to_string()),
+            "stored update",
+            None,
+            None,
+            None,
+            Some(&mailbox),
+            None,
+        )
+        .expect("mailbox send persists");
+    let value = outcome.to_value();
+    assert_eq!(value.get("status"), Some(&json!("stored_only")));
+    assert!(value.get("message_id").and_then(Value::as_str).is_some());
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // CROSS-TEAM PRE-REFUSAL (C23) — refuse_cross_team_peer (tools.py:185-213)
 // ════════════════════════════════════════════════════════════════════════

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

@@ -79,7 +79,7 @@ fn tools_contract_has_thirteen_tools_in_order() {
         .unwrap();
     assert_eq!(
             send["description"],
-            json!("Send a message to a teammate, the leader, or '*' for all other team members. Team Agent fills identity and delivery metadata; optional presentation routing is durable and never drops the message.")
+            json!("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.")
         );
     assert_eq!(send["inputSchema"]["additionalProperties"], json!(false));
     assert_eq!(send["inputSchema"]["required"], json!(["to", "content"]));

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

@@ -1,3 +1,4 @@
+//!
 //! step 14a · mcp_server::tools — `TeamOrchestratorTools`, the 12 typed handlers.
 
 use std::path::{Path, PathBuf};
@@ -17,17 +18,17 @@ use crate::state::persist::{
 };
 
 // ── REUSE: step 11 messaging delegate surface ───────────────────────────────
-use crate::messaging::{self, MessageTarget, SendOptions, TrustedSender};
+use crate::messaging::{self, DeliveryStatus, MessageTarget, SendOptions, TrustedSender};
 
 use super::helpers::{
     current_reportable_message_for, delivery_outcome_value, direct_message_attribution_for,
-    ensure_object, enum_value, insert_array, is_worker_recipient, json_dumps_default,
-    latest_task_for_assignee, non_empty_string, normalized_envelope_value, object_fields,
-    requires_ack_for_target, tool_runtime_error, DirectMessageAttribution,
+    ensure_object, enum_value, is_worker_recipient, json_dumps_default, latest_task_for_assignee,
+    non_empty_string, object_fields, requires_ack_for_target, tool_runtime_error,
+    DirectMessageAttribution,
 };
 use super::normalize::{
-    compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
-    report_result_integrity_warnings, validate_test_evidence_schema,
+    compact_tool_result, normalize_report_envelope, report_result_integrity_warnings,
+    validate_test_evidence_schema,
 };
 use super::types::{
     Scope, SendOutcome, ToolError, ToolErrorReason, ToolOk, ToolResult, VisiblePeers,
@@ -116,6 +117,22 @@ impl TeamOrchestratorTools {
                 "ValueError",
             ));
         };
+        if let Some(route) = task.get("result_route") {
+            let Some(route) = route.as_str() else {
+                return Err(ToolError::new(
+                    ToolErrorReason::InvalidToolArguments,
+                    "assign_task task.result_route must be 'leader' or 'pipeline'",
+                    "ValueError",
+                ));
+            };
+            if crate::messaging::results::ResultRoute::parse(route).is_none() {
+                return Err(ToolError::new(
+                    ToolErrorReason::InvalidToolArguments,
+                    format!("assign_task task.result_route has unknown value: {route}"),
+                    "ValueError",
+                ));
+            }
+        }
 
         let task_value = Value::Object(task_obj.clone());
         let recovery = task_recovery_marker(&task_value);
@@ -185,6 +202,7 @@ impl TeamOrchestratorTools {
             requires_ack,
             scope_override,
             None,
+            None,
         )
     }
 
@@ -195,17 +213,20 @@ impl TeamOrchestratorTools {
         task_id: Option<&str>,
         requires_ack: Option<bool>,
         scope_override: Option<Scope>,
+        mailbox: Option<&Value>,
         presentation: Option<&Value>,
     ) -> Result<SendOutcome, ToolError> {
-        let (presentation, presentation_error) =
-            crate::messaging::presentation::normalize_presentation(presentation);
-        if let Some(error) = presentation_error {
-            return Err(ToolError::new(
-                ToolErrorReason::InvalidToolArguments,
-                format!("invalid presentation: {error}"),
-                "PresentationError",
-            ));
-        }
+        let normalized =
+            crate::messaging::presentation::normalize_send_presentation(mailbox, presentation)
+                .map_err(|error| {
+                    ToolError::new(
+                        ToolErrorReason::InvalidToolArguments,
+                        format!("invalid send routing: {error}"),
+                        "PresentationError",
+                    )
+                })?;
+        let presentation = normalized.request;
+        let deprecation = normalized.deprecation;
         let canonical_owner_team = self.canonical_owner_team_key()?;
         if matches!(scope_override, Some(Scope::Workspace)) {
             return Err(self.rpc_scope_refused(
@@ -261,6 +282,21 @@ impl TeamOrchestratorTools {
         if is_worker_recipient(to) {
             let out = messaging::send_message(&self.workspace, to, content, &opts)
                 .map_err(tool_runtime_error)?;
+            if matches!(out.status, DeliveryStatus::StoredOnly) {
+                let value = delivery_outcome_value(&out);
+                let mut ok = compact_tool_result(&value)?;
+                if let Some(verification) = out.verification.as_deref() {
+                    ok.fields.insert(
+                        "verification".to_string(),
+                        Value::String(verification.to_string()),
+                    );
+                }
+                if let Some(deprecation) = deprecation {
+                    ok.fields
+                        .insert("warning".to_string(), Value::String(deprecation));
+                }
+                return Ok(SendOutcome::Direct(ok));
+            }
             // tools.py:175-181 — accepted+poll_via ONLY for a REAL message_id; any other
             // outcome falls back to the compacted direct result. Never invent an
             // `mcp_<timestamp>` id: it does not exist in the store and makes the
@@ -276,12 +312,25 @@ impl TeamOrchestratorTools {
             return Ok(SendOutcome::WorkerAccepted {
                 poll_via: format!("team-agent inbox {message_id}"),
                 message_id,
+                warning: deprecation,
             });
         }
         let out = messaging::send_message(&self.workspace, to, content, &opts)
             .map_err(tool_runtime_error)?;
         let value = delivery_outcome_value(&out);
-        let ok = compact_tool_result(&value)?;
+        let mut ok = compact_tool_result(&value)?;
+        if matches!(out.status, DeliveryStatus::StoredOnly) {
+            if let Some(verification) = out.verification.as_deref() {
+                ok.fields.insert(
+                    "verification".to_string(),
+                    Value::String(verification.to_string()),
+                );
+            }
+        }
+        if let Some(deprecation) = deprecation {
+            ok.fields
+                .insert("warning".to_string(), Value::String(deprecation));
+        }
         Ok(SendOutcome::Direct(ok))
     }
 
@@ -352,10 +401,11 @@ impl TeamOrchestratorTools {
         task_id: Option<&str>,
         agent_id: Option<&str>,
     ) -> ToolResult {
+        let status = enum_value(status);
         self.report_result_with_presentation(
             envelope,
             summary,
-            status,
+            status.as_str(),
             changes,
             tests,
             risks,
@@ -372,7 +422,7 @@ impl TeamOrchestratorTools {
         &self,
         envelope: Option<&Value>,
         summary: Option<&str>,
-        status: ResultStatus,
+        status: Option<&str>,
         changes: Option<&[Value]>,
         tests: Option<&[Value]>,
         risks: Option<&[Value]>,
@@ -404,7 +454,10 @@ impl TeamOrchestratorTools {
                 );
             }
             if !obj.contains_key("status") {
-                obj.insert("status".to_string(), enum_value(status));
+                obj.insert(
+                    "status".to_string(),
+                    Value::String(status.unwrap_or("success").to_string()),
+                );
             }
             if !obj.contains_key("task_id") {
                 // Blocker-1 (prerelease 0.4.0): scoped-team task inference +
@@ -499,29 +552,36 @@ impl TeamOrchestratorTools {
                 obj.insert("agent_id".to_string(), Value::String(resolved));
             }
             if !obj.contains_key("changes") {
-                insert_array(obj, "changes", changes);
+                obj.insert(
+                    "changes".to_string(),
+                    Value::Array(changes.unwrap_or(&[]).to_vec()),
+                );
             }
             if !obj.contains_key("tests") {
-                insert_array(obj, "tests", tests);
+                obj.insert(
+                    "tests".to_string(),
+                    Value::Array(tests.unwrap_or(&[]).to_vec()),
+                );
             }
             if !obj.contains_key("risks") {
-                insert_array(obj, "risks", risks);
+                obj.insert(
+                    "risks".to_string(),
+                    Value::Array(risks.unwrap_or(&[]).to_vec()),
+                );
             }
             if !obj.contains_key("artifacts") {
-                insert_array(obj, "artifacts", artifacts);
+                obj.insert(
+                    "artifacts".to_string(),
+                    Value::Array(artifacts.unwrap_or(&[]).to_vec()),
+                );
             }
             if !obj.contains_key("next_actions") {
-                insert_array(obj, "next_actions", next_actions);
+                obj.insert(
+                    "next_actions".to_string(),
+                    Value::Array(next_actions.unwrap_or(&[]).to_vec()),
+                );
             }
         }
-        // T3-1 cr verdict (refined): an unknown non-empty status literal normalizes to
-        // Partial and must be OBSERVABLE at this ingestion boundary (the envelope-borne
-        // path; the wire `status` arg path emits at dispatch). Never a silent swallow.
-        if let Some(raw) =
-            normalize_result_status_observed(base.get("status").and_then(Value::as_str)).1
-        {
-            self.note_unknown_result_status(&raw);
-        }
         if let Err(error) = validate_test_evidence_schema(base.get("tests")) {
             return Err(ToolError::new(
                 ToolErrorReason::InvalidToolArguments,
@@ -538,8 +598,15 @@ impl TeamOrchestratorTools {
             ));
         }
         let warnings = report_result_integrity_warnings(&base, &normalized);
-        let mut env_value = normalized_envelope_value(&normalized);
-        copy_report_attribution_fields(&base, &mut env_value);
+        let mut env_value = base;
+        if let Some(obj) = env_value.as_object_mut() {
+            obj.entry("schema_version")
+                .or_insert_with(|| Value::String("result_envelope_v1".to_string()));
+            obj.insert(
+                "presentation".to_string(),
+                serde_json::to_value(&normalized.presentation).unwrap_or(Value::Null),
+            );
+        }
         if !warnings.is_empty() {
             if let Some(obj) = env_value.as_object_mut() {
                 obj.insert("warnings".to_string(), Value::Array(warnings));
@@ -555,20 +622,6 @@ impl TeamOrchestratorTools {
         .and_then(|value| compact_tool_result(&value))
     }
 
-    /// T3-1 cr verdict: the observable record of an unknown→Partial status
-    /// normalization (`provider.result.unknown_status_normalized`, raw literal
-    /// included) — MUST-NOT-13: the swallow is never silent.
-    pub(crate) fn note_unknown_result_status(&self, raw: &str) {
-        let _ = EventLog::new(&self.workspace).write(
-            "provider.result.unknown_status_normalized",
-            serde_json::json!({
-                "agent_id": self.agent_id.as_ref().map(AgentId::as_str),
-                "raw_status": raw,
-                "normalized": "partial",
-            }),
-        );
-    }
-
     /// `update_state` (`tools.py:316-325`): delegated through the lifecycle tools
     /// facade. S0 preserves the old placeholder behavior.
     pub fn update_state(&self, note: &str) -> ToolResult {
@@ -1179,24 +1232,6 @@ fn merge_object_fields(existing: &mut Value, incoming: &Value) {
     }
 }
 
-fn copy_report_attribution_fields(source: &Value, target: &mut Value) {
-    let Some(src) = source.as_object() else {
-        return;
-    };
-    let Some(dst) = target.as_object_mut() else {
-        return;
-    };
-    for key in [
-        "attributed_message_id",
-        "attribution_scope",
-        "task_id_source",
-    ] {
-        if let Some(value) = src.get(key) {
-            dst.entry(key.to_string()).or_insert(value.clone());
-        }
-    }
-}
-
 fn push_report_warning(obj: &mut serde_json::Map<String, Value>, warning: Value) {
     let Some(code) = warning.get("code").and_then(Value::as_str) else {
         return;

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

@@ -1,3 +1,4 @@
+//!
 //! step 14a · mcp_server::types — wire enums / envelopes / normalized-result carriers.
 
 use serde::{Deserialize, Serialize};
@@ -210,24 +211,6 @@ pub struct RpcError {
     pub message: String,
 }
 
-/// The `tools/call` result wrapper (`server.py:74-86`): `{content:[{type:"text",
-/// text:<json>}], isError:<bool>}`. `text` is the JSON-encoded [`ToolResult`]; the
-/// `is_error` flag mirrors `result.get("ok") is False`.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ToolCallResult {
-    pub content: Vec<ToolCallContent>,
-    #[serde(rename = "isError")]
-    pub is_error: bool,
-}
-
-/// One `content[]` block — always `{type:"text", text:<json>}` here.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ToolCallContent {
-    #[serde(rename = "type")]
-    pub kind: String,
-    pub text: String,
-}
-
 /// A successful tool result body — the compacted delegate result
 /// (`normalize._compact_tool_result`, `normalize.py:6-64`). The whitelist-key
 /// compaction (ok/error key sets + `fanout_*` extras + `acknowledged_count`) lives
@@ -322,6 +305,7 @@ pub enum SendOutcome {
         message_id: String,
         /// Byte-stable `"team-agent inbox <message_id>"`.
         poll_via: String,
+        warning: Option<String>,
     },
     /// Compacted delegate result (leader / `*` / broadcast / fanout).
     Direct(ToolOk),
@@ -335,12 +319,16 @@ impl SendOutcome {
             SendOutcome::WorkerAccepted {
                 message_id,
                 poll_via,
+                warning,
             } => {
                 let mut obj = serde_json::Map::new();
                 obj.insert("status".to_string(), Value::String("accepted".to_string()));
                 obj.insert("delivery_pending".to_string(), Value::Bool(true));
                 obj.insert("poll_via".to_string(), Value::String(poll_via.clone()));
                 obj.insert("message_id".to_string(), Value::String(message_id.clone()));
+                if let Some(warning) = warning {
+                    obj.insert("warning".to_string(), Value::String(warning.clone()));
+                }
                 Value::Object(obj)
             }
             SendOutcome::Direct(ok) => Value::Object(ok.fields.clone()),