@team-agent/installer 0.3.13 → 0.3.15

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

@@ -86,7 +86,14 @@ pub(crate) fn start_agent_at_paths(
     }
     let session_name = state_session_name(&state);
     let window = agent_window(&agent, agent_id);
-    if !force && window_exists(transport, &session_name, &window) {
+    let adaptive_layout =
+        open_display && crate::lifecycle::launch::state_uses_adaptive_layout(&state);
+    let agent_live = if adaptive_layout {
+        agent_pane_live(transport, &agent)
+    } else {
+        window_exists(transport, &session_name, &window)
+    };
+    if !force && agent_live {
         mark_agent_running_noop(&mut state, agent_id, &session_name, &window)?;
         crate::state::projection::save_team_scoped_state(workspace, &state)
             .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
@@ -141,6 +148,28 @@ 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 layout_placement = if adaptive_layout {
+        crate::lifecycle::launch::adaptive_existing_placement_for_agent(
+            &state,
+            transport,
+            &session_name,
+            agent_id,
+        )
+        .or_else(|| {
+            crate::lifecycle::launch::adaptive_placement_for_agent(
+                &state,
+                transport,
+                &session_name,
+                agent_id,
+            )
+        })
+    } else {
+        None
+    };
+    let spawn_window = layout_placement
+        .as_ref()
+        .map(|placement| placement.layout_window.as_str().to_string())
+        .unwrap_or_else(|| window.clone());
     let spawn = spawn_agent_window(
         workspace,
         &session_name,
@@ -150,9 +179,10 @@ pub(crate) fn start_agent_at_paths(
         into_existing_session,
         transport,
         Some(&safety),
+        layout_placement.as_ref(),
         None,
     )?;
-    mark_agent_started(&mut state, agent_id, &window, &spawn, &safety)?;
+    mark_agent_started(&mut state, agent_id, &spawn_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(
@@ -162,9 +192,9 @@ pub(crate) fn start_agent_at_paths(
         provider,
         start_mode,
         &session_name,
-        &window,
+        &spawn_window,
         spawn_session_id,
-        into_existing_session,
+        tmux_start_mode_for_spawn(&spawn, into_existing_session),
     )?;
     let coordinator_started = start_coordinator_for_workspace(workspace)?;
     Ok(StartAgentOutcome::Running {
@@ -180,6 +210,55 @@ pub(crate) fn start_agent_at_paths(
     })
 }
 
+fn agent_pane_live(
+    transport: &dyn crate::transport::Transport,
+    agent: &serde_json::Value,
+) -> bool {
+    let Some(pane) = agent
+        .get("pane_id")
+        .and_then(serde_json::Value::as_str)
+        .filter(|pane| !pane.is_empty())
+        .map(crate::transport::PaneId::new)
+    else {
+        return false;
+    };
+    agent_pane_live_by_id(transport, &pane)
+}
+
+fn agent_pane_live_by_id(
+    transport: &dyn crate::transport::Transport,
+    pane: &crate::transport::PaneId,
+) -> bool {
+    match transport.has_pane(&pane) {
+        Ok(Some(live)) => live,
+        Ok(None) | Err(_) => !matches!(
+            transport.liveness(&pane),
+            Ok(crate::model::enums::PaneLiveness::Dead)
+        ),
+    }
+}
+
+fn tmux_start_mode_for_spawn(
+    spawn: &SpawnedAgentWindow,
+    into_existing_session: bool,
+) -> &'static str {
+    if let Some(placement) = spawn.layout_placement.as_ref() {
+        if placement.starts_window {
+            if into_existing_session {
+                "new-window"
+            } else {
+                "new-session"
+            }
+        } else {
+            "split-window"
+        }
+    } else if into_existing_session {
+        "new-window"
+    } else {
+        "new-session"
+    }
+}
+
 /// `stop_agent(workspace, agent_id, team)`(`lifecycle/operations.py:62`)。
 /// owner-gate → kill window → **同时关显示** → 写 state。
 pub fn stop_agent(
@@ -233,16 +312,34 @@ pub(super) fn stop_agent_at_paths(
         .filter(|s| !s.is_empty())
         .unwrap_or_else(|| agent_id.as_str())
         .to_string();
-    let target_str = format!("{}:{window}", session_name.as_str());
-    let stopped = window_exists(transport, &session_name, &window);
+    let pane_id = state
+        .get("agents")
+        .and_then(|v| v.get(agent_id.as_str()))
+        .and_then(|v| v.get("pane_id"))
+        .and_then(|v| v.as_str())
+        .filter(|pane| !pane.is_empty())
+        .map(crate::transport::PaneId::new);
+    let target_str = pane_id
+        .as_ref()
+        .map(|pane| pane.as_str().to_string())
+        .unwrap_or_else(|| format!("{}:{window}", session_name.as_str()));
+    let stopped = pane_id
+        .as_ref()
+        .map(|pane| agent_pane_live_by_id(transport, pane))
+        .unwrap_or_else(|| window_exists(transport, &session_name, &window));
     if stopped {
-        let target = Target::SessionWindow {
-            session: session_name.clone(),
-            window: WindowName::new(&window),
-        };
         // golden operations.py:84-86: a non-zero kill-window raises
         // RuntimeError(f"failed to stop agent {agent_id}: {proc.stderr.strip()}").
-        if let Err(e) = transport.kill_window(&target) {
+        let kill_result = if let Some(pane) = pane_id.as_ref() {
+            transport.kill_pane(pane)
+        } else {
+            let target = Target::SessionWindow {
+                session: session_name.clone(),
+                window: WindowName::new(&window),
+            };
+            transport.kill_window(&target)
+        };
+        if let Err(e) = kill_result {
             let stderr = match &e {
                 crate::transport::TransportError::Subprocess { stderr, .. } => stderr.trim().to_string(),
                 other => other.to_string(),
@@ -335,6 +432,34 @@ fn mark_agent_started(
         &spawn.profile_launch,
     );
     crate::lifecycle::launch::persist_effective_approval_policy(agent, safety);
+    if let Some(placement) = spawn.layout_placement.as_ref() {
+        agent.insert(
+            "layout_window".to_string(),
+            serde_json::json!(placement.layout_window.as_str()),
+        );
+        agent.insert(
+            "layout_index".to_string(),
+            serde_json::json!(placement.layout_index),
+        );
+        agent.insert("pane_index".to_string(), serde_json::json!(placement.pane_index));
+        agent.insert(
+            "display".to_string(),
+            serde_json::json!({
+                "backend": "adaptive",
+                "status": "opened",
+                "window": placement.layout_window.as_str(),
+                "workspace_window": null,
+                "pane_id": spawn.spawn.pane_id.as_str(),
+                "pane_title": agent_id.as_str(),
+                "target": spawn.spawn.pane_id.as_str(),
+                "target_worker_session": spawn.spawn.session.as_str(),
+                "linked_session": null,
+                "leader_session": spawn.spawn.session.as_str(),
+                "display_session": null,
+                "fallback": null,
+            }),
+        );
+    }
     Ok(())
 }
 
@@ -458,7 +583,7 @@ fn write_start_agent_start_event(
     session_name: &SessionName,
     window: &str,
     session_id: Option<&SessionId>,
-    into_existing_session: bool,
+    tmux_start_mode: &'static str,
 ) -> Result<(), LifecycleError> {
     let auth_mode = agent_auth_mode(agent);
     let model = agent.get("model").and_then(|v| v.as_str());
@@ -535,11 +660,6 @@ fn write_start_agent_start_event(
         agent_id.as_str(),
         team_id,
     );
-    let tmux_start_mode = if into_existing_session {
-        "new-window"
-    } else {
-        "new-session"
-    };
     crate::event_log::EventLog::new(workspace)
         .write(
             "start_agent.agent_start",

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

@@ -4,6 +4,7 @@ pub(super) struct SpawnedAgentWindow {
     pub spawn: crate::transport::SpawnResult,
     pub plan: crate::provider::CommandPlan,
     pub profile_launch: crate::provider::ProviderProfileLaunch,
+    pub layout_placement: Option<crate::lifecycle::launch::LayoutPlacement>,
 }
 
 pub(super) fn spawn_agent_window(
@@ -15,6 +16,7 @@ pub(super) fn spawn_agent_window(
     into_existing_session: bool,
     transport: &dyn crate::transport::Transport,
     safety: Option<&DangerousApproval>,
+    layout_placement: Option<&crate::lifecycle::launch::LayoutPlacement>,
     spawn_cwd_override: Option<&Path>,
 ) -> Result<SpawnedAgentWindow, LifecycleError> {
     let provider = agent_provider(agent);
@@ -36,12 +38,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 +61,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 +74,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 +86,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),
@@ -115,7 +116,9 @@ pub(super) fn spawn_agent_window(
         agent_id.as_str(),
         team_id.as_deref(),
     );
-    let window = WindowName::new(agent_id.as_str());
+    let window = layout_placement
+        .map(|placement| placement.layout_window.clone())
+        .unwrap_or_else(|| WindowName::new(agent_id.as_str()));
     let mut env = crate::lifecycle::launch::inherited_env_with_team_overrides(
         workspace,
         agent_id.as_str(),
@@ -133,7 +136,38 @@ pub(super) fn spawn_agent_window(
         })
         .unwrap_or(workspace);
     let env_unset: Vec<String> = profile_launch.env_unset.iter().cloned().collect();
-    let result = if into_existing_session {
+    let result = if let Some(placement) = layout_placement {
+        if placement.starts_window {
+            if into_existing_session {
+                transport.spawn_into_with_env_unset(
+                    session_name,
+                    &window,
+                    &plan.argv,
+                    spawn_cwd,
+                    &env,
+                    &env_unset,
+                )
+            } else {
+                transport.spawn_first_with_env_unset(
+                    session_name,
+                    &window,
+                    &plan.argv,
+                    spawn_cwd,
+                    &env,
+                    &env_unset,
+                )
+            }
+        } else {
+            transport.spawn_split_with_env_unset(
+                session_name,
+                &window,
+                &plan.argv,
+                spawn_cwd,
+                &env,
+                &env_unset,
+            )
+        }
+    } else if into_existing_session {
         transport.spawn_into_with_env_unset(
             session_name,
             &window,
@@ -163,6 +197,7 @@ pub(super) fn spawn_agent_window(
         spawn,
         plan,
         profile_launch,
+        layout_placement: layout_placement.cloned(),
     })
 }
 
@@ -252,19 +287,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 +354,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 +514,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 +527,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 +757,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())