@team-agent/installer 0.5.60 → 0.5.62

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

@@ -1,3 +1,4 @@
+//!
 //! step 14a · mcp_server::wire — stdio loop + JSON-RPC route + tool dispatch + contracts.
 
 use std::io::{BufRead, Write};
@@ -9,7 +10,6 @@ use crate::event_log::EventLog;
 use crate::messaging::MessageTarget;
 
 use super::helpers::{json_dumps_default, object_fields};
-use super::normalize::normalize_result_status;
 use super::tools::TeamOrchestratorTools;
 use super::types::{
     McpError, McpTool, RpcError, RpcId, RpcMethod, RpcResponse, Scope, SendOutcome,
@@ -87,16 +87,15 @@ pub fn dispatch(tools: &TeamOrchestratorTools, request: &Value) -> ToolResult {
 /// `handle_mcp(tools, request)` (`server.py:46-91`): the JSON-RPC router.
 ///   - `initialize` → serverInfo `team_orchestrator` v0.1.4 + echoed protocolVersion.
 ///   - `tools/list` → `{tools: TOOLS}`.
-///   - `tools/call` → run [`dispatch`], wrap into [`ToolCallResult`] (`isError` =
-///     dispatch returned `Err`); the arg-vs-runtime exception split (`server.py:
-///     69-72`) classifies a caught failure into `InvalidToolArguments` vs
-///     `InternalRuntimeError`.
+///   - `tools/call` → run [`dispatch`], wrap through the live
+///     `tool_call_result_value` path (`isError` = dispatch returned `Err`); the
+///     arg-vs-runtime exception split (`server.py:69-72`) classifies a caught
+///     failure into `InvalidToolArguments` vs `InternalRuntimeError`.
 ///   - `notifications/*` → `Ok(None)` (no frame; **must not** emit to stdout).
 ///   - unknown method → `-32601` error frame.
 /// Returns `Ok(None)` only for the notifications path; every other branch yields a
 /// frame.
 ///
-/// [`ToolCallResult`]: super::ToolCallResult
 pub fn handle_mcp(
     tools: &TeamOrchestratorTools,
     request: &Value,
@@ -369,7 +368,7 @@ fn python_repr(value: &str) -> String {
 fn tool_contract(tool: McpTool) -> Value {
     let (description, required) = match tool {
         McpTool::SendMessage => (
-            "Send a message to a teammate, the leader, or '*' for all other team members. Team Agent fills identity and delivery metadata; optional presentation routing is durable and never drops the message.",
+            "Send a message to a teammate, the leader, or '*' for all other team members. mailbox=true stores durably without live injection; the default is live delivery.",
             vec!["to", "content"],
         ),
         McpTool::AssignTask => ("Assign or update a task in the team graph and deliver it to its assignee.", vec!["task"]),
@@ -404,11 +403,7 @@ fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
     let mut properties = serde_json::Map::new();
     match tool {
         McpTool::AssignTask => {
-            insert_property(
-                &mut properties,
-                "task",
-                object_property("Task object to add or update."),
-            );
+            insert_property(&mut properties, "task", task_property());
             insert_property(
                 &mut properties,
                 "message",
@@ -424,8 +419,10 @@ fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
             insert_property(&mut properties, "content", string_property("Message body."));
             insert_property(
                 &mut properties,
-                "presentation",
-                presentation_property("Optional durable presentation routing."),
+                "mailbox",
+                boolean_property(
+                    "Set true to store durably without live injection; omit for default live delivery.",
+                ),
             );
         }
         McpTool::ReportResult => {
@@ -603,6 +600,25 @@ fn object_property(description: &str) -> Value {
     serde_json::json!({"type": "object", "description": description, "additionalProperties": true})
 }
 
+fn task_property() -> Value {
+    serde_json::json!({
+        "type": "object",
+        "description": "Task object to add or update.",
+        "properties": {
+            "result_route": {
+                "type": "string",
+                "enum": crate::messaging::results::ResultRoute::ALL
+                    .iter()
+                    .map(|route| route.as_str())
+                    .collect::<Vec<_>>(),
+                "default": crate::messaging::results::ResultRoute::default().as_str(),
+                "description": "Result destination chosen by the task assigner."
+            }
+        },
+        "additionalProperties": true
+    })
+}
+
 fn presentation_property(description: &str) -> Value {
     serde_json::json!({
         "type": "object",
@@ -646,6 +662,7 @@ pub(crate) fn dispatch_tool(
                 None,
                 None,
                 None,
+                args.get("mailbox"),
                 args.get("presentation"),
             )?;
             match outcome {
@@ -658,18 +675,7 @@ pub(crate) fn dispatch_tool(
         McpTool::ReportResult => tools.report_result_with_presentation(
             args.get("envelope"),
             args.get("summary").and_then(Value::as_str),
-            // cr verdict (T3-1 refined): an unknown status literal normalizes to
-            // Partial and is OBSERVABLE at this ingestion boundary, never silent.
-            {
-                let (status, unknown) =
-                    crate::mcp_server::normalize::normalize_result_status_observed(
-                        args.get("status").and_then(Value::as_str),
-                    );
-                if let Some(raw) = unknown {
-                    tools.note_unknown_result_status(&raw);
-                }
-                status
-            },
+            args.get("status").and_then(Value::as_str),
             args.get("changes")
                 .and_then(Value::as_array)
                 .map(Vec::as_slice),

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

@@ -1,3 +1,4 @@
+//!
 //! idle_alerts.py — idle/deadlock 检测 (team-scoped 抑制 + last-fire 节流;card §23) +
 //! activity_detector.py — classifier 产物 (card §24)。
 //! §11 IRON LAW (bug-071/077/085):无信号 → Uncertain,绝不 Idle。

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

@@ -1,3 +1,4 @@
+//!
 //! Pure logical-address grammar shared by public entry-point adapters.
 
 use std::path::PathBuf;

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

@@ -1,3 +1,4 @@
+//!
 //! internal_delivery.py + delivery.py — coordinator/调度器侧 thin wrapper + 单条 tmux 注入投递
 //! + trust 有界重试 + turn-open arm (card §16/§65)。
 
@@ -93,7 +94,7 @@ pub fn deliver_persisted_message(
 
 /// `_tmux_pane_width` (`delivery.py:20`):查询 pane 列宽。**fail-safe** (bug-064/082):失败
 /// 返回 [`PaneWidthQuery::Failed`],**绝不**给默认宽度。借 step 9 transport 的 query。
-pub fn tmux_pane_width(transport: &dyn Transport, target: &Target) -> PaneWidthQuery {
+pub(crate) fn tmux_pane_width(transport: &dyn Transport, target: &Target) -> PaneWidthQuery {
     let queried = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
         transport.query(target, crate::transport::PaneField::PaneWidth)
     }));
@@ -220,7 +221,12 @@ pub fn deliver_pending_message(
         }
         _ => state,
     };
-    if message.recipient == "leader" && message.status == "submitted_pending_acceptance" {
+    if message.recipient == "leader"
+        && matches!(
+            message.status.as_str(),
+            "submitted_pending_acceptance" | "injected_awaiting_receipt"
+        )
+    {
         return observe_pending_leader_acceptance(store, event_log, state, message_id);
     }
     if message.recipient == "leader" && message.status == "queued_until_leader_attach" {
@@ -341,6 +347,12 @@ pub fn deliver_pending_message(
                     .get("status")
                     .and_then(serde_json::Value::as_str)
                     .unwrap_or("unbound");
+                let refusal = match &reason {
+                    crate::messaging::LeaderChannelUnbound::PaneWorkspaceMismatch(_) => {
+                        DeliveryRefusal::PaneWorkspaceMismatch
+                    }
+                    _ => DeliveryRefusal::LeaderNotAttached,
+                };
                 store.mark(message_id, "failed", Some("leader_not_attached"))?;
                 event_log.write(
                     "leader_receiver.delivery_blocked",
@@ -349,7 +361,7 @@ pub fn deliver_pending_message(
                         "sender": message.sender,
                         "reason": "leader_receiver_not_attached",
                         "error": "leader_not_attached",
-                        "channel_reason": format!("{reason:?}"),
+                        "channel_reason": reason.reason_code(),
                         "channel": "rebind_required",
                         "action": "run team-agent attach-leader or team-agent takeover",
                         "status": receiver_status,
@@ -364,7 +376,7 @@ pub fn deliver_pending_message(
                         "run team-agent attach-leader or team-agent takeover".to_string(),
                     ),
                     stage: None,
-                    reason: Some(DeliveryRefusal::LeaderNotAttached),
+                    reason: Some(refusal),
                     channel: Some("rebind_required".to_string()),
                 });
             }
@@ -711,19 +723,30 @@ pub fn deliver_pending_message(
     }
     if is_leader_recipient {
         store.record_delivery_submission(message_id, readback_verified)?;
-        if !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,
-                    "reason": "provider_receipt_not_observed",
-                }),
-            )?;
-            return Ok(leader_acceptance_pending_outcome(
-                message_id,
-                "submitted_pending_acceptance",
-            ));
+        match observe_leader_receipt(state, message_id) {
+            LeaderReceiptObservation::SourceUnavailable => {
+                store.mark_injected_awaiting_receipt(message_id)?;
+                event_log.write(
+                    "leader_receiver.receipt_source_unavailable",
+                    serde_json::json!({"message_id": message_id}),
+                )?;
+                return Ok(leader_receipt_source_unavailable_outcome(message_id));
+            }
+            LeaderReceiptObservation::TokenAbsent => {
+                store.mark(message_id, "submitted_pending_acceptance", None)?;
+                event_log.write(
+                    "leader_receiver.acceptance_pending",
+                    serde_json::json!({
+                        "message_id": message_id,
+                        "reason": "provider_receipt_not_observed",
+                    }),
+                )?;
+                return Ok(leader_acceptance_pending_outcome(
+                    message_id,
+                    "submitted_pending_acceptance",
+                ));
+            }
+            LeaderReceiptObservation::TokenObserved => {}
         }
         store.mark_delivered_with_receipt(message_id)?;
     } else {
@@ -2041,15 +2064,36 @@ fn leader_rollout_path(state: &serde_json::Value) -> Option<std::path::PathBuf>
         .map(std::path::PathBuf::from)
 }
 
-pub(crate) fn leader_transcript_has_token(state: &serde_json::Value, message_id: &str) -> bool {
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum LeaderReceiptObservation {
+    SourceUnavailable,
+    TokenAbsent,
+    TokenObserved,
+}
+
+pub(crate) fn observe_leader_receipt(
+    state: &serde_json::Value,
+    message_id: &str,
+) -> LeaderReceiptObservation {
     let Some(path) = leader_rollout_path(state) else {
-        return false;
+        return LeaderReceiptObservation::SourceUnavailable;
     };
-    rollout_tail_contains(
+    let Ok(observed) = rollout_tail_contains_result(
         &path,
         &format!("[team-agent-token:{message_id}]"),
         64 * 1024,
-    )
+    ) else {
+        return LeaderReceiptObservation::SourceUnavailable;
+    };
+    if observed {
+        LeaderReceiptObservation::TokenObserved
+    } else {
+        LeaderReceiptObservation::TokenAbsent
+    }
+}
+
+pub(crate) fn leader_transcript_has_token(state: &serde_json::Value, message_id: &str) -> bool {
+    observe_leader_receipt(state, message_id) == LeaderReceiptObservation::TokenObserved
 }
 
 fn leader_acceptance_pending_outcome(message_id: &str, status: &str) -> DeliveryOutcome {
@@ -2065,17 +2109,41 @@ fn leader_acceptance_pending_outcome(message_id: &str, status: &str) -> Delivery
     }
 }
 
+pub(crate) fn leader_receipt_source_unavailable_outcome(message_id: &str) -> DeliveryOutcome {
+    DeliveryOutcome {
+        ok: true,
+        status: DeliveryStatus::Blocked,
+        message_status: MessageStatusShadow("injected_awaiting_receipt".to_string()),
+        message_id: Some(message_id.to_string()),
+        verification: Some("leader_receipt_source_unavailable".to_string()),
+        stage: Some(DeliveryStage::Submit),
+        reason: None,
+        channel: Some("leader_receipt_source_unavailable".to_string()),
+    }
+}
+
 fn observe_pending_leader_acceptance(
     store: &MessageStore,
     event_log: &EventLog,
     state: &serde_json::Value,
     message_id: &str,
 ) -> Result<DeliveryOutcome, MessagingError> {
-    if !leader_transcript_has_token(state, message_id) {
-        return Ok(leader_acceptance_pending_outcome(
-            message_id,
-            "submitted_pending_acceptance",
-        ));
+    match observe_leader_receipt(state, message_id) {
+        LeaderReceiptObservation::SourceUnavailable => {
+            store.mark_injected_awaiting_receipt(message_id)?;
+            event_log.write(
+                "leader_receiver.receipt_source_unavailable",
+                serde_json::json!({"message_id": message_id}),
+            )?;
+            return Ok(leader_receipt_source_unavailable_outcome(message_id));
+        }
+        LeaderReceiptObservation::TokenAbsent => {
+            return Ok(leader_acceptance_pending_outcome(
+                message_id,
+                "submitted_pending_acceptance",
+            ));
+        }
+        LeaderReceiptObservation::TokenObserved => {}
     }
     store.mark_delivered_with_receipt(message_id)?;
     event_log.write(
@@ -2187,7 +2255,7 @@ pub fn execute_trust_retry(
 
 /// `_record_turn_open_if_leader_to_worker` (`delivery.py:430`):**take-over arm 来自真实投递**
 /// (card §121) —— 仅 leader→worker 注入/投递成功后才 arm,绝不凭空 arm。
-pub fn record_turn_open_if_leader_to_worker(
+pub(crate) fn record_turn_open_if_leader_to_worker(
     workspace: &Path,
     state: &serde_json::Value,
     sender: &str,
@@ -2346,7 +2414,7 @@ fn arm_turn_open(state: &mut serde_json::Value, recipient: &str, message_id: &Op
 
 /// `_stamp_first_send_at_if_leader_to_worker` (`delivery.py:380`):首次 leader→worker 投递戳
 /// `first_send_at` (step 13 restart Route B atomicity 决策读它)。
-pub fn stamp_first_send_at_if_leader_to_worker(
+pub(crate) fn stamp_first_send_at_if_leader_to_worker(
     workspace: &Path,
     state: &serde_json::Value,
     sender: &str,
@@ -2744,22 +2812,22 @@ fn claude_recipient_rollout(
 /// Silent on read errors — callers treat missing/unreadable as "token not
 /// present" which forces the unverified path.
 fn rollout_tail_contains(path: &std::path::Path, needle: &str, tail_bytes: u64) -> bool {
+    rollout_tail_contains_result(path, needle, tail_bytes).unwrap_or(false)
+}
+
+fn rollout_tail_contains_result(
+    path: &std::path::Path,
+    needle: &str,
+    tail_bytes: u64,
+) -> std::io::Result<bool> {
     use std::io::{Read, Seek, SeekFrom};
-    let Ok(mut file) = std::fs::File::open(path) else {
-        return false;
-    };
-    let Ok(metadata) = file.metadata() else {
-        return false;
-    };
+    let mut file = std::fs::File::open(path)?;
+    let metadata = file.metadata()?;
     let len = metadata.len();
     let start = len.saturating_sub(tail_bytes);
-    if file.seek(SeekFrom::Start(start)).is_err() {
-        return false;
-    }
+    file.seek(SeekFrom::Start(start))?;
     let mut buf = Vec::with_capacity(tail_bytes.min(len) as usize);
-    if file.take(tail_bytes).read_to_end(&mut buf).is_err() {
-        return false;
-    }
+    file.take(tail_bytes).read_to_end(&mut buf)?;
     let haystack = String::from_utf8_lossy(&buf);
-    haystack.contains(needle)
+    Ok(haystack.contains(needle))
 }

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

@@ -1,3 +1,4 @@
+//!
 //! 私有内部 helpers (status wire / envelope 校验 / scheduled kind 解析 / activity 信号
 //! 解析 / id 生成 / MessageStatusShadow 占位)。跨子模块/测试可见者升 `pub(crate)`。
 
@@ -268,7 +269,7 @@ fn idle_activity() -> AgentActivity {
 /// outcome **不被视为 success**(I-3 反向断言要求 `leader_receiver.rs` 源文件不得含
 /// `DeliveryStatus::FallbackLog` 或 `fallback_inbox` 字面量,所以本函数从 `leader_receiver.rs`
 /// 搬到本 helpers 模块,字面量在此被允许)。
-pub fn fail_leader_delivery(
+pub(crate) fn fail_leader_delivery(
     workspace: &std::path::Path,
     payload: &serde_json::Value,
     reason: DeliveryRefusal,

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

@@ -1,8 +1,10 @@
+//!
 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 +28,7 @@ pub enum LeaderChannelResolution {
     ProbeFailed(String),
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum LeaderChannelUnbound {
     ReceiverNotAttached,
     TransportConflict,
@@ -34,10 +36,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 +96,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 +115,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

@@ -1,3 +1,4 @@
+//!
 //! leader.py — leader pane 注入边界 + 恰好一次去重门 (card §21/§72)。
 
 use std::path::Path;
@@ -59,7 +60,7 @@ pub fn send_to_leader_receiver(
 /// 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(
+pub(crate) fn send_to_leader_receiver_with_message_id(
     workspace: &Path,
     state: &serde_json::Value,
     leader_id: &str,
@@ -397,29 +398,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/mod.rs

@@ -1,3 +1,4 @@
+//!
 //! step 11 · messaging — delivery / scheduler / results / collect / report_result /
 //! watchers / leader-receiver / selftest 编排状态机 (ROUND-0 SKELETON).
 //!
@@ -83,11 +84,8 @@ pub use address::{parse_logical_address, LogicalAddress, LogicalAddressTarget};
 pub use delivery::{
     deliver_pending_message, deliver_pending_messages, deliver_persisted_message,
     deliver_stored_message, execute_trust_retry, handle_trust_retry_needed,
-    record_turn_open_if_leader_to_worker,
-    retry_injection_after_trust_auto_answer, stamp_first_send_at_if_leader_to_worker,
-    tmux_pane_width,
+    retry_injection_after_trust_auto_answer,
 };
-pub use helpers::fail_leader_delivery;
 pub use leader_channel::{
     resolve_live_leader_channel, DirectTmuxLeaderChannel, LeaderChannelResolution,
     LeaderChannelUnbound, LiveLeaderChannel,
@@ -95,7 +93,7 @@ pub use leader_channel::{
 pub use leader_receiver::{
     deliver_to_leader_fallback_pane, enqueue_leader_mailbox_until_attach,
     mirror_peer_message_to_leader, send_to_leader_receiver,
-    send_to_leader_receiver_with_message_id, send_to_leader_receiver_with_presentation,
+    send_to_leader_receiver_with_presentation,
 };
 pub use peers::allow_peer_talk;
 pub use persist::{
@@ -107,24 +105,22 @@ pub use results::{
     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 selftest::{run_comms_selftest, CommsSelftestDriver};
 pub use send::{
-    apply_worker_sender_bypass, send_message, session_drift_refusal, MessageTarget, SendOptions,
-    TrustedSender,
+    apply_worker_sender_bypass, send_message, MessageTarget, SendOptions, TrustedSender,
 };
 pub use trust::{attempt_trust_auto_answer, TrustAnswerOutcome};
 pub use types::{
-    ActivityStatus, AgentActivity, AlertSnapshot, AlertSuppression, AlertType, CheckEvidence,
-    CheckKind, CheckStatus, ContractSuiteCheck, DeliveryOutcome, DeliveryRefusal, DeliveryStage,
-    DeliveryStatus, IdleEvaluation, LeaderNotificationKey, LeaderReceiver, PaneWidthQuery,
+    ActivityStatus, AgentActivity, AlertType, CheckEvidence, CheckKind, CheckStatus,
+    ContractSuiteCheck, DeliveryOutcome, DeliveryRefusal, DeliveryStage, DeliveryStatus,
+    IdleEvaluation, LeaderNotificationKey, LeaderReceiver, PaneWidthQuery,
     ProviderSdkCalls, ReceiverMode, ScheduledKind, SelftestCheck, SelftestReport, SendEventPayload,
     TrustRetryPayload, WatcherNotice, WorkerRuntimeState, RESULT_DELIVERY_MAX_ATTEMPTS,
     SEND_RETRY_MAX_ATTEMPTS, TRUST_RETRY_BACKOFF_SECONDS, TRUST_RETRY_MAX_ATTEMPTS,
 };
 pub use watchers::{
-    delivered_result_message, format_result_watcher_notification, notify_result_watchers,
-    requeue_after_claim_leader, requeue_delivery_exhausted_watchers, result_id_from_text,
-    retry_result_deliveries,
+    format_result_watcher_notification, requeue_after_claim_leader,
+    requeue_delivery_exhausted_watchers, result_id_from_text, retry_result_deliveries,
 };
 
 // `MessageStatusShadow` 是 [`DeliveryOutcome::message_status`] 的公有字段类型,原在模块根

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

@@ -1,3 +1,4 @@
+//!
 //! peer messaging compatibility helpers.
 
 use std::path::Path;
@@ -7,6 +8,7 @@ use crate::message_store::MessageStore;
 
 use super::MessagingError;
 
+///
 /// `leader.py:allow_peer_talk`: persist a bidirectional peer allowlist entry.
 pub fn allow_peer_talk(
     workspace: &Path,

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

@@ -1,3 +1,4 @@
+//!
 //! Durable boundary between resolved logical addressing and delivery/recovery.
 
 use std::path::{Path, PathBuf};
@@ -152,6 +153,7 @@ pub enum PersistResolution {
     Duplicate(String),
 }
 
+///
 /// The only production entry point that creates a durable message row.
 pub fn persist_resolved_send(
     intent: &ResolvedSendIntent,
@@ -168,7 +170,7 @@ pub fn persist_resolved_send(
         message_id: intent.requested_message_id.as_deref(),
         owner_team_id: intent.owner_team_id.as_ref().map(TeamKey::as_str),
         task_id: intent.task_id.as_ref().map(TaskId::as_str),
-        sender: intent.sender.as_str(),
+        sender: intent.sender.display_name(),
         recipient: intent.recipient.as_str(),
         reply_to: intent.reply_to.as_deref(),
         requires_ack: intent.requires_ack,