@team-agent/installer 0.3.0 → 0.3.1

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -67,6 +67,58 @@ fn quick_start_compiles_real_spec_to_team_spec_yaml() {
     }
 }
 
+#[test]
+fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_collect() {
+    let workspace = temp_ws();
+    let team = workspace.join(".team").join("current");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
+    std::fs::write(team.join("agents").join("implementer.md"), QS_VALID_ROLE).unwrap();
+
+    let transport = OfflineTransport::new();
+    let result = quick_start_with_transport(&team, None, true, true, None, &transport);
+    assert!(matches!(result, Ok(QuickStartReport::Ready { .. })), "quick-start failed: {result:?}");
+
+    let state_path = crate::state::persist::runtime_state_path(&workspace);
+    assert!(state_path.exists(), "quick-start .team/current must persist runtime state under project root");
+    assert!(
+        !workspace.join(".team").join(".team").join("runtime").join("state.json").exists(),
+        "quick-start .team/current must not create nested .team/.team runtime state"
+    );
+
+    for input in [&workspace, &team] {
+        let selected = crate::state::selector::resolve_active_team(
+            input,
+            None,
+            crate::state::selector::SelectorMode::RuntimeOnly,
+        )
+        .expect("status/collect selector should resolve project root");
+        assert_eq!(selected.run_workspace, workspace, "input={}", input.display());
+        assert_eq!(
+            selected.spec_path.as_deref().map(std::fs::canonicalize).transpose().unwrap(),
+            Some(std::fs::canonicalize(team.join("team.spec.yaml")).unwrap()),
+            "input={}",
+            input.display()
+        );
+    }
+
+    let status = crate::cli::cmd_status(&crate::cli::StatusArgs {
+        agent: None,
+        workspace: team.clone(),
+        detail: false,
+        summary: false,
+        json: true,
+    });
+    assert!(status.is_ok(), "status should normalize teamdir to project-root runtime state: {status:?}");
+
+    let collect = crate::cli::cmd_collect(&crate::cli::CollectArgs {
+        result_file: None,
+        workspace: team.clone(),
+        json: true,
+    });
+    assert!(collect.is_ok(), "collect should normalize teamdir to the same project-root state/spec: {collect:?}");
+}
+
 // P0 — quick_start over an INVALID role doc (missing `provider`) must surface the REAL compile
 // error, distinct from the stub's hardcoded "no role docs found". Golden: compile_team raises
 // "missing front matter field provider" (compiler.py:_validate_role_doc), before preflight.

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

@@ -445,6 +445,24 @@ pub struct PermissionSummary {
     pub raw: serde_json::Value,
 }
 
+/// BUG-7 (0.3.1): quick-start cannot honestly report "ready" before the workers'
+/// MCP tool sets have actually loaded — provider-side schema rejections (codex
+/// invalid_function_parameters etc.) happen AFTER spawn and silently disable the
+/// worker. The report must therefore carry a readiness verdict so the CLI surface
+/// never emits bare "ready" while worker capability is unverified or already known
+/// to be degraded.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum QuickStartReadiness {
+    /// At least one agent already failed to materialize a live tmux window (BUG-2
+    /// observable). The team is *not* ready; user must inspect / restart.
+    Degraded { unhealthy_agents: Vec<String> },
+    /// All spawned agents have live windows but their MCP tool set load has NOT
+    /// been verified yet — provider-side schema/auth failures could still leave
+    /// the worker unable to call team_orchestrator tools. CLI must label this
+    /// `pending` / `unverified`, NOT bare `ready`.
+    PendingToolLoad,
+}
+
 /// `quick_start(...)` 报告(`diagnose/quick_start.py:103` typed 版)。`Refused` 区分
 /// existing-context(需 restart 或 --fresh)与 preflight 失败。
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -454,6 +472,13 @@ pub enum QuickStartReport {
         session_name: SessionName,
         launch: Box<LaunchReport>,
         next_actions: Vec<String>,
+        /// BUG-7: real readiness verdict. `Ready` ⇒ the wrapper completed AND the
+        /// caller already verified tool-set availability; the framework itself
+        /// never emits this without an external observable confirming worker
+        /// tool calls succeeded. quick_start_with_transport always defaults to
+        /// [`QuickStartReadiness::PendingToolLoad`] (or `Degraded` if any agent
+        /// failed to spawn) so the CLI surface cannot lie about availability.
+        worker_readiness: QuickStartReadiness,
     },
     /// 已有 runtime state,非 --fresh → 引导用 restart(`quick_start.py:42`)。
     ExistingRuntime {

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

@@ -68,6 +68,34 @@
         assert_eq!(send["inputSchema"]["required"], json!(["to", "content"]));
     }
 
+    #[test]
+    fn tools_contract_input_schemas_are_openai_strict_top_level_objects() {
+        let forbidden = ["oneOf", "anyOf", "allOf", "enum", "not"];
+        for tool in tools_contract() {
+            let schema = tool["inputSchema"].as_object().unwrap();
+            assert_eq!(schema.get("type"), Some(&json!("object")), "schema must be a top-level object: {tool}");
+            for key in forbidden {
+                assert!(
+                    !schema.contains_key(key),
+                    "OpenAI rejects top-level `{key}` in MCP tool schema: {tool}"
+                );
+            }
+            let properties = schema
+                .get("properties")
+                .and_then(Value::as_object)
+                .unwrap_or_else(|| panic!("schema properties must be an object: {tool}"));
+            for required in schema.get("required").and_then(Value::as_array).into_iter().flatten() {
+                let Some(name) = required.as_str() else {
+                    panic!("required entries must be strings: {tool}");
+                };
+                assert!(
+                    properties.contains_key(name),
+                    "required property `{name}` must be declared in properties: {tool}"
+                );
+            }
+        }
+    }
+
     // ════════════════════════════════════════════════════════════════════════
     // handle_mcp — JSON-RPC routing (server.py:46-91)
     // ════════════════════════════════════════════════════════════════════════

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

@@ -298,13 +298,93 @@ fn tool_contract(tool: McpTool) -> Value {
         "description": description,
         "inputSchema": {
             "type": "object",
-            "properties": {},
+            "properties": tool_properties(tool),
             "required": required,
             "additionalProperties": false
         }
     })
 }
 
+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, "message", string_property("Optional message to deliver with the task."));
+        }
+        McpTool::SendMessage => {
+            insert_property(&mut properties, "to", string_property("Target agent id, 'leader', or '*' for broadcast."));
+            insert_property(&mut properties, "content", string_property("Message body."));
+            insert_property(&mut properties, "task_id", string_property("Optional task id to associate with the message."));
+            insert_property(&mut properties, "sender", string_property("Optional sender override."));
+            insert_property(&mut properties, "requires_ack", boolean_property("Whether the recipient should acknowledge delivery."));
+            insert_property(&mut properties, "scope", string_property("Optional delivery scope: team or workspace."));
+        }
+        McpTool::ReportResult => {
+            insert_property(&mut properties, "envelope", object_property("Optional full result envelope."));
+            insert_property(&mut properties, "summary", string_property("Short result summary."));
+            insert_property(&mut properties, "status", string_property("Result status."));
+            insert_property(&mut properties, "changes", array_property("Changed files or artifacts."));
+            insert_property(&mut properties, "tests", array_property("Tests or checks performed."));
+            insert_property(&mut properties, "risks", array_property("Risks or blockers."));
+            insert_property(&mut properties, "artifacts", array_property("Artifact references."));
+            insert_property(&mut properties, "next_actions", array_property("Suggested next actions."));
+            insert_property(&mut properties, "task_id", string_property("Optional task id override."));
+            insert_property(&mut properties, "agent_id", string_property("Optional reporting agent id override."));
+        }
+        McpTool::UpdateState => {
+            insert_property(&mut properties, "note", string_property("Note to append to team state."));
+        }
+        McpTool::GetTeamStatus | McpTool::StuckList => {}
+        McpTool::StopAgent => {
+            insert_property(&mut properties, "agent_id", string_property("Agent id to stop."));
+        }
+        McpTool::ResetAgent => {
+            insert_property(&mut properties, "agent_id", string_property("Agent id to reset."));
+            insert_property(&mut properties, "discard_session", boolean_property("Whether to discard the existing provider session."));
+        }
+        McpTool::AddAgent => {
+            insert_property(&mut properties, "new_agent_id", string_property("New agent id."));
+            insert_property(&mut properties, "role_file_path", string_property("Workspace-relative role file path."));
+        }
+        McpTool::ForkAgent => {
+            insert_property(&mut properties, "source_agent_id", string_property("Agent id to fork from."));
+            insert_property(&mut properties, "as_agent_id", string_property("Agent id for the forked worker."));
+            insert_property(&mut properties, "label", string_property("Optional display label."));
+        }
+        McpTool::RequestHuman => {
+            insert_property(&mut properties, "question", string_property("Question to ask the human."));
+            insert_property(&mut properties, "task_id", string_property("Optional related task id."));
+            insert_property(&mut properties, "agent_id", string_property("Optional requesting agent id."));
+        }
+        McpTool::StuckCancel => {
+            insert_property(&mut properties, "agent_id", string_property("Agent id whose stuck alerts should be suppressed."));
+            insert_property(&mut properties, "alert_type", string_property("Alert type to suppress, or all."));
+        }
+    }
+    properties
+}
+
+fn insert_property(properties: &mut serde_json::Map<String, Value>, name: &str, schema: Value) {
+    properties.insert(name.to_string(), schema);
+}
+
+fn string_property(description: &str) -> Value {
+    serde_json::json!({"type": "string", "description": description})
+}
+
+fn boolean_property(description: &str) -> Value {
+    serde_json::json!({"type": "boolean", "description": description})
+}
+
+fn object_property(description: &str) -> Value {
+    serde_json::json!({"type": "object", "description": description, "additionalProperties": true})
+}
+
+fn array_property(description: &str) -> Value {
+    serde_json::json!({"type": "array", "description": description, "items": {"type": "object", "additionalProperties": true}})
+}
+
 pub(crate) fn dispatch_tool(tools: &TeamOrchestratorTools, tool: McpTool, args: &Value) -> ToolResult {
     match tool {
         McpTool::AssignTask => tools.assign_task(args.get("task").unwrap_or(args), args.get("message").and_then(Value::as_str)),

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

@@ -7,7 +7,7 @@ use rusqlite::{params, OptionalExtension};
 
 use crate::event_log::EventLog;
 use crate::message_store::MessageStore;
-use crate::model::enums::Provider;
+use crate::model::enums::{PaneLiveness, Provider};
 use crate::model::ids::TeamKey;
 use crate::transport::{InjectPayload, Key, PaneId, SessionName, Target, Transport, WindowName};
 
@@ -135,6 +135,61 @@ pub fn deliver_pending_message(
             channel: None,
         });
     };
+    if message.recipient == "leader" && leader_receiver_has_noncanonical_tmux_socket(state) {
+        store.mark(message_id, "failed", Some("leader_not_attached"))?;
+        event_log.write(
+            "leader_receiver.delivery_blocked",
+            serde_json::json!({
+                "message_id": message_id,
+                "sender": message.sender,
+                "reason": "leader_not_attached",
+                "channel": "rebind_required",
+                "action": "run team-agent claim-leader or team-agent takeover",
+                "error": "leader_receiver.tmux_socket is not a canonical full socket path",
+            }),
+        )?;
+        return Ok(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 or team-agent takeover".to_string(),
+            ),
+            stage: None,
+            reason: Some(DeliveryRefusal::LeaderNotAttached),
+            channel: Some("rebind_required".to_string()),
+        });
+    }
+    let delivery_transport =
+        delivery_transport_for_recipient(workspace, transport, state, &message.recipient);
+    let transport = delivery_transport.as_transport();
+    // Do not inject queued leader messages into a synthetic "leader" window.
+    if message.recipient == "leader" && !leader_receiver_pane_is_usable(transport, state) {
+        store.mark(message_id, "failed", Some("leader_not_attached"))?;
+        event_log.write(
+            "leader_receiver.delivery_blocked",
+            serde_json::json!({
+                "message_id": message_id,
+                "sender": message.sender,
+                "reason": "leader_not_attached",
+                "channel": "rebind_required",
+                "action": "run team-agent claim-leader or team-agent takeover",
+            }),
+        )?;
+        return Ok(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 or team-agent takeover".to_string(),
+            ),
+            stage: None,
+            reason: Some(DeliveryRefusal::LeaderNotAttached),
+            channel: Some("rebind_required".to_string()),
+        });
+    }
     let target = resolve_inject_target(state, &message.recipient);
     // Contract B / MUST-10 / N31/N32: physical paste+Enter into a startup trust/update
     // menu is NOT provider delivery — the menu consumes the Enter and the task text
@@ -170,12 +225,40 @@ pub fn deliver_pending_message(
         &message.content,
         message_id,
     );
-    transport.inject(
+    if let Err(error) = transport.inject(
         &target,
         &InjectPayload::Text(rendered),
         Key::Enter,
         true,
-    )?;
+    ) {
+        if message.recipient == "leader" {
+            store.mark(message_id, "failed", Some("leader_not_attached"))?;
+            event_log.write(
+                "leader_receiver.delivery_blocked",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "sender": message.sender,
+                    "reason": "leader_not_attached",
+                    "channel": "rebind_required",
+                    "action": "run team-agent claim-leader or team-agent takeover",
+                    "error": error.to_string(),
+                }),
+            )?;
+            return Ok(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 or team-agent takeover".to_string(),
+                ),
+                stage: None,
+                reason: Some(DeliveryRefusal::LeaderNotAttached),
+                channel: Some("rebind_required".to_string()),
+            });
+        }
+        return Err(error.into());
+    }
     store.mark(message_id, "delivered", None)?;
     event_log.write(
         "message.delivered",
@@ -220,7 +303,15 @@ fn render_message(sender: &str, task_id: Option<&str>, content: &str, message_id
 /// 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
 /// ("can't find pane: w1", rt-host-a loop #3). Mirrors `coordinator/tick.rs::capture_target`.
+///
+/// Leader delivery uses the bound leader receiver pane. The leader is not a worker agent and
+/// must not fall through to a synthetic `SessionWindow{window="leader"}` target.
 fn resolve_inject_target(state: &serde_json::Value, recipient: &str) -> Target {
+    if recipient == "leader" {
+        if let Some(pane_id) = leader_receiver_pane_id(state) {
+            return Target::Pane(PaneId::new(pane_id));
+        }
+    }
     let agent = state.get("agents").and_then(|a| a.get(recipient));
     if let Some(pane_id) = agent
         .and_then(|a| a.get("pane_id"))
@@ -244,6 +335,116 @@ fn resolve_inject_target(state: &serde_json::Value, recipient: &str) -> Target {
     }
 }
 
+/// Read the bound leader pane id off the projected or team-scoped runtime state.
+fn leader_receiver_pane_id(state: &serde_json::Value) -> Option<&str> {
+    leader_receiver_pane_id_in_state(state)
+        .or_else(|| active_team_entry(state).and_then(leader_receiver_pane_id_in_state))
+        .or_else(|| only_team_entry(state).and_then(leader_receiver_pane_id_in_state))
+}
+
+fn leader_receiver_pane_is_usable(transport: &dyn Transport, state: &serde_json::Value) -> bool {
+    let Some(pane_id) = leader_receiver_pane_id(state) else {
+        return false;
+    };
+    if transport
+        .list_targets()
+        .unwrap_or_default()
+        .iter()
+        .any(|target| target.pane_id.as_str() == pane_id)
+    {
+        return true;
+    }
+    !matches!(transport.liveness(&PaneId::new(pane_id)), Ok(PaneLiveness::Dead))
+}
+
+enum DeliveryTransport<'a> {
+    Borrowed(&'a dyn Transport),
+    Owned(crate::tmux_backend::TmuxBackend),
+}
+
+impl<'a> DeliveryTransport<'a> {
+    fn as_transport(&'a self) -> &'a dyn Transport {
+        match self {
+            Self::Borrowed(transport) => *transport,
+            Self::Owned(transport) => transport,
+        }
+    }
+}
+
+fn delivery_transport_for_recipient<'a>(
+    workspace: &Path,
+    product_transport: &'a dyn Transport,
+    state: &serde_json::Value,
+    recipient: &str,
+) -> DeliveryTransport<'a> {
+    if recipient != "leader" {
+        return DeliveryTransport::Borrowed(product_transport);
+    }
+    let Some(socket) = leader_receiver_tmux_socket(state) else {
+        return DeliveryTransport::Borrowed(product_transport);
+    };
+    if socket == crate::tmux_backend::socket_name_for_workspace(workspace) {
+        DeliveryTransport::Borrowed(product_transport)
+    } else {
+        DeliveryTransport::Owned(crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket))
+    }
+}
+
+fn leader_receiver_pane_id_in_state(state: &serde_json::Value) -> Option<&str> {
+    ["leader_receiver", "team_owner"].into_iter().find_map(|key| {
+        state
+            .get(key)
+            .and_then(|r| r.get("pane_id"))
+            .and_then(serde_json::Value::as_str)
+            .filter(|s| !s.is_empty())
+    })
+}
+
+fn leader_receiver_tmux_socket(state: &serde_json::Value) -> Option<&str> {
+    leader_receiver_field(state, "tmux_socket")
+}
+
+fn leader_receiver_has_noncanonical_tmux_socket(state: &serde_json::Value) -> bool {
+    leader_receiver_tmux_socket(state)
+        .is_some_and(|socket| {
+            socket != "default" && !std::path::Path::new(socket).is_absolute()
+        })
+}
+
+fn leader_receiver_field<'a>(state: &'a serde_json::Value, field: &str) -> Option<&'a str> {
+    leader_receiver_field_in_state(state, field)
+        .or_else(|| active_team_entry(state).and_then(|team| leader_receiver_field_in_state(team, field)))
+        .or_else(|| only_team_entry(state).and_then(|team| leader_receiver_field_in_state(team, field)))
+}
+
+fn leader_receiver_field_in_state<'a>(
+    state: &'a serde_json::Value,
+    field: &str,
+) -> Option<&'a str> {
+    state
+        .get("leader_receiver")
+        .and_then(|receiver| receiver.get(field))
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+}
+
+fn active_team_entry(state: &serde_json::Value) -> Option<&serde_json::Value> {
+    let team = state.get("active_team_key").and_then(serde_json::Value::as_str)?;
+    state
+        .get("teams")
+        .and_then(serde_json::Value::as_object)
+        .and_then(|teams| teams.get(team))
+}
+
+fn only_team_entry(state: &serde_json::Value) -> Option<&serde_json::Value> {
+    let teams = state.get("teams").and_then(serde_json::Value::as_object)?;
+    if teams.len() == 1 {
+        teams.values().next()
+    } else {
+        None
+    }
+}
+
 /// `_deliver_pending_messages` (`delivery.py:484`):扫 pending 队列逐条投递;busy 收件人写
 /// `send.deferred_busy` 跳过 (**不丢**,card §131)。返回投递的 message_id 列表。
 pub fn deliver_pending_messages(

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

@@ -10,7 +10,7 @@ use crate::model::ids::{OwnerEpoch, TaskId};
 use crate::transport::Transport;
 
 use super::helpers::MessageStatusShadow;
-use super::{DeliveryOutcome, DeliveryRefusal, DeliveryStatus, MessagingError};
+use super::{DeliveryOutcome, 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 /
@@ -105,40 +105,6 @@ pub fn send_to_leader_receiver(
             "result_id": result_id,
         }),
     )?;
-    // I-4: unbound leader pane → rebind_required (not the legacy diagnostic success).
-    // The row IS persisted (caller / rebind audit / future replay need the message_id),
-    // but marked `failed` so `deliver_pending_messages` does NOT pick it up — pane stays
-    // untouched, ok=false, channel=rebind_required. #231 auto-reclaim's
-    // requeue_after_claim_leader flips this row back to `accepted` after rebind, and
-    // deliver_pending replays it through the same pipeline (same message_id, exactly once).
-    let pane_attached = leader_pane_id(state)
-        .filter(|pane_id| leader_pane_is_live(workspace, pane_id))
-        .is_some();
-    if !pane_attached {
-        let _ = store.mark(&message_id, "failed", Some("leader_not_attached"));
-        event_log.write(
-            "leader_receiver.delivery_blocked",
-            serde_json::json!({
-                "message_id": message_id,
-                "sender": sender,
-                "leader_id": leader_id,
-                "owner_team_id": owner_team,
-                "reason": "leader_not_attached",
-                "channel": "rebind_required",
-                "action": "run team-agent claim-leader or team-agent takeover",
-            }),
-        )?;
-        return Ok(DeliveryOutcome {
-            ok: false,
-            status: DeliveryStatus::Blocked,
-            message_status: MessageStatusShadow("blocked".to_string()),
-            message_id: Some(message_id),
-            verification: None,
-            stage: None,
-            reason: Some(DeliveryRefusal::LeaderNotAttached),
-            channel: Some("rebind_required".to_string()),
-        });
-    }
     event_log.write(
         "leader_receiver.queued",
         serde_json::json!({
@@ -221,6 +187,15 @@ pub fn claim_leader_receiver(
         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));
+        }
     }
     crate::state::persist::save_runtime_state(workspace, state)?;
     event_log.write(
@@ -310,10 +285,17 @@ 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, pane_id))
+        .is_some_and(|pane_id| !leader_pane_is_live(workspace, state, pane_id))
 }
 
-fn leader_pane_is_live(workspace: &Path, pane_id: &str) -> bool {
+fn leader_pane_is_live(workspace: &Path, state: &Value, pane_id: &str) -> bool {
+    if let Some(socket) = leader_tmux_socket(state) {
+        return crate::tmux_backend::TmuxBackend::for_tmux_endpoint(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)
         .list_targets()
         .unwrap_or_default();
@@ -329,6 +311,13 @@ fn leader_pane_id(state: &Value) -> Option<&str> {
     leader_record_field(state, "pane_id").and_then(Value::as_str)
 }
 
+fn leader_tmux_socket(state: &Value) -> Option<&str> {
+    leader_record_field(state, "tmux_socket")
+        .and_then(Value::as_str)
+        .filter(|socket| !socket.is_empty())
+        .filter(|socket| std::path::Path::new(socket).is_absolute())
+}
+
 fn copy_candidate_field(
     out: &mut serde_json::Map<String, Value>,
     candidate: &Value,

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

@@ -394,7 +394,7 @@ pub fn report_result(
     let content = format_report_result_notification(&result_id, task_id, agent_id, status, envelope);
     let state = crate::state::persist::load_runtime_state(workspace).unwrap_or(serde_json::json!({}));
     let event_log = EventLog::new(workspace);
-    let outcome = super::leader_receiver::send_to_leader_receiver(
+    let mut outcome = super::leader_receiver::send_to_leader_receiver(
         workspace,
         &state,
         "leader",
@@ -405,10 +405,26 @@ pub fn report_result(
         Some(&result_id),
         &event_log,
     )?;
+    if matches!(outcome.status, crate::messaging::DeliveryStatus::Queued) {
+        if let Some(message_id) = outcome.message_id.clone() {
+            let store = MessageStore::open(workspace)?;
+            let transport = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
+            outcome = super::delivery::deliver_pending_message(
+                workspace,
+                &store,
+                &transport,
+                &message_id,
+                &event_log,
+                &state,
+            )?;
+        }
+    }
     let leader_notified = outcome.ok;
     let notification_status_wire = if outcome.ok {
         "delivered"
-    } else if matches!(outcome.status, crate::messaging::DeliveryStatus::Blocked) {
+    } else if outcome.channel.as_deref() == Some("rebind_required")
+        || matches!(outcome.status, crate::messaging::DeliveryStatus::Blocked)
+    {
         "rebind_required"
     } else {
         "refused"

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

@@ -8,7 +8,7 @@ use crate::model::enums::PaneLiveness;
 use crate::transport::{PaneId, Transport};
 
 use super::helpers::{status_wire, MessageStatusShadow};
-use super::leader_receiver::{leader_pane_bound_but_not_live, send_to_leader_receiver};
+use super::leader_receiver::send_to_leader_receiver;
 use super::{DeliveryOutcome, DeliveryRefusal, DeliveryStatus, MessagingError};
 
 /// 发件目标:单 target / 广播 `*` / 扇出 list (`send.py:36` `target: str|list[str]|None`)。
@@ -86,25 +86,9 @@ pub fn send_message(
         .map(|team| crate::state::projection::project_top_level_view(&raw_state, team.as_str()))
         .unwrap_or_else(|| raw_state.clone());
     backfill_leader_binding_for_delivery_view(&mut state, &raw_state);
-    let target_is_leader = matches!(target, MessageTarget::Single(target) if target == "leader");
-    if target_is_leader
-        && sender_is_leader(&state, &opts.sender)
-        && leader_pane_bound_but_not_live(workspace, &state)
-    {
-        event_log.write(
-            "leader_receiver.delivery_blocked",
-            serde_json::json!({
-                "sender": opts.sender,
-                "reason": "leader_not_attached",
-                "channel": "rebind_required",
-                "action": "run team-agent claim-leader or team-agent takeover",
-            }),
-        )?;
-        return Ok(rebind_required_outcome(None));
-    }
     let recipient = match target {
         MessageTarget::Single(target) if target == "leader" => {
-            return send_to_leader_receiver(
+            let outcome = send_to_leader_receiver(
                 workspace,
                 &state,
                 "leader",
@@ -114,7 +98,19 @@ pub fn send_message(
                 opts.requires_ack,
                 None,
                 &event_log,
-            );
+            )?;
+            if matches!(outcome.status, DeliveryStatus::Queued) && owner_pane_is_dead(&state) {
+                if let Some(message_id) = outcome.message_id.clone() {
+                    let team_key = owner_gate_hint_team_key(&state);
+                    if !explicit_claim_applied(workspace, &team_key, "") {
+                        return Ok(rebind_required_outcome_with_verification(
+                            Some(message_id),
+                            format!("team-agent claim-leader --team {team_key}"),
+                        ));
+                    }
+                }
+            }
+            return Ok(outcome);
         }
         MessageTarget::Single(target) if target.is_empty() => {
             return Ok(refused_outcome(DeliveryRefusal::UnknownRecipient));