@team-agent/installer 0.5.60 → 0.5.62

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

@@ -1,3 +1,4 @@
+//!
 //! Typed presentation metadata shared by message and result ingress.
 
 use serde::{Deserialize, Serialize};
@@ -98,6 +99,12 @@ pub struct PresentationDecision {
     pub policy_version: String,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SendPresentationInput {
+    pub request: PresentationRequest,
+    pub deprecation: Option<String>,
+}
+
 impl Default for PresentationRequest {
     fn default() -> Self {
         Self {
@@ -177,7 +184,80 @@ pub fn normalize_report_presentation(
     (request, None)
 }
 
-pub fn normalize_presentation(value: Option<&Value>) -> (PresentationRequest, Option<String>) {
+/// Normalize the one-bit send surface and the temporary S-011 compatibility
+/// input into the existing presentation disposition primitive.
+///
+/// S-011 sensitive: if the compatibility period is ended by a hard-cut
+/// decision, replace this table with one uniform legacy-input refusal.
+pub fn normalize_send_presentation(
+    mailbox: Option<&Value>,
+    legacy_presentation: Option<&Value>,
+) -> Result<SendPresentationInput, String> {
+    if mailbox.is_some() && legacy_presentation.is_some() {
+        return Err("mailbox_conflicts_with_deprecated_presentation".to_string());
+    }
+    if let Some(mailbox) = mailbox {
+        let Some(mailbox) = mailbox.as_bool() else {
+            return Err("mailbox_must_be_boolean".to_string());
+        };
+        return Ok(SendPresentationInput {
+            request: PresentationRequest {
+                sink: if mailbox {
+                    PresentationSink::Casefile
+                } else {
+                    PresentationSink::Leader
+                },
+                class: PresentationClass::Message,
+                case_id: None,
+            },
+            deprecation: None,
+        });
+    }
+    let Some(legacy) = legacy_presentation else {
+        return Ok(SendPresentationInput {
+            request: PresentationRequest::default(),
+            deprecation: None,
+        });
+    };
+    let Some(object) = legacy.as_object() else {
+        return Err("malformed_presentation".to_string());
+    };
+    let Some(class) = object.get("class").and_then(Value::as_str) else {
+        return Err("missing_class".to_string());
+    };
+    let Some(class) = PresentationClass::parse(class) else {
+        return Err(format!("unknown_class:{class}"));
+    };
+    let sink = match class {
+        PresentationClass::Message | PresentationClass::Blocking | PresentationClass::Timeout => {
+            PresentationSink::Leader
+        }
+        PresentationClass::Progress => PresentationSink::Casefile,
+        PresentationClass::StageResult
+        | PresentationClass::StagePass
+        | PresentationClass::Bounce
+        | PresentationClass::FinalReview => {
+            return Err(format!(
+                "deprecated_message_class:{}_requires_result_route",
+                class.as_str()
+            ));
+        }
+    };
+    Ok(SendPresentationInput {
+        request: PresentationRequest {
+            sink,
+            class: PresentationClass::Message,
+            case_id: None,
+        },
+        deprecation: Some(format!(
+            "message-class={} is deprecated; use mailbox={} instead",
+            class.as_str(),
+            sink != PresentationSink::Leader
+        )),
+    })
+}
+
+pub(crate) fn normalize_presentation(value: Option<&Value>) -> (PresentationRequest, Option<String>) {
     let Some(value) = value else {
         return (PresentationRequest::default(), None);
     };
@@ -304,4 +384,34 @@ mod tests {
             "send normalization remains unchanged"
         );
     }
+
+    #[test]
+    fn send_mailbox_and_s011_compatibility_map_to_one_bit() {
+        let mailbox = normalize_send_presentation(Some(&json!(true)), None).unwrap();
+        assert_eq!(mailbox.request.sink, PresentationSink::Casefile);
+        assert_eq!(mailbox.deprecation, None);
+
+        for (class, sink) in [
+            ("message", PresentationSink::Leader),
+            ("progress", PresentationSink::Casefile),
+            ("blocking", PresentationSink::Leader),
+            ("timeout", PresentationSink::Leader),
+        ] {
+            let legacy = json!({"sink": "silent", "class": class});
+            let mapped = normalize_send_presentation(None, Some(&legacy)).unwrap();
+            assert_eq!(mapped.request.sink, sink, "{class}");
+            assert!(mapped.deprecation.is_some(), "{class}");
+        }
+    }
+
+    #[test]
+    fn s011_stage_classes_require_result_route() {
+        for class in ["stage_result", "stage_pass", "bounce", "final_review"] {
+            let legacy = json!({"sink": "leader", "class": class});
+            assert_eq!(
+                normalize_send_presentation(None, Some(&legacy)).unwrap_err(),
+                format!("deprecated_message_class:{class}_requires_result_route")
+            );
+        }
+    }
 }

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

@@ -1,3 +1,4 @@
+//!
 //! results.py — collect + report_result + envelope 校验编排 (card §66/§67)。
 
 use std::path::{Path, PathBuf};
@@ -14,6 +15,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 +717,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 +740,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 +747,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 +1082,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 +1161,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/scheduler.rs

@@ -1,3 +1,4 @@
+//!
 //! scheduler.py — 调度器心脏 + stuck 检测 + 告警抑制 (card §18/§68/§73)。
 
 use std::path::Path;

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

@@ -291,7 +291,7 @@ fn message_owner_team(db_path: &Path, message_id: &str) -> Result<Option<String>
 }
 
 /// `evaluate_idle_behavior` (`diagnose/comms.py:50`):idle 分类准确性评估。零 token,走 driver。
-pub fn evaluate_idle_behavior(
+pub(crate) fn evaluate_idle_behavior(
     workspace: &Path,
     agent_id: &str,
     claimed_status: &str,