@team-agent/installer 0.5.53 → 0.5.54

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

@@ -0,0 +1,307 @@
+//! Typed presentation metadata shared by message and result ingress.
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum PresentationSink {
+    Leader,
+    Casefile,
+    Silent,
+}
+
+impl PresentationSink {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Leader => "leader",
+            Self::Casefile => "casefile",
+            Self::Silent => "silent",
+        }
+    }
+
+    fn parse(value: &str) -> Option<Self> {
+        match value {
+            "leader" => Some(Self::Leader),
+            "casefile" => Some(Self::Casefile),
+            "silent" => Some(Self::Silent),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum PresentationClass {
+    Message,
+    Progress,
+    StageResult,
+    StagePass,
+    Bounce,
+    Blocking,
+    FinalReview,
+    Timeout,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PresentationSource {
+    Send,
+    ReportResult,
+}
+
+impl PresentationClass {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Message => "message",
+            Self::Progress => "progress",
+            Self::StageResult => "stage_result",
+            Self::StagePass => "stage_pass",
+            Self::Bounce => "bounce",
+            Self::Blocking => "blocking",
+            Self::FinalReview => "final_review",
+            Self::Timeout => "timeout",
+        }
+    }
+
+    fn parse(value: &str) -> Option<Self> {
+        match value {
+            "message" => Some(Self::Message),
+            "progress" => Some(Self::Progress),
+            "stage_result" => Some(Self::StageResult),
+            "stage_pass" => Some(Self::StagePass),
+            "bounce" => Some(Self::Bounce),
+            "blocking" => Some(Self::Blocking),
+            "final_review" => Some(Self::FinalReview),
+            "timeout" => Some(Self::Timeout),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PresentationRequest {
+    pub sink: PresentationSink,
+    pub class: PresentationClass,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub case_id: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PresentationDecision {
+    pub sink: PresentationSink,
+    pub class: PresentationClass,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub case_id: Option<String>,
+    pub requested_sink: PresentationSink,
+    pub effective_sink: PresentationSink,
+    pub policy_reason: String,
+    pub policy_version: String,
+}
+
+impl Default for PresentationRequest {
+    fn default() -> Self {
+        Self {
+            sink: PresentationSink::Leader,
+            class: PresentationClass::Message,
+            case_id: None,
+        }
+    }
+}
+
+impl Default for PresentationDecision {
+    fn default() -> Self {
+        decide_presentation(
+            &PresentationRequest::default(),
+            PresentationSource::ReportResult,
+        )
+    }
+}
+
+pub fn decide_presentation(
+    request: &PresentationRequest,
+    source: PresentationSource,
+) -> PresentationDecision {
+    let critical = matches!(
+        request.class,
+        PresentationClass::StagePass
+            | PresentationClass::Bounce
+            | PresentationClass::Blocking
+            | PresentationClass::FinalReview
+            | PresentationClass::Timeout
+    );
+    let (effective_sink, policy_reason) = if critical {
+        (
+            PresentationSink::Leader,
+            format!("critical_class:{}", request.class.as_str()),
+        )
+    } else if source == PresentationSource::ReportResult
+        && request.class != PresentationClass::StageResult
+    {
+        (
+            PresentationSink::Leader,
+            format!("user_delivery_class:{}", request.class.as_str()),
+        )
+    } else {
+        (
+            request.sink,
+            format!("requested_sink:{}", request.sink.as_str()),
+        )
+    };
+    PresentationDecision {
+        sink: request.sink,
+        class: request.class,
+        case_id: request.case_id.clone(),
+        requested_sink: request.sink,
+        effective_sink,
+        policy_reason,
+        policy_version: "team-presentation-v1".to_string(),
+    }
+}
+
+pub fn normalize_report_presentation(
+    value: Option<&Value>,
+) -> (PresentationRequest, Option<String>) {
+    let (request, error) = normalize_presentation(value);
+    if error.is_some() {
+        return (request, error);
+    }
+    let missing_case_id = request.class == PresentationClass::StageResult
+        && request.sink != PresentationSink::Leader
+        && request
+            .case_id
+            .as_deref()
+            .is_none_or(|case_id| case_id.trim().is_empty());
+    if missing_case_id {
+        return (request, Some("missing_case_id".to_string()));
+    }
+    (request, None)
+}
+
+pub fn normalize_presentation(value: Option<&Value>) -> (PresentationRequest, Option<String>) {
+    let Some(value) = value else {
+        return (PresentationRequest::default(), None);
+    };
+    let Some(object) = value.as_object() else {
+        return (
+            PresentationRequest::default(),
+            Some("malformed_presentation".to_string()),
+        );
+    };
+    let Some(sink) = object.get("sink").and_then(Value::as_str) else {
+        return (
+            PresentationRequest::default(),
+            Some("missing_sink".to_string()),
+        );
+    };
+    let Some(sink) = PresentationSink::parse(sink) else {
+        return (
+            PresentationRequest::default(),
+            Some(format!("unknown_sink:{sink}")),
+        );
+    };
+    let Some(class) = object.get("class").and_then(Value::as_str) else {
+        return (
+            PresentationRequest::default(),
+            Some("missing_class".to_string()),
+        );
+    };
+    let Some(class) = PresentationClass::parse(class) else {
+        return (
+            PresentationRequest::default(),
+            Some(format!("unknown_class:{class}")),
+        );
+    };
+    let case_id = object
+        .get("case_id")
+        .and_then(Value::as_str)
+        .map(ToOwned::to_owned);
+    (
+        PresentationRequest {
+            sink,
+            class,
+            case_id,
+        },
+        None,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn missing_metadata_keeps_legacy_leader_default() {
+        assert_eq!(
+            normalize_presentation(None),
+            (PresentationRequest::default(), None)
+        );
+    }
+
+    #[test]
+    fn malformed_or_unknown_metadata_is_observable() {
+        assert_eq!(
+            normalize_presentation(Some(&json!({"sink": "casefile"}))).1,
+            Some("missing_class".to_string())
+        );
+        assert_eq!(
+            normalize_presentation(Some(&json!({"sink": "bogus", "class": "message"}))).1,
+            Some("unknown_sink:bogus".to_string())
+        );
+    }
+
+    #[test]
+    fn critical_classes_force_leader_while_prose_is_ignored() {
+        let request = PresentationRequest {
+            sink: PresentationSink::Casefile,
+            class: PresentationClass::Blocking,
+            case_id: None,
+        };
+        let decision = decide_presentation(&request, PresentationSource::ReportResult);
+        assert_eq!(decision.effective_sink, PresentationSink::Leader);
+        assert_eq!(decision.policy_reason, "critical_class:blocking");
+
+        let benign = PresentationRequest {
+            sink: PresentationSink::Casefile,
+            class: PresentationClass::Message,
+            case_id: None,
+        };
+        assert_eq!(
+            decide_presentation(&benign, PresentationSource::Send).effective_sink,
+            PresentationSink::Casefile
+        );
+        assert_eq!(
+            decide_presentation(&benign, PresentationSource::ReportResult).effective_sink,
+            PresentationSink::Leader
+        );
+    }
+
+    #[test]
+    fn report_stage_result_requires_case_id_only_for_non_leader_sink() {
+        assert_eq!(
+            normalize_report_presentation(Some(
+                &json!({"sink": "casefile", "class": "stage_result"})
+            ))
+            .1,
+            Some("missing_case_id".to_string())
+        );
+        assert_eq!(
+            normalize_report_presentation(Some(&json!({
+                "sink": "casefile",
+                "class": "stage_result",
+                "case_id": "case-1"
+            })))
+            .1,
+            None
+        );
+        assert_eq!(
+            normalize_presentation(Some(&json!({
+                "sink": "casefile",
+                "class": "stage_result"
+            })))
+            .1,
+            None,
+            "send normalization remains unchanged"
+        );
+    }
+}

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

@@ -628,6 +628,17 @@ fn report_result_for_owner_team_inner(
     fallback_primary_error: Option<&str>,
 ) -> Result<serde_json::Value, MessagingError> {
     validate_result_envelope(envelope)?;
+    let (presentation_request, presentation_error) =
+        super::presentation::normalize_report_presentation(envelope.get("presentation"));
+    if let Some(error) = presentation_error {
+        return Err(MessagingError::Validation(format!(
+            "invalid presentation: {error}"
+        )));
+    }
+    let presentation = super::presentation::decide_presentation(
+        &presentation_request,
+        super::presentation::PresentationSource::ReportResult,
+    );
     let store = MessageStore::open(workspace)?;
     let result_id = envelope
         .get("result_id")
@@ -645,6 +656,12 @@ fn report_result_for_owner_team_inner(
             );
         }
     }
+    if let Some(obj) = stored.as_object_mut() {
+        obj.insert(
+            "presentation".to_string(),
+            serde_json::to_value(&presentation)?,
+        );
+    }
     let conn = crate::db::schema::open_db(store.db_path())?;
     let state_for_owner =
         crate::state::persist::load_runtime_state(workspace).unwrap_or(serde_json::json!({}));
@@ -710,6 +727,71 @@ fn report_result_for_owner_team_inner(
         out.insert("notification_event_id".to_string(), serde_json::Value::Null);
         return Ok(serde_json::Value::Object(out));
     }
+    let event_log = EventLog::new(workspace);
+    if presentation.effective_sink != super::presentation::PresentationSink::Leader {
+        event_log.write(
+            "presentation.stored_without_live_inject",
+            serde_json::json!({
+                "result_id": result_id,
+                "owner_team_id": owner_team,
+                "requested_sink": presentation.requested_sink,
+                "effective_sink": presentation.effective_sink,
+                "class": presentation.class,
+                "policy_reason": presentation.policy_reason,
+            }),
+        )?;
+        event_log.write(
+            "mcp.report_result",
+            serde_json::json!({
+                "leader_notified": false,
+                "notification_channel": presentation.effective_sink,
+                "notification_message_id": serde_json::Value::Null,
+                "notification_status": "stored_not_presented",
+                "owner_team_id": owner_team,
+                "result_id": result_id,
+            }),
+        )?;
+        let mut out = serde_json::Map::new();
+        out.insert("ok".to_string(), serde_json::Value::Bool(true));
+        out.insert(
+            "result_id".to_string(),
+            serde_json::Value::String(result_id),
+        );
+        out.insert(
+            "task_id".to_string(),
+            serde_json::Value::String(task_id.to_string()),
+        );
+        copy_report_attribution_fields(envelope, &mut out);
+        out.insert(
+            "agent_id".to_string(),
+            serde_json::Value::String(agent_id.to_string()),
+        );
+        out.insert("acknowledged_messages".to_string(), serde_json::json!([]));
+        out.insert(
+            "leader_notified".to_string(),
+            serde_json::Value::Bool(false),
+        );
+        out.insert(
+            "notification_message_id".to_string(),
+            serde_json::Value::Null,
+        );
+        out.insert(
+            "notification_status".to_string(),
+            serde_json::Value::String("stored_not_presented".to_string()),
+        );
+        out.insert(
+            "notification_channel".to_string(),
+            serde_json::Value::String(presentation.effective_sink.as_str().to_string()),
+        );
+        out.insert("notification_event_id".to_string(), serde_json::Value::Null);
+        if let Some(warnings) = report_result_array(envelope, "warnings") {
+            out.insert(
+                "warnings".to_string(),
+                serde_json::Value::Array(warnings.clone()),
+            );
+        }
+        return Ok(serde_json::Value::Object(out));
+    }
     // #230 N31/N32 funnel: report_result must go through the shared leader-delivery
     // primitive synchronously, NOT via a parallel queued scheduled_events row. The
     // legacy path was MUST-8 / I-3 violating (the deferred notification status was returned
@@ -717,8 +799,7 @@ fn report_result_for_owner_team_inner(
     let content =
         format_report_result_notification(&result_id, task_id, agent_id, status, envelope);
     let state = report_owner_state(&state_for_owner, &owner_team);
-    let event_log = EventLog::new(workspace);
-    let mut outcome = match super::leader_receiver::send_to_leader_receiver(
+    let mut outcome = match super::leader_receiver::send_to_leader_receiver_with_presentation(
         workspace,
         &state,
         "leader",
@@ -727,6 +808,8 @@ fn report_result_for_owner_team_inner(
         agent_id,
         false,
         Some(&result_id),
+        None,
+        &presentation,
         &event_log,
     ) {
         Ok(outcome) => outcome,
@@ -1245,7 +1328,8 @@ pub fn collect_results_and_notify_watchers(
 
 #[cfg(test)]
 mod tests {
-    use super::format_report_result_notification;
+    use super::{format_report_result_notification, report_result};
+    use crate::message_store::MessageStore;
 
     #[test]
     fn report_result_notification_includes_full_envelope_sections() {
@@ -1292,4 +1376,47 @@ mod tests {
         assert!(notification.contains("Next actions: ship after review"));
         assert!(notification.contains("Result id: res_1"));
     }
+
+    #[test]
+    fn casefile_result_is_stored_without_a_leader_notification_row() {
+        let workspace = std::env::temp_dir().join(format!(
+            "ta-casefile-result-{}-{}",
+            std::process::id(),
+            super::next_result_id()
+        ));
+        std::fs::create_dir_all(&workspace).unwrap();
+        let out = report_result(
+            &workspace,
+            &serde_json::json!({
+                "schema_version": "result_envelope_v1",
+                "task_id": "task-1",
+                "agent_id": "worker",
+                "status": "success",
+                "summary": "stage evidence",
+                "changes": [],
+                "tests": [],
+                "risks": [],
+                "artifacts": [],
+                "next_actions": [],
+                "presentation": {
+                    "sink": "casefile",
+                    "class": "stage_result",
+                    "case_id": "case-1"
+                }
+            }),
+        )
+        .unwrap();
+        assert_eq!(out["notification_status"], "stored_not_presented");
+        assert_eq!(out["leader_notified"], false);
+        let store = MessageStore::open(&workspace).unwrap();
+        let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+        let result_count: i64 = conn
+            .query_row("select count(*) from results", [], |row| row.get(0))
+            .unwrap();
+        let message_count: i64 = conn
+            .query_row("select count(*) from messages", [], |row| row.get(0))
+            .unwrap();
+        assert_eq!(result_count, 1);
+        assert_eq!(message_count, 0);
+    }
 }

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

@@ -142,6 +142,7 @@ fn run_contract_suite(
             false,
             None,
             super::InitialDisposition::Accepted,
+            None,
         )
         .ok()?
         {

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

@@ -9,7 +9,10 @@ use crate::model::ids::{AgentId, TaskId, TeamKey};
 use crate::transport::{PaneId, Transport};
 
 use super::helpers::{status_wire, MessageStatusShadow};
-use super::leader_receiver::{send_to_leader_receiver, send_to_leader_receiver_with_message_id};
+use super::leader_receiver::{send_to_leader_receiver, send_to_leader_receiver_with_presentation};
+use super::presentation::{
+    decide_presentation, PresentationRequest, PresentationSink, PresentationSource,
+};
 use super::{
     persist_resolved_send, DeliveryBlocker, DeliveryOutcome, DeliveryRefusal, DeliveryStatus,
     InitialDisposition, LogicalRecipient, MessagingError, PersistResolution, ResolvedSendIntent,
@@ -72,6 +75,7 @@ pub struct SendOptions {
     /// the store insert uses this id verbatim; a repeat with the same id is rejected
     /// as [`DeliveryRefusal::Duplicate`] instead of creating a second row.
     pub message_id: Option<String>,
+    pub presentation: PresentationRequest,
 }
 
 impl Default for SendOptions {
@@ -91,6 +95,7 @@ impl Default for SendOptions {
             block_until_delivered: true,
             team: None,
             message_id: None,
+            presentation: PresentationRequest::default(),
         }
     }
 }
@@ -118,7 +123,53 @@ pub fn send_message(
     backfill_leader_binding_for_delivery_view(&mut state, &raw_state);
     let recipient = match target {
         MessageTarget::Single(target) if target == "leader" => {
-            let outcome = send_to_leader_receiver_with_message_id(
+            let presentation = decide_presentation(&opts.presentation, PresentationSource::Send);
+            if presentation.effective_sink != PresentationSink::Leader {
+                let mut intent = ResolvedSendIntent::accepted(
+                    opts.origin,
+                    workspace,
+                    opts.team.clone(),
+                    LogicalRecipient::Leader,
+                    opts.sender.clone(),
+                    opts.task_id.clone(),
+                    content,
+                    None,
+                    false,
+                    opts.message_id.clone(),
+                );
+                intent.initial_disposition = InitialDisposition::StoredOnly;
+                intent.presentation = presentation.clone();
+                let persisted = match persist_resolved_send(&intent)? {
+                    PersistResolution::Persisted(persisted) => persisted,
+                    PersistResolution::Duplicate(message_id) => {
+                        return Ok(refused_outcome_with_id(
+                            DeliveryRefusal::Duplicate,
+                            Some(message_id),
+                        ));
+                    }
+                };
+                event_log.write(
+                    "presentation.stored_without_live_inject",
+                    serde_json::json!({
+                        "message_id": persisted.message_id,
+                        "requested_sink": presentation.requested_sink,
+                        "effective_sink": presentation.effective_sink,
+                        "class": presentation.class,
+                        "policy_reason": presentation.policy_reason,
+                    }),
+                )?;
+                return Ok(DeliveryOutcome {
+                    ok: true,
+                    status: DeliveryStatus::StoredOnly,
+                    message_status: MessageStatusShadow("stored_only".to_string()),
+                    message_id: Some(persisted.message_id),
+                    verification: Some("durable_without_live_inject".to_string()),
+                    stage: None,
+                    reason: None,
+                    channel: Some(presentation.effective_sink.as_str().to_string()),
+                });
+            }
+            let outcome = send_to_leader_receiver_with_presentation(
                 workspace,
                 &state,
                 "leader",
@@ -128,6 +179,7 @@ pub fn send_message(
                 opts.requires_ack,
                 None,
                 opts.message_id.as_deref(),
+                &presentation,
                 &event_log,
             )?;
             if matches!(outcome.status, DeliveryStatus::Queued) && owner_pane_is_dead(&state) {

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

@@ -446,7 +446,10 @@ fn message_not_silently_stuck_accepted_when_coordinator_dead() {
     assert!(out.ok, "durable persistence is the send success boundary");
     assert_eq!(out.status, DeliveryStatus::Blocked);
     assert_eq!(out.message_status.0, "queued_coordinator_unavailable");
-    assert!(out.message_id.as_deref().is_some_and(|id| id.starts_with("msg_")));
+    assert!(out
+        .message_id
+        .as_deref()
+        .is_some_and(|id| id.starts_with("msg_")));
     assert_eq!(out.reason, Some(DeliveryRefusal::CoordinatorUnavailable));
     assert!(
         out.verification
@@ -2290,6 +2293,53 @@ fn u1_multi_team_send_does_not_backfill_top_level_leader_binding() {
     assert_eq!(owner_team_id.as_deref(), Some("team-b"));
 }
 
+#[test]
+fn casefile_leader_send_is_durable_without_entering_leader_funnel() {
+    let ws = tmp_ws("casefile-send");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &serde_json::json!({
+            "session_name": "team-a",
+            "active_team_key": "team-a",
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let opts = SendOptions {
+        team: Some(TeamKey::new("team-a")),
+        requires_ack: false,
+        presentation: crate::messaging::presentation::PresentationRequest {
+            sink: crate::messaging::presentation::PresentationSink::Casefile,
+            class: crate::messaging::presentation::PresentationClass::Progress,
+            case_id: Some("case-1".to_string()),
+        },
+        ..SendOptions::default()
+    };
+    let out = send_message(
+        &ws,
+        &MessageTarget::Single("leader".to_string()),
+        "internal progress",
+        &opts,
+    )
+    .unwrap();
+    assert_eq!(out.status, DeliveryStatus::StoredOnly);
+    assert_eq!(out.message_status.0, "stored_only");
+    let store = store_for(&ws);
+    let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+    let (status, presentation): (String, String) = conn
+        .query_row(
+            "select status, presentation from messages where message_id = ?1",
+            [out.message_id.as_deref().unwrap()],
+            |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()["effective_sink"],
+        "casefile"
+    );
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // GROUP V — retry_result_deliveries: re-route notify_failed watchers with
 // dedupe_reason rebind_retry. result_delivery.py:19-35.

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

@@ -20,6 +20,8 @@ use super::helpers::MessageStatusShadow;
 #[serde(rename_all = "snake_case")]
 pub enum DeliveryStatus {
     Delivered,
+    /// Durable presentation obligation intentionally did not enter physical injection.
+    StoredOnly,
     Failed,
     /// busy → 延后不丢 (card §131:不 mark failed,留队列)。
     Queued,

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

@@ -195,6 +195,7 @@ fn deliver_primary_watcher(
         false,
         None,
         super::InitialDisposition::Accepted,
+        None,
     )?
     else {
         unreachable!("watcher notifications do not accept caller-supplied ids")