@team-agent/installer 0.3.14 → 0.3.16

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

@@ -413,6 +413,8 @@ pub struct LaunchReport {
     pub started: Vec<StartedAgent>,
     /// 是否 dry-run(只解析路由/权限,不起进程)。
     pub dry_run: bool,
+    /// Selected tmux endpoint for the team transport when known.
+    pub tmux_endpoint: Option<String>,
     /// 路由决策(每 task 一条;`routing.decision` 事件)。
     pub routes: Vec<RoutingDecision>,
     /// 权限摘要(每 agent 一条)。
@@ -436,6 +438,9 @@ pub struct StartedAgent {
     pub claude_config_dir: Option<PathBuf>,
     pub provider_projects_root: Option<PathBuf>,
     pub managed_mcp_config: bool,
+    pub layout_window: Option<WindowName>,
+    pub layout_index: Option<usize>,
+    pub pane_index: Option<usize>,
     pub display: WorkerDisplay,
 }
 

package/crates/team-agent/src/lifecycle/worker_command_context.rs

@@ -22,6 +22,14 @@ Use Team Agent MCP tools for team-visible coordination:
 - Do not pass sender, task_id, agent_id, schema_version, or ack fields unless
   doing a low-level compatibility diagnostic. The MCP runtime fills protocol
   fields from the current worker and task state.
+- Emergency fallback exception: if a leader-bound MCP send/report payload is
+  already built but the MCP transport itself fails or the primary delivery path
+  errors (for example `Transport closed`, `Connection refused`, `Broken pipe`,
+  `EOF`, timeout, or internal delivery error), use `team-agent fallback-send-leader`
+  or `team-agent fallback-report-result` exactly once with `--primary-error`.
+  Do not use fallback for business refusals such as permission, quota, or unknown
+  target. After fallback, tell the leader to run `team-agent restart-agent` to
+  refresh the worker MCP transport.
 
 If you are blocked or cannot continue, message the leader promptly instead of
 waiting silently. If work takes several minutes, send a short progress update.

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

@@ -5,6 +5,7 @@ use std::path::Path;
 
 use serde_json::Value;
 
+use crate::event_log::EventLog;
 use crate::messaging::MessageTarget;
 
 use super::helpers::{json_dumps_default, object_fields};
@@ -172,19 +173,35 @@ fn run_stdio_loop<R: BufRead, W: Write>(
 ) -> Result<ServerRunReport, McpError> {
     let tools = TeamOrchestratorTools::new(workspace);
     let mut report = ServerRunReport::default();
+    let marker = McpServerLifecycleMarker::from_env(workspace);
+    marker.write_started();
+    let result = run_stdio_loop_inner(&tools, reader, &mut writer, &mut report);
+    match &result {
+        Ok(_) => marker.write_exit("stdin_eof", None),
+        Err(error) => marker.write_exit("fatal_error", Some(&error.to_string())),
+    }
+    result
+}
+
+fn run_stdio_loop_inner<R: BufRead, W: Write>(
+    tools: &TeamOrchestratorTools,
+    reader: R,
+    writer: &mut W,
+    report: &mut ServerRunReport,
+) -> Result<ServerRunReport, McpError> {
     for line in reader.lines() {
         let line = line?;
         report.requests_read = report.requests_read.saturating_add(1);
-        let frame = handle_stdin_line(&tools, &line, &mut report)?;
+        let frame = handle_stdin_line(tools, &line, report)?;
         if let Some(value) = frame {
-            serde_json::to_writer(&mut writer, &value)?;
+            serde_json::to_writer(&mut *writer, &value)?;
             writer.write_all(b"\n")?;
             writer.flush()?;
             report.responses_written = report.responses_written.saturating_add(1);
         }
     }
     report.clean_eof = true;
-    Ok(report)
+    Ok(report.clone())
 }
 
 fn handle_stdin_line(
@@ -247,6 +264,66 @@ fn tool_call_result_value(is_error: bool, body: &Value) -> Value {
     })
 }
 
+struct McpServerLifecycleMarker {
+    workspace: std::path::PathBuf,
+    agent_id: Option<String>,
+    owner_team_id: Option<String>,
+    pid: u32,
+    ppid: u32,
+}
+
+impl McpServerLifecycleMarker {
+    fn from_env(workspace: &Path) -> Self {
+        Self {
+            workspace: workspace.to_path_buf(),
+            agent_id: non_empty_env("TEAM_AGENT_ID"),
+            owner_team_id: non_empty_env("TEAM_AGENT_OWNER_TEAM_ID"),
+            pid: std::process::id(),
+            ppid: parent_pid(),
+        }
+    }
+
+    fn write_started(&self) {
+        self.write("mcp.server_started", None, None);
+    }
+
+    fn write_exit(&self, reason: &str, error: Option<&str>) {
+        self.write("mcp.server_exit", Some(reason), error);
+    }
+
+    fn write(&self, event: &str, reason: Option<&str>, error: Option<&str>) {
+        let _ = EventLog::new(&self.workspace).write(
+            event,
+            serde_json::json!({
+                "agent_id": self.agent_id.as_deref(),
+                "owner_team_id": self.owner_team_id.as_deref(),
+                "workspace": self.workspace.display().to_string(),
+                "pid": self.pid,
+                "ppid": self.ppid,
+                "reason": reason,
+                "error": error,
+            }),
+        );
+    }
+}
+
+fn non_empty_env(key: &str) -> Option<String> {
+    std::env::var(key)
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+#[cfg(unix)]
+fn parent_pid() -> u32 {
+    u32::try_from(unsafe { libc::getppid() }).unwrap_or(0)
+}
+
+#[cfg(not(unix))]
+fn parent_pid() -> u32 {
+    0
+}
+
 fn error_response_value(id: RpcId, code: i64, message: String) -> Value {
     let response = RpcResponse {
         jsonrpc: "2.0".to_string(),
@@ -489,3 +566,76 @@ fn message_target_from_value(value: Option<&Value>) -> MessageTarget {
         _ => MessageTarget::Single(String::new()),
     }
 }
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod e23_lifecycle_marker_tests {
+    use super::*;
+
+    fn marker_ws(tag: &str) -> std::path::PathBuf {
+        use std::sync::atomic::{AtomicU64, Ordering};
+        static N: AtomicU64 = AtomicU64::new(0);
+        let path = std::env::temp_dir().join(format!(
+            "ta-rs-mcp-marker-{tag}-{}-{}",
+            std::process::id(),
+            N.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&path).unwrap();
+        path
+    }
+
+    #[test]
+    fn stdio_loop_writes_started_and_stdin_eof_exit_markers() {
+        let ws = marker_ws("eof");
+        let input = std::io::Cursor::new(Vec::<u8>::new());
+        let mut output = Vec::new();
+
+        let report = run_stdio_loop(&ws, input, &mut output).unwrap();
+
+        assert!(report.clean_eof);
+        assert!(output.is_empty(), "empty stdin must not write stdout");
+        let events = EventLog::new(&ws).tail(0).unwrap();
+        assert_eq!(events.len(), 2, "started + stdin_eof exit events");
+        assert_eq!(events[0]["event"], serde_json::json!("mcp.server_started"));
+        assert_eq!(events[1]["event"], serde_json::json!("mcp.server_exit"));
+        assert_eq!(events[1]["reason"], serde_json::json!("stdin_eof"));
+        assert_eq!(events[1]["workspace"], serde_json::json!(ws.display().to_string()));
+        assert_eq!(events[1]["pid"], serde_json::json!(std::process::id()));
+        assert!(events[1].get("ppid").is_some());
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn stdio_loop_writes_fatal_error_marker_before_returning_io_error() {
+        struct FailingWriter;
+        impl Write for FailingWriter {
+            fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
+                Err(std::io::Error::other("simulated stdout failure"))
+            }
+
+            fn flush(&mut self) -> std::io::Result<()> {
+                Ok(())
+            }
+        }
+
+        let ws = marker_ws("fatal");
+        let input = std::io::Cursor::new(
+            br#"{"jsonrpc":"2.0","id":1,"method":"initialize"}"#.to_vec(),
+        );
+
+        let err = run_stdio_loop(&ws, input, FailingWriter).expect_err("writer failure");
+
+        assert!(err.to_string().contains("simulated stdout failure"));
+        let events = EventLog::new(&ws).tail(0).unwrap();
+        assert_eq!(events[0]["event"], serde_json::json!("mcp.server_started"));
+        assert_eq!(events[1]["event"], serde_json::json!("mcp.server_exit"));
+        assert_eq!(events[1]["reason"], serde_json::json!("fatal_error"));
+        assert!(
+            events[1]["error"]
+                .as_str()
+                .unwrap_or_default()
+                .contains("simulated stdout failure")
+        );
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+}

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

@@ -2,15 +2,16 @@
 
 use std::path::Path;
 
+use rusqlite::OptionalExtension;
 use serde_json::Value;
 
 use crate::event_log::EventLog;
 use crate::message_store::{MessageStore, NotificationClaimParams};
 use crate::model::ids::{OwnerEpoch, TaskId};
-use crate::transport::Transport;
+use crate::transport::{InjectPayload, Key, PaneId, Target, Transport};
 
 use super::helpers::MessageStatusShadow;
-use super::{DeliveryOutcome, DeliveryStatus, MessagingError};
+use super::{DeliveryOutcome, DeliveryRefusal, DeliveryStatus, MessagingError};
 
 /// `_send_to_leader_receiver` (`leader.py:69`) — **N31/N32 funnel primitive**:所有 leader-bound
 /// caller(send_message(to=leader) / report_result / request_human / idle reminder /
@@ -32,6 +33,36 @@ pub fn send_to_leader_receiver(
     requires_ack: bool,
     result_id: Option<&str>,
     event_log: &EventLog,
+) -> Result<DeliveryOutcome, MessagingError> {
+    send_to_leader_receiver_with_message_id(
+        workspace,
+        state,
+        leader_id,
+        content,
+        task_id,
+        sender,
+        requires_ack,
+        result_id,
+        None,
+        event_log,
+    )
+}
+
+/// Same leader funnel as [`send_to_leader_receiver`], but lets the caller supply a
+/// stable message id for transport-fallback retries. The public function above
+/// keeps the existing call surface unchanged.
+#[allow(clippy::too_many_arguments)]
+pub fn send_to_leader_receiver_with_message_id(
+    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>,
+    event_log: &EventLog,
 ) -> Result<DeliveryOutcome, MessagingError> {
     let store = MessageStore::open(workspace)?;
     let owner_team = active_team_key(workspace, state);
@@ -41,15 +72,40 @@ pub fn send_to_leader_receiver(
             serde_json::json!({"sender": sender, "leader_id": leader_id, "result_id": result_id}),
         )?;
     }
-    let message_id = store.create_message(
-        task_id.map(TaskId::as_str),
-        sender,
-        leader_id,
-        content,
-        None,
-        false,
-        Some(&owner_team),
-    )?;
+    let message_id = if let Some(requested) = requested_message_id {
+        if store.message_exists(requested)? {
+            return Ok(DeliveryOutcome {
+                ok: false,
+                status: DeliveryStatus::Refused,
+                message_status: MessageStatusShadow("refused".to_string()),
+                message_id: Some(requested.to_string()),
+                verification: None,
+                stage: None,
+                reason: Some(DeliveryRefusal::Duplicate),
+                channel: Some("leader_receiver".to_string()),
+            });
+        }
+        store.create_message_with_id(
+            requested,
+            task_id.map(TaskId::as_str),
+            sender,
+            leader_id,
+            content,
+            None,
+            false,
+            Some(&owner_team),
+        )?
+    } else {
+        store.create_message(
+            task_id.map(TaskId::as_str),
+            sender,
+            leader_id,
+            content,
+            None,
+            false,
+            Some(&owner_team),
+        )?
+    };
     // #231 exactly-once across rebind: insert the leader_notification_log PK BEFORE the
     // unbound-pane check. That way, if the result row gets blocked (I-4) and later the
     // leader rebinds + reclaim replays this row, the dedup PK still gates any second
@@ -170,7 +226,9 @@ pub fn claim_leader_receiver(
     }
     let next_epoch = owner_epoch(state).unwrap_or(0).saturating_add(1);
     let Some(root) = state.as_object_mut() else {
-        return Err(MessagingError::Routing("runtime state root is not an object".to_string()));
+        return Err(MessagingError::Routing(
+            "runtime state root is not an object".to_string(),
+        ));
     };
     let owner = root
         .entry("team_owner")
@@ -225,49 +283,199 @@ pub fn mirror_peer_message_to_leader(
     event_log: &EventLog,
 ) -> Result<(), MessagingError> {
     let _ = send_to_leader_receiver(
-        workspace,
-        state,
-        "leader",
-        content,
-        task_id,
-        sender,
-        false,
-        None,
-        event_log,
+        workspace, state, "leader", content, task_id, sender, false, None, event_log,
     )?;
     let _ = recipient;
     Ok(())
 }
 
+/// E23 transport fallback: physically inject the already-built leader payload into
+/// the bound leader pane only after the caller's primary path is known not to have
+/// succeeded. This primitive is reclaim-neutral: it reads leader_receiver/team_owner
+/// fields but never writes binding state.
+#[allow(clippy::too_many_arguments)]
+pub fn deliver_to_leader_fallback_pane(
+    workspace: &Path,
+    state: &Value,
+    message_id: &str,
+    result_id: Option<&str>,
+    content: &str,
+    primary_ok: bool,
+    primary_error: Option<&str>,
+    event_log: &EventLog,
+) -> Result<DeliveryOutcome, MessagingError> {
+    if primary_ok {
+        return Ok(DeliveryOutcome {
+            ok: true,
+            status: DeliveryStatus::AlreadyDelivered,
+            message_status: MessageStatusShadow("delivered".to_string()),
+            message_id: Some(message_id.to_string()),
+            verification: None,
+            stage: None,
+            reason: None,
+            channel: Some("leader_receiver".to_string()),
+        });
+    }
+
+    let store = MessageStore::open(workspace)?;
+    if message_already_delivered(&store, message_id)? {
+        return Ok(DeliveryOutcome {
+            ok: true,
+            status: DeliveryStatus::AlreadyDelivered,
+            message_status: MessageStatusShadow("delivered".to_string()),
+            message_id: Some(message_id.to_string()),
+            verification: None,
+            stage: None,
+            reason: None,
+            channel: Some("leader_receiver".to_string()),
+        });
+    }
+
+    let owner_team_id = active_team_key(workspace, state);
+    let pane_id = leader_pane_id(state).map(str::to_string);
+    let primary_error = primary_error
+        .filter(|error| !error.trim().is_empty())
+        .unwrap_or("primary delivery failed");
+    let attempt_payload = serde_json::json!({
+        "message_id": message_id,
+        "result_id": result_id,
+        "owner_team_id": owner_team_id,
+        "pane_id": pane_id,
+        "primary_error": primary_error,
+        "delivered_via": "fallback_pane",
+    });
+    event_log.write(
+        "leader_receiver.fallback_pane_attempt",
+        attempt_payload.clone(),
+    )?;
+
+    let Some(pane_id) = pane_id.filter(|pane| !pane.is_empty() && pane != "__team_agent_unbound__")
+    else {
+        let failed = serde_json::json!({
+            "message_id": message_id,
+            "result_id": result_id,
+            "owner_team_id": owner_team_id,
+            "pane_id": null,
+            "primary_error": primary_error,
+            "delivered_via": "fallback_pane",
+            "reason": "no_bound_pane",
+        });
+        event_log.write("leader_receiver.fallback_pane_failed", failed)?;
+        return Ok(DeliveryOutcome {
+            ok: false,
+            status: DeliveryStatus::Blocked,
+            message_status: MessageStatusShadow("blocked".to_string()),
+            message_id: Some(message_id.to_string()),
+            verification: Some("run team-agent claim-leader or team-agent takeover".to_string()),
+            stage: None,
+            reason: Some(DeliveryRefusal::LeaderNotAttached),
+            channel: Some("fallback_pane".to_string()),
+        });
+    };
+
+    let rendered = render_fallback_pane_message(content, message_id, primary_error);
+    let target = Target::Pane(PaneId::new(&pane_id));
+    let payload = InjectPayload::Text(rendered);
+    let inject_result = leader_tmux_socket(state)
+        .and_then(|socket| {
+            let backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
+            backend.inject(&target, &payload, Key::Enter, true).ok()
+        })
+        .map(Ok)
+        .unwrap_or_else(|| {
+            let backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
+            backend.inject(&target, &payload, Key::Enter, true)
+        })
+        .or_else(|_| {
+            let backend = crate::tmux_backend::TmuxBackend::new();
+            backend.inject(&target, &payload, Key::Enter, true)
+        });
+
+    match inject_result {
+        Ok(report) => {
+            store.mark(message_id, "delivered", None)?;
+            event_log.write(
+                "leader_receiver.fallback_pane_submitted",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "result_id": result_id,
+                    "owner_team_id": owner_team_id,
+                    "pane_id": pane_id,
+                    "primary_error": primary_error,
+                    "delivered_via": "fallback_pane",
+                    "verification": format!("{:?}", report.submit_verification),
+                }),
+            )?;
+            Ok(DeliveryOutcome {
+                ok: true,
+                status: DeliveryStatus::Delivered,
+                message_status: MessageStatusShadow("delivered".to_string()),
+                message_id: Some(message_id.to_string()),
+                verification: Some("delivered_via=fallback_pane".to_string()),
+                stage: None,
+                reason: None,
+                channel: Some("fallback_pane".to_string()),
+            })
+        }
+        Err(error) => {
+            event_log.write(
+                "leader_receiver.fallback_pane_failed",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "result_id": result_id,
+                    "owner_team_id": owner_team_id,
+                    "pane_id": pane_id,
+                    "primary_error": primary_error,
+                    "delivered_via": "fallback_pane",
+                    "reason": error.to_string(),
+                }),
+            )?;
+            Ok(DeliveryOutcome {
+                ok: false,
+                status: DeliveryStatus::Failed,
+                message_status: MessageStatusShadow("failed".to_string()),
+                message_id: Some(message_id.to_string()),
+                verification: Some(error.to_string()),
+                stage: None,
+                reason: Some(DeliveryRefusal::TmuxTargetMissing),
+                channel: Some("fallback_pane".to_string()),
+            })
+        }
+    }
+}
+
 pub(crate) fn active_team_key(workspace: &Path, state: &Value) -> String {
     state
         .get("active_team_key")
         .and_then(Value::as_str)
         .filter(|team| !team.is_empty())
         .map(ToString::to_string)
-        .or_else(|| workspace.file_name().map(|name| name.to_string_lossy().to_string()))
+        .or_else(|| {
+            workspace
+                .file_name()
+                .map(|name| name.to_string_lossy().to_string())
+        })
         .unwrap_or_else(|| "current".to_string())
 }
 
 fn owner_epoch(state: &Value) -> Option<u64> {
     receiver_or_owner_field(state, "team_owner", "owner_epoch")
         .and_then(Value::as_u64)
-        .or_else(|| receiver_or_owner_field(state, "leader_receiver", "owner_epoch").and_then(Value::as_u64))
+        .or_else(|| {
+            receiver_or_owner_field(state, "leader_receiver", "owner_epoch").and_then(Value::as_u64)
+        })
 }
 
 fn receiver_or_owner_field<'a>(state: &'a Value, record: &str, field: &str) -> Option<&'a Value> {
-    state
-        .get(record)
-        .and_then(|v| v.get(field))
-        .or_else(|| {
-            let active = state.get("active_team_key").and_then(Value::as_str)?;
-            state
-                .get("teams")
-                .and_then(Value::as_object)
-                .and_then(|teams| teams.get(active))
-                .and_then(|team| team.get(record))
-                .and_then(|v| v.get(field))
-        })
+    state.get(record).and_then(|v| v.get(field)).or_else(|| {
+        let active = state.get("active_team_key").and_then(Value::as_str)?;
+        state
+            .get("teams")
+            .and_then(Value::as_object)
+            .and_then(|teams| teams.get(active))
+            .and_then(|team| team.get(record))
+            .and_then(|v| v.get(field))
+    })
 }
 
 fn leader_record_field<'a>(state: &'a Value, field: &str) -> Option<&'a Value> {
@@ -284,8 +492,7 @@ fn leader_session_uuid(state: &Value) -> Option<&str> {
 }
 
 pub(crate) fn leader_pane_bound_but_not_live(workspace: &Path, state: &Value) -> bool {
-    leader_pane_id(state)
-        .is_some_and(|pane_id| !leader_pane_is_live(workspace, state, pane_id))
+    leader_pane_id(state).is_some_and(|pane_id| !leader_pane_is_live(workspace, state, pane_id))
 }
 
 fn leader_pane_is_live(workspace: &Path, state: &Value, pane_id: &str) -> bool {
@@ -304,7 +511,9 @@ fn leader_pane_is_live(workspace: &Path, state: &Value, pane_id: &str) -> bool {
             .list_targets()
             .unwrap_or_default(),
     );
-    targets.iter().any(|target| target.pane_id.as_str() == pane_id)
+    targets
+        .iter()
+        .any(|target| target.pane_id.as_str() == pane_id)
 }
 
 fn leader_pane_id(state: &Value) -> Option<&str> {
@@ -318,11 +527,35 @@ fn leader_tmux_socket(state: &Value) -> Option<&str> {
         .filter(|socket| std::path::Path::new(socket).is_absolute())
 }
 
-fn copy_candidate_field(
-    out: &mut serde_json::Map<String, Value>,
-    candidate: &Value,
-    key: &str,
-) {
+fn message_already_delivered(
+    store: &MessageStore,
+    message_id: &str,
+) -> Result<bool, MessagingError> {
+    let conn = crate::db::schema::open_db(store.db_path())?;
+    let status = conn
+        .query_row(
+            "select status from messages where message_id = ?1",
+            [message_id],
+            |row| row.get::<_, String>(0),
+        )
+        .optional()?;
+    Ok(matches!(
+        status.as_deref(),
+        Some("delivered" | "acknowledged" | "submitted" | "submitted_unverified")
+    ))
+}
+
+fn render_fallback_pane_message(content: &str, message_id: &str, primary_error: &str) -> String {
+    format!(
+        "Team Agent fallback delivery\n\
+         delivered_via=fallback_pane\n\
+         primary_error: {primary_error}\n\n\
+         {content}\n\n\
+         [team-agent-token:{message_id}]"
+    )
+}
+
+fn copy_candidate_field(out: &mut serde_json::Map<String, Value>, candidate: &Value, key: &str) {
     if let Some(value) = candidate.get(key) {
         out.insert(key.to_string(), value.clone());
     }

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

@@ -83,16 +83,19 @@ pub use delivery::{
 };
 pub use helpers::fail_leader_delivery;
 pub use leader_receiver::{
-    claim_leader_receiver, mirror_peer_message_to_leader, send_to_leader_receiver,
+    claim_leader_receiver, deliver_to_leader_fallback_pane, mirror_peer_message_to_leader,
+    send_to_leader_receiver, send_to_leader_receiver_with_message_id,
 };
 pub use peers::allow_peer_talk;
 pub use results::{
     collect, collect_for_team, collect_results_and_notify_watchers, report_result,
-    report_result_for_owner_team,
+    report_result_for_owner_team, report_result_for_owner_team_with_primary_error,
 };
 pub use scheduler::{detect_stuck_agents, fire_due_scheduled_events, stuck_cancel, stuck_list};
 pub use selftest::{evaluate_idle_behavior, run_comms_selftest, CommsSelftestDriver};
-pub use send::{apply_worker_sender_bypass, send_message, session_drift_refusal, MessageTarget, SendOptions};
+pub use send::{
+    apply_worker_sender_bypass, send_message, session_drift_refusal, MessageTarget, SendOptions,
+};
 pub use trust::{attempt_trust_auto_answer, TrustAnswerOutcome};
 pub use types::{
     ActivityStatus, AgentActivity, AlertSnapshot, AlertSuppression, AlertType, CheckEvidence,