@team-agent/installer 0.3.14 → 0.3.16

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);
@@ -114,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(),
@@ -132,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,
@@ -162,6 +197,7 @@ pub(super) fn spawn_agent_window(
         spawn,
         plan,
         profile_launch,
+        layout_placement: layout_placement.cloned(),
     })
 }
 

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

@@ -281,6 +281,12 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         if fatal_resume_failure {
             continue;
         }
+        let layout_placement = crate::lifecycle::launch::adaptive_existing_placement_for_agent(
+            &state,
+            transport,
+            &session_name,
+            &decision.agent_id,
+        );
         let spawn = match spawn_agent_window(
             &selected.run_workspace,
             &session_name,
@@ -290,6 +296,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             session_live,
             transport,
             Some(&safety),
+            layout_placement.as_ref(),
             Some(spec_workspace),
         ) {
             Ok(spawn) => spawn,
@@ -312,7 +319,14 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         };
         if let Err(error) = verify_spawned_agent_live(&decision.agent_id, &spawn, transport)
             .and_then(|_| {
-                mark_agent_respawned(&mut state, &decision.agent_id, &spawn, transport, &safety)
+                mark_agent_respawned(
+                    &mut state,
+                    &decision.agent_id,
+                    decision.restart_mode,
+                    &spawn,
+                    transport,
+                    &safety,
+                )
             })
         {
             let error = error.to_string();
@@ -381,13 +395,17 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         restart_readiness_deadline(readiness_deadline_ms),
         restart_readiness_poll_interval(),
     )?;
-    let attach_commands = crate::tmux_backend::attach_commands_for_windows(
-        &selected.run_workspace,
-        &session_name,
+    let attach_windows = crate::lifecycle::launch::attach_window_names_for_state_agents(
+        &state,
         successful_agents
             .iter()
             .map(|decision| decision.agent_id.as_str()),
     );
+    let attach_commands = crate::tmux_backend::attach_commands_for_windows(
+        &selected.run_workspace,
+        &session_name,
+        attach_windows.iter().map(String::as_str),
+    );
     let mut next_actions = attach_commands.clone();
     if !failed_agents.is_empty() {
         next_actions.extend(restart_failure_next_actions(&failed_agents));
@@ -851,6 +869,7 @@ fn mark_restart_targets_stopped_after_teardown(
 fn mark_agent_respawned(
     state: &mut serde_json::Value,
     agent_id: &AgentId,
+    restart_mode: StartMode,
     spawn: &SpawnedAgentWindow,
     transport: &dyn crate::transport::Transport,
     safety: &DangerousApproval,
@@ -867,6 +886,10 @@ fn mark_agent_respawned(
         )));
     };
     agent.insert("status".to_string(), serde_json::json!("running"));
+    agent.insert(
+        "window".to_string(),
+        serde_json::json!(spawn.spawn.window.as_str()),
+    );
     agent.insert(
         "pane_id".to_string(),
         serde_json::json!(spawn.spawn.pane_id.as_str()),
@@ -882,8 +905,60 @@ fn mark_agent_respawned(
     if let Some(pane_pid) = pane_pid {
         agent.insert("pane_pid".to_string(), serde_json::json!(pane_pid));
     }
+    if matches!(
+        restart_mode,
+        StartMode::Fresh | StartMode::FreshAfterMissingRollout
+    ) {
+        if let Some(session_id) = spawn.plan.expected_session_id.as_ref() {
+            agent.insert(
+                "session_id".to_string(),
+                serde_json::json!(session_id.as_str()),
+            );
+        }
+    }
     crate::lifecycle::launch::persist_command_plan_state(agent, &spawn.plan, &spawn.profile_launch);
     persist_effective_approval_policy_for_restart(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,
+            }),
+        );
+    }
+    if matches!(
+        restart_mode,
+        StartMode::Fresh | StartMode::FreshAfterMissingRollout
+    ) && spawn.plan.expected_session_id.is_some()
+    {
+        agent.insert("rollout_path".to_string(), serde_json::Value::Null);
+        agent.insert("captured_at".to_string(), serde_json::Value::Null);
+        agent.insert("captured_via".to_string(), serde_json::Value::Null);
+        agent.insert(
+            "attribution_confidence".to_string(),
+            serde_json::Value::Null,
+        );
+    }
     agent.remove("startup_prompts");
     agent.remove("startup_prompt_status");
     Ok(())

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

@@ -213,14 +213,21 @@ fn plan_condition_rejects_out_of_grammar() {
 
 // ───────────────────────────────────────────────────────────────────────
 // resolve_display_backend — display/backend.py
-// 默认 none;非默认非静默(non_default=true 触发 display.backend_resolved)。
+// 默认 adaptive;显式 none 是逃生口。
 // ───────────────────────────────────────────────────────────────────────
 
 #[test]
-fn resolve_backend_defaults_to_none_when_none_requested() {
+fn resolve_backend_defaults_to_adaptive_when_none_requested() {
     let r = resolve_display_backend(None, None);
+    assert_eq!(r.backend, DisplayBackend::Adaptive);
+    assert!(!r.non_default, "默认 adaptive 不应标记 non_default");
+}
+
+#[test]
+fn resolve_backend_explicit_none_is_escape_hatch() {
+    let r = resolve_display_backend(Some(DisplayBackend::None), None);
     assert_eq!(r.backend, DisplayBackend::None);
-    assert!(!r.non_default, "默认 none 不应标记 non_default");
+    assert!(r.non_default, "显式 none 是偏离默认 adaptive 的逃生口");
 }
 
 #[test]
@@ -732,8 +739,10 @@ fn remove_agent_without_from_spec_is_refused_confirm() {
         Ok(RemoveAgentOutcome::RefusedFromSpecConfirm { agent_id }) => {
             assert_eq!(agent_id, aid("w1"));
         }
-        // 若先撞 owner / 缺 state 门也可接受(门在 confirm 之前)。
-        Err(LifecycleError::OwnerRefused(_)) | Err(LifecycleError::TeamSelect(_)) => {}
+        // 若先撞 owner / 缺 state / runtime-missing 门也可接受(门在 confirm 之前)。
+        Err(LifecycleError::OwnerRefused(_))
+        | Err(LifecycleError::RequirementUnmet(_))
+        | Err(LifecycleError::TeamSelect(_)) => {}
         other => panic!("from_spec=false 应 RefusedFromSpecConfirm 或更上游门:{other:?}"),
     }
 }