@team-agent/installer 0.3.12 → 0.3.14

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

@@ -9,7 +9,7 @@ use crate::model::ids::AgentId;
 use crate::model::permissions::{self, AgentPermissionInput};
 use crate::model::yaml::{self, Value};
 use crate::state::persist::{load_runtime_state, save_runtime_state};
-use crate::transport::{SessionName, Target, Transport, WindowName};
+use crate::transport::{PaneId, SessionName, Target, Transport, WindowName};
 
 use super::*;
 
@@ -595,7 +595,7 @@ fn merge_workspace_team_state_with_key(
     launched_key: &str,
 ) -> serde_json::Value {
     let mut launched_obj = launched.as_object().cloned().unwrap_or_default();
-    let mut teams = launched
+    let mut teams = existing
         .get("teams")
         .and_then(serde_json::Value::as_object)
         .cloned()
@@ -638,6 +638,41 @@ fn merge_workspace_team_state_with_key(
     serde_json::Value::Object(merged)
 }
 
+#[cfg(test)]
+mod merge_workspace_team_state_with_key_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn empty_top_level_existing_session_preserves_existing_teams() {
+        let existing = json!({
+            "session_name": "",
+            "active_team_key": "parent",
+            "teams": {
+                "parent": {
+                    "session_name": "team-parent",
+                    "agents": {"parent_worker": {"status": "running"}}
+                }
+            }
+        });
+        let launched = json!({
+            "session_name": "team-child",
+            "agents": {"child_worker": {"status": "running"}}
+        });
+        let merged = merge_workspace_team_state_with_key(&existing, &launched, "child");
+        assert_eq!(
+            merged.pointer("/teams/parent/session_name"),
+            Some(&json!("team-parent")),
+            "existing.teams must survive even when existing.session_name is empty: {merged}"
+        );
+        assert_eq!(
+            merged.pointer("/teams/child/session_name"),
+            Some(&json!("team-child")),
+            "launched team must still be inserted under its runtime key: {merged}"
+        );
+    }
+}
+
 fn promote_launched_binding_from_team_entry(launched: &mut serde_json::Value, launched_key: &str) {
     let entry = launched
         .get("teams")
@@ -849,6 +884,29 @@ fn write_invalid_leader_pane_env_warning(workspaces: &[&Path], pane_id_raw: &str
     }
 }
 
+fn warn_ignored_owner_team_id(workspace: &Path, team_dir: &Path, runtime_team_key: &str) {
+    let Ok(Some(ignored)) = crate::compiler::ignored_owner_team_id_from_team_md(team_dir) else {
+        return;
+    };
+    eprintln!("Warning: ignored TEAM.md {}={}", ignored.field, ignored.value);
+    eprintln!("Reason: owner identity is the canonical runtime team key ({runtime_team_key}), not TEAM.md front matter");
+    eprintln!("Action: remove {} from TEAM.md", ignored.field);
+    if let Err(err) = crate::event_log::EventLog::new(workspace).write(
+        "spec.field_ignored",
+        serde_json::json!({
+            "field": ignored.field,
+            "source": team_dir.join("TEAM.md").to_string_lossy().to_string(),
+            "value": ignored.value,
+            "warning": "ignored user-set owner_team_id",
+            "reason": "owner identity is derived from the canonical runtime team key",
+            "action": "remove owner_team_id from TEAM.md",
+            "runtime_team_key": runtime_team_key,
+        }),
+    ) {
+        eprintln!("Warning: spec.field_ignored event write failed: {err}");
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum LeaderPaneEnvState {
     Live,
@@ -932,12 +990,13 @@ fn seed_unbound_launched_owner(launched: &mut serde_json::Value, launched_key: &
     let Some(owner) = unbound_launched_owner(launched, launched_key) else {
         return;
     };
-    let provider = launched
-        .get("team_owner")
-        .and_then(|owner| owner.get("provider"))
+    let Some(provider) = owner
+        .get("provider")
         .and_then(serde_json::Value::as_str)
         .filter(|provider| !provider.is_empty())
-        .unwrap_or("codex");
+    else {
+        return;
+    };
     let owner_epoch = 1u64;
     let receiver = serde_json::json!({
         "mode": "direct_tmux",
@@ -958,12 +1017,7 @@ fn unbound_launched_owner(
     launched: &serde_json::Value,
     launched_key: &str,
 ) -> Option<serde_json::Value> {
-    let provider = launched
-        .get("team_owner")
-        .and_then(|owner| owner.get("provider"))
-        .and_then(serde_json::Value::as_str)
-        .filter(|provider| !provider.is_empty())
-        .unwrap_or("codex");
+    let provider = unbound_launched_provider(launched)?;
     let machine_fingerprint = launched
         .get("team_owner")
         .and_then(|owner| owner.get("machine_fingerprint"))
@@ -994,6 +1048,193 @@ fn unbound_launched_owner(
     }))
 }
 
+fn unbound_launched_provider(launched: &serde_json::Value) -> Option<String> {
+    if let Some(provider) = launched
+        .get("team_owner")
+        .and_then(|owner| owner.get("provider"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|provider| !provider.is_empty())
+        .and_then(parse_provider)
+        .and_then(provider_wire_string)
+    {
+        return Some(provider);
+    }
+    let pane = launched
+        .get("team_owner")
+        .and_then(|owner| owner.get("pane_id"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|pane| !pane.is_empty())?;
+    let target = PaneId::new(pane);
+    attributed_provider_for_pane_across_tmux_sockets(&target).and_then(provider_wire_string)
+}
+
+fn provider_wire_string(provider: Provider) -> Option<String> {
+    serde_json::to_value(provider)
+        .ok()
+        .and_then(|value| value.as_str().map(str::to_string))
+}
+
+fn attributed_provider_for_pane_across_tmux_sockets(pane: &PaneId) -> Option<Provider> {
+    crate::tmux_backend::tmux_socket_endpoints()
+        .into_iter()
+        .filter_map(|endpoint| {
+            crate::tmux_backend::TmuxBackend::for_tmux_endpoint(&endpoint)
+                .list_targets()
+                .ok()
+        })
+        .flatten()
+        .find(|info| info.pane_id == *pane)
+        .and_then(|info| crate::leader::attribute_pane_provider(&info))
+}
+
+fn caller_provider_for_seed_with_lookup(
+    caller: &crate::state::owner_gate::CallerIdentity,
+    lookup_pane_provider: impl Fn(&PaneId) -> Option<Provider>,
+) -> Option<String> {
+    if !caller.provider.is_empty() {
+        if let Some(provider) = parse_provider(&caller.provider).and_then(provider_wire_string) {
+            return Some(provider);
+        }
+    }
+    (!caller.pane_id.is_empty())
+        .then(|| PaneId::new(&caller.pane_id))
+        .and_then(|pane| lookup_pane_provider(&pane))
+        .and_then(provider_wire_string)
+}
+
+#[cfg(test)]
+mod e22_unbound_owner_provider_tests {
+    use super::*;
+    use crate::state::owner_gate::CallerIdentity;
+
+    #[test]
+    fn unbound_owner_preserves_explicit_copilot_provider() {
+        let mut launched = serde_json::json!({
+            "workspace": "/tmp/team-agent-e22",
+            "team_owner": {
+                "provider": "copilot",
+                "machine_fingerprint": "machine"
+            }
+        });
+
+        seed_unbound_launched_owner(&mut launched, "team-e22");
+
+        assert_eq!(
+            launched
+                .pointer("/team_owner/provider")
+                .and_then(serde_json::Value::as_str),
+            Some("copilot")
+        );
+        assert_eq!(
+            launched
+                .pointer("/leader_receiver/provider")
+                .and_then(serde_json::Value::as_str),
+            Some("copilot")
+        );
+    }
+
+    #[test]
+    fn unbound_owner_without_attributed_provider_does_not_default_codex() {
+        let mut launched = serde_json::json!({
+            "workspace": "/tmp/team-agent-e22",
+            "team_owner": {
+                "machine_fingerprint": "machine"
+            }
+        });
+
+        seed_unbound_launched_owner(&mut launched, "team-e22");
+
+        assert!(
+            launched.get("leader_receiver").is_none(),
+            "unattributed unbound owner must not seed a codex receiver: {launched}"
+        );
+        assert!(
+            launched
+                .pointer("/team_owner/provider")
+                .and_then(serde_json::Value::as_str)
+                != Some("codex"),
+            "unattributed unbound owner must not silently become codex: {launched}"
+        );
+    }
+
+    fn caller(provider: &str, pane_id: &str) -> CallerIdentity {
+        CallerIdentity {
+            pane_id: pane_id.to_string(),
+            provider: provider.to_string(),
+            machine_fingerprint: "machine".to_string(),
+            leader_session_uuid: "leader-uuid".to_string(),
+            leader_session_uuid_source: "derived".to_string(),
+        }
+    }
+
+    #[test]
+    fn env_seed_attributes_in_tmux_node_form_copilot_from_caller_pane() {
+        let mut state = serde_json::json!({
+            "workspace": "/tmp/team-agent-e22",
+            "leader": {"provider": "copilot"},
+        });
+
+        assert!(seed_launched_owner_from_caller_with_provider_lookup(
+            &mut state,
+            caller("", "%0"),
+            |pane| (pane.as_str() == "%0").then_some(Provider::Copilot),
+        ));
+
+        assert_eq!(
+            state
+                .pointer("/team_owner/provider")
+                .and_then(serde_json::Value::as_str),
+            Some("copilot")
+        );
+        assert_eq!(
+            state
+                .pointer("/leader_receiver/provider")
+                .and_then(serde_json::Value::as_str),
+            Some("copilot")
+        );
+    }
+
+    #[test]
+    fn env_seed_unknown_caller_pane_does_not_default_codex() {
+        let mut state = serde_json::json!({
+            "workspace": "/tmp/team-agent-e22",
+            "leader": {"provider": "copilot"},
+        });
+
+        assert!(seed_launched_owner_from_caller_with_provider_lookup(
+            &mut state,
+            caller("", "%0"),
+            |_| None,
+        ));
+        assert_eq!(
+            state
+                .pointer("/team_owner/pane_id")
+                .and_then(serde_json::Value::as_str),
+            Some("%0")
+        );
+        assert_eq!(
+            state
+                .pointer("/leader_receiver/pane_id")
+                .and_then(serde_json::Value::as_str),
+            Some("%0")
+        );
+        assert!(
+            state
+                .pointer("/leader_receiver/provider")
+                .and_then(serde_json::Value::as_str)
+                != Some("codex"),
+            "unknown caller pane must not silently seed a codex receiver: {state}"
+        );
+        assert!(
+            state
+                .pointer("/team_owner/provider")
+                .and_then(serde_json::Value::as_str)
+                != Some("codex"),
+            "unknown caller pane must not silently become codex: {state}"
+        );
+    }
+}
+
 fn owner_pane_belongs_to_other_team(
     existing: &serde_json::Value,
     launched_key: &str,
@@ -2144,6 +2385,7 @@ pub fn quick_start_with_transport_in_workspace(
     let state_team_key = explicit_team_key.clone().unwrap_or_else(|| {
         runtime_team_key_for_spec(&agents_dir.join("team.spec.yaml"), &spec, &session_name)
     });
+    warn_ignored_owner_team_id(workspace.as_path(), agents_dir, &state_team_key);
     // E5 spec 迁移:spec 写到 .team/runtime/<team_key>/(中间产物,绝不落用户目录 agents_dir)。
     // Bug2:原子写(tmp+rename),避免半截 spec。
     let spec_path = crate::model::paths::runtime_spec_path(&workspace, &state_team_key);
@@ -3565,19 +3807,26 @@ fn seed_launched_owner_from_env(state: &mut serde_json::Value) -> bool {
     ) else {
         return false;
     };
-    let provider = if caller.provider.is_empty() {
-        "codex".to_string()
-    } else {
-        caller.provider
-    };
-    let pane_id = caller.pane_id;
-    if pane_id.is_empty() {
+    seed_launched_owner_from_caller_with_provider_lookup(
+        state,
+        caller,
+        attributed_provider_for_pane_across_tmux_sockets,
+    )
+}
+
+fn seed_launched_owner_from_caller_with_provider_lookup(
+    state: &mut serde_json::Value,
+    caller: crate::state::owner_gate::CallerIdentity,
+    lookup_pane_provider: impl Fn(&PaneId) -> Option<Provider>,
+) -> bool {
+    if caller.pane_id.is_empty() {
         return false;
     }
+    let provider = caller_provider_for_seed_with_lookup(&caller, lookup_pane_provider);
+    let pane_id = caller.pane_id;
     let owner_epoch = 1u64;
-    let owner = serde_json::json!({
+    let mut owner = serde_json::json!({
         "pane_id": pane_id,
-        "provider": provider.clone(),
         "machine_fingerprint": caller.machine_fingerprint,
         "leader_session_uuid": caller.leader_session_uuid,
         "owner_epoch": owner_epoch,
@@ -3587,17 +3836,23 @@ fn seed_launched_owner_from_env(state: &mut serde_json::Value) -> bool {
             .or_else(|_| std::env::var("USERNAME"))
             .unwrap_or_default(),
     });
-    let receiver = serde_json::json!({
+    let mut receiver = serde_json::json!({
         "mode": "direct_tmux",
         "status": "attached",
-        "provider": provider,
         "pane_id": owner.get("pane_id").cloned().unwrap_or(serde_json::Value::Null),
         "pane": owner.get("pane_id").cloned().unwrap_or(serde_json::Value::Null),
         "leader_session_uuid": owner.get("leader_session_uuid").cloned().unwrap_or(serde_json::Value::Null),
         "owner_epoch": owner_epoch,
         "discovery": "quick_start",
     });
-    let mut receiver = receiver;
+    if let Some(provider) = provider.as_ref() {
+        if let Some(owner) = owner.as_object_mut() {
+            owner.insert("provider".to_string(), serde_json::json!(provider));
+        }
+        if let Some(receiver) = receiver.as_object_mut() {
+            receiver.insert("provider".to_string(), serde_json::json!(provider));
+        }
+    }
     if let (Some(receiver), Some(socket)) = (
         receiver.as_object_mut(),
         crate::tmux_backend::socket_name_from_tmux_env(),

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

@@ -36,12 +36,11 @@ pub(super) fn spawn_agent_window(
         detected_safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn()?;
         &detected_safety
     };
-    let command_agent =
-        crate::lifecycle::worker_command_context::WorkerCommandAgent::from_json(
-            agent,
-            Some(agent_id.as_str()),
-            provider,
-        );
+    let command_agent = crate::lifecycle::worker_command_context::WorkerCommandAgent::from_json(
+        agent,
+        Some(agent_id.as_str()),
+        provider,
+    );
     let system_prompt =
         crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
     let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(
@@ -60,7 +59,8 @@ pub(super) fn spawn_agent_window(
         .and_then(|v| v.as_str())
         .map(str::to_string)
         .or_else(|| {
-            let key = crate::messaging::leader_receiver::active_team_key(workspace, &state_for_team);
+            let key =
+                crate::messaging::leader_receiver::active_team_key(workspace, &state_for_team);
             (!key.is_empty()).then_some(key)
         });
     let mcp_config = adapter
@@ -72,8 +72,11 @@ pub(super) fn spawn_agent_window(
         agent_id.as_str(),
         team_id.as_deref().unwrap_or(""),
     );
-    let mcp_config_path =
-        crate::lifecycle::launch::write_worker_mcp_config(workspace, agent_id.as_str(), &mcp_config)?;
+    let mcp_config_path = crate::lifecycle::launch::write_worker_mcp_config(
+        workspace,
+        agent_id.as_str(),
+        &mcp_config,
+    )?;
     let profile_launch =
         crate::lifecycle::profile_launch::prepare_provider_profile_launch_from_json(
             workspace,
@@ -81,11 +84,7 @@ pub(super) fn spawn_agent_window(
             agent,
             Some(&mcp_config),
         )?;
-    let command_model = profile_launch
-        .command_overrides
-        .model
-        .as_deref()
-        .or(model);
+    let command_model = profile_launch.command_overrides.model.as_deref().or(model);
     let context = crate::provider::ProviderCommandContext {
         auth_mode,
         mcp_config: Some(&mcp_config),
@@ -252,19 +251,30 @@ pub(super) fn resume_backing_exists_for_agent(
     rollout_path: Option<&RolloutPath>,
 ) -> bool {
     match provider {
+        provider if !provider_supports_resume(provider) => {
+            let _ = (workspace, agent_id, agent, session_id, rollout_path);
+            false
+        }
         Provider::Codex => rollout_path_exists(rollout_path),
         Provider::Claude | Provider::ClaudeCode => {
             rollout_path_exists(rollout_path)
                 || event_log_transcript_exists(workspace, agent_id.as_str(), session_id.as_str())
         }
         Provider::Copilot => copilot_session_store_has_session(session_id.as_str()),
-        Provider::GeminiCli | Provider::Fake => {
-            let _ = agent;
-            true
-        }
+        Provider::GeminiCli | Provider::Fake => false,
     }
 }
 
+pub(super) fn provider_supports_resume(provider: Provider) -> bool {
+    crate::provider::get_adapter(provider).caps().resume
+}
+
+pub(super) fn provider_wire_supports_resume(provider: &str) -> bool {
+    parse_provider(provider)
+        .map(provider_supports_resume)
+        .unwrap_or(false)
+}
+
 fn rollout_path_exists(rollout_path: Option<&RolloutPath>) -> bool {
     rollout_path
         .as_ref()
@@ -308,13 +318,12 @@ fn copilot_session_store_has_session(session_id: &str) -> bool {
     ) else {
         return false;
     };
-    conn
-        .query_row(
-            "select 1 from sessions where id = ?1 limit 1",
-            [session_id],
-            |_| Ok(()),
-        )
-        .is_ok()
+    conn.query_row(
+        "select 1 from sessions where id = ?1 limit 1",
+        [session_id],
+        |_| Ok(()),
+    )
+    .is_ok()
 }
 
 pub(crate) fn refresh_missing_provider_sessions(
@@ -469,7 +478,10 @@ pub(super) fn load_team_spec(workspace: &Path) -> Result<YamlValue, LifecycleErr
     yaml::loads(&text).map_err(|e| LifecycleError::Compile(e.to_string()))
 }
 
-pub(super) fn find_spec_agent<'a>(spec: &'a YamlValue, agent_id: &AgentId) -> Option<&'a YamlValue> {
+pub(super) fn find_spec_agent<'a>(
+    spec: &'a YamlValue,
+    agent_id: &AgentId,
+) -> Option<&'a YamlValue> {
     let leader_is_agent = spec
         .get("leader")
         .and_then(|v| v.get("id"))
@@ -479,23 +491,23 @@ pub(super) fn find_spec_agent<'a>(spec: &'a YamlValue, agent_id: &AgentId) -> Op
     if leader_is_agent {
         return None;
     }
-    spec.get("agents")?
-        .as_list()?
-        .iter()
-        .find(|agent| {
-            agent
-                .get("id")
-                .and_then(YamlValue::as_str)
-                .map(|id| id == agent_id.as_str())
-                .unwrap_or(false)
-        })
+    spec.get("agents")?.as_list()?.iter().find(|agent| {
+        agent
+            .get("id")
+            .and_then(YamlValue::as_str)
+            .map(|id| id == agent_id.as_str())
+            .unwrap_or(false)
+    })
 }
 
 pub(super) fn unknown_worker(agent_id: &AgentId) -> LifecycleError {
     LifecycleError::RequirementUnmet(format!("unknown worker agent id: {agent_id}"))
 }
 
-pub(super) fn state_session_name_from_spec(state: &serde_json::Value, spec: &YamlValue) -> SessionName {
+pub(super) fn state_session_name_from_spec(
+    state: &serde_json::Value,
+    spec: &YamlValue,
+) -> SessionName {
     state
         .get("session_name")
         .and_then(|v| v.as_str())
@@ -709,9 +721,7 @@ pub(super) fn agent_is_running(
     agent_id: &AgentId,
     transport: &dyn crate::transport::Transport,
 ) -> bool {
-    let agent_state = state
-        .get("agents")
-        .and_then(|v| v.get(agent_id.as_str()));
+    let agent_state = state.get("agents").and_then(|v| v.get(agent_id.as_str()));
     let status = agent_state
         .and_then(|v| v.get("status"))
         .and_then(|v| v.as_str())