@team-agent/installer 0.3.15 → 0.3.16

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

@@ -858,6 +858,7 @@ fn save_launched_team_state_for_key(
         );
     }
     promote_launched_binding_from_team_entry(&mut launched, &launched_key);
+    preserve_existing_leader_topology(&existing, &launched_key, &mut launched);
     drop_foreign_seeded_owner(&existing, &launched_key, &mut launched);
     drop_bare_worker_seeded_owner(&mut launched, &launched_key);
     let merged = if team_key.is_some() {
@@ -871,6 +872,28 @@ fn save_launched_team_state_for_key(
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
+fn preserve_existing_leader_topology(
+    existing: &serde_json::Value,
+    launched_key: &str,
+    launched: &mut serde_json::Value,
+) {
+    let Some(obj) = launched.as_object_mut() else {
+        return;
+    };
+    let existing_team = existing
+        .get("teams")
+        .and_then(serde_json::Value::as_object)
+        .and_then(|teams| teams.get(launched_key))
+        .unwrap_or(existing);
+    for key in ["is_external_leader", "leader_client"] {
+        if !obj.contains_key(key) {
+            if let Some(value) = existing_team.get(key).or_else(|| existing.get(key)) {
+                obj.insert(key.to_string(), value.clone());
+            }
+        }
+    }
+}
+
 fn drop_bare_worker_seeded_owner(launched: &mut serde_json::Value, launched_key: &str) {
     if has_positive_caller_leader_env() {
         return;
@@ -2834,7 +2857,12 @@ pub fn quick_start_with_transport_in_workspace_with_display(
     //   asynchronously after spawn), so the verdict is PendingToolLoad — never
     //   bare Ready.
     let worker_readiness = quick_start_worker_readiness(&workspace, &state_team_key);
-    let attach_windows = started_attach_window_names(&launch.started);
+    let attach_windows = load_runtime_state(&workspace)
+        .ok()
+        .map(|state| {
+            attach_window_names_with_managed_leader(&state, started_attach_window_names(&launch.started))
+        })
+        .unwrap_or_else(|| started_attach_window_names(&launch.started));
     let attach_commands = attach_commands_for_runtime_windows(
         launch.tmux_endpoint.as_deref(),
         &workspace,
@@ -2934,8 +2962,33 @@ fn started_attach_window_names(started: &[StartedAgent]) -> Vec<String> {
     windows
 }
 
+pub(crate) fn attach_window_names_for_state_agents<'a>(
+    state: &serde_json::Value,
+    agent_ids: impl IntoIterator<Item = &'a str>,
+) -> Vec<String> {
+    let windows = agent_ids
+        .into_iter()
+        .map(|agent_id| {
+            state
+                .get("agents")
+                .and_then(serde_json::Value::as_object)
+                .and_then(|agents| agents.get(agent_id))
+                .and_then(|agent| {
+                    agent
+                        .get("layout_window")
+                        .or_else(|| agent.get("window"))
+                        .and_then(serde_json::Value::as_str)
+                        .filter(|window| !window.is_empty())
+                })
+                .unwrap_or(agent_id)
+                .to_string()
+        })
+        .collect::<Vec<_>>();
+    attach_window_names_with_managed_leader(state, windows)
+}
+
 fn quick_start_attach_window_names(state: &serde_json::Value) -> Vec<String> {
-    let mut windows = state
+    let windows = state
         .get("agents")
         .and_then(serde_json::Value::as_object)
         .map(|agents| {
@@ -2952,11 +3005,28 @@ fn quick_start_attach_window_names(state: &serde_json::Value) -> Vec<String> {
                 .collect::<Vec<_>>()
         })
         .unwrap_or_default();
+    attach_window_names_with_managed_leader(state, windows)
+}
+
+fn attach_window_names_with_managed_leader(
+    state: &serde_json::Value,
+    mut windows: Vec<String>,
+) -> Vec<String> {
+    if state_uses_managed_leader(state) {
+        windows.push("leader".to_string());
+    }
     windows.sort();
     windows.dedup();
     windows
 }
 
+fn state_uses_managed_leader(state: &serde_json::Value) -> bool {
+    state
+        .get("is_external_leader")
+        .and_then(serde_json::Value::as_bool)
+        .is_some_and(|external| !external)
+}
+
 /// BUG-7 helper: derive a [`QuickStartReadiness`] verdict from the just-written
 /// runtime state. Reads `agents[*].status`; any non-`running` agent flips the
 /// verdict to `Degraded { unhealthy_agents }` (sorted, deduped); otherwise

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

@@ -395,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));

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

@@ -1205,6 +1205,69 @@ fn quick_start_persists_selected_tmux_endpoint_and_attach_commands() {
     assert_eq!(state["tmux_socket"], json!(endpoint));
 }
 
+#[test]
+fn quick_start_preserves_managed_leader_topology_and_emits_leader_attach_command() {
+    let team = quick_start_team_dir(QS_VALID_ROLE);
+    let workspace = team.parent().expect("team_workspace(team_dir) = parent");
+    seed_healthy_coordinator(workspace);
+    crate::state::persist::save_runtime_state(
+        workspace,
+        &json!({
+            "active_team_key": "teamdir",
+            "session_name": "team-teamdir",
+            "is_external_leader": false,
+            "leader_client": {"diagnostic_only": true, "attach_mode": "attach-session"},
+            "leader_receiver": {"mode": "direct_tmux", "status": "attached", "pane_id": "%42"},
+            "team_owner": {"pane_id": "%42", "owner_epoch": 1},
+            "agents": {},
+            "teams": {
+                "teamdir": {
+                    "session_name": "team-teamdir",
+                    "is_external_leader": false,
+                    "leader_client": {"diagnostic_only": true, "attach_mode": "attach-session"},
+                    "agents": {}
+                }
+            }
+        }),
+    )
+    .expect("seed managed leader state");
+    let transport = OfflineTransport::new();
+
+    let report = quick_start_with_transport(&team, None, true, true, None, &transport)
+        .expect("quick_start_with_transport must reach Ready");
+    let attach_commands = match report {
+        QuickStartReport::Ready { attach_commands, .. } => attach_commands,
+        other => panic!("quick_start must reach Ready; got {other:?}"),
+    };
+
+    assert!(
+        attach_commands.iter().any(|cmd| cmd.contains(":leader")),
+        "managed topology quick-start output must include the leader window attach command: {attach_commands:?}"
+    );
+    let (_raw, state) = raw_runtime_state(workspace);
+    assert_eq!(state["is_external_leader"], json!(false));
+    assert_eq!(state["leader_client"]["diagnostic_only"], json!(true));
+}
+
+#[test]
+fn attach_window_names_for_state_agents_include_managed_leader_and_layout_windows() {
+    let state = json!({
+        "is_external_leader": false,
+        "agents": {
+            "w1": {"layout_window": "team-w1", "window": "w1"},
+            "w2": {"layout_window": "team-w1", "window": "w2"},
+            "w4": {"layout_window": "team-w2", "window": "w4"}
+        }
+    });
+
+    let windows = crate::lifecycle::launch::attach_window_names_for_state_agents(
+        &state,
+        ["w1", "w2", "w4"].into_iter(),
+    );
+
+    assert_eq!(windows, vec!["leader", "team-w1", "team-w2"]);
+}
+
 #[test]
 fn quick_start_no_display_keeps_one_window_per_agent() {
     let roles = ["w1", "w2"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.3.15",
-    "@team-agent/cli-darwin-x64": "0.3.15",
-    "@team-agent/cli-linux-x64": "0.3.15"
+    "@team-agent/cli-darwin-arm64": "0.3.16",
+    "@team-agent/cli-darwin-x64": "0.3.16",
+    "@team-agent/cli-linux-x64": "0.3.16"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",