@team-agent/installer 0.5.60 → 0.5.61

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

@@ -3,6 +3,7 @@ use std::path::Path;
 use serde_json::Value;
 
 use crate::codex_app_server::AppServerBinding;
+use crate::model::pane_authority_refusal::PaneWorkspaceMismatchFacts;
 use crate::transport::{PaneInfo, Transport};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -26,7 +27,7 @@ pub enum LeaderChannelResolution {
     ProbeFailed(String),
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum LeaderChannelUnbound {
     ReceiverNotAttached,
     TransportConflict,
@@ -34,10 +35,25 @@ pub enum LeaderChannelUnbound {
     NonCanonicalTmuxSocket,
     EndpointMismatch,
     PaneNotLive,
-    PaneWorkspaceMismatch,
+    PaneWorkspaceMismatch(PaneWorkspaceMismatchFacts),
     AppServerBindingInvalid,
 }
 
+impl LeaderChannelUnbound {
+    pub const fn reason_code(&self) -> &'static str {
+        match self {
+            Self::ReceiverNotAttached => "ReceiverNotAttached",
+            Self::TransportConflict => "TransportConflict",
+            Self::MissingPaneId => "MissingPaneId",
+            Self::NonCanonicalTmuxSocket => "NonCanonicalTmuxSocket",
+            Self::EndpointMismatch => "EndpointMismatch",
+            Self::PaneNotLive => "PaneNotLive",
+            Self::PaneWorkspaceMismatch(_) => "PaneWorkspaceMismatch",
+            Self::AppServerBindingInvalid => "AppServerBindingInvalid",
+        }
+    }
+}
+
 /// Resolve the canonical receiver's live physical channel without mutating
 /// ownership. For direct tmux, `(absolute socket, pane id)` plus an available
 /// pane cwd inside the target workspace is the authority. Session/window/tty/
@@ -79,11 +95,12 @@ pub fn resolve_live_leader_channel(
         .get("tmux_socket")
         .and_then(Value::as_str)
         .filter(|socket| !socket.is_empty());
+    let transport_endpoint = transport.tmux_endpoint();
     if tmux_socket.is_some_and(|socket| !std::path::Path::new(socket).is_absolute()) {
         return LeaderChannelResolution::Unbound(LeaderChannelUnbound::NonCanonicalTmuxSocket);
     }
     if let Some(expected) = tmux_socket {
-        if transport.tmux_endpoint().as_deref() != Some(expected) {
+        if transport_endpoint.as_deref() != Some(expected) {
             return LeaderChannelResolution::Unbound(LeaderChannelUnbound::EndpointMismatch);
         }
     }
@@ -97,13 +114,19 @@ pub fn resolve_live_leader_channel(
     else {
         return LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneNotLive);
     };
-    if observed
-        .current_path
-        .as_deref()
-        .is_some_and(|path| !path_is_in_workspace(path, workspace))
-        && !explicit_claim_authority_matches(workspace, receiver, &observed)
-    {
-        return LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch);
+    if let Some(observed_pane_workspace) = observed.current_path.clone() {
+        if !path_is_in_workspace(&observed_pane_workspace, workspace)
+            && !explicit_claim_authority_matches(workspace, receiver, &observed)
+        {
+            return LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch(
+                PaneWorkspaceMismatchFacts {
+                    requested_workspace: canonical_path(workspace),
+                    observed_pane_id: observed.pane_id.as_str().to_string(),
+                    observed_pane_workspace,
+                    endpoint: transport_endpoint.unwrap_or_else(|| "default".to_string()),
+                },
+            ));
+        }
     }
     let metadata_drift = receiver_metadata_drift(receiver, &observed);
     LeaderChannelResolution::Live(LiveLeaderChannel::DirectTmux(DirectTmuxLeaderChannel {

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

@@ -397,29 +397,46 @@ pub fn deliver_to_leader_fallback_pane(
             let readback_ok = super::delivery::pane_readback_verified(&report);
             if submit_ok {
                 store.record_delivery_submission(message_id, readback_ok)?;
-                if !super::delivery::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,
-                            "result_id": result_id,
-                            "reason": "provider_receipt_not_observed",
-                            "channel": "fallback_pane",
-                        }),
-                    )?;
-                    return Ok(DeliveryOutcome {
-                        ok: true,
-                        status: DeliveryStatus::RetryScheduled,
-                        message_status: MessageStatusShadow(
-                            "submitted_pending_acceptance".to_string(),
-                        ),
-                        message_id: Some(message_id.to_string()),
-                        verification: Some("provider_receipt_not_observed".to_string()),
-                        stage: Some(DeliveryStage::Submit),
-                        reason: None,
-                        channel: Some("leader_acceptance_pending".to_string()),
-                    });
+                match super::delivery::observe_leader_receipt(state, message_id) {
+                    super::delivery::LeaderReceiptObservation::SourceUnavailable => {
+                        store.mark_injected_awaiting_receipt(message_id)?;
+                        event_log.write(
+                            "leader_receiver.receipt_source_unavailable",
+                            serde_json::json!({
+                                "message_id": message_id,
+                                "result_id": result_id,
+                                "channel": "fallback_pane",
+                            }),
+                        )?;
+                        return Ok(super::delivery::leader_receipt_source_unavailable_outcome(
+                            message_id,
+                        ));
+                    }
+                    super::delivery::LeaderReceiptObservation::TokenAbsent => {
+                        store.mark(message_id, "submitted_pending_acceptance", None)?;
+                        event_log.write(
+                            "leader_receiver.acceptance_pending",
+                            serde_json::json!({
+                                "message_id": message_id,
+                                "result_id": result_id,
+                                "reason": "provider_receipt_not_observed",
+                                "channel": "fallback_pane",
+                            }),
+                        )?;
+                        return Ok(DeliveryOutcome {
+                            ok: true,
+                            status: DeliveryStatus::RetryScheduled,
+                            message_status: MessageStatusShadow(
+                                "submitted_pending_acceptance".to_string(),
+                            ),
+                            message_id: Some(message_id.to_string()),
+                            verification: Some("provider_receipt_not_observed".to_string()),
+                            stage: Some(DeliveryStage::Submit),
+                            reason: None,
+                            channel: Some("leader_acceptance_pending".to_string()),
+                        });
+                    }
+                    super::delivery::LeaderReceiptObservation::TokenObserved => {}
                 }
                 store.mark_delivered_with_receipt(message_id)?;
                 event_log.write(

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

@@ -98,6 +98,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,6 +183,79 @@ pub fn normalize_report_presentation(
     (request, None)
 }
 
+/// 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 fn normalize_presentation(value: Option<&Value>) -> (PresentationRequest, Option<String>) {
     let Some(value) = value else {
         return (PresentationRequest::default(), None);
@@ -304,4 +383,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

@@ -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>,