@team-agent/installer 0.5.73 → 0.5.74

package/crates/team-agent/src/lifecycle/launch/quick_start_transport.rs

@@ -183,13 +183,23 @@ pub(crate) fn annotate_runtime_tmux_endpoint(
     transport: &dyn Transport,
     workspace: &Path,
 ) {
-    let transport_endpoint = transport.tmux_endpoint();
-    let endpoint = crate::tmux_backend::owning_tmux_endpoint_from_state(state)
-        .map(|(endpoint, _source)| endpoint.to_string())
-        .or_else(|| transport_endpoint.clone());
-    let Some(endpoint) = endpoint else {
+    let Some(transport_endpoint) = transport.tmux_endpoint() else {
         return;
     };
+    let persisted_endpoint = ["tmux_endpoint", "tmux_socket"]
+        .into_iter()
+        .find_map(|key| {
+            state
+                .get(key)
+                .and_then(serde_json::Value::as_str)
+                .filter(|endpoint| !endpoint.is_empty())
+        });
+    // The worker endpoint is its own authority. A restart/add-agent spawn
+    // must not let an independently-bound leader receiver rewrite it.
+    if persisted_endpoint.is_some_and(|endpoint| endpoint != transport_endpoint.as_str()) {
+        return;
+    }
+    let endpoint = transport_endpoint.clone();
     let endpoint_for_state = if Path::new(&endpoint).is_absolute() || endpoint == "default" {
         endpoint.clone()
     } else if endpoint == crate::tmux_backend::socket_name_for_workspace(workspace) {
@@ -212,7 +222,7 @@ pub(crate) fn annotate_runtime_tmux_endpoint(
                 .cloned()
                 .unwrap_or(serde_json::Value::Null),
         );
-        if transport_endpoint.as_deref() == Some(endpoint.as_str()) {
+        if transport_endpoint == endpoint {
             if let Some(source) = selected_tmux_socket_source(transport, workspace) {
                 obj.insert("tmux_socket_source".to_string(), serde_json::json!(source));
             }

package/crates/team-agent/src/lifecycle/launch/state_projection.rs

@@ -577,15 +577,17 @@ pub(super) fn seeded_pane_looks_like_worker(pane: &str, started: &[StartedAgent]
 }
 
 /// ---
-/// purpose: 给出 worker 侧使用的 tmux socket 名
-/// returns: transport 是 tmux 后端时按 workspace 推出 socket 名，否则 None
+/// purpose: 给出 worker 侧实际使用的 tmux endpoint
+/// returns: transport 是 tmux 后端时优先返回 transport endpoint；缺失时按 workspace 推出 socket 名，否则 None
 /// ---
 pub(super) fn launched_worker_tmux_socket(
     transport: &dyn Transport,
     workspace: &Path,
 ) -> Option<String> {
     if matches!(transport.kind(), crate::transport::BackendKind::Tmux) {
-        Some(crate::tmux_backend::socket_name_for_workspace(workspace))
+        transport
+            .tmux_endpoint()
+            .or_else(|| Some(crate::tmux_backend::socket_name_for_workspace(workspace)))
     } else {
         None
     }

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -976,14 +976,6 @@ pub(super) fn lifecycle_worker_tmux_backend_selection_for_state(
             )));
         }
     }
-    if let Some((endpoint, source)) = crate::tmux_backend::owning_tmux_endpoint_from_state(state) {
-        let backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint);
-        return Ok(crate::tmux_backend::RuntimeTmuxBackendSelection {
-            tmux_endpoint_used: backend.tmux_endpoint(),
-            backend,
-            tmux_endpoint_source: source,
-        });
-    }
     Ok(
         crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
             run_workspace,
@@ -1000,9 +992,6 @@ pub(super) fn lifecycle_worker_tmux_backend_for_state(
     run_workspace: &Path,
     state: &serde_json::Value,
 ) -> crate::tmux_backend::TmuxBackend {
-    if let Some((endpoint, _source)) = crate::tmux_backend::owning_tmux_endpoint_from_state(state) {
-        return crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint);
-    }
     crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(run_workspace, Some(state))
         .backend
 }

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

@@ -3496,6 +3496,66 @@ fn add_agent_resolves_to_persisted_endpoint_socket_not_workspace_hash() {
     );
 }
 
+/// **Regression guard**: lifecycle worker resolution must ignore the leader
+/// receiver endpoint. The receiver may live on the caller's default socket
+/// while workers/coordinator remain on their persisted private socket.
+#[test]
+fn lifecycle_worker_resolver_prefers_persisted_worker_over_leader_receiver() {
+    let team = temp_ws().join("addteam-split-leader-worker-endpoints");
+    std::fs::create_dir_all(&team).unwrap();
+    let worker_endpoint = "/private/tmp/tmux-501/ta-worker";
+    let leader_endpoint = "/private/tmp/tmux-501/default";
+    crate::state::persist::save_runtime_state(
+        &team,
+        &json!({
+            "session_name": "team-split",
+            "tmux_endpoint": worker_endpoint,
+            "tmux_socket": worker_endpoint,
+            "leader_receiver": {
+                "pane_id": "%169",
+                "tmux_socket": leader_endpoint,
+                "status": "attached"
+            },
+            "agents": {}
+        }),
+    )
+    .unwrap();
+
+    let resolved = crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
+        &team, None,
+    )
+    .expect("resolver must succeed when state has worker and receiver endpoints");
+    let endpoint = <crate::tmux_backend::TmuxBackend as crate::transport::Transport>::tmux_endpoint(
+        &resolved,
+    );
+    assert_eq!(
+        endpoint.as_deref(),
+        Some(worker_endpoint),
+        "worker lifecycle operations must stay on persisted worker endpoint, not leader receiver"
+    );
+}
+
+/// **Regression guard**: annotating a worker spawn must not overwrite a
+/// persisted worker endpoint with the independent leader receiver endpoint.
+#[test]
+fn annotate_runtime_tmux_endpoint_does_not_follow_leader_receiver() {
+    let worker_endpoint = "/private/tmp/tmux-501/ta-worker";
+    let leader_endpoint = "/private/tmp/tmux-501/default";
+    let mut state = json!({
+        "tmux_endpoint": worker_endpoint,
+        "tmux_socket": worker_endpoint,
+        "leader_receiver": {"tmux_socket": leader_endpoint}
+    });
+    let transport = OfflineTransport::new().with_tmux_endpoint(worker_endpoint);
+    crate::lifecycle::launch::annotate_runtime_tmux_endpoint(
+        &mut state,
+        &transport,
+        std::path::Path::new("/tmp/annotate-split"),
+    );
+    assert_eq!(state["tmux_endpoint"], json!(worker_endpoint));
+    assert_eq!(state["tmux_socket"], json!(worker_endpoint));
+}
+
 /// **Regression guard**: cold workspace (no persisted endpoint) must safely
 /// fall back to `TmuxBackend::for_workspace(workspace)`. Encodes the
 /// first-agent / fresh-launch path so a future refactor doesn't accidentally

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

@@ -243,3 +243,34 @@ fn pi_role_tools_validate_team_capabilities_without_replacing_direct_pi_tools()
         "role tools validate Team Agent capabilities but must not replace direct Pi tools: {argv:?}"
     );
 }
+
+#[test]
+fn pi_role_rejects_unsupported_categories_during_compile() {
+    compile_pi_role(&valid_role_with("")).expect("supported Pi tools must compile");
+
+    for unsupported in ["git_diff", "network", "provider_builtin"] {
+        let role = valid_role_with("").replace(
+            "  - execute_bash\n",
+            &format!("  - execute_bash\n  - {unsupported}\n"),
+        );
+        let error = compile_error(compile_pi_role(&role)).to_string();
+        assert!(
+            error.contains(&format!("Pi does not support Team Agent tool category {unsupported:?}")),
+            "compile must reject {unsupported} before launch preparation: {error}"
+        );
+        assert!(
+            error.contains("remove it from the role's tools"),
+            "compile error must provide an actionable fix: {error}"
+        );
+    }
+
+    let alias = valid_role_with("").replace(
+        "  - execute_bash\n",
+        "  - execute_bash\n  - \"@builtin\"\n",
+    );
+    let error = compile_error(compile_pi_role(&alias)).to_string();
+    assert!(
+        error.contains("Pi does not support Team Agent tool category \"provider_builtin\""),
+        "@builtin must use the same Pi capability contract: {error}"
+    );
+}

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

@@ -320,26 +320,26 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
         .get("agents")
         .cloned()
         .expect("fixture agents");
-    let owning_socket = "/private/tmp/tmux-501/ta-owning-team";
+    let receiver_socket = "/private/tmp/tmux-501/ta-leader-receiver";
     let owning_session = "team-agent-leader-pi-owning-team";
-    let wrong_socket = "/private/tmp/tmux-501/ta-workspace-derived";
+    let worker_socket = "/private/tmp/tmux-501/ta-worker-persisted";
     crate::state::persist::save_runtime_state(
         &success_team,
         &json!({
             "active_team_key": "dynamic-success",
-            "tmux_endpoint": wrong_socket,
-            "tmux_socket": wrong_socket,
+            "tmux_endpoint": worker_socket,
+            "tmux_socket": worker_socket,
             "teams": {
                 "dynamic-success": {
                     "agents": success_agents,
                     "team_dir": success_team,
                     "session_name": null,
-                    "tmux_endpoint": wrong_socket,
-                    "tmux_socket": wrong_socket,
+                    "tmux_endpoint": worker_socket,
+                    "tmux_socket": worker_socket,
                     "leader_receiver": {
                         "status": "attached",
                         "session_name": owning_session,
-                        "tmux_socket": owning_socket
+                        "tmux_socket": receiver_socket
                     }
                 }
             }
@@ -351,15 +351,15 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
             &success_team,
             Some("dynamic-success"),
         )
-        .expect("resolve selected owning transport");
+        .expect("resolve selected worker transport");
     assert_eq!(
         selected_transport.tmux_endpoint().as_deref(),
-        Some(owning_socket),
-        "nested selected-team receiver must beat stale top-level and team socket fields"
+        Some(worker_socket),
+        "lifecycle worker transport must use persisted worker endpoint, not receiver endpoint"
     );
     let mut annotation_state =
         crate::state::persist::load_runtime_state(&success_team).expect("load annotation fixture");
-    let wrong_transport = OfflineTransport::new().with_tmux_endpoint(wrong_socket);
+    let wrong_transport = OfflineTransport::new().with_tmux_endpoint(worker_socket);
     crate::lifecycle::launch::annotate_runtime_tmux_endpoint(
         &mut annotation_state,
         &wrong_transport,
@@ -369,18 +369,18 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
         annotation_state
             .get("tmux_endpoint")
             .and_then(serde_json::Value::as_str),
-        Some(owning_socket),
-        "worker-derived annotation must not clobber the owning endpoint"
+        Some(worker_socket),
+        "worker-derived annotation must preserve the persisted worker endpoint"
     );
     assert_eq!(
         annotation_state
             .pointer("/teams/dynamic-success/leader_receiver/tmux_socket")
             .and_then(serde_json::Value::as_str),
-        Some(owning_socket)
+        Some(receiver_socket)
     );
     let success_transport = OfflineTransport::new()
         .with_session_present(true)
-        .with_tmux_endpoint(owning_socket);
+        .with_tmux_endpoint(worker_socket);
     crate::lifecycle::add_agent_with_transport(
         &success_team,
         &AgentId::new("mate"),
@@ -516,8 +516,8 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
             &live,
             &json!({
                 "active_team_key": "current",
-                "tmux_endpoint": wrong_socket,
-                "tmux_socket": wrong_socket,
+                "tmux_endpoint": worker_socket,
+                "tmux_socket": worker_socket,
                 "agents": {
                     "implementer": {
                         "status": "running",
@@ -532,6 +532,8 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
                         "status": "alive",
                         "team_dir": live,
                         "session_name": null,
+                        "tmux_endpoint": worker_socket,
+                        "tmux_socket": worker_socket,
                         "agents": {
                             "implementer": {
                                 "status": "running",
@@ -655,9 +657,9 @@ int main(int argc, char **argv) {
 
         let preflight = run_file_h_command_with_deadline(
             std::process::Command::new(&shim)
-                .args(["-S", live_socket, "has-session"])
+                .args(["-S", worker_socket, "has-session"])
                 .env("TEAM_AGENT_PI_TMUX_LOG", shim_root.join("preflight.log"))
-                .env("TEAM_AGENT_PI_OWNING_SOCKET", live_socket)
+                .env("TEAM_AGENT_PI_OWNING_SOCKET", worker_socket)
                 .env("TEAM_AGENT_PI_OWNING_SESSION", live_session)
                 .env("TEAM_AGENT_PI_RUN_WORKSPACE", &live),
             "File-H native fake has-session preflight",
@@ -678,7 +680,7 @@ int main(int argc, char **argv) {
         .expect("join native shim PATH");
         let _path = EnvVarGuard::set("PATH", joined_path);
         let _log = EnvVarGuard::set("TEAM_AGENT_PI_TMUX_LOG", &shim_log);
-        let _socket = EnvVarGuard::set("TEAM_AGENT_PI_OWNING_SOCKET", live_socket);
+        let _socket = EnvVarGuard::set("TEAM_AGENT_PI_OWNING_SOCKET", worker_socket);
         let _session = EnvVarGuard::set("TEAM_AGENT_PI_OWNING_SESSION", live_session);
         let _workspace = EnvVarGuard::set("TEAM_AGENT_PI_RUN_WORKSPACE", &live);
 
@@ -689,15 +691,15 @@ int main(int argc, char **argv) {
         );
         let result = tools
             .add_agent("mate", "roles/mate.md")
-            .expect("public MCP add must use the nested owning receiver");
+            .expect("public MCP add must use the persisted worker endpoint");
         assert_eq!(
             result.fields.get("ok").and_then(serde_json::Value::as_bool),
             Some(true)
         );
         let tmux_argv = std::fs::read_to_string(&shim_log).expect("read tmux shim log");
         assert!(
-            tmux_argv.contains(&format!("-S {live_socket}")),
-            "public add must address the selected owning socket: {tmux_argv}"
+            tmux_argv.contains(&format!("-S {worker_socket}")),
+            "public add must address the persisted worker socket: {tmux_argv}"
         );
         assert!(
             tmux_argv.contains(&format!(

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

@@ -2866,7 +2866,9 @@ fn project_state_for_owner_team(
             return Ok(OwnerTeamProjection::Refused(outcome));
         }
     };
-    if top_level_state_matches_owner_team(fallback, &canonical_team) {
+    if top_level_state_matches_owner_team(fallback, &canonical_team)
+        && state_has_no_team_entries(fallback)
+    {
         let mut state = fallback.clone();
         carry_top_level_leader_binding(&mut state, &raw);
         return Ok(OwnerTeamProjection::Projected {
@@ -2874,7 +2876,8 @@ fn project_state_for_owner_team(
             canonical_team,
         });
     }
-    if top_level_state_matches_owner_team(&raw, &canonical_team) {
+    if top_level_state_matches_owner_team(&raw, &canonical_team) && state_has_no_team_entries(&raw)
+    {
         return Ok(OwnerTeamProjection::Projected {
             state: raw,
             canonical_team,
@@ -2999,16 +3002,31 @@ fn project_state_for_owner_team_value(
     None
 }
 
-fn top_level_state_matches_owner_team(state: &serde_json::Value, team: &str) -> bool {
-    state
+pub(crate) fn top_level_state_matches_owner_team(state: &serde_json::Value, team: &str) -> bool {
+    if !state.is_object() {
+        return false;
+    }
+    if state
         .get("active_team_key")
         .and_then(serde_json::Value::as_str)
         .is_some_and(|value| value == team)
-        || crate::state::projection::team_state_key(state) == team
-        || state
-            .get("session_name")
+    {
+        return true;
+    }
+    if state
+        .get("session_name")
+        .and_then(serde_json::Value::as_str)
+        .is_some_and(|session| session == team || session.strip_prefix("team-") == Some(team))
+    {
+        return true;
+    }
+    let has_explicit_key = ["team_key", "team_dir", "spec_path"].iter().any(|field| {
+        state
+            .get(*field)
             .and_then(serde_json::Value::as_str)
-            .is_some_and(|session| session == team || session.strip_prefix("team-") == Some(team))
+            .is_some_and(|value| !value.is_empty())
+    });
+    has_explicit_key && crate::state::projection::team_state_key(state) == team
 }
 
 /// `retry_injection_after_trust_auto_answer` (`trust_auto_answer.py`):leader 路径 trust 应答

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::transport::test_support::OfflineTransport;
+use crate::transport::{PaneId, Target};
 
 fn pane_info(pane_id: &str, session: &str, window: &str) -> PaneInfo {
     PaneInfo {
@@ -3421,3 +3422,236 @@ fn gate054_fallback_pane_grep_guard_no_cross_server_chain_when_socket_recorded()
         "fallback injection must consume the shared resolver's typed channel"
     );
 }
+
+fn delivery_blocked_channel_reasons(ws: &std::path::Path) -> Vec<String> {
+    EventLog::new(ws)
+        .tail(80)
+        .unwrap()
+        .into_iter()
+        .filter(|event| event.get("event") == Some(&serde_json::json!("leader_receiver.delivery_blocked")))
+        .filter_map(|event| {
+            event
+                .get("channel_reason")
+                .and_then(serde_json::Value::as_str)
+                .map(str::to_string)
+        })
+        .collect()
+}
+
+fn live_leader_pane(ws: &std::path::Path, pane_id: &str) -> PaneInfo {
+    let mut pane = pane_info(pane_id, "team-current", "leader");
+    pane.current_path = Some(ws.to_path_buf());
+    pane
+}
+
+#[test]
+fn owner_projection_null_fallback_projects_nested_current_receiver() {
+    let ws = tmp_ws("proj-null-current");
+    let state = serde_json::json!({
+        "active_team_key": "current",
+        "team_key": "current",
+        "teams": {
+            "current": {
+                "team_key": "current",
+                "leader_receiver": {
+                    "status": "attached",
+                    "mode": "direct_tmux",
+                    "pane_id": "%9"
+                },
+                "agents": {}
+            }
+        },
+        "agents": {}
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(None, "w1", "leader", "nested current", None, false, Some("current"))
+        .unwrap();
+    let transport = OfflineTransport::new().with_targets(vec![live_leader_pane(&ws, "%9")]);
+
+    let out = deliver_pending_message(&ws, &store, &transport, &message_id, &log, &serde_json::json!({}))
+        .unwrap();
+
+    assert!(
+        !delivery_blocked_channel_reasons(&ws)
+            .iter()
+            .any(|reason| reason == "receiver_missing"),
+        "fresh Null fallback must project teams.current, not return Null; out={out:?} reasons={:?}",
+        delivery_blocked_channel_reasons(&ws)
+    );
+    assert_eq!(
+        transport.inject_targets(),
+        vec![Target::Pane(PaneId::new("%9"))],
+        "nested current receiver must select pane %9; out={out:?}"
+    );
+}
+
+#[test]
+fn owner_projection_non_object_does_not_match_current() {
+    assert!(
+        !crate::messaging::delivery::top_level_state_matches_owner_team(
+            &serde_json::Value::Null,
+            "current"
+        ),
+        "Null must not match current through team_state_key default"
+    );
+    assert!(
+        !crate::messaging::delivery::top_level_state_matches_owner_team(
+            &serde_json::json!([]),
+            "current"
+        ),
+        "non-object must not match current"
+    );
+}
+
+#[test]
+fn owner_projection_legacy_top_level_receiver_survives_null_fallback() {
+    let ws = tmp_ws("proj-legacy-top");
+    let state = serde_json::json!({
+        "active_team_key": "current",
+        "leader_receiver": {
+            "status": "attached",
+            "mode": "direct_tmux",
+            "pane_id": "%3"
+        },
+        "agents": {}
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(None, "w1", "leader", "legacy top", None, false, Some("current"))
+        .unwrap();
+    let transport = OfflineTransport::new().with_targets(vec![live_leader_pane(&ws, "%3")]);
+
+    let out = deliver_pending_message(&ws, &store, &transport, &message_id, &log, &serde_json::json!({}))
+        .unwrap();
+
+    assert!(
+        !delivery_blocked_channel_reasons(&ws)
+            .iter()
+            .any(|reason| reason == "receiver_missing"),
+        "legacy top-level receiver must remain usable; out={out:?}"
+    );
+    assert_eq!(
+        transport.inject_targets(),
+        vec![Target::Pane(PaneId::new("%3"))],
+        "legacy top-level receiver must select pane %3; out={out:?}"
+    );
+}
+
+#[test]
+fn owner_projection_missing_selected_does_not_borrow_sibling() {
+    let ws = tmp_ws("proj-no-sibling");
+    let state = serde_json::json!({
+        "active_team_key": "alpha",
+        "team_key": "alpha",
+        "teams": {
+            "alpha": {
+                "team_key": "alpha",
+                "agents": {}
+            },
+            "beta": {
+                "team_key": "beta",
+                "leader_receiver": {
+                    "status": "attached",
+                    "mode": "direct_tmux",
+                    "pane_id": "%beta"
+                },
+                "agents": {}
+            }
+        },
+        "agents": {}
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(None, "w1", "leader", "alpha has no receiver", None, false, Some("alpha"))
+        .unwrap();
+    let transport = OfflineTransport::new().with_targets(vec![live_leader_pane(&ws, "%beta")]);
+
+    let out = deliver_pending_message(&ws, &store, &transport, &message_id, &log, &serde_json::json!({}))
+        .unwrap();
+
+    assert!(
+        delivery_blocked_channel_reasons(&ws)
+            .iter()
+            .any(|reason| reason == "receiver_missing"),
+        "alpha must not borrow beta's receiver; out={out:?} reasons={:?}",
+        delivery_blocked_channel_reasons(&ws)
+    );
+    assert_eq!(transport.inject_targets().len(), 0, "must not inject into the sibling pane");
+}
+
+#[test]
+fn owner_projection_peer_inject_uses_nested_worker_pane_not_top_level() {
+    let ws = tmp_ws("proj-peer-nested");
+    let state = serde_json::json!({
+        "active_team_key": "teamA",
+        "session_name": "team-top",
+        "agents": {
+            "worker_b": {
+                "provider": "fake",
+                "status": "running",
+                "window": "worker_b",
+                "pane_id": "%top-b"
+            }
+        },
+        "teams": {
+            "teamA": {
+                "session_name": "team-nested",
+                "agents": {
+                    "worker_b": {
+                        "provider": "fake",
+                        "status": "running",
+                        "window": "worker_b",
+                        "pane_id": "%nested-b"
+                    }
+                }
+            }
+        }
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(
+            None,
+            "worker_a",
+            "worker_b",
+            "MCP_SIM_BROADCAST_CANARY",
+            None,
+            false,
+            Some("teamA"),
+        )
+        .unwrap();
+    let transport = OfflineTransport::new().with_targets(vec![
+        pane_info("%top-b", "team-top", "worker_b"),
+        pane_info("%nested-b", "team-nested", "worker_b"),
+    ]);
+
+    let out = deliver_pending_message(
+        &ws,
+        &store,
+        &transport,
+        &message_id,
+        &log,
+        &serde_json::json!({}),
+    )
+    .unwrap();
+
+    let targets = transport.inject_targets();
+    assert!(
+        !targets.is_empty(),
+        "owner teamA peer inject must attempt the nested worker pane; out={out:?}"
+    );
+    assert!(
+        targets
+            .iter()
+            .all(|target| target == &Target::Pane(PaneId::new("%nested-b"))),
+        "owner teamA peer inject must select nested worker pane %nested-b, not top-level %top-b; out={out:?} targets={targets:?}"
+    );
+}