@team-agent/installer 0.5.74 → 0.5.75

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/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)

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

@@ -54,14 +54,14 @@ fn worker_spawn_inherits_parent_process_env_for_proxy_and_ca() {
         &launch_transport,
     )
     .expect("launch fixture should spawn worker");
-    let launch_command_line = launch_transport.single_spawn_command_line();
+    let launch_spawn = launch_transport.single_spawn();
 
     let restart_team = compiled_team_dir("restart", &[("worker_a", "Restart Worker")]);
     seed_restart_state(&restart_team, "worker_a");
     let restart_transport = RecordingTransport::new().with_session_present(false);
     restart_with_transport(&restart_team, true, None, &restart_transport)
         .expect("restart fixture should spawn worker");
-    let restart_command_line = restart_transport.single_spawn_command_line();
+    let restart_spawn = restart_transport.single_spawn();
 
     let add_team = compiled_team_dir("add-agent", &[("worker_a", "Existing Worker")]);
     seed_running_add_agent_state(&add_team, "worker_a");
@@ -77,17 +77,15 @@ fn worker_spawn_inherits_parent_process_env_for_proxy_and_ca() {
         &add_transport,
     )
     .expect("add-agent fixture should spawn worker");
-    let add_command_line = add_transport.single_spawn_command_line();
+    let add_spawn = add_transport.single_spawn();
 
     let failures = [
-        ("quick-start launch", launch_command_line, "worker_a"),
-        ("restart", restart_command_line, "worker_a"),
-        ("add-agent", add_command_line, "worker_b"),
+        ("quick-start launch", launch_spawn, "worker_a"),
+        ("restart", restart_spawn, "worker_a"),
+        ("add-agent", add_spawn, "worker_b"),
     ]
     .into_iter()
-    .flat_map(|(surface, command_line, agent_id)| {
-        spawn_env_contract_failures(surface, &command_line, agent_id)
-    })
+    .flat_map(|(surface, spawn, agent_id)| spawn_env_contract_failures(surface, &spawn, agent_id))
     .collect::<Vec<_>>();
 
     assert!(
@@ -97,6 +95,61 @@ fn worker_spawn_inherits_parent_process_env_for_proxy_and_ca() {
     );
 }
 
+#[test]
+fn tmux_control_filter_uses_env_keys_not_substring_in_inherited_values() {
+    let mut env = BTreeMap::from([
+        ("TA_SPAWN_ENV_CANARY".to_string(), "FOO".to_string()),
+        (
+            "HTTP_PROXY".to_string(),
+            "http://canary-proxy:1".to_string(),
+        ),
+        (
+            "NODE_EXTRA_CA_CERTS".to_string(),
+            "/canary/ca.pem".to_string(),
+        ),
+        ("TEAM_AGENT_WORKSPACE".to_string(), "/ws".to_string()),
+        (
+            "TEAM_AGENT_OWNER_TEAM_ID".to_string(),
+            "teamdir".to_string(),
+        ),
+        ("TEAM_AGENT_AGENT_ID".to_string(), "worker_a".to_string()),
+        (
+            "HARNESS_PROBE".to_string(),
+            "printf 'LS_USR_BIN_TMUX=%s\\n'\n".to_string(),
+        ),
+    ]);
+    let spawn = RecordedSpawn {
+        argv: vec!["codex".to_string()],
+        env: env.clone(),
+        env_unset: Vec::new(),
+        session: SessionName::new("s"),
+        window: WindowName::new("w"),
+        pane_id: PaneId::new("%1"),
+    };
+    assert!(
+        spawn_env_contract_failures("harness-value", &spawn, "worker_a").is_empty(),
+        "inherited values may contain the letters TMUX= without leaking TMUX/TMUX_PANE keys"
+    );
+
+    env.insert(
+        "TMUX".to_string(),
+        "/tmp/tmux-canary/default,1".to_string(),
+    );
+    let leaked = RecordedSpawn {
+        env,
+        ..spawn
+    };
+    let failures = spawn_env_contract_failures("key-leak", &leaked, "worker_a");
+    assert!(
+        failures.iter().any(|row| row.contains("present_keys=") && row.contains("TMUX")),
+        "actual TMUX key must still fail closed; failures={failures:?}"
+    );
+    assert!(
+        failures.iter().all(|row| !row.contains("command_line=")),
+        "failures must not dump command_line; failures={failures:?}"
+    );
+}
+
 #[test]
 #[serial(env)]
 fn worker_spawn_scrubs_cross_provider_process_identity_but_keeps_config_env() {
@@ -234,42 +287,67 @@ fn worker_spawn_stays_out_of_coordinator_tick_and_daemon_preserves_parent_env()
     );
 }
 
-fn spawn_env_contract_failures(surface: &str, command_line: &str, agent_id: &str) -> Vec<String> {
+fn spawn_env_has_tmux_control_assignment(spawn: &RecordedSpawn) -> bool {
+    spawn.env.contains_key("TMUX")
+        || spawn.env.contains_key("TMUX_PANE")
+        || spawn.argv.iter().any(|part| {
+            part.split_whitespace().any(|tok| {
+                tok == "TMUX" || tok.starts_with("TMUX=") || tok.starts_with("TMUX_PANE=")
+            })
+        })
+}
+
+fn spawn_env_contract_failures(
+    surface: &str,
+    spawn: &RecordedSpawn,
+    agent_id: &str,
+) -> Vec<String> {
     let mut failures = Vec::new();
-    for expected in [
-        "TA_SPAWN_ENV_CANARY=FOO",
-        "HTTP_PROXY=http://canary-proxy:1",
-        "NODE_EXTRA_CA_CERTS=/canary/ca.pem",
-        "TEAM_AGENT_WORKSPACE=",
-        "TEAM_AGENT_OWNER_TEAM_ID=teamdir",
+    for (key, expected) in [
+        ("TA_SPAWN_ENV_CANARY", Some("FOO")),
+        ("HTTP_PROXY", Some("http://canary-proxy:1")),
+        ("NODE_EXTRA_CA_CERTS", Some("/canary/ca.pem")),
+        ("TEAM_AGENT_OWNER_TEAM_ID", Some("teamdir")),
     ] {
-        if !command_line.contains(expected) {
-            failures.push(format!(
-                "{surface}: missing `{expected}`; worker spawn must inherit parent env and overlay Team Agent identity; command_line={command_line:?}"
-            ));
+        match (spawn.env.get(key).map(String::as_str), expected) {
+            (Some(actual), Some(wanted)) if actual == wanted => {}
+            (Some(_), Some(wanted)) => failures.push(format!(
+                "{surface}: `{key}` present but not `{wanted}`"
+            )),
+            _ => failures.push(format!(
+                "{surface}: missing `{key}` overlay/inherit"
+            )),
         }
     }
-    if !command_line.contains(&format!("TEAM_AGENT_AGENT_ID={agent_id}")) {
+    if spawn
+        .env
+        .get("TEAM_AGENT_WORKSPACE")
+        .is_none_or(|value| value.is_empty())
+    {
+        failures.push(format!("{surface}: missing `TEAM_AGENT_WORKSPACE` overlay"));
+    }
+    if spawn.env.get("TEAM_AGENT_AGENT_ID").map(String::as_str) != Some(agent_id) {
         failures.push(format!(
-            "{surface}: missing `TEAM_AGENT_AGENT_ID={agent_id}` overlay; command_line={command_line:?}"
+            "{surface}: missing `TEAM_AGENT_AGENT_ID={agent_id}` overlay"
         ));
     }
-    if command_line.contains("TMUX=") || command_line.contains("TMUX_PANE=") {
+    if spawn_env_has_tmux_control_assignment(spawn) {
+        let present: Vec<&str> = ["TMUX", "TMUX_PANE"]
+            .into_iter()
+            .filter(|key| spawn.env.contains_key(*key))
+            .collect();
         failures.push(format!(
-            "{surface}: worker spawn must filter tmux control env from inherited parent env; command_line={command_line:?}"
+            "{surface}: worker spawn must filter tmux control env from inherited parent env; present_keys={present:?}"
         ));
     }
-    if !command_line.split_whitespace().any(|part| part == "codex") {
+    if !spawn.argv.iter().any(|part| part == "codex") {
         failures.push(format!(
-            "{surface}: provider executable must remain the command name `codex`; command_line={command_line:?}"
+            "{surface}: provider executable must remain the command name `codex`"
         ));
     }
-    if command_line
-        .split_whitespace()
-        .any(|part| part.ends_with("/codex"))
-    {
+    if spawn.argv.iter().any(|part| part.ends_with("/codex")) {
         failures.push(format!(
-            "{surface}: provider executable must not be hard-coded as an absolute codex path; command_line={command_line:?}"
+            "{surface}: provider executable must not be hard-coded as an absolute codex path"
         ));
     }
     failures
@@ -580,6 +658,7 @@ impl RecordingTransport {
         self
     }
 
+    #[allow(dead_code)]
     fn single_spawn_command_line(&self) -> String {
         self.single_spawn().command_line()
     }