@team-agent/installer 0.5.1 → 0.5.2

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

@@ -179,6 +179,29 @@ pub fn deliver_pending_message(
             channel: None,
         });
     };
+    if message.recipient == "leader" {
+        if let Some(receiver) = leader_receiver_value(state) {
+            if let Some(outcome) = leader_receiver_transport_conflict_outcome(
+                store,
+                event_log,
+                message_id,
+                receiver,
+                &message.sender,
+            )? {
+                return Ok(outcome);
+            }
+            if crate::codex_app_server::receiver_is_app_server(receiver) {
+                return deliver_leader_via_app_server(
+                    store,
+                    event_log,
+                    state,
+                    message_id,
+                    &message,
+                    canonical_owner_team_id.as_deref(),
+                );
+            }
+        }
+    }
     if message.recipient == "leader" && leader_receiver_has_noncanonical_tmux_socket(state) {
         store.mark(message_id, "failed", Some("leader_not_attached"))?;
         event_log.write(
@@ -604,6 +627,223 @@ pub fn render_message(
     format!("{header}:\n\n{content}\n\n[team-agent-token:{message_id}]")
 }
 
+fn deliver_leader_via_app_server(
+    store: &MessageStore,
+    event_log: &EventLog,
+    state: &serde_json::Value,
+    message_id: &str,
+    message: &PendingMessage,
+    owner_team_id: Option<&str>,
+) -> Result<DeliveryOutcome, MessagingError> {
+    let receiver = leader_receiver_value(state).ok_or_else(|| {
+        MessagingError::Routing("codex_app_server leader_receiver missing".to_string())
+    })?;
+    let binding = match crate::codex_app_server::binding_from_receiver(receiver) {
+        Ok(binding) => binding,
+        Err(error) => {
+            return Ok(app_server_delivery_failure(
+                store,
+                event_log,
+                receiver,
+                message_id,
+                &message.sender,
+                owner_team_id,
+                &error,
+            )?);
+        }
+    };
+    let rendered = render_message(
+        &message.sender,
+        message.task_id.as_deref(),
+        &message.content,
+        message_id,
+    );
+    match crate::codex_app_server::submit_to_bound_thread(&binding, message_id, &rendered) {
+        Ok(submit) => {
+            store.mark(message_id, "delivered", None)?;
+            event_log.write(
+                "message.delivered",
+                serde_json::json!({"message_id": message_id}),
+            )?;
+            event_log.write(
+                "leader_receiver.app_server_submitted",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "owner_team_id": owner_team_id,
+                    "owner_epoch": receiver_owner_epoch(receiver),
+                    "socket": binding.socket,
+                    "thread_id": binding.thread_id,
+                    "turn_id": submit.turn_id,
+                    "turn_status": submit.turn_status,
+                }),
+            )?;
+            Ok(DeliveryOutcome {
+                ok: true,
+                status: DeliveryStatus::Delivered,
+                message_status: MessageStatusShadow("delivered".to_string()),
+                message_id: Some(message_id.to_string()),
+                verification: None,
+                stage: None,
+                reason: None,
+                channel: Some("codex_app_server".to_string()),
+            })
+        }
+        Err(error) => app_server_delivery_failure(
+            store,
+            event_log,
+            receiver,
+            message_id,
+            &message.sender,
+            owner_team_id,
+            &error,
+        ),
+    }
+}
+
+fn app_server_delivery_failure(
+    store: &MessageStore,
+    event_log: &EventLog,
+    receiver: &serde_json::Value,
+    message_id: &str,
+    sender: &str,
+    owner_team_id: Option<&str>,
+    error: &crate::codex_app_server::AppServerError,
+) -> Result<DeliveryOutcome, MessagingError> {
+    let action = app_server_rebind_action(owner_team_id, receiver);
+    match error {
+        crate::codex_app_server::AppServerError::LeaderBusy(message) => {
+            store.mark(message_id, "target_resolved", Some("leader_busy"))?;
+            event_log.write(
+                "leader_receiver.app_server_busy",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "sender": sender,
+                    "reason": "leader_busy",
+                    "error": message,
+                }),
+            )?;
+            Ok(DeliveryOutcome {
+                ok: false,
+                status: DeliveryStatus::RetryScheduled,
+                message_status: MessageStatusShadow("target_resolved".to_string()),
+                message_id: Some(message_id.to_string()),
+                verification: Some("leader_busy".to_string()),
+                stage: None,
+                reason: Some(DeliveryRefusal::RecipientBusy),
+                channel: Some("leader_busy".to_string()),
+            })
+        }
+        crate::codex_app_server::AppServerError::ThreadStale { expected, actual } => {
+            store.mark(message_id, "failed", Some(error.code()))?;
+            event_log.write(
+                "leader_receiver.app_server_thread_stale",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "sender": sender,
+                    "owner_team_id": owner_team_id,
+                    "owner_epoch": receiver_owner_epoch(receiver),
+                    "expected": expected,
+                    "actual": actual,
+                    "action": action,
+                }),
+            )?;
+            Ok(rebind_required_outcome(message_id, &action))
+        }
+        crate::codex_app_server::AppServerError::ApprovalUnsupported(method) => {
+            store.mark(message_id, "failed", Some("approval_unsupported"))?;
+            event_log.write(
+                "codex_app_server.approval_unsupported",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "sender": sender,
+                    "method": method,
+                    "action": "handle approval in the Codex app-server session",
+                }),
+            )?;
+            Ok(DeliveryOutcome {
+                ok: false,
+                status: DeliveryStatus::Blocked,
+                message_status: MessageStatusShadow("failed".to_string()),
+                message_id: Some(message_id.to_string()),
+                verification: Some("handle approval in the Codex app-server session".to_string()),
+                stage: None,
+                reason: Some(DeliveryRefusal::MissingPermissions),
+                channel: Some("codex_app_server".to_string()),
+            })
+        }
+        crate::codex_app_server::AppServerError::ProtocolMismatch(_)
+        | crate::codex_app_server::AppServerError::MissingUserAgent => {
+            store.mark(message_id, "failed", Some(error.code()))?;
+            event_log.write(
+                "leader_receiver.app_server_protocol_mismatch",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "sender": sender,
+                    "owner_team_id": owner_team_id,
+                    "owner_epoch": receiver_owner_epoch(receiver),
+                    "reason": error.code(),
+                    "error": error.to_string(),
+                    "action": action,
+                }),
+            )?;
+            Ok(rebind_required_outcome(message_id, &action))
+        }
+        crate::codex_app_server::AppServerError::SocketUnreachable(_)
+        | crate::codex_app_server::AppServerError::SocketOwnershipInvalid(_)
+        | crate::codex_app_server::AppServerError::ThreadNotLive(_)
+        | crate::codex_app_server::AppServerError::Io(_)
+        | crate::codex_app_server::AppServerError::Json(_) => {
+            store.mark(message_id, "failed", Some(error.code()))?;
+            event_log.write(
+                "leader_receiver.delivery_blocked",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "sender": sender,
+                    "reason": error.code(),
+                    "channel": "rebind_required",
+                    "action": action,
+                    "error": error.to_string(),
+                }),
+            )?;
+            Ok(rebind_required_outcome(message_id, &action))
+        }
+    }
+}
+
+fn rebind_required_outcome(message_id: &str, action: &str) -> DeliveryOutcome {
+    DeliveryOutcome {
+        ok: false,
+        status: DeliveryStatus::Refused,
+        message_status: MessageStatusShadow("failed".to_string()),
+        message_id: Some(message_id.to_string()),
+        verification: Some(action.to_string()),
+        stage: None,
+        reason: Some(DeliveryRefusal::LeaderNotAttached),
+        channel: Some("rebind_required".to_string()),
+    }
+}
+
+fn app_server_rebind_action(owner_team_id: Option<&str>, receiver: &serde_json::Value) -> String {
+    let team = owner_team_id
+        .filter(|team| !team.is_empty())
+        .map(|team| format!(" --team {team}"))
+        .unwrap_or_default();
+    let Some(app) = receiver.get("app_server") else {
+        return format!("run team-agent attach-app-server-leader{team} --socket <socket> --thread-id <thread_id>");
+    };
+    let socket = app
+        .get("socket")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("<socket>");
+    let thread_id = app
+        .get("thread_id")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("<thread_id>");
+    format!(
+        "run team-agent attach-app-server-leader{team} --socket {socket} --thread-id {thread_id}"
+    )
+}
+
 /// Resolve a recipient agent-id to a tmux-RESOLVABLE inject target: the persisted pane-id if present,
 /// else a session-qualified `SessionWindow` (state.session_name + the agent's window, defaulting to the
 /// id). NEVER the bare agent-id as a pane — a clientless coordinator cannot resolve that
@@ -770,6 +1010,70 @@ fn leader_receiver_pane_id(state: &serde_json::Value) -> Option<&str> {
         .or_else(|| only_team_entry(state).and_then(leader_receiver_pane_id_in_state))
 }
 
+fn leader_receiver_value(state: &serde_json::Value) -> Option<&serde_json::Value> {
+    leader_receiver_value_in_state(state)
+        .or_else(|| active_team_entry(state).and_then(leader_receiver_value_in_state))
+        .or_else(|| only_team_entry(state).and_then(leader_receiver_value_in_state))
+}
+
+fn leader_receiver_value_in_state(state: &serde_json::Value) -> Option<&serde_json::Value> {
+    state.get("leader_receiver")
+}
+
+fn receiver_owner_epoch(receiver: &serde_json::Value) -> Option<u64> {
+    receiver
+        .get("owner_epoch")
+        .and_then(serde_json::Value::as_u64)
+}
+
+fn leader_receiver_transport_conflict_outcome(
+    store: &MessageStore,
+    event_log: &EventLog,
+    message_id: &str,
+    receiver: &serde_json::Value,
+    sender: &str,
+) -> Result<Option<DeliveryOutcome>, MessagingError> {
+    let mode = receiver.get("mode").and_then(serde_json::Value::as_str);
+    let transport_kind = receiver
+        .get("transport_kind")
+        .and_then(serde_json::Value::as_str);
+    if let (Some(mode), Some(transport_kind)) = (mode, transport_kind) {
+        if !mode.is_empty() && !transport_kind.is_empty() && mode != transport_kind {
+            store.mark(
+                message_id,
+                "failed",
+                Some("leader_receiver_transport_conflict"),
+            )?;
+            event_log.write(
+                "leader_receiver.delivery_blocked",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "sender": sender,
+                    "reason": "leader_receiver_transport_conflict",
+                    "mode": mode,
+                    "transport_kind": transport_kind,
+                    "channel": "rebind_required",
+                    "action": "run team-agent claim-leader, takeover, or attach-app-server-leader",
+                }),
+            )?;
+            return Ok(Some(DeliveryOutcome {
+                ok: false,
+                status: DeliveryStatus::Refused,
+                message_status: MessageStatusShadow("failed".to_string()),
+                message_id: Some(message_id.to_string()),
+                verification: Some(
+                    "run team-agent claim-leader, takeover, or attach-app-server-leader"
+                        .to_string(),
+                ),
+                stage: None,
+                reason: Some(DeliveryRefusal::LeaderNotAttached),
+                channel: Some("rebind_required".to_string()),
+            }));
+        }
+    }
+    Ok(None)
+}
+
 fn leader_receiver_pane_binding(state: &serde_json::Value) -> Option<PaneSocketBinding<'_>> {
     leader_receiver_pane_binding_in_state(state)
         .or_else(|| active_team_entry(state).and_then(leader_receiver_pane_binding_in_state))
@@ -802,16 +1106,24 @@ fn leader_receiver_pane_is_usable(
     )
 }
 
+/// 0.5.x Phase 1d Batch 4: the `Owned` variant now carries a boxed
+/// `Transport` trait object rather than a concrete `TmuxBackend`. All
+/// existing leader-fallback sites still supply a `TmuxBackend` here
+/// (Batch 4 is a helper replacement at the leader channel only —
+/// `transport_kind`-based dispatch belongs to the parallel
+/// `feat/appserver-leader-host` work per leader msg_4ac2122489e0),
+/// but the type is now open so a future conpty leader-hosting flow
+/// can plug in without another enum widen.
 enum DeliveryTransport<'a> {
     Borrowed(&'a dyn Transport),
-    Owned(crate::tmux_backend::TmuxBackend),
+    Owned(Box<dyn Transport>),
 }
 
 impl<'a> DeliveryTransport<'a> {
     fn as_transport(&'a self) -> &'a dyn Transport {
         match self {
             Self::Borrowed(transport) => *transport,
-            Self::Owned(transport) => transport,
+            Self::Owned(transport) => transport.as_ref(),
         }
     }
 }
@@ -825,6 +1137,14 @@ fn delivery_transport_for_recipient<'a>(
     if recipient != "leader" {
         return DeliveryTransport::Borrowed(product_transport);
     }
+    // 0.5.x Phase 1d Batch 4: leader-fallback chain uses the factory
+    // tmux channel helpers instead of `TmuxBackend::{new,for_workspace,
+    // for_tmux_endpoint}` directly. Semantics are identical (helpers
+    // are thin wrappers) but `grep -rn transport_factory::tmux_` at any
+    // future point returns every intentional tmux-only leader-channel
+    // site. Leader-channel dispatch by `transport_kind` is the parallel
+    // `feat/appserver-leader-host` work — this batch stays helper-swap
+    // only per leader msg_4ac2122489e0.
     let pane_id = leader_receiver_pane_id(state);
     let Some(socket) = leader_receiver_tmux_socket(state) else {
         if let Some(pane_id) = pane_id {
@@ -834,14 +1154,14 @@ fn delivery_transport_for_recipient<'a>(
                 .iter()
                 .any(|target| target.pane_id.as_str() == pane_id);
             if !in_workspace {
-                let default_backend = crate::tmux_backend::TmuxBackend::new();
+                let default_backend = crate::transport_factory::tmux_default_transport();
                 if default_backend
                     .list_targets()
                     .unwrap_or_default()
                     .iter()
                     .any(|target| target.pane_id.as_str() == pane_id)
                 {
-                    return DeliveryTransport::Owned(default_backend);
+                    return DeliveryTransport::Owned(Box::new(default_backend));
                 }
             }
         }
@@ -850,7 +1170,7 @@ fn delivery_transport_for_recipient<'a>(
     if socket == crate::tmux_backend::socket_name_for_workspace(workspace) {
         DeliveryTransport::Borrowed(product_transport)
     } else {
-        let endpoint_backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
+        let endpoint_backend = crate::transport_factory::tmux_endpoint_transport(socket);
         if let Some(pane_id) = pane_id {
             if endpoint_backend
                 .list_targets()
@@ -858,7 +1178,7 @@ fn delivery_transport_for_recipient<'a>(
                 .iter()
                 .any(|target| target.pane_id.as_str() == pane_id)
             {
-                return DeliveryTransport::Owned(endpoint_backend);
+                return DeliveryTransport::Owned(Box::new(endpoint_backend));
             }
             if product_transport
                 .list_targets()
@@ -868,17 +1188,17 @@ fn delivery_transport_for_recipient<'a>(
             {
                 return DeliveryTransport::Borrowed(product_transport);
             }
-            let default_backend = crate::tmux_backend::TmuxBackend::new();
+            let default_backend = crate::transport_factory::tmux_default_transport();
             if default_backend
                 .list_targets()
                 .unwrap_or_default()
                 .iter()
                 .any(|target| target.pane_id.as_str() == pane_id)
             {
-                return DeliveryTransport::Owned(default_backend);
+                return DeliveryTransport::Owned(Box::new(default_backend));
             }
         }
-        DeliveryTransport::Owned(endpoint_backend)
+        DeliveryTransport::Owned(Box::new(endpoint_backend))
     }
 }
 

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

@@ -7,7 +7,7 @@ use serde_json::Value;
 
 use crate::event_log::EventLog;
 use crate::message_store::{MessageStore, NotificationClaimParams};
-use crate::model::ids::{OwnerEpoch, TaskId};
+use crate::model::ids::TaskId;
 use crate::transport::{InjectPayload, Key, PaneId, Target, Transport};
 
 use super::helpers::MessageStatusShadow;
@@ -182,131 +182,6 @@ pub fn send_to_leader_receiver_with_message_id(
     })
 }
 
-/// `claim_leader_receiver` (`leader.py:348`):认领/接管 leader pane + `owner_epoch++`。身份判定
-/// 借 step 10 原语 (`_target_matches_owner_identity`/`_leader_command_looks_usable`)。
-pub fn claim_leader_receiver(
-    workspace: &Path,
-    state: &mut serde_json::Value,
-    candidate: &serde_json::Value,
-    event_log: &EventLog,
-    confirm: bool,
-    expected_epoch: Option<OwnerEpoch>,
-) -> Result<serde_json::Value, MessagingError> {
-    if !confirm {
-        return Ok(serde_json::json!({
-            "ok": false,
-            "status": "refused",
-            "reason": "confirm_required",
-            "action": "team-agent claim-leader --confirm",
-        }));
-    }
-    if let Some(expected) = expected_epoch {
-        if owner_epoch(state).is_some_and(|current| current != expected.0) {
-            let owner_epoch = owner_epoch(state).unwrap_or(0);
-            let bound_pane_id = leader_pane_id(state).map(ToString::to_string);
-            let value = serde_json::json!({
-                "ok": false,
-                "status": "refused",
-                "reason": "owner_epoch_advanced",
-                "owner_epoch": owner_epoch,
-                "bound_pane_id": bound_pane_id,
-            });
-            event_log.write("leader_receiver.claim_refused", value.clone())?;
-            return Ok(value);
-        }
-    }
-    let candidate_pane = candidate.get("pane_id").and_then(Value::as_str);
-    if candidate_pane.is_some() && candidate_pane == leader_pane_id(state) {
-        return Ok(serde_json::json!({
-            "ok": true,
-            "status": "already_bound",
-            "pane_id": candidate_pane,
-            "owner_epoch": owner_epoch(state).unwrap_or(0),
-        }));
-    }
-    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(),
-        ));
-    };
-    // Build the updated owner + receiver values in-place (field-level
-    // mutation preserves any extra fields the caller carries), then publish
-    // through the ownership repository. This keeps `claim_leader_receiver`'s
-    // legacy field-merge semantics while sourcing all owner mutations from
-    // one API surface (Stage 3a, architect direction 2026-06-23).
-    let mut owner_value = root
-        .get("team_owner")
-        .cloned()
-        .unwrap_or_else(|| serde_json::json!({}));
-    if let Some(owner) = owner_value.as_object_mut() {
-        owner.insert("owner_epoch".to_string(), serde_json::json!(next_epoch));
-    }
-    let mut receiver_value = root
-        .get("leader_receiver")
-        .cloned()
-        .unwrap_or_else(|| serde_json::json!({}));
-    if let Some(receiver) = receiver_value.as_object_mut() {
-        receiver.insert("mode".to_string(), serde_json::json!("direct_tmux"));
-        receiver.insert("owner_epoch".to_string(), serde_json::json!(next_epoch));
-        copy_candidate_field(receiver, candidate, "pane_id");
-        copy_candidate_field(receiver, candidate, "provider");
-        copy_candidate_field(receiver, candidate, "leader_session_uuid");
-        if let Some(socket) = candidate
-            .get("tmux_socket")
-            .and_then(Value::as_str)
-            .filter(|socket| std::path::Path::new(socket).is_absolute())
-            .map(str::to_string)
-            .or_else(crate::tmux_backend::socket_name_from_tmux_env)
-        {
-            receiver.insert("tmux_socket".to_string(), serde_json::json!(socket));
-        }
-    }
-    // The `root` borrow above is released by NLL before this call.
-    let team_key = crate::state::projection::team_state_key(state);
-    let record = crate::state::ownership::OwnershipWrite::new()
-        .with_team_owner(owner_value)
-        .with_leader_receiver(receiver_value)
-        .with_owner_epoch(next_epoch);
-    crate::state::ownership::write_owner(state, &team_key, record);
-    crate::state::persist::save_runtime_state_reapplying_after_conflict(
-        workspace,
-        state,
-        |latest| {
-            let team_key = crate::state::projection::team_state_key(latest);
-            let record = crate::state::ownership::OwnershipWrite::new()
-                .with_team_owner(
-                    state
-                        .get("team_owner")
-                        .cloned()
-                        .unwrap_or_else(|| serde_json::json!({})),
-                )
-                .with_leader_receiver(
-                    state
-                        .get("leader_receiver")
-                        .cloned()
-                        .unwrap_or_else(|| serde_json::json!({})),
-                )
-                .with_owner_epoch(next_epoch);
-            crate::state::ownership::write_owner(latest, &team_key, record);
-        },
-    )?;
-    event_log.write(
-        "leader_receiver.claimed",
-        serde_json::json!({"owner_epoch": next_epoch, "candidate": candidate}),
-    )?;
-    let receiver = state
-        .get("leader_receiver")
-        .cloned()
-        .unwrap_or_else(|| candidate.clone());
-    Ok(serde_json::json!({
-        "ok": true,
-        "status": "claimed",
-        "leader_receiver": receiver,
-        "owner_epoch": next_epoch,
-    }))
-}
-
 /// `_mirror_peer_message_to_leader` (`leader.py:31`):peer→peer 消息镜像到 leader receiver。
 pub fn mirror_peer_message_to_leader(
     workspace: &Path,
@@ -411,18 +286,25 @@ pub fn deliver_to_leader_fallback_pane(
     let rendered = render_fallback_pane_message(content, message_id, primary_error);
     let target = Target::Pane(PaneId::new(&pane_id));
     let payload = InjectPayload::Text(rendered);
+    // 0.5.x Phase 1d Batch 4: leader-fallback pane inject uses the
+    // factory tmux channel helpers so `grep transport_factory::tmux_`
+    // enumerates every tmux-only leader-channel site. Semantics are
+    // identical to the previous direct `TmuxBackend::*` calls
+    // (helpers are thin wrappers). `transport_kind`-based dispatch
+    // is the parallel `feat/appserver-leader-host` work; this batch
+    // stays helper-swap only.
     let inject_result = leader_tmux_socket(state)
         .and_then(|socket| {
-            let backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
+            let backend = crate::transport_factory::tmux_endpoint_transport(socket);
             backend.inject(&target, &payload, Key::Enter, true).ok()
         })
         .map(Ok)
         .unwrap_or_else(|| {
-            let backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
+            let backend = crate::transport_factory::tmux_workspace_transport(workspace);
             backend.inject(&target, &payload, Key::Enter, true)
         })
         .or_else(|_| {
-            let backend = crate::tmux_backend::TmuxBackend::new();
+            let backend = crate::transport_factory::tmux_default_transport();
             backend.inject(&target, &payload, Key::Enter, true)
         });
 
@@ -563,18 +445,21 @@ pub(crate) fn leader_pane_bound_but_not_live(workspace: &Path, state: &Value) ->
 }
 
 fn leader_pane_is_live(workspace: &Path, state: &Value, pane_id: &str) -> bool {
+    // 0.5.x Phase 1d Batch 4: leader liveness uses factory tmux
+    // channel helpers. Semantics unchanged; `transport_kind`-based
+    // dispatch is the parallel feat/appserver-leader-host work.
     if let Some(socket) = leader_tmux_socket(state) {
-        return crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket)
+        return crate::transport_factory::tmux_endpoint_transport(socket)
             .list_targets()
             .unwrap_or_default()
             .iter()
             .any(|target| target.pane_id.as_str() == pane_id);
     }
-    let mut targets = crate::tmux_backend::TmuxBackend::for_workspace(workspace)
+    let mut targets = crate::transport_factory::tmux_workspace_transport(workspace)
         .list_targets()
         .unwrap_or_default();
     targets.extend(
-        crate::tmux_backend::TmuxBackend::new()
+        crate::transport_factory::tmux_default_transport()
             .list_targets()
             .unwrap_or_default(),
     );
@@ -621,9 +506,3 @@ fn render_fallback_pane_message(content: &str, message_id: &str, primary_error:
          [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,8 +83,8 @@ pub use delivery::{
 };
 pub use helpers::fail_leader_delivery;
 pub use 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,
+    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::{