@team-agent/installer 0.5.60 → 0.5.61

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

@@ -17,17 +17,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 +116,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 +201,7 @@ impl TeamOrchestratorTools {
             requires_ack,
             scope_override,
             None,
+            None,
         )
     }
 
@@ -195,17 +212,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 +281,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 +311,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 +400,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 +421,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 +453,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 +551,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 +597,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 +621,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 +1231,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

@@ -322,6 +322,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 +336,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()),

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

@@ -9,7 +9,6 @@ use crate::event_log::EventLog;
 use crate::messaging::MessageTarget;
 
 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,
@@ -369,7 +368,7 @@ fn python_repr(value: &str) -> String {
 fn tool_contract(tool: McpTool) -> Value {
     let (description, required) = match tool {
         McpTool::SendMessage => (
-            "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.",
+            "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"]),
@@ -404,11 +403,7 @@ 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, "task", task_property());
             insert_property(
                 &mut properties,
                 "message",
@@ -424,8 +419,10 @@ fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
             insert_property(&mut properties, "content", string_property("Message body."));
             insert_property(
                 &mut properties,
-                "presentation",
-                presentation_property("Optional durable presentation routing."),
+                "mailbox",
+                boolean_property(
+                    "Set true to store durably without live injection; omit for default live delivery.",
+                ),
             );
         }
         McpTool::ReportResult => {
@@ -603,6 +600,25 @@ 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",
@@ -646,6 +662,7 @@ pub(crate) fn dispatch_tool(
                 None,
                 None,
                 None,
+                args.get("mailbox"),
                 args.get("presentation"),
             )?;
             match outcome {
@@ -658,18 +675,7 @@ pub(crate) fn dispatch_tool(
         McpTool::ReportResult => tools.report_result_with_presentation(
             args.get("envelope"),
             args.get("summary").and_then(Value::as_str),
-            // 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),
-                    );
-                if let Some(raw) = unknown {
-                    tools.note_unknown_result_status(&raw);
-                }
-                status
-            },
+            args.get("status").and_then(Value::as_str),
             args.get("changes")
                 .and_then(Value::as_array)
                 .map(Vec::as_slice),

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

@@ -220,7 +220,12 @@ pub fn deliver_pending_message(
         }
         _ => state,
     };
-    if message.recipient == "leader" && message.status == "submitted_pending_acceptance" {
+    if message.recipient == "leader"
+        && matches!(
+            message.status.as_str(),
+            "submitted_pending_acceptance" | "injected_awaiting_receipt"
+        )
+    {
         return observe_pending_leader_acceptance(store, event_log, state, message_id);
     }
     if message.recipient == "leader" && message.status == "queued_until_leader_attach" {
@@ -341,6 +346,12 @@ pub fn deliver_pending_message(
                     .get("status")
                     .and_then(serde_json::Value::as_str)
                     .unwrap_or("unbound");
+                let refusal = match &reason {
+                    crate::messaging::LeaderChannelUnbound::PaneWorkspaceMismatch(_) => {
+                        DeliveryRefusal::PaneWorkspaceMismatch
+                    }
+                    _ => DeliveryRefusal::LeaderNotAttached,
+                };
                 store.mark(message_id, "failed", Some("leader_not_attached"))?;
                 event_log.write(
                     "leader_receiver.delivery_blocked",
@@ -349,7 +360,7 @@ pub fn deliver_pending_message(
                         "sender": message.sender,
                         "reason": "leader_receiver_not_attached",
                         "error": "leader_not_attached",
-                        "channel_reason": format!("{reason:?}"),
+                        "channel_reason": reason.reason_code(),
                         "channel": "rebind_required",
                         "action": "run team-agent attach-leader or team-agent takeover",
                         "status": receiver_status,
@@ -364,7 +375,7 @@ pub fn deliver_pending_message(
                         "run team-agent attach-leader or team-agent takeover".to_string(),
                     ),
                     stage: None,
-                    reason: Some(DeliveryRefusal::LeaderNotAttached),
+                    reason: Some(refusal),
                     channel: Some("rebind_required".to_string()),
                 });
             }
@@ -711,19 +722,30 @@ pub fn deliver_pending_message(
     }
     if is_leader_recipient {
         store.record_delivery_submission(message_id, readback_verified)?;
-        if !leader_transcript_has_token(state, message_id) {
-            store.mark(message_id, "submitted_pending_acceptance", None)?;
-            event_log.write(
-                "leader_receiver.acceptance_pending",
-                serde_json::json!({
-                    "message_id": message_id,
-                    "reason": "provider_receipt_not_observed",
-                }),
-            )?;
-            return Ok(leader_acceptance_pending_outcome(
-                message_id,
-                "submitted_pending_acceptance",
-            ));
+        match observe_leader_receipt(state, message_id) {
+            LeaderReceiptObservation::SourceUnavailable => {
+                store.mark_injected_awaiting_receipt(message_id)?;
+                event_log.write(
+                    "leader_receiver.receipt_source_unavailable",
+                    serde_json::json!({"message_id": message_id}),
+                )?;
+                return Ok(leader_receipt_source_unavailable_outcome(message_id));
+            }
+            LeaderReceiptObservation::TokenAbsent => {
+                store.mark(message_id, "submitted_pending_acceptance", None)?;
+                event_log.write(
+                    "leader_receiver.acceptance_pending",
+                    serde_json::json!({
+                        "message_id": message_id,
+                        "reason": "provider_receipt_not_observed",
+                    }),
+                )?;
+                return Ok(leader_acceptance_pending_outcome(
+                    message_id,
+                    "submitted_pending_acceptance",
+                ));
+            }
+            LeaderReceiptObservation::TokenObserved => {}
         }
         store.mark_delivered_with_receipt(message_id)?;
     } else {
@@ -2041,15 +2063,36 @@ fn leader_rollout_path(state: &serde_json::Value) -> Option<std::path::PathBuf>
         .map(std::path::PathBuf::from)
 }
 
-pub(crate) fn leader_transcript_has_token(state: &serde_json::Value, message_id: &str) -> bool {
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum LeaderReceiptObservation {
+    SourceUnavailable,
+    TokenAbsent,
+    TokenObserved,
+}
+
+pub(crate) fn observe_leader_receipt(
+    state: &serde_json::Value,
+    message_id: &str,
+) -> LeaderReceiptObservation {
     let Some(path) = leader_rollout_path(state) else {
-        return false;
+        return LeaderReceiptObservation::SourceUnavailable;
     };
-    rollout_tail_contains(
+    let Ok(observed) = rollout_tail_contains_result(
         &path,
         &format!("[team-agent-token:{message_id}]"),
         64 * 1024,
-    )
+    ) else {
+        return LeaderReceiptObservation::SourceUnavailable;
+    };
+    if observed {
+        LeaderReceiptObservation::TokenObserved
+    } else {
+        LeaderReceiptObservation::TokenAbsent
+    }
+}
+
+pub(crate) fn leader_transcript_has_token(state: &serde_json::Value, message_id: &str) -> bool {
+    observe_leader_receipt(state, message_id) == LeaderReceiptObservation::TokenObserved
 }
 
 fn leader_acceptance_pending_outcome(message_id: &str, status: &str) -> DeliveryOutcome {
@@ -2065,17 +2108,41 @@ fn leader_acceptance_pending_outcome(message_id: &str, status: &str) -> Delivery
     }
 }
 
+pub(crate) fn leader_receipt_source_unavailable_outcome(message_id: &str) -> DeliveryOutcome {
+    DeliveryOutcome {
+        ok: true,
+        status: DeliveryStatus::Blocked,
+        message_status: MessageStatusShadow("injected_awaiting_receipt".to_string()),
+        message_id: Some(message_id.to_string()),
+        verification: Some("leader_receipt_source_unavailable".to_string()),
+        stage: Some(DeliveryStage::Submit),
+        reason: None,
+        channel: Some("leader_receipt_source_unavailable".to_string()),
+    }
+}
+
 fn observe_pending_leader_acceptance(
     store: &MessageStore,
     event_log: &EventLog,
     state: &serde_json::Value,
     message_id: &str,
 ) -> Result<DeliveryOutcome, MessagingError> {
-    if !leader_transcript_has_token(state, message_id) {
-        return Ok(leader_acceptance_pending_outcome(
-            message_id,
-            "submitted_pending_acceptance",
-        ));
+    match observe_leader_receipt(state, message_id) {
+        LeaderReceiptObservation::SourceUnavailable => {
+            store.mark_injected_awaiting_receipt(message_id)?;
+            event_log.write(
+                "leader_receiver.receipt_source_unavailable",
+                serde_json::json!({"message_id": message_id}),
+            )?;
+            return Ok(leader_receipt_source_unavailable_outcome(message_id));
+        }
+        LeaderReceiptObservation::TokenAbsent => {
+            return Ok(leader_acceptance_pending_outcome(
+                message_id,
+                "submitted_pending_acceptance",
+            ));
+        }
+        LeaderReceiptObservation::TokenObserved => {}
     }
     store.mark_delivered_with_receipt(message_id)?;
     event_log.write(
@@ -2744,22 +2811,22 @@ fn claude_recipient_rollout(
 /// Silent on read errors — callers treat missing/unreadable as "token not
 /// present" which forces the unverified path.
 fn rollout_tail_contains(path: &std::path::Path, needle: &str, tail_bytes: u64) -> bool {
+    rollout_tail_contains_result(path, needle, tail_bytes).unwrap_or(false)
+}
+
+fn rollout_tail_contains_result(
+    path: &std::path::Path,
+    needle: &str,
+    tail_bytes: u64,
+) -> std::io::Result<bool> {
     use std::io::{Read, Seek, SeekFrom};
-    let Ok(mut file) = std::fs::File::open(path) else {
-        return false;
-    };
-    let Ok(metadata) = file.metadata() else {
-        return false;
-    };
+    let mut file = std::fs::File::open(path)?;
+    let metadata = file.metadata()?;
     let len = metadata.len();
     let start = len.saturating_sub(tail_bytes);
-    if file.seek(SeekFrom::Start(start)).is_err() {
-        return false;
-    }
+    file.seek(SeekFrom::Start(start))?;
     let mut buf = Vec::with_capacity(tail_bytes.min(len) as usize);
-    if file.take(tail_bytes).read_to_end(&mut buf).is_err() {
-        return false;
-    }
+    file.take(tail_bytes).read_to_end(&mut buf)?;
     let haystack = String::from_utf8_lossy(&buf);
-    haystack.contains(needle)
+    Ok(haystack.contains(needle))
 }