@team-agent/installer 0.3.34 → 0.3.35

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.34"
+version = "0.3.35"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.34"
+version = "0.3.35"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/mod.rs

@@ -158,13 +158,7 @@ pub mod lifecycle_port {
             crate::leader::LeaderLaunchStatus::Detached => true,
             crate::leader::LeaderLaunchStatus::NotStarted => false,
         };
-        let leader_attach_command = if plan.is_external_leader {
-            None
-        } else {
-            plan.session_name.as_ref().and_then(|session| {
-                crate::tmux_backend::attach_command_for_workspace(cwd, session, "leader")
-            })
-        };
+        let leader_attach_command = leader_attach_command_for_plan(cwd, &plan);
         Ok(json!({
             "ok": ok,
             "provider": provider,
@@ -182,6 +176,18 @@ pub mod lifecycle_port {
             "session_name": plan.session_name.as_ref().map(|session| session.as_str().to_string()),
         }))
     }
+
+    pub(crate) fn leader_attach_command_for_plan(
+        cwd: &Path,
+        plan: &crate::leader::LeaderStartPlan,
+    ) -> Option<String> {
+        if plan.is_external_leader {
+            return None;
+        }
+        let session = plan.session_name.as_ref()?;
+        let window = plan.leader_window.as_ref()?;
+        crate::tmux_backend::attach_command_for_workspace(cwd, session, window.as_str())
+    }
     /// `runtime.shutdown`(`cmd_shutdown`)。
     pub fn shutdown(workspace: &Path, keep_logs: bool, team: Option<&str>) -> Result<Value, CliError> {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)

package/crates/team-agent/src/cli/status_port.rs

@@ -53,11 +53,15 @@ use rusqlite::params;
         let leader_attach_command = if is_external_leader {
             None
         } else {
+            let window_name = state
+                .pointer("/leader_receiver/window_name")
+                .and_then(Value::as_str)
+                .unwrap_or("leader");
             session_name.as_str().and_then(|session| {
                 crate::tmux_backend::attach_command_for_workspace(
                     workspace,
                     &crate::transport::SessionName::new(session.to_string()),
-                    "leader",
+                    window_name,
                 )
             })
         };

package/crates/team-agent/src/cli/tests/status_send.rs

@@ -86,6 +86,59 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn status_port_managed_attach_command_uses_receiver_window_name() {
+        let ws = seed_status_workspace();
+        let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        if let Some(obj) = state.as_object_mut() {
+            obj.insert("is_external_leader".to_string(), json!(false));
+            obj.insert("session_name".to_string(), json!("team-current"));
+            obj.insert(
+                "leader_receiver".to_string(),
+                json!({"pane_id": "%3", "window_name": "claude_code", "status": "attached"}),
+            );
+        }
+        crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+
+        let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
+
+        let attach = v["leader_attach_command"]
+            .as_str()
+            .expect("managed status includes attach command");
+        assert!(attach.contains("attach -t team-current:claude_code"), "{attach}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn leader_attach_command_for_plan_uses_plan_leader_window() {
+        let ws = tmp_workspace();
+        let plan = crate::leader::LeaderStartPlan {
+            mode: crate::leader::LeaderStartMode::ManagedTmuxClient,
+            provider: crate::provider::Provider::ClaudeCode,
+            workspace: ws.clone(),
+            socket: crate::leader::LeaderLaunchSocket::Workspace,
+            session_name: Some(crate::transport::SessionName::new(
+                "team-agent-leader-claude_code-demo".to_string(),
+            )),
+            argv: Vec::new(),
+            provider_argv: Vec::new(),
+            leader_window: Some(crate::transport::WindowName::new("claude_code")),
+            is_external_leader: false,
+            leader_env: std::collections::BTreeMap::new(),
+            identity: None,
+            detached: false,
+        };
+
+        let attach = lifecycle_port::leader_attach_command_for_plan(&ws, &plan)
+            .expect("managed plan has attach command");
+
+        assert!(
+            attach.contains("attach -t team-agent-leader-claude_code-demo:claude_code"),
+            "{attach}"
+        );
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn status_port_missing_topology_marker_defaults_to_managed() {
         let ws = seed_status_workspace();

package/crates/team-agent/src/leader/start.rs

@@ -7,7 +7,9 @@ use std::process::{Command, Stdio};
 
 use crate::provider::{get_adapter, Provider};
 use crate::tmux_backend::TmuxBackend;
-use crate::transport::{PaneId, SessionName, SpawnResult, Target, Transport, WindowName};
+use crate::transport::{
+    PaneId, PaneLiveness, SessionName, SpawnResult, Target, Transport, WindowName,
+};
 
 use super::helpers::{
     provider_wire, resolve_workspace_for_hash, sanitize_session_folder, sha1_hex_prefix,
@@ -405,6 +407,7 @@ fn execute_managed_leader_plan(
                 .unwrap_or_else(|| "signal".to_string())
         )));
     }
+    ensure_managed_provider_live_after_attach(&transport, &spawned)?;
     Ok(LeaderLaunchOutcome {
         status: LeaderLaunchStatus::Exited,
         exit_code: code,
@@ -414,7 +417,7 @@ fn execute_managed_leader_plan(
 }
 
 fn ensure_managed_leader_pane(
-    transport: &TmuxBackend,
+    transport: &dyn Transport,
     session: &SessionName,
     window: &WindowName,
     plan: &LeaderStartPlan,
@@ -455,6 +458,39 @@ fn ensure_managed_leader_pane(
     }
 }
 
+fn ensure_managed_provider_live_after_attach(
+    transport: &dyn Transport,
+    spawned: &SpawnResult,
+) -> Result<(), LeaderError> {
+    let live = match transport.liveness(&spawned.pane_id) {
+        Ok(PaneLiveness::Live) => true,
+        Ok(PaneLiveness::Dead) => false,
+        Ok(PaneLiveness::Unknown) | Err(_) => managed_spawned_pane_in_targets(transport, spawned),
+    };
+    if live {
+        return Ok(());
+    }
+    Err(LeaderError::Start(format!(
+        "managed leader provider pane is not running after tmux client returned: {} {}:{}",
+        spawned.pane_id.as_str(),
+        spawned.session.as_str(),
+        spawned.window.as_str()
+    )))
+}
+
+fn managed_spawned_pane_in_targets(transport: &dyn Transport, spawned: &SpawnResult) -> bool {
+    transport
+        .list_targets()
+        .unwrap_or_default()
+        .iter()
+        .any(|pane| {
+            pane.pane_id.as_str() == spawned.pane_id.as_str()
+                && pane.session.as_str() == spawned.session.as_str()
+                && pane.window_name.as_ref().map(WindowName::as_str)
+                    == Some(spawned.window.as_str())
+        })
+}
+
 fn persist_managed_leader_binding(
     plan: &LeaderStartPlan,
     workspace: &Path,
@@ -911,11 +947,16 @@ mod tests {
         TurnVerification, WindowName,
     };
 
-    use super::{execute_leader_plan, handle_exec_provider_startup_prompts, shlex_quote};
+    use super::{
+        ensure_managed_provider_live_after_attach, execute_leader_plan,
+        handle_exec_provider_startup_prompts, shlex_quote,
+    };
 
     struct ScriptedTransport {
         screens: Mutex<Vec<String>>,
         sent: Mutex<Vec<(Target, Vec<Key>)>>,
+        liveness: PaneLiveness,
+        targets: Vec<PaneInfo>,
     }
 
     impl ScriptedTransport {
@@ -923,6 +964,26 @@ mod tests {
             Self {
                 screens: Mutex::new(screens),
                 sent: Mutex::new(Vec::new()),
+                liveness: PaneLiveness::Unknown,
+                targets: Vec::new(),
+            }
+        }
+
+        fn with_liveness(liveness: PaneLiveness) -> Self {
+            Self {
+                screens: Mutex::new(Vec::new()),
+                sent: Mutex::new(Vec::new()),
+                liveness,
+                targets: Vec::new(),
+            }
+        }
+
+        fn with_liveness_and_targets(liveness: PaneLiveness, targets: Vec<PaneInfo>) -> Self {
+            Self {
+                screens: Mutex::new(Vec::new()),
+                sent: Mutex::new(Vec::new()),
+                liveness,
+                targets,
             }
         }
 
@@ -1024,11 +1085,11 @@ mod tests {
         }
 
         fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
-            Ok(PaneLiveness::Unknown)
+            Ok(self.liveness)
         }
 
         fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-            Ok(Vec::new())
+            Ok(self.targets.clone())
         }
 
         fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
@@ -1063,6 +1124,69 @@ mod tests {
         }
     }
 
+    fn managed_spawn_result() -> SpawnResult {
+        SpawnResult {
+            pane_id: PaneId::new("%42"),
+            session: SessionName::new("team-agent-leader-claude_code-demo"),
+            window: WindowName::new("claude_code"),
+            child_pid: Some(1234),
+        }
+    }
+
+    fn managed_pane_info(spawned: &SpawnResult) -> PaneInfo {
+        PaneInfo {
+            pane_id: spawned.pane_id.clone(),
+            session: spawned.session.clone(),
+            window_index: Some(0),
+            window_name: Some(spawned.window.clone()),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("claude".to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: spawned.child_pid,
+            leader_env: BTreeMap::new(),
+        }
+    }
+
+    #[test]
+    fn managed_attach_success_requires_live_provider_pane() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness(PaneLiveness::Dead);
+
+        let err = ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect_err("dead provider pane must fail managed launch");
+
+        let text = err.to_string();
+        assert!(
+            text.contains("managed leader provider pane is not running"),
+            "{text}"
+        );
+        assert!(text.contains("%42"), "{text}");
+        assert!(text.contains("claude_code"), "{text}");
+    }
+
+    #[test]
+    fn managed_attach_success_accepts_live_provider_pane() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness(PaneLiveness::Live);
+
+        ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect("live provider pane keeps managed launch successful");
+    }
+
+    #[test]
+    fn managed_attach_success_uses_target_scan_when_liveness_unknown() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness_and_targets(
+            PaneLiveness::Unknown,
+            vec![managed_pane_info(&spawned)],
+        );
+
+        ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect("target scan can prove provider pane is still live");
+    }
+
     struct EnvGuard {
         saved: Vec<(&'static str, Option<String>)>,
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.34",
+  "version": "0.3.35",
   "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.34",
-    "@team-agent/cli-darwin-x64": "0.3.34",
-    "@team-agent/cli-linux-x64": "0.3.34"
+    "@team-agent/cli-darwin-arm64": "0.3.35",
+    "@team-agent/cli-darwin-x64": "0.3.35",
+    "@team-agent/cli-linux-x64": "0.3.35"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",