@team-agent/installer 0.5.73 → 0.5.75

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/spawn.rs

@@ -277,6 +277,10 @@ pub(super) fn spawn_agents(
                 provider,
             ),
         );
+        // The provider is the final typed value after profile overlays. Keep it
+        // separate from inherited LEADER_* identity and let the tmux invocation
+        // boundary add the actual pane/socket only for the provider process.
+        crate::layout::worker_env::inject_current_caller_provider(&mut env, provider);
         // BUG / C-1-2 / C-6-1 cr verdict — Copilot system_prompt 走 spawn env overlay +
         // per-worker AGENTS.md(B2 灵魂件降级):写
         //   <workspace>/.team/runtime/copilot-instructions/<agent_id>/AGENTS.md

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

@@ -51,6 +51,10 @@
 //! sites can reference the phases by name. The phase fns themselves
 //! remain in launch.rs until the next batch of relocations.
 
+#[cfg(test)]
+#[path = "../../../tests/support/hermetic.rs"]
+mod hermetic;
+
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -66,16 +70,14 @@ use crate::transport::{PaneId, SessionName, Target, Transport, WindowName};
 use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
 
 use super::identity::spec_display_backend;
-use super::leader_context::{
-    attributed_provider_for_pane_across_tmux_sockets, caller_provider_for_seed_with_lookup,
-    seed_unbound_launched_owner,
-};
+use super::leader_context::{caller_provider_for_seed_with_lookup, seed_unbound_launched_owner};
 use super::worker_env::spawn_timestamp;
 
 /// ---
 /// purpose: 由 spec 生成首份 runtime state 树
 /// params:
 ///   team_key: 本团队的 runtime 键
+///   scoped_endpoint: 本次起队已选中的 transport tmux endpoint，与 fresh bind 同源
 /// returns: 含 spec_path、workspace、team_dir、session_name、leader、agents、tasks 与 display_backend 的 state；随后按环境种入 launched owner，种不到则种一份 unbound owner
 /// ---
 pub(super) fn initial_runtime_state(
@@ -84,6 +86,7 @@ pub(super) fn initial_runtime_state(
     workspace: &Path,
     team_dir: &Path,
     team_key: &str,
+    scoped_endpoint: Option<&str>,
 ) -> serde_json::Value {
     let mut agents = serde_json::Map::new();
     for agent in spec_agent_values(spec) {
@@ -144,7 +147,7 @@ pub(super) fn initial_runtime_state(
     );
     state.insert("is_external_leader".to_string(), serde_json::json!(false));
     let mut state = serde_json::Value::Object(state);
-    if !seed_launched_owner_from_env(&mut state) {
+    if !seed_launched_owner_from_env(&mut state, scoped_endpoint) {
         let team_id = crate::state::projection::team_state_key(&state);
         seed_unbound_launched_owner(&mut state, &team_id);
     }
@@ -157,9 +160,12 @@ pub(super) fn initial_runtime_state(
 ///   state: 待改写的 state，成功时写入 owner 与 leader receiver
 /// returns: true 表示已种入，取不到 caller 身份或无 pane 时为 false
 /// ---
-pub(super) fn seed_launched_owner_from_env(state: &mut serde_json::Value) -> bool {
+pub(super) fn seed_launched_owner_from_env(
+    state: &mut serde_json::Value,
+    scoped_endpoint: Option<&str>,
+) -> bool {
     let team_id = crate::state::projection::team_state_key(state);
-    let Ok(caller) = crate::state::identity::caller_identity_from_env(
+    let Ok(mut caller) = crate::state::identity::caller_identity_from_env(
         Some(state),
         &crate::state::identity::SystemEnv,
         Some(&team_id),
@@ -167,11 +173,27 @@ pub(super) fn seed_launched_owner_from_env(state: &mut serde_json::Value) -> boo
     ) else {
         return false;
     };
-    seed_launched_owner_from_caller_with_provider_lookup(
-        state,
-        caller,
-        attributed_provider_for_pane_across_tmux_sockets,
-    )
+    let current_pane = std::env::var("TMUX_PANE")
+        .ok()
+        .filter(|pane| !pane.is_empty());
+    let current_endpoint = crate::tmux_backend::socket_name_from_tmux_env();
+    match crate::layout::worker_env::caller_provider_resolution(
+        current_pane.as_deref(),
+        current_endpoint.as_deref(),
+        scoped_endpoint,
+    ) {
+        crate::layout::worker_env::CallerProviderResolution::Invalid => return false,
+        crate::layout::worker_env::CallerProviderResolution::Valid(provider) => {
+            caller.provider = crate::provider::wire::provider_wire(provider).to_string();
+        }
+        crate::layout::worker_env::CallerProviderResolution::Absent => {}
+    }
+    // Absent keeps the existing explicit/direct pane path. Do not unbind a
+    // caller TMUX_PANE just because launcher context and LEADER_PROVIDER are
+    // both missing; that is the external-leader same-id-across-sockets case.
+    // Invalid already returned. Do not replace a missing provider with broad
+    // pane/process attribution.
+    seed_launched_owner_from_caller_with_provider_lookup(state, caller, |_| None)
 }
 
 /// ---
@@ -619,9 +641,13 @@ pub(super) fn team_workspace(team_dir: &Path) -> PathBuf {
 
 #[cfg(test)]
 mod tests {
-    #![allow(clippy::unwrap_used)]
+    #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
     use super::*;
+    use crate::layout::worker_env::{CALLER_ENDPOINT_ENV, CALLER_PANE_ENV, CALLER_PROVIDER_ENV};
     use crate::model::enums::Provider;
+    use serde_json::json;
+
+    use super::hermetic::HermeticTestEnv;
 
     fn yaml_agent(bypass: bool) -> Value {
         crate::model::yaml::loads(&format!(
@@ -651,4 +677,103 @@ mod tests {
         assert!(!safety.enabled);
         assert_eq!(safety.source, DangerousApprovalSource::Disabled);
     }
+
+    fn seed_state() -> serde_json::Value {
+        json!({
+            "team_key": "verify031",
+            "workspace": "/tmp/ws",
+            "session_name": "team-verify031",
+            "agents": {}
+        })
+    }
+
+    fn owner_pane(state: &serde_json::Value) -> Option<&str> {
+        state
+            .pointer("/teams/verify031/team_owner/pane_id")
+            .and_then(serde_json::Value::as_str)
+    }
+
+    fn owner_provider(state: &serde_json::Value) -> Option<&str> {
+        state
+            .pointer("/teams/verify031/team_owner/provider")
+            .and_then(serde_json::Value::as_str)
+    }
+
+    fn receiver_pane(state: &serde_json::Value) -> Option<&str> {
+        state
+            .pointer("/teams/verify031/leader_receiver/pane_id")
+            .and_then(serde_json::Value::as_str)
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn seed_absent_caller_keeps_direct_tmux_pane_without_unbinding() {
+        let hermetic = HermeticTestEnv::enter("seed-absent-direct-pane");
+        let _tmux = hermetic.with_env("TMUX", "/tmp/default-tmux-socket,123,0");
+        let _pane = hermetic.with_env("TMUX_PANE", "%0");
+        let mut state = seed_state();
+        assert!(
+            seed_launched_owner_from_env(&mut state, Some("/tmp/product-team.sock")),
+            "Absent caller context must still seed the caller's TMUX_PANE; state={state}"
+        );
+        assert_eq!(owner_pane(&state), Some("%0"));
+        assert_eq!(receiver_pane(&state), Some("%0"));
+        assert!(
+            owner_provider(&state).is_none(),
+            "direct pane seed must not invent a provider; state={state}"
+        );
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn seed_valid_caller_uses_typed_provider_and_same_scoped_endpoint() {
+        let hermetic = HermeticTestEnv::enter("seed-valid-scoped");
+        let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
+        let _pane = hermetic.with_env("TMUX_PANE", "%1");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
+        let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
+        let mut state = seed_state();
+        assert!(seed_launched_owner_from_env(
+            &mut state,
+            Some("/tmp/tmux.sock")
+        ));
+        assert_eq!(owner_pane(&state), Some("%1"));
+        assert_eq!(owner_provider(&state), Some("pi"));
+        assert_eq!(receiver_pane(&state), Some("%1"));
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn seed_invalid_caller_does_not_fall_back_to_direct_pane() {
+        let hermetic = HermeticTestEnv::enter("seed-invalid-scoped");
+        let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
+        let _pane = hermetic.with_env("TMUX_PANE", "%1");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
+        let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
+        let mut state = seed_state();
+        assert!(
+            !seed_launched_owner_from_env(&mut state, Some("/tmp/product.sock")),
+            "scoped endpoint mismatch must fail closed; state={state}"
+        );
+        assert!(owner_pane(&state).is_none(), "state={state}");
+        assert!(receiver_pane(&state).is_none(), "state={state}");
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn seed_absent_keeps_explicit_leader_provider() {
+        let hermetic = HermeticTestEnv::enter("seed-absent-explicit");
+        let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
+        let _pane = hermetic.with_env("TMUX_PANE", "%3");
+        let _leader = hermetic.with_env("TEAM_AGENT_LEADER_PROVIDER", "pi");
+        let mut state = seed_state();
+        assert!(seed_launched_owner_from_env(
+            &mut state,
+            Some("/tmp/tmux.sock")
+        ));
+        assert_eq!(owner_pane(&state), Some("%3"));
+        assert_eq!(owner_provider(&state), Some("pi"));
+    }
 }

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

@@ -523,6 +523,9 @@ pub(super) fn spawn_agent_window(
             provider,
         ),
     );
+    // Keep the launcher-known typed provider independent from inherited
+    // LEADER_* identity. The tmux wrapper binds pane/socket at invocation time.
+    crate::layout::worker_env::inject_current_caller_provider(&mut env, provider);
 
     // 0.4.6 Stage 2: write actual spawn plan event BEFORE invoking the
     // transport spawn. Mirrors `launch.rs:359-380` (the reference impl)
@@ -976,14 +979,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 +995,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!(