@team-agent/installer 0.5.72 → 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/spawn.rs

@@ -189,6 +189,7 @@ pub(super) fn spawn_agents(
                     tool_categories: &resolved_tool_refs,
                     team_mcp_tools: &["send_message", "report_result"],
                     mcp_config: &mcp_config,
+                    session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
                 },
             )
             .map_err(|e| LifecycleError::Provider(e.to_string()))?

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

@@ -402,6 +402,7 @@ pub(super) fn spawn_agent_window(
             tool_categories: &resolved_tool_refs,
             team_mcp_tools: &["send_message", "report_result"],
             mcp_config: &mcp_config,
+            session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
         };
         match resume_session_id {
             Some(session_id) => {
@@ -975,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,
@@ -999,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_catalog_red.rs

@@ -22,7 +22,7 @@ fn command_for_model(model: &str) -> Vec<String> {
         effort: Some(ProviderEffort::Medium),
         system_prompt: "worker contract",
         tool_categories: &["mcp_team"],
-        session_dir: Path::new("/workspace/.team/runtime/pi/t1/w1/sessions"),
+        session_dir: Some(Path::new("/workspace/.team/runtime/pi/t1/w1/sessions")),
         session: PiSessionSelector::Fresh {
             session_id: "716ba0cb-c491-4471-b41a-43c8d5e1f05a",
         },

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

@@ -1,5 +1,6 @@
 use std::path::Path;
 
+use crate::lifecycle::launch::pi_mcp::{pi_leader_session_scope, PiSessionScope};
 use crate::model::enums::ProviderEffort;
 use crate::provider::adapters::pi::{build_pi_command_argv, PiCommandRequest, PiSessionSelector};
 
@@ -11,7 +12,9 @@ fn request(session: PiSessionSelector<'static>) -> PiCommandRequest<'static> {
         effort: Some(ProviderEffort::High),
         system_prompt: "frozen worker prompt",
         tool_categories: &["mcp_team", "fs_read", "fs_write", "execute_bash"],
-        session_dir: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/sessions"),
+        session_dir: Some(Path::new(
+            "/workspace/.team/runtime/pi/team-a/worker-a/sessions",
+        )),
         session,
         agent_id: "worker-a",
     }
@@ -30,6 +33,73 @@ fn pi_command_omits_unset_model_and_thinking_flags() {
     assert!(!argv.iter().any(|arg| arg == "--thinking"), "argv={argv:?}");
 }
 
+fn leader_request() -> PiCommandRequest<'static> {
+    PiCommandRequest {
+        executable: Path::new("/verified/pi"),
+        extension: Path::new("/workspace/.team/runtime/pi/current/leader/team-mcp.ts"),
+        model: None,
+        effort: None,
+        system_prompt: "frozen leader prompt",
+        tool_categories: &["mcp_team", "fs_read", "fs_write", "execute_bash"],
+        session_dir: None,
+        session: PiSessionSelector::Fresh {
+            session_id: "da8c3622-2378-4d05-a26c-e826a6ef6d63",
+        },
+        agent_id: "leader",
+    }
+}
+
+#[test]
+fn pi_interactive_leader_argv_preserves_native_session_discovery() {
+    let argv = build_pi_command_argv(leader_request()).expect("native Pi leader command");
+
+    assert_eq!(
+        argv,
+        [
+            "/verified/pi",
+            "-e",
+            "/workspace/.team/runtime/pi/current/leader/team-mcp.ts",
+            "--append-system-prompt",
+            "frozen leader prompt",
+            "--session-id",
+            "da8c3622-2378-4d05-a26c-e826a6ef6d63",
+            "--name",
+            "leader",
+        ]
+        .map(str::to_string)
+    );
+    assert!(!argv.iter().any(|arg| arg == "--session-dir"));
+    for forbidden in ["--cwd", "--workspace", "--session"] {
+        assert!(!argv.iter().any(|arg| arg == forbidden), "argv={argv:?}");
+    }
+}
+
+#[test]
+fn pi_leader_session_scope_keeps_explicit_and_external_routes_isolated() {
+    assert_eq!(
+        pi_leader_session_scope(&[], false, false),
+        PiSessionScope::NativeDefault
+    );
+    for (args, external_path, allow_nested_attach) in [
+        (
+            vec![
+                "--model".to_string(),
+                "openai-codex/gpt-5.6-sol".to_string(),
+            ],
+            false,
+            false,
+        ),
+        (Vec::new(), true, false),
+        (Vec::new(), false, true),
+    ] {
+        assert_eq!(
+            pi_leader_session_scope(&args, external_path, allow_nested_attach),
+            PiSessionScope::Isolated,
+            "only the zero-argument managed route may use Pi's native root"
+        );
+    }
+}
+
 #[test]
 fn pi_command_preserves_direct_pi_defaults_with_only_team_runtime_additions() {
     let fresh = build_pi_command_argv(request(PiSessionSelector::Fresh {

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

@@ -59,7 +59,9 @@ fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<St
         effort: Some(effort),
         system_prompt: "Pi worker contract.",
         tool_categories: tools,
-        session_dir: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/sessions"),
+        session_dir: Some(Path::new(
+            "/workspace/.team/runtime/pi/t1/pi-worker/sessions",
+        )),
         session: PiSessionSelector::Fresh {
             session_id: "c5ddf218-24a5-4e74-960c-ab6606ea7e8c",
         },
@@ -241,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!(