@team-agent/installer 0.5.53 → 0.5.54

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

@@ -178,6 +178,34 @@ impl TeamOrchestratorTools {
         requires_ack: Option<bool>,
         scope_override: Option<Scope>,
     ) -> Result<SendOutcome, ToolError> {
+        self.send_message_with_presentation(
+            to,
+            content,
+            task_id,
+            requires_ack,
+            scope_override,
+            None,
+        )
+    }
+
+    pub fn send_message_with_presentation(
+        &self,
+        to: &MessageTarget,
+        content: &str,
+        task_id: Option<&str>,
+        requires_ack: Option<bool>,
+        scope_override: Option<Scope>,
+        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 canonical_owner_team = self.canonical_owner_team_key()?;
         if matches!(scope_override, Some(Scope::Workspace)) {
             return Err(self.rpc_scope_refused(
@@ -227,6 +255,7 @@ impl TeamOrchestratorTools {
             sender,
             requires_ack: ack,
             team: canonical_owner_team,
+            presentation,
             ..SendOptions::default()
         };
         if is_worker_recipient(to) {
@@ -322,6 +351,36 @@ impl TeamOrchestratorTools {
         next_actions: Option<&[Value]>,
         task_id: Option<&str>,
         agent_id: Option<&str>,
+    ) -> ToolResult {
+        self.report_result_with_presentation(
+            envelope,
+            summary,
+            status,
+            changes,
+            tests,
+            risks,
+            artifacts,
+            next_actions,
+            task_id,
+            agent_id,
+            None,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn report_result_with_presentation(
+        &self,
+        envelope: Option<&Value>,
+        summary: Option<&str>,
+        status: ResultStatus,
+        changes: Option<&[Value]>,
+        tests: Option<&[Value]>,
+        risks: Option<&[Value]>,
+        artifacts: Option<&[Value]>,
+        next_actions: Option<&[Value]>,
+        task_id: Option<&str>,
+        agent_id: Option<&str>,
+        presentation: Option<&Value>,
     ) -> ToolResult {
         if let Some(envelope) = envelope {
             self.validate_rpc_scope_args("report_result", envelope)?;
@@ -331,6 +390,11 @@ impl TeamOrchestratorTools {
             .unwrap_or_else(|| Value::Object(serde_json::Map::new()));
         ensure_object(&mut base);
         if let Some(obj) = base.as_object_mut() {
+            if !obj.contains_key("presentation") {
+                if let Some(presentation) = presentation {
+                    obj.insert("presentation".to_string(), presentation.clone());
+                }
+            }
             if !obj.contains_key("summary") {
                 obj.insert(
                     "summary".to_string(),
@@ -459,6 +523,13 @@ impl TeamOrchestratorTools {
             self.note_unknown_result_status(&raw);
         }
         let normalized = normalize_report_envelope(&base);
+        if let Some(error) = normalized.presentation_error.as_deref() {
+            return Err(ToolError::new(
+                ToolErrorReason::InvalidToolArguments,
+                format!("invalid presentation: {error}"),
+                "PresentationError",
+            ));
+        }
         let warnings = report_result_integrity_warnings(&base, &normalized);
         let mut env_value = normalized_envelope_value(&normalized);
         copy_report_attribution_fields(&base, &mut env_value);

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

@@ -5,6 +5,7 @@ use serde_json::Value;
 use thiserror::Error;
 
 // ── REUSE: step 2 model (ids + normalized-envelope value enums) ─────────────
+use crate::messaging::presentation::PresentationDecision;
 use crate::model::enums::{ChangeKind, ResultStatus, RiskSeverity, TestStatus};
 use crate::model::ids::{AgentId, TaskId, TeamKey};
 
@@ -367,6 +368,9 @@ pub struct NormalizedReportEnvelope {
     pub risks: Vec<NormalizedRisk>,
     pub artifacts: Vec<NormalizedArtifact>,
     pub next_actions: Vec<NormalizedNextAction>,
+    pub presentation: PresentationDecision,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub presentation_error: Option<String>,
 }
 
 /// `changes[]` (`normalize.py:126-142`): path + regularized [`ChangeKind`] +

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

@@ -369,11 +369,14 @@ 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. Provide only target and content; Team Agent fills sender, task id, ack policy, and delivery metadata.",
+            "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.",
             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 result envelope.", Vec::new()),
+        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"]),
@@ -419,6 +422,11 @@ fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
                 string_property("Target agent id, 'leader', or '*' for broadcast."),
             );
             insert_property(&mut properties, "content", string_property("Message body."));
+            insert_property(
+                &mut properties,
+                "presentation",
+                presentation_property("Optional durable presentation routing."),
+            );
         }
         McpTool::ReportResult => {
             insert_property(
@@ -467,6 +475,11 @@ fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
                 "agent_id",
                 string_property("Optional reporting agent id override."),
             );
+            insert_property(
+                &mut properties,
+                "presentation",
+                presentation_property("Optional durable presentation routing."),
+            );
         }
         McpTool::UpdateState => {
             insert_property(
@@ -590,6 +603,23 @@ fn object_property(description: &str) -> Value {
     serde_json::json!({"type": "object", "description": description, "additionalProperties": true})
 }
 
+fn presentation_property(description: &str) -> Value {
+    serde_json::json!({
+        "type": "object",
+        "description": description,
+        "properties": {
+            "sink": {"type": "string", "enum": ["leader", "casefile", "silent"]},
+            "class": {"type": "string", "enum": [
+                "message", "progress", "stage_result", "stage_pass", "bounce",
+                "blocking", "final_review", "timeout"
+            ]},
+            "case_id": {"type": "string"}
+        },
+        "required": ["sink", "class"],
+        "additionalProperties": false
+    })
+}
+
 fn array_property(description: &str) -> Value {
     serde_json::json!({"type": "array", "description": description, "items": {"type": "object", "additionalProperties": true}})
 }
@@ -610,7 +640,14 @@ pub(crate) fn dispatch_tool(
         McpTool::SendMessage => {
             let target = message_target_from_value(args.get("to"));
             let content = args.get("content").and_then(Value::as_str).unwrap_or("");
-            let outcome = tools.send_message(&target, content, None, None, None)?;
+            let outcome = tools.send_message_with_presentation(
+                &target,
+                content,
+                None,
+                None,
+                None,
+                args.get("presentation"),
+            )?;
             match outcome {
                 SendOutcome::WorkerAccepted { .. } => Ok(ToolOk {
                     fields: object_fields(outcome.to_value()),
@@ -618,7 +655,7 @@ pub(crate) fn dispatch_tool(
                 SendOutcome::Direct(ok) => Ok(ok),
             }
         }
-        McpTool::ReportResult => tools.report_result(
+        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
@@ -650,6 +687,7 @@ pub(crate) fn dispatch_tool(
                 .map(Vec::as_slice),
             args.get("task_id").and_then(Value::as_str),
             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(""))

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

@@ -57,6 +57,7 @@ pub fn deliver_stored_message(
         requires_ack,
         None,
         super::InitialDisposition::Accepted,
+        None,
     )?
     else {
         unreachable!("internal delivery does not accept caller-supplied ids")
@@ -1828,6 +1829,7 @@ pub fn deliver_pending_messages(
     let store = MessageStore::open(workspace)?;
     let message_ids = {
         let conn = crate::db::schema::open_db(store.db_path())?;
+        // `stored_only` is intentionally absent: C6 chose durable presentation without C5.
         let mut stmt = conn.prepare(
             "select message_id from messages
              where status in (

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

@@ -25,6 +25,7 @@ static RESULT_COUNTER: AtomicU64 = AtomicU64::new(0);
 pub(crate) fn status_wire(status: DeliveryStatus) -> &'static str {
     match status {
         DeliveryStatus::Delivered => "delivered",
+        DeliveryStatus::StoredOnly => "stored_only",
         DeliveryStatus::Failed => "failed",
         DeliveryStatus::Queued => "queued",
         DeliveryStatus::Blocked => "blocked",

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

@@ -14,6 +14,7 @@ use crate::transport::{
 
 use super::helpers::MessageStatusShadow;
 use super::persist::persist_internal_send;
+use super::presentation::PresentationDecision;
 use super::{
     DeliveryOutcome, DeliveryRefusal, DeliveryStage, DeliveryStatus, InitialDisposition,
     InternalSendKind, MessagingError, PersistResolution,
@@ -69,6 +70,35 @@ pub fn send_to_leader_receiver_with_message_id(
     result_id: Option<&str>,
     requested_message_id: Option<&str>,
     event_log: &EventLog,
+) -> Result<DeliveryOutcome, MessagingError> {
+    send_to_leader_receiver_with_presentation(
+        workspace,
+        state,
+        leader_id,
+        content,
+        task_id,
+        sender,
+        requires_ack,
+        result_id,
+        requested_message_id,
+        &PresentationDecision::default(),
+        event_log,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn send_to_leader_receiver_with_presentation(
+    workspace: &Path,
+    state: &serde_json::Value,
+    leader_id: &str,
+    content: &str,
+    task_id: Option<&TaskId>,
+    sender: &str,
+    requires_ack: bool,
+    result_id: Option<&str>,
+    requested_message_id: Option<&str>,
+    presentation: &PresentationDecision,
+    event_log: &EventLog,
 ) -> Result<DeliveryOutcome, MessagingError> {
     let store = MessageStore::open(workspace)?;
     let owner_team = active_team_key(workspace, state);
@@ -90,6 +120,7 @@ pub fn send_to_leader_receiver_with_message_id(
         false,
         requested_message_id,
         InitialDisposition::Accepted,
+        Some(presentation),
     )? {
         PersistResolution::Duplicate(requested) => {
             return Ok(DeliveryOutcome {
@@ -643,6 +674,7 @@ pub fn enqueue_leader_mailbox_until_attach(
         false,
         None,
         InitialDisposition::QueuedUntilLeaderAttach,
+        None,
     )?
     else {
         unreachable!("offline mailbox does not accept caller-supplied ids")

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

@@ -68,6 +68,7 @@ pub mod leader_channel;
 pub mod leader_receiver;
 pub mod peers;
 pub mod persist;
+pub mod presentation;
 pub mod results;
 pub mod scheduler;
 pub mod selftest;
@@ -94,7 +95,7 @@ pub use leader_channel::{
 pub use leader_receiver::{
     deliver_to_leader_fallback_pane, enqueue_leader_mailbox_until_attach,
     mirror_peer_message_to_leader, send_to_leader_receiver,
-    send_to_leader_receiver_with_message_id,
+    send_to_leader_receiver_with_message_id, send_to_leader_receiver_with_presentation,
 };
 pub use peers::allow_peer_talk;
 pub use persist::{

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

@@ -5,6 +5,7 @@ use std::path::{Path, PathBuf};
 use crate::db::message_store::{MessageRowStatus, MessageStore, PersistMessageInput};
 use crate::model::ids::{AgentId, TaskId, TeamKey};
 
+use super::presentation::PresentationDecision;
 use super::send::TrustedSender;
 use super::MessagingError;
 
@@ -64,6 +65,7 @@ impl DeliveryBlocker {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum InitialDisposition {
     Accepted,
+    StoredOnly,
     QueuedUntilLeaderAttach,
     Blocked(DeliveryBlocker),
 }
@@ -72,6 +74,7 @@ impl InitialDisposition {
     fn row_status(self) -> MessageRowStatus {
         match self {
             Self::Accepted => MessageRowStatus::Accepted,
+            Self::StoredOnly => MessageRowStatus::StoredOnly,
             Self::QueuedUntilLeaderAttach => MessageRowStatus::QueuedUntilLeaderAttach,
             Self::Blocked(DeliveryBlocker::CoordinatorUnavailable) => {
                 MessageRowStatus::QueuedCoordinatorUnavailable
@@ -82,7 +85,7 @@ impl InitialDisposition {
     fn error(self) -> Option<&'static str> {
         match self {
             Self::Blocked(blocker) => Some(blocker.as_str()),
-            Self::Accepted | Self::QueuedUntilLeaderAttach => None,
+            Self::Accepted | Self::StoredOnly | Self::QueuedUntilLeaderAttach => None,
         }
     }
 }
@@ -100,6 +103,7 @@ pub struct ResolvedSendIntent {
     pub requires_ack: bool,
     pub requested_message_id: Option<String>,
     pub initial_disposition: InitialDisposition,
+    pub presentation: PresentationDecision,
 }
 
 impl ResolvedSendIntent {
@@ -128,6 +132,7 @@ impl ResolvedSendIntent {
             requires_ack,
             requested_message_id,
             initial_disposition: InitialDisposition::Accepted,
+            presentation: PresentationDecision::default(),
         }
     }
 }
@@ -158,6 +163,7 @@ pub fn persist_resolved_send(
         }
     }
     let status = intent.initial_disposition.row_status();
+    let presentation = serde_json::to_string(&intent.presentation)?;
     let message_id = store.persist_message(PersistMessageInput {
         message_id: intent.requested_message_id.as_deref(),
         owner_team_id: intent.owner_team_id.as_ref().map(TeamKey::as_str),
@@ -168,6 +174,7 @@ pub fn persist_resolved_send(
         requires_ack: intent.requires_ack,
         status,
         content: &intent.content,
+        presentation: &presentation,
         error: intent.initial_disposition.error(),
     })?;
     Ok(PersistResolution::Persisted(PersistedSend {
@@ -177,7 +184,9 @@ pub fn persist_resolved_send(
         row_status: status,
         blocker: match intent.initial_disposition {
             InitialDisposition::Blocked(blocker) => Some(blocker),
-            InitialDisposition::Accepted | InitialDisposition::QueuedUntilLeaderAttach => None,
+            InitialDisposition::Accepted
+            | InitialDisposition::StoredOnly
+            | InitialDisposition::QueuedUntilLeaderAttach => None,
         },
     }))
 }
@@ -195,6 +204,7 @@ pub(crate) fn persist_internal_send(
     requires_ack: bool,
     requested_message_id: Option<&str>,
     initial_disposition: InitialDisposition,
+    presentation: Option<&PresentationDecision>,
 ) -> Result<PersistResolution, MessagingError> {
     let mut intent = ResolvedSendIntent::accepted(
         SendOrigin::Internal(kind),
@@ -209,6 +219,9 @@ pub(crate) fn persist_internal_send(
         requested_message_id.map(ToOwned::to_owned),
     );
     intent.initial_disposition = initial_disposition;
+    if let Some(presentation) = presentation {
+        intent.presentation = presentation.clone();
+    }
     persist_resolved_send(&intent)
 }
 
@@ -266,6 +279,59 @@ mod tests {
         assert_eq!(error.as_deref(), Some("coordinator_unavailable"));
     }
 
+    #[test]
+    fn stored_only_persists_requested_presentation_without_delivery_eligibility() {
+        let workspace = workspace("stored-only");
+        let mut intent = ResolvedSendIntent::accepted(
+            SendOrigin::Mcp,
+            &workspace,
+            Some(TeamKey::new("team-a")),
+            LogicalRecipient::Leader,
+            TrustedSender::from_runtime_identity(AgentId::new("worker_a")),
+            None,
+            "stage evidence",
+            None,
+            false,
+            None,
+        );
+        intent.initial_disposition = InitialDisposition::StoredOnly;
+        intent.presentation = super::super::presentation::decide_presentation(
+            &super::super::presentation::PresentationRequest {
+                sink: super::super::presentation::PresentationSink::Casefile,
+                class: super::super::presentation::PresentationClass::StageResult,
+                case_id: Some("case-7".to_string()),
+            },
+            super::super::presentation::PresentationSource::Send,
+        );
+        let PersistResolution::Persisted(persisted) = persist_resolved_send(&intent).unwrap()
+        else {
+            panic!("fresh intent must persist")
+        };
+        assert_eq!(persisted.row_status, MessageRowStatus::StoredOnly);
+        let store = MessageStore::open(&workspace).unwrap();
+        let connection = crate::db::schema::open_db(store.db_path()).unwrap();
+        let (status, presentation): (String, String) = connection
+            .query_row(
+                "select status, presentation from messages where message_id = ?1",
+                [&persisted.message_id],
+                |row| Ok((row.get(0)?, row.get(1)?)),
+            )
+            .unwrap();
+        assert_eq!(status, "stored_only");
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&presentation).unwrap(),
+            serde_json::json!({
+                "sink": "casefile",
+                "class": "stage_result",
+                "case_id": "case-7",
+                "requested_sink": "casefile",
+                "effective_sink": "casefile",
+                "policy_reason": "requested_sink:casefile",
+                "policy_version": "team-presentation-v1"
+            })
+        );
+    }
+
     #[test]
     fn production_row_creation_is_owned_by_persisted_primitive() {
         for (name, source) in [