@team-agent/installer 0.3.2 → 0.3.4

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

@@ -75,7 +75,8 @@ pub(crate) fn start_agent_at_paths(
     let agent = state
         .get("agents")
         .and_then(|v| v.get(agent_id.as_str()))
-        .ok_or_else(|| LifecycleError::RequirementUnmet(format!("agent {agent_id} not found")))?;
+        .ok_or_else(|| LifecycleError::RequirementUnmet(format!("agent {agent_id} not found")))?
+        .clone();
     if agent
         .get("paused")
         .and_then(serde_json::Value::as_bool)
@@ -84,7 +85,7 @@ pub(crate) fn start_agent_at_paths(
         return Ok(StartAgentOutcome::Paused { agent_id: agent_id.clone() });
     }
     let session_name = state_session_name(&state);
-    let window = agent_window(agent, agent_id);
+    let window = agent_window(&agent, agent_id);
     if !force && window_exists(transport, &session_name, &window) {
         mark_agent_running_noop(&mut state, agent_id, &session_name, &window)?;
         crate::state::projection::save_team_scoped_state(workspace, &state)
@@ -104,9 +105,9 @@ pub(crate) fn start_agent_at_paths(
             target,
         });
     }
-    let provider = agent_provider(agent);
-    let session_id = agent_session_id(agent);
-    let rollout_path = agent_rollout_path(agent);
+    let provider = agent_provider(&agent);
+    let session_id = agent_session_id(&agent);
+    let rollout_path = agent_rollout_path(&agent);
     let rollout_exists = rollout_path
         .as_ref()
         .map(|p| p.as_path().exists())
@@ -125,20 +126,25 @@ pub(crate) fn start_agent_at_paths(
     };
     let into_existing_session =
         session_live_or_default(transport, &session_name, session_name_present(&state));
+    let safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn()?;
     let spawn = spawn_agent_window(
         workspace,
         &session_name,
         agent_id,
-        agent,
+        &agent,
         spawn_session_id,
         into_existing_session,
         transport,
+        Some(&safety),
         None,
     )?;
+    mark_agent_started(&mut state, agent_id, &window, &spawn, &safety)?;
+    crate::state::projection::save_team_scoped_state(workspace, &state)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     write_start_agent_start_event(
         workspace,
         agent_id,
-        agent,
+        &agent,
         provider,
         start_mode,
         &session_name,
@@ -154,7 +160,7 @@ pub(crate) fn start_agent_at_paths(
             coordinator_started,
         },
         start_mode,
-        target: spawn.pane_id.as_str().to_string(),
+        target: spawn.spawn.pane_id.as_str().to_string(),
         session_id,
         rollout_path,
     })
@@ -281,6 +287,43 @@ pub(super) fn resolve_team_scoped_state_or_refuse(
     state.ok_or_else(|| LifecycleError::StatePersist("resolve_team_scoped_state returned no state".to_string()))
 }
 
+fn mark_agent_started(
+    state: &mut serde_json::Value,
+    agent_id: &AgentId,
+    window: &str,
+    spawn: &SpawnedAgentWindow,
+    safety: &DangerousApproval,
+) -> Result<(), LifecycleError> {
+    let Some(agent) = state
+        .get_mut("agents")
+        .and_then(serde_json::Value::as_object_mut)
+        .and_then(|agents| agents.get_mut(agent_id.as_str()))
+        .and_then(serde_json::Value::as_object_mut)
+    else {
+        return Err(LifecycleError::StatePersist(format!(
+            "agent {} state is not an object",
+            agent_id
+        )));
+    };
+    agent.insert("status".to_string(), serde_json::json!("running"));
+    agent.insert("agent_id".to_string(), serde_json::json!(agent_id.as_str()));
+    agent.insert("window".to_string(), serde_json::json!(window));
+    agent.insert(
+        "pane_id".to_string(),
+        serde_json::json!(spawn.spawn.pane_id.as_str()),
+    );
+    if let Some(pane_pid) = spawn.spawn.child_pid {
+        agent.insert("pane_pid".to_string(), serde_json::json!(pane_pid));
+    }
+    crate::lifecycle::launch::persist_command_plan_state(
+        agent,
+        &spawn.plan,
+        &spawn.profile_launch,
+    );
+    crate::lifecycle::launch::persist_effective_approval_policy(agent, safety);
+    Ok(())
+}
+
 /// `reset_agent(workspace, agent_id, discard_session, open_display, team)`
 /// (`lifecycle/operations.py:102`)。discard + 重起;**未传 discard_session → 拒绝**。
 pub fn reset_agent(
@@ -408,32 +451,76 @@ fn write_start_agent_start_event(
     let adapter = crate::provider::get_adapter(provider);
     // Contract C / F6.4: event log must record the same context-aware argv that the
     // actual spawn used — so the role/tools/MCP context appears in `start_agent.agent_start`.
-    let role = agent.get("role").and_then(|v| v.as_str());
     let safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn()?;
-    let tools = crate::lifecycle::launch::worker_tool_refs(agent_tool_strings(agent), &safety);
-    let tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
+    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(
+        &command_agent,
+        provider,
+        &safety,
+    )?;
+    let resolved_tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
     let mcp_config = adapter
         .mcp_config(auth_mode)
         .map_err(|e| LifecycleError::Provider(e.to_string()))?;
-    let mut argv = match session_id {
+    let team_id = agent
+        .get("owner_team_id")
+        .and_then(|v| v.as_str());
+    let mcp_config = crate::lifecycle::launch::resolve_mcp_config(
+        mcp_config,
+        workspace,
+        agent_id.as_str(),
+        team_id.unwrap_or(""),
+    );
+    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,
+            agent_id.as_str(),
+            agent,
+            Some(&mcp_config),
+        )?;
+    let command_model = profile_launch
+        .command_overrides
+        .model
+        .as_deref()
+        .or(model);
+    let context = crate::provider::ProviderCommandContext {
+        auth_mode,
+        mcp_config: Some(&mcp_config),
+        system_prompt: Some(system_prompt.as_str()),
+        model: command_model,
+        tools: &resolved_tool_refs,
+        profile_launch: Some(&profile_launch),
+    };
+    let mut plan = match session_id {
         Some(session_id) => adapter
-            .build_resume_command_with_context(
-                Some(session_id),
-                auth_mode,
-                Some(&mcp_config),
-                role,
-                model,
-                &tool_refs,
-            )
+            .build_resume_command_plan(Some(session_id), context)
             .map_err(|e| LifecycleError::Provider(e.to_string()))?,
         None => adapter
-            .build_command_with_tools(auth_mode, Some(&mcp_config), role, model, &tool_refs)
+            .build_command_plan(context)
             .map_err(|e| LifecycleError::Provider(e.to_string()))?,
     };
-    let team_id = agent
-        .get("owner_team_id")
-        .and_then(|v| v.as_str());
-    crate::lifecycle::launch::fill_spawn_placeholders_full(&mut argv, workspace, agent_id.as_str(), team_id);
+    if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
+        crate::lifecycle::launch::point_native_mcp_config_at_file(
+            &mut plan.argv,
+            provider,
+            &mcp_config_path,
+        );
+    }
+    crate::lifecycle::launch::fill_spawn_placeholders_full(
+        &mut plan.argv,
+        workspace,
+        agent_id.as_str(),
+        team_id,
+    );
     let tmux_start_mode = if into_existing_session {
         "new-window"
     } else {
@@ -450,7 +537,7 @@ fn write_start_agent_start_event(
                 "session": session_name.as_str(),
                 "window": window,
                 "tmux_start_mode": tmux_start_mode,
-                "command": argv,
+                "command": plan.argv,
                 "mcp_config": agent.get("mcp_config").cloned().unwrap_or(serde_json::Value::Null),
             }),
         )

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

@@ -1,5 +1,11 @@
 use super::*;
 
+pub(super) struct SpawnedAgentWindow {
+    pub spawn: crate::transport::SpawnResult,
+    pub plan: crate::provider::CommandPlan,
+    pub profile_launch: crate::provider::ProviderProfileLaunch,
+}
+
 pub(super) fn spawn_agent_window(
     workspace: &Path,
     session_name: &SessionName,
@@ -9,7 +15,8 @@ pub(super) fn spawn_agent_window(
     into_existing_session: bool,
     transport: &dyn crate::transport::Transport,
     safety: Option<&DangerousApproval>,
-) -> Result<crate::transport::SpawnResult, LifecycleError> {
+    spawn_cwd_override: Option<&Path>,
+) -> Result<SpawnedAgentWindow, LifecycleError> {
     let provider = agent_provider(agent);
     let auth_mode = agent_auth_mode(agent);
     let model = agent.get("model").and_then(|v| v.as_str());
@@ -22,7 +29,6 @@ pub(super) fn spawn_agent_window(
     // Contract C / F6.4: thread compiled role/tools/MCP context through restart as well —
     // a restarted worker must come back up with the SAME callable MCP capability + role
     // prompt as a fresh launch, else `report_result` becomes unreachable after every restart.
-    let role = agent.get("role").and_then(|v| v.as_str());
     let detected_safety;
     let safety = if let Some(safety) = safety {
         safety
@@ -30,26 +36,20 @@ pub(super) fn spawn_agent_window(
         detected_safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn()?;
         &detected_safety
     };
-    let tools = crate::lifecycle::launch::worker_tool_refs(agent_tool_strings(agent), safety);
-    let tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
-    let mcp_config = adapter
-        .mcp_config(auth_mode)
-        .map_err(|e| LifecycleError::Provider(e.to_string()))?;
-    let mut argv = match resume_session_id {
-        Some(session_id) => adapter
-            .build_resume_command_with_context(
-                Some(session_id),
-                auth_mode,
-                Some(&mcp_config),
-                role,
-                model,
-                &tool_refs,
-            )
-            .map_err(|e| LifecycleError::Provider(e.to_string()))?,
-        None => adapter
-            .build_command_with_tools(auth_mode, Some(&mcp_config), role, model, &tool_refs)
-            .map_err(|e| LifecycleError::Provider(e.to_string()))?,
-    };
+    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(
+        &command_agent,
+        provider,
+        safety,
+    )?;
+    let resolved_tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
     // owner_team_id resolution: prefer the runtime-state row's `owner_team_id` (set by
     // launch/restart); fall back to the active team key for paths that don't write the
     // row first (e.g. add-agent calls spawn before upserting team metadata).
@@ -63,22 +63,78 @@ pub(super) fn spawn_agent_window(
             let key = crate::messaging::leader_receiver::active_team_key(workspace, &state_for_team);
             (!key.is_empty()).then_some(key)
         });
+    let mcp_config = adapter
+        .mcp_config(auth_mode)
+        .map_err(|e| LifecycleError::Provider(e.to_string()))?;
+    let mcp_config = crate::lifecycle::launch::resolve_mcp_config(
+        mcp_config,
+        workspace,
+        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 profile_launch =
+        crate::lifecycle::profile_launch::prepare_provider_profile_launch_from_json(
+            workspace,
+            agent_id.as_str(),
+            agent,
+            Some(&mcp_config),
+        )?;
+    let command_model = profile_launch
+        .command_overrides
+        .model
+        .as_deref()
+        .or(model);
+    let context = crate::provider::ProviderCommandContext {
+        auth_mode,
+        mcp_config: Some(&mcp_config),
+        system_prompt: Some(system_prompt.as_str()),
+        model: command_model,
+        tools: &resolved_tool_refs,
+        profile_launch: Some(&profile_launch),
+    };
+    let mut plan = match resume_session_id {
+        Some(session_id) => adapter
+            .build_resume_command_plan(Some(session_id), context)
+            .map_err(|e| LifecycleError::Provider(e.to_string()))?,
+        None => adapter
+            .build_command_plan(context)
+            .map_err(|e| LifecycleError::Provider(e.to_string()))?,
+    };
+    if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
+        crate::lifecycle::launch::point_native_mcp_config_at_file(
+            &mut plan.argv,
+            provider,
+            &mcp_config_path,
+        );
+    }
     crate::lifecycle::launch::fill_spawn_placeholders_full(
-        &mut argv,
+        &mut plan.argv,
         workspace,
         agent_id.as_str(),
         team_id.as_deref(),
     );
     let window = WindowName::new(agent_id.as_str());
-    let env = crate::lifecycle::launch::inherited_env_with_team_overrides(
+    let mut env = crate::lifecycle::launch::inherited_env_with_team_overrides(
         workspace,
         agent_id.as_str(),
         team_id.as_deref(),
     );
+    crate::lifecycle::launch::apply_profile_launch_env(&mut env, &profile_launch);
+    let spawn_cwd = spawn_cwd_override
+        .or_else(|| {
+            agent
+                .get("spawn_cwd")
+                .and_then(|v| v.as_str())
+                .filter(|cwd| !cwd.is_empty())
+                .map(Path::new)
+        })
+        .unwrap_or(workspace);
     let result = if into_existing_session {
-        transport.spawn_into(session_name, &window, &argv, workspace, &env)
+        transport.spawn_into(session_name, &window, &plan.argv, spawn_cwd, &env)
     } else {
-        transport.spawn_first(session_name, &window, &argv, workspace, &env)
+        transport.spawn_first(session_name, &window, &plan.argv, spawn_cwd, &env)
     };
     let spawn = result.map_err(|e| LifecycleError::Transport(e.to_string()))?;
     let _ = adapter.handle_startup_prompts(
@@ -87,7 +143,11 @@ pub(super) fn spawn_agent_window(
         30,
         0.5,
     );
-    Ok(spawn)
+    Ok(SpawnedAgentWindow {
+        spawn,
+        plan,
+        profile_launch,
+    })
 }
 
 pub(super) fn start_coordinator_for_workspace(workspace: &Path) -> Result<bool, LifecycleError> {
@@ -97,6 +157,13 @@ pub(super) fn start_coordinator_for_workspace(workspace: &Path) -> Result<bool,
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
+pub(super) fn persist_effective_approval_policy_for_restart(
+    agent: &mut serde_json::Map<String, serde_json::Value>,
+    safety: &DangerousApproval,
+) {
+    crate::lifecycle::launch::persist_effective_approval_policy(agent, safety);
+}
+
 pub(super) fn state_session_name(state: &serde_json::Value) -> SessionName {
     state
         .get("session_name")
@@ -163,86 +230,106 @@ pub(super) fn agent_rollout_path(agent: &serde_json::Value) -> Option<RolloutPat
 pub(crate) fn refresh_missing_provider_sessions(
     state: &mut serde_json::Value,
 ) -> Result<bool, LifecycleError> {
-    let Some(agents) = state.get_mut("agents").and_then(serde_json::Value::as_object_mut) else {
-        return Ok(false);
-    };
-    let mut changed = false;
-    for (agent_id, agent) in agents {
-        let Some(agent_obj) = agent.as_object_mut() else {
-            continue;
-        };
-        if agent_obj
-            .get("session_id")
-            .and_then(serde_json::Value::as_str)
-            .is_some_and(|session| !session.is_empty())
-        {
-            continue;
-        }
-        let Some(spawn_cwd) = agent_obj
-            .get("spawn_cwd")
-            .and_then(serde_json::Value::as_str)
-            .filter(|cwd| !cwd.is_empty())
-        else {
-            continue;
-        };
-        let provider = agent_provider(&serde_json::Value::Object(agent_obj.clone()));
-        let adapter = crate::provider::get_adapter(provider);
-        let captured = adapter
-            .capture_session_id(agent_id, Path::new(spawn_cwd), 0)
-            .map_err(|e| LifecycleError::Provider(e.to_string()))?;
-        let Some(captured) = captured else {
-            continue;
-        };
-        if let Some(session_id) = captured.session_id {
-            agent_obj.insert(
-                "session_id".to_string(),
-                serde_json::json!(session_id.as_str()),
-            );
-            changed = true;
-        }
-        if let Some(rollout_path) = captured.rollout_path {
-            agent_obj.insert(
-                "rollout_path".to_string(),
-                serde_json::json!(rollout_path.as_path().to_string_lossy()),
-            );
-            changed = true;
-        }
-        agent_obj.insert(
-            "captured_at".to_string(),
-            serde_json::json!(chrono::Utc::now().to_rfc3339()),
-        );
-        agent_obj.insert(
-            "captured_via".to_string(),
-            serde_json::to_value(captured.captured_via)
-                .map_err(|e| LifecycleError::StatePersist(e.to_string()))?,
-        );
-        agent_obj.insert(
-            "attribution_confidence".to_string(),
-            serde_json::to_value(captured.attribution_confidence)
-                .map_err(|e| LifecycleError::StatePersist(e.to_string()))?,
-        );
+    crate::session_capture::capture_missing_provider_sessions_once(
+        state,
+        &mut crate::provider::get_adapter,
+        false,
+        0,
+    )
+    .map(|report| report.changed)
+    .map_err(|e| LifecycleError::Provider(e.to_string()))
+}
+
+pub(crate) fn converge_missing_provider_sessions(
+    state: &mut serde_json::Value,
+    deadline: std::time::Duration,
+    poll_interval: std::time::Duration,
+    workspace: &Path,
+    allow_fresh: bool,
+) -> Result<crate::session_capture::SessionConvergence, LifecycleError> {
+    crate::session_capture::converge_missing_provider_sessions(
+        state,
+        &mut crate::provider::get_adapter,
+        deadline,
+        poll_interval,
+        restart_required_missing_session_agent_ids,
+        |progress| {
+            let pending_agent_ids = progress.pending_agent_ids.clone();
+            write_session_convergence_progress_event(
+                workspace,
+                serde_json::json!({
+                    "ts": chrono::Utc::now().to_rfc3339(),
+                    "event": "provider.session.converging",
+                    "iteration": progress.iteration,
+                    "elapsed_ms": progress.elapsed_ms,
+                    "deadline_ms": progress.deadline_ms,
+                    "changed": progress.changed,
+                    "assigned": progress.assigned,
+                    "missing": progress.missing,
+                    "required_missing": progress.required_missing_agent_ids.clone(),
+                    "required_missing_agent_ids": progress.required_missing_agent_ids,
+                    "pending": pending_agent_ids,
+                    "pending_agent_ids": progress.pending_agent_ids,
+                    "candidate_count_by_agent": progress.candidate_count_by_agent,
+                    "remaining_ms": progress.remaining_ms,
+                    "allow_fresh": allow_fresh,
+                }),
+            )
+        },
+    )
+    .map_err(LifecycleError::StatePersist)
+}
+
+fn write_session_convergence_progress_event(
+    workspace: &Path,
+    event: serde_json::Value,
+) -> Result<(), String> {
+    use std::io::Write as _;
+
+    let path = workspace.join(".team").join("logs").join("events.jsonl");
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
     }
-    Ok(changed)
+    let line = serde_json::to_string(&event).map_err(|e| e.to_string())?;
+    let mut file = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)
+        .map_err(|e| e.to_string())?;
+    file.write_all(line.as_bytes())
+        .and_then(|_| file.write_all(b"\n"))
+        .map_err(|e| e.to_string())
 }
 
-/// Tools list off an agent's runtime state entry (`tools: [...]`). Restart paths
-/// don't have the full spec object, only the runtime state — so they read tools from
-/// the state row, falling back to an empty list. Contract C requires the worker
-/// command be built with the tool list, even on restart.
-pub(super) fn agent_tool_strings(agent: &serde_json::Value) -> Vec<String> {
-    agent
-        .get("tools")
-        .and_then(|v| v.as_array())
-        .map(|items| {
-            items
-                .iter()
-                .filter_map(|v| v.as_str())
-                .map(str::to_string)
-                .collect()
+pub(crate) fn restart_required_missing_session_agent_ids(state: &serde_json::Value) -> Vec<String> {
+    let mut missing = crate::session_capture::incomplete_resumable_agent_ids(state)
+        .into_iter()
+        .filter(|agent_id| {
+            let Some(agent) = state.get("agents").and_then(|agents| agents.get(agent_id)) else {
+                return false;
+            };
+            let missing_session_id = agent
+                .get("session_id")
+                .and_then(|value| value.as_str())
+                .is_none_or(|session| session.is_empty());
+            let is_running = agent
+                .get("status")
+                .and_then(|value| value.as_str())
+                .is_some_and(|status| status == "running");
+            let has_live_pane_binding = agent
+                .get("pane_id")
+                .and_then(|value| value.as_str())
+                .is_some_and(|pane| !pane.is_empty());
+            let has_interaction_marker = agent
+                .get("first_send_at")
+                .and_then(|value| value.as_str())
+                .is_some_and(|value| !value.is_empty());
+            missing_session_id && is_running && (has_live_pane_binding || has_interaction_marker)
         })
-        .unwrap_or_default()
+        .collect::<Vec<_>>();
+    missing.sort();
+    missing
 }
-
 pub(super) fn agent_window(agent: &serde_json::Value, agent_id: &AgentId) -> String {
     agent
         .get("window")