@team-agent/installer 0.5.59 → 0.5.61

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

@@ -14,6 +14,95 @@ use super::MessagingError;
 use crate::model::ids::TaskId;
 use crate::state::projection::OwnerTeamResolution;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ResultRoute {
+    Leader,
+    Pipeline,
+}
+
+impl ResultRoute {
+    pub const ALL: [Self; 2] = [Self::Leader, Self::Pipeline];
+
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Leader => "leader",
+            Self::Pipeline => "pipeline",
+        }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        match value {
+            "leader" => Some(Self::Leader),
+            "pipeline" => Some(Self::Pipeline),
+            _ => None,
+        }
+    }
+}
+
+impl Default for ResultRoute {
+    fn default() -> Self {
+        Self::Leader
+    }
+}
+
+pub fn results_for_case(
+    workspace: &Path,
+    case_id: &str,
+    owner_team_id: Option<&str>,
+    requested_owner_team_id: Option<&str>,
+) -> Result<Vec<serde_json::Value>, MessagingError> {
+    let current_db = workspace.join(".team/runtime/team.db");
+    let legacy_db = workspace.join(".team/team.db");
+    if current_db.exists() {
+        return results_for_case_in_db(
+            &current_db,
+            case_id,
+            owner_team_id,
+            requested_owner_team_id,
+        );
+    }
+    if legacy_db.exists() {
+        return results_for_case_in_db(&legacy_db, case_id, owner_team_id, requested_owner_team_id);
+    }
+    Ok(Vec::new())
+}
+
+fn results_for_case_in_db(
+    db_path: &Path,
+    case_id: &str,
+    owner_team_id: Option<&str>,
+    requested_owner_team_id: Option<&str>,
+) -> Result<Vec<serde_json::Value>, MessagingError> {
+    let conn = crate::db::schema::open_db(db_path)?;
+    // The second predicate works around
+    // `.team/bugs/BUG-caseid-writable-when-route-undeclared-20260730.md`;
+    // it is not design intent.
+    let case_predicate = "task_id = ?1 or json_extract(envelope,'$.presentation.case_id') = ?1";
+    let sql = match owner_team_id {
+        Some(_) => format!(
+            "select envelope from results where ({case_predicate}) \
+             and (owner_team_id = ?2 or owner_team_id = ?3) \
+             order by created_at, result_id"
+        ),
+        None => format!(
+            "select envelope from results where {case_predicate} order by created_at, result_id"
+        ),
+    };
+    let mut stmt = conn.prepare(&sql)?;
+    let row_mapper = |row: &rusqlite::Row<'_>| row.get::<_, String>(0);
+    let rows = match (owner_team_id, requested_owner_team_id) {
+        (Some(team), Some(requested_team)) => {
+            stmt.query_map(params![case_id, team, requested_team], row_mapper)
+        }
+        (Some(team), None) => stmt.query_map(params![case_id, team, team], row_mapper),
+        (None, _) => stmt.query_map(params![case_id], row_mapper),
+    }?
+    .collect::<Result<Vec<_>, _>>()?;
+    rows.into_iter()
+        .map(|envelope| serde_json::from_str(&envelope).map_err(MessagingError::from))
+        .collect()
+}
+
 /// `collect` (`results.py:45`):投递 pending、捞 uncollected results、校验 envelope、更新任务态、
 /// 写 team_state、ensure coordinator。CLI `collect` + coordinator tick 调。
 pub fn collect(
@@ -627,18 +716,12 @@ fn report_result_for_owner_team_inner(
     explicit_owner_team: Option<&str>,
     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}"
-        )));
+    if envelope.get("result_route").is_some() {
+        return Err(MessagingError::Validation(
+            "report_result result_route is task-owned and cannot be set by a worker".to_string(),
+        ));
     }
-    let presentation = super::presentation::decide_presentation(
-        &presentation_request,
-        super::presentation::PresentationSource::ReportResult,
-    );
+    validate_result_envelope(envelope)?;
     let store = MessageStore::open(workspace)?;
     let result_id = envelope
         .get("result_id")
@@ -656,12 +739,6 @@ 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!({}));
@@ -669,6 +746,42 @@ fn report_result_for_owner_team_inner(
         .filter(|team| !team.is_empty())
         .map(str::to_string)
         .unwrap_or_else(|| super::leader_receiver::active_team_key(workspace, &state_for_owner));
+    let (result_route, route_declared) = task_result_route(&state_for_owner, &owner_team, task_id)?;
+    let presentation = if route_declared {
+        let request = super::presentation::PresentationRequest {
+            sink: match result_route {
+                ResultRoute::Leader => super::presentation::PresentationSink::Leader,
+                ResultRoute::Pipeline => super::presentation::PresentationSink::Casefile,
+            },
+            class: match result_route {
+                ResultRoute::Leader => super::presentation::PresentationClass::Message,
+                ResultRoute::Pipeline => super::presentation::PresentationClass::StageResult,
+            },
+            case_id: (result_route == ResultRoute::Pipeline).then(|| task_id.to_string()),
+        };
+        super::presentation::decide_presentation(
+            &request,
+            super::presentation::PresentationSource::ReportResult,
+        )
+    } else {
+        let (request, error) =
+            super::presentation::normalize_report_presentation(envelope.get("presentation"));
+        if let Some(error) = error {
+            return Err(MessagingError::Validation(format!(
+                "invalid presentation: {error}"
+            )));
+        }
+        super::presentation::decide_presentation(
+            &request,
+            super::presentation::PresentationSource::ReportResult,
+        )
+    };
+    if let Some(obj) = stored.as_object_mut() {
+        obj.insert(
+            "presentation".to_string(),
+            serde_json::to_value(&presentation)?,
+        );
+    }
     let inserted = insert_result_if_absent(
         &conn,
         &result_id,
@@ -968,6 +1081,8 @@ fn report_result_for_owner_team_inner(
     let leader_notified = matches!(outcome.status, crate::messaging::DeliveryStatus::Delivered);
     let notification_status_wire = if leader_notified {
         "delivered"
+    } else if outcome.channel.as_deref() == Some("leader_receipt_source_unavailable") {
+        "injected_awaiting_receipt"
     } else if outcome.channel.as_deref() == Some("leader_acceptance_pending") {
         "submitted_pending_acceptance"
     } else if outcome.channel.as_deref() == Some("rebind_required")
@@ -1045,6 +1160,39 @@ fn report_result_for_owner_team_inner(
     Ok(serde_json::Value::Object(out))
 }
 
+fn task_result_route(
+    state: &serde_json::Value,
+    owner_team: &str,
+    task_id: &str,
+) -> Result<(ResultRoute, bool), MessagingError> {
+    let scoped_tasks = state
+        .get("teams")
+        .and_then(|teams| teams.get(owner_team))
+        .and_then(|team| team.get("tasks"))
+        .and_then(serde_json::Value::as_array);
+    let top_level_tasks = state.get("tasks").and_then(serde_json::Value::as_array);
+    let task = scoped_tasks
+        .into_iter()
+        .flatten()
+        .chain(top_level_tasks.into_iter().flatten())
+        .find(|task| task.get("id").and_then(serde_json::Value::as_str) == Some(task_id));
+    let Some(route) = task.and_then(|task| task.get("result_route")) else {
+        return Ok((ResultRoute::default(), false));
+    };
+    let route = route.as_str().ok_or_else(|| {
+        MessagingError::Validation(format!(
+            "task {task_id} has non-string result_route and cannot accept results"
+        ))
+    })?;
+    ResultRoute::parse(route)
+        .map(|route| (route, true))
+        .ok_or_else(|| {
+            MessagingError::Validation(format!(
+                "task {task_id} has unknown result_route {route:?} and cannot accept results"
+            ))
+        })
+}
+
 fn copy_report_attribution_fields(
     envelope: &serde_json::Value,
     out: &mut serde_json::Map<String, serde_json::Value>,

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

@@ -9,9 +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_presentation};
+use super::leader_receiver::send_to_leader_receiver_with_presentation;
 use super::presentation::{
-    decide_presentation, PresentationRequest, PresentationSink, PresentationSource,
+    decide_presentation, PresentationDecision, PresentationRequest, PresentationSink,
+    PresentationSource,
 };
 use super::{
     persist_resolved_send, DeliveryBlocker, DeliveryOutcome, DeliveryRefusal, DeliveryStatus,
@@ -125,49 +126,14 @@ pub fn send_message(
         MessageTarget::Single(target) if target == "leader" => {
             let presentation = decide_presentation(&opts.presentation, PresentationSource::Send);
             if presentation.effective_sink != PresentationSink::Leader {
-                let mut intent = ResolvedSendIntent::accepted(
-                    opts.origin,
+                return persist_stored_only_send(
                     workspace,
-                    opts.team.clone(),
                     LogicalRecipient::Leader,
-                    opts.sender.clone(),
-                    opts.task_id.clone(),
                     content,
-                    None,
-                    false,
-                    opts.message_id.clone(),
+                    opts,
+                    &presentation,
+                    &event_log,
                 );
-                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,
@@ -201,15 +167,7 @@ pub fn send_message(
         MessageTarget::Single(target) => target,
         MessageTarget::Broadcast => {
             let recipients = broadcast_recipients(&state, opts.sender.as_str(), opts.team.as_ref());
-            return fanout_send(
-                workspace,
-                &state,
-                &recipients,
-                content,
-                opts,
-                &event_log,
-                "*",
-            );
+            return fanout_send(workspace, &recipients, content, opts, "*");
         }
         MessageTarget::Fanout(recipients) if recipients.is_empty() => {
             // swallow batch 3 ②: a failed send carries its reason (Python send error
@@ -226,9 +184,7 @@ pub fn send_message(
             });
         }
         MessageTarget::Fanout(recipients) => {
-            return fanout_send(
-                workspace, &state, recipients, content, opts, &event_log, "fanout",
-            );
+            return fanout_send(workspace, recipients, content, opts, "fanout");
         }
     };
     // send.py:259-261 — a non-leader target that is NOT a known team agent is refused
@@ -240,6 +196,17 @@ pub fn send_message(
     if !in_team {
         return Ok(refused_outcome(DeliveryRefusal::TargetNotInTeam));
     }
+    let presentation = decide_presentation(&opts.presentation, PresentationSource::Send);
+    if presentation.effective_sink != PresentationSink::Leader {
+        return persist_stored_only_send(
+            workspace,
+            LogicalRecipient::from_resolved(recipient),
+            content,
+            opts,
+            &presentation,
+            &event_log,
+        );
+    }
     if let Some(outcome) = session_drift_refusal(
         &state,
         recipient,
@@ -354,6 +321,59 @@ pub fn send_message(
     })
 }
 
+fn persist_stored_only_send(
+    workspace: &Path,
+    recipient: LogicalRecipient,
+    content: &str,
+    opts: &SendOptions,
+    presentation: &PresentationDecision,
+    event_log: &EventLog,
+) -> Result<DeliveryOutcome, MessagingError> {
+    let mut intent = ResolvedSendIntent::accepted(
+        opts.origin,
+        workspace,
+        opts.team.clone(),
+        recipient,
+        opts.sender.clone(),
+        opts.task_id.clone(),
+        content,
+        None,
+        opts.requires_ack,
+        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,
+        }),
+    )?;
+    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()),
+    })
+}
+
 fn stale_worker_target_missing_preflight(
     workspace: &Path,
     state: &serde_json::Value,
@@ -804,11 +824,9 @@ fn broadcast_recipients(
 
 fn fanout_send(
     workspace: &Path,
-    state: &serde_json::Value,
     recipients: &[String],
     content: &str,
     opts: &SendOptions,
-    event_log: &EventLog,
     channel_label: &str,
 ) -> Result<DeliveryOutcome, MessagingError> {
     let mut last_message_id: Option<String> = None;
@@ -821,30 +839,17 @@ fn fanout_send(
             continue;
         }
         attempted_count = attempted_count.saturating_add(1);
-        let outcome = if recipient == "leader" {
-            send_to_leader_receiver(
-                workspace,
-                state,
-                recipient,
-                content,
-                opts.task_id.as_ref(),
-                opts.sender.as_str(),
-                opts.requires_ack,
-                None,
-                event_log,
-            )?
-        } else {
-            // single-recipient re-entry — strip fanout metadata to avoid recursion + ensure
-            // each row gets its own caller-supplied message_id (none) so SQLite PK doesn't clash.
-            let mut inner_opts = opts.clone();
-            inner_opts.message_id = None;
-            super::send::send_message(
-                workspace,
-                &MessageTarget::Single(recipient.clone()),
-                content,
-                &inner_opts,
-            )?
-        };
+        // Every expanded recipient re-enters the same presentation-aware send
+        // funnel. Strip the caller idempotency key so each durable fanout row
+        // receives its own stable message id.
+        let mut inner_opts = opts.clone();
+        inner_opts.message_id = None;
+        let outcome = super::send::send_message(
+            workspace,
+            &MessageTarget::Single(recipient.clone()),
+            content,
+            &inner_opts,
+        )?;
         if outcome.ok {
             delivered_count = delivered_count.saturating_add(1);
             if let Some(mid) = outcome.message_id.clone() {
@@ -862,8 +867,12 @@ fn fanout_send(
             return Ok(outcome);
         }
     }
+    let presentation = decide_presentation(&opts.presentation, PresentationSource::Send);
+    let stored_only = presentation.effective_sink != PresentationSink::Leader;
     let status = if any_failure {
         DeliveryStatus::FanoutPartial
+    } else if delivered_count > 0 && stored_only {
+        DeliveryStatus::StoredOnly
     } else if delivered_count > 0 {
         DeliveryStatus::FanoutDelivered
     } else {
@@ -874,9 +883,13 @@ fn fanout_send(
         status,
         message_status: MessageStatusShadow(status_wire(status).to_string()),
         message_id: last_message_id,
-        verification: None,
+        verification: stored_only.then(|| "durable_without_live_inject".to_string()),
         stage: None,
         reason: None,
-        channel: Some(channel_label.to_string()),
+        channel: Some(if stored_only {
+            presentation.effective_sink.as_str().to_string()
+        } else {
+            channel_label.to_string()
+        }),
     })
 }

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

@@ -101,10 +101,10 @@ fn legacy_receiver_without_status_still_rejects_a_foreign_workspace() {
         .with_tmux_endpoint(socket)
         .with_targets(vec![observed]);
 
-    assert_eq!(
+    assert!(matches!(
         resolve_live_leader_channel(workspace, &receiver, &transport),
-        LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch)
-    );
+        LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch(_))
+    ));
 }
 
 #[test]
@@ -162,8 +162,8 @@ fn same_socket_and_pane_in_a_foreign_workspace_is_not_a_live_leader() {
         .with_tmux_endpoint(socket)
         .with_targets(vec![observed]);
 
-    assert_eq!(
+    assert!(matches!(
         resolve_live_leader_channel(workspace, &receiver(socket), &transport),
-        LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch)
-    );
+        LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch(_))
+    ));
 }