@team-agent/installer 0.5.43 → 0.5.44

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.43"
+version = "0.5.44"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.43"
+version = "0.5.44"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -4100,7 +4100,7 @@ pub mod leader_port {
                 "action": "rerun with --confirm to claim ownership of this team",
             }));
         }
-        let state = crate::state::persist::load_runtime_state(workspace)
+        let state = crate::state::persist::load_runtime_state_without_migrations(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let Some(team_id) = resolve_owner_team_id(&state, team) else {
             return Ok(json!({
@@ -4112,8 +4112,7 @@ pub mod leader_port {
             }));
         };
         let requested_team = team;
-        let explicit_team = requested_team.filter(|team| !team.is_empty());
-        let resolved_team = explicit_team.map(|_| team_id.as_str().to_string());
+        let resolved_team = Some(team_id.as_str().to_string());
         if !positive_caller_pane_env_present() {
             let bind = crate::leader::bind_owner_from_caller_pane(workspace, &team_id, None)
                 .map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -4124,6 +4123,7 @@ pub mod leader_port {
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let mut value = lease_value(result);
         insert_resolved_team(&mut value, requested_team, resolved_team.as_deref());
+        append_team_session_ready(workspace, resolved_team.as_deref(), &mut value);
         if value.get("ok").and_then(Value::as_bool) == Some(true) {
             emit_topology_convergence_event(
                 workspace,
@@ -4137,6 +4137,7 @@ pub mod leader_port {
                 "takeover",
                 &mut value,
             );
+            restore_non_target_teams(workspace, &state, resolved_team.as_deref());
         }
         Ok(value)
     }
@@ -4146,7 +4147,7 @@ pub mod leader_port {
         team: Option<&str>,
         confirm: bool,
     ) -> Result<Value, CliError> {
-        let state = crate::state::persist::load_runtime_state(workspace)
+        let state = crate::state::persist::load_runtime_state_without_migrations(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let Some(team_id) = resolve_owner_team_id(&state, team) else {
             return Ok(json!({
@@ -4165,12 +4166,12 @@ pub mod leader_port {
             }
             return Ok(owner_bind_value(bind));
         }
-        let explicit_team = team.filter(|team| !team.is_empty());
-        let resolved_team = explicit_team.map(|_| team_id.as_str().to_string());
+        let resolved_team = Some(team_id.as_str().to_string());
         let result = crate::leader::claim_leader(workspace, resolved_team.as_deref(), confirm)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let mut value = lease_value(result);
         insert_resolved_team(&mut value, team, resolved_team.as_deref());
+        append_team_session_ready(workspace, resolved_team.as_deref(), &mut value);
         if value.get("ok").and_then(Value::as_bool) == Some(true) {
             emit_topology_convergence_event(
                 workspace,
@@ -4184,6 +4185,7 @@ pub mod leader_port {
                 "claim-leader",
                 &mut value,
             );
+            restore_non_target_teams(workspace, &state, resolved_team.as_deref());
         }
         Ok(value)
     }
@@ -4279,6 +4281,7 @@ pub mod leader_port {
                 "owner_epoch": convergence.get("owner_epoch").cloned().unwrap_or(Value::Null),
                 "persisted": convergence.get("persisted").cloned().unwrap_or(Value::Bool(false)),
                 "checked_paths": convergence.get("checked_paths").cloned().unwrap_or_else(|| json!([])),
+                "team_session_ready": response.get("team_session_ready").cloned().unwrap_or(Value::Null),
             }),
         );
     }
@@ -4344,9 +4347,96 @@ pub mod leader_port {
                     | crate::state::projection::OwnerTeamResolution::Ambiguous { .. } => None,
                 }
             }
-            None => Some(TeamKey::new(crate::state::projection::team_state_key(
-                state,
-            ))),
+            None => Some(TeamKey::new(active_or_derived_team_key(state))),
+        }
+    }
+
+    fn active_or_derived_team_key(state: &Value) -> String {
+        state
+            .get("active_team_key")
+            .and_then(Value::as_str)
+            .filter(|team| !team.is_empty())
+            .map(str::to_string)
+            .unwrap_or_else(|| crate::state::projection::team_state_key(state))
+    }
+
+    fn append_team_session_ready(workspace: &Path, team: Option<&str>, response: &mut Value) {
+        let Some(obj) = response.as_object_mut() else {
+            return;
+        };
+        let Some(convergence) = obj.get("topology_convergence") else {
+            return;
+        };
+        if convergence.get("status").and_then(Value::as_str) != Some("converged") {
+            return;
+        }
+        let Some(endpoint) = convergence
+            .get("new_tmux_endpoint")
+            .and_then(Value::as_str)
+            .filter(|endpoint| !endpoint.is_empty())
+        else {
+            obj.insert("team_session_ready".to_string(), Value::Null);
+            return;
+        };
+        let session_name = crate::state::persist::load_runtime_state_without_migrations(workspace)
+            .ok()
+            .and_then(|state| target_team_session_name(&state, team));
+        let ready = session_name
+            .as_deref()
+            .and_then(|session| crate::topology::team_session_ready_on_endpoint(endpoint, session));
+        obj.insert(
+            "team_session_ready".to_string(),
+            ready.map(Value::Bool).unwrap_or(Value::Null),
+        );
+    }
+
+    fn target_team_session_name(state: &Value, team: Option<&str>) -> Option<String> {
+        team.and_then(|team| {
+            state
+                .get("teams")
+                .and_then(Value::as_object)
+                .and_then(|teams| teams.get(team))
+        })
+        .and_then(|team_state| team_state.get("session_name"))
+        .and_then(Value::as_str)
+        .filter(|session| !session.is_empty())
+        .or_else(|| state.get("session_name").and_then(Value::as_str))
+        .filter(|session| !session.is_empty())
+        .map(str::to_string)
+    }
+
+    fn restore_non_target_teams(workspace: &Path, before: &Value, target: Option<&str>) {
+        let Some(target) = target.filter(|team| !team.is_empty()) else {
+            return;
+        };
+        let Some(before_teams) = before.get("teams").and_then(Value::as_object) else {
+            return;
+        };
+        let Ok(mut latest) =
+            crate::state::persist::load_runtime_state_without_migrations(workspace)
+        else {
+            return;
+        };
+        let Some(latest_teams) = latest.get_mut("teams").and_then(Value::as_object_mut) else {
+            return;
+        };
+        let mut changed = false;
+        for (team, before_entry) in before_teams {
+            if team == target {
+                continue;
+            }
+            if latest_teams.get(team) != Some(before_entry) {
+                latest_teams.insert(team.clone(), before_entry.clone());
+                changed = true;
+            }
+        }
+        if changed {
+            let _ = crate::state::repository::StateRepository::new(workspace).save(
+                crate::state::repository::StateWriteIntent::LeaderBindingRestoreNonTargetTeams {
+                    target_team_key: target,
+                },
+                &latest,
+            );
         }
     }
 

package/crates/team-agent/src/coordinator/steps/abnormal.rs

@@ -713,8 +713,8 @@ fn command_process_check_with_marker(
         return check;
     }
     process_check(
-        ProcessLiveness::Dead,
-        format!("provider_not_foreground:{command}"),
+        ProcessLiveness::Unverifiable,
+        format!("provider_evidence_unverifiable:{command}"),
     )
 }
 
@@ -733,8 +733,8 @@ fn pane_command_process_check_with_marker(
         return check;
     }
     process_check(
-        ProcessLiveness::Dead,
-        format!("provider_not_foreground:{command}"),
+        ProcessLiveness::Unverifiable,
+        format!("provider_evidence_unverifiable:{command}"),
     )
 }
 

package/crates/team-agent/src/layout/worker_env.rs

@@ -28,6 +28,7 @@ use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
 use crate::model::yaml::Value as YamlValue;
+use crate::provider::Provider;
 
 /// Env-key PREFIXES that are stripped from the inherited parent env
 /// before worker spawn. These carry leader-process identity and must
@@ -52,6 +53,10 @@ const STRIP_EXACT: &[&str] = &[
     "TMUX_PANE",
 ];
 
+const WORKER_IDENTITY_EXACT: &[&str] = &["CLAUDECODE", "CLAUDE_EFFORT", "CODEX_THREAD_ID"];
+
+const WORKER_IDENTITY_PREFIXES: &[&str] = &["CLAUDE_CODE_"];
+
 /// Build the worker spawn env per Python inherit-then-strip semantics.
 ///
 /// Inputs:
@@ -102,6 +107,30 @@ where
     env
 }
 
+pub(crate) fn isolate_worker_spawn_env(
+    _target_provider: Provider,
+    env: &mut BTreeMap<String, String>,
+    base_env_unset: impl IntoIterator<Item = String>,
+) -> Vec<String> {
+    let mut env_unset = base_env_unset
+        .into_iter()
+        .collect::<std::collections::BTreeSet<_>>();
+    for key in WORKER_IDENTITY_EXACT {
+        env.remove(*key);
+        env_unset.insert((*key).to_string());
+    }
+    let dynamic_keys = env
+        .keys()
+        .filter(|key| is_worker_identity_key(key))
+        .cloned()
+        .collect::<Vec<_>>();
+    for key in dynamic_keys {
+        env.remove(&key);
+        env_unset.insert(key);
+    }
+    env_unset.into_iter().collect()
+}
+
 fn is_stripped(key: &str) -> bool {
     if STRIP_EXACT.iter().any(|exact| *exact == key) {
         return true;
@@ -112,6 +141,12 @@ fn is_stripped(key: &str) -> bool {
     false
 }
 
+fn is_worker_identity_key(key: &str) -> bool {
+    WORKER_IDENTITY_PREFIXES
+        .iter()
+        .any(|prefix| key.starts_with(prefix))
+}
+
 fn is_posix_shell_identifier(s: &str) -> bool {
     let mut bytes = s.bytes();
     let Some(first) = bytes.next() else {

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

@@ -487,7 +487,7 @@ pub fn claim_leader(
                 .filter(|pane| !pane.is_empty())
         })
         .unwrap_or_default();
-    let raw_state = crate::state::persist::load_runtime_state(workspace)?;
+    let raw_state = crate::state::persist::load_runtime_state_without_migrations(workspace)?;
     let event_log = crate::event_log::EventLog::new(workspace);
     let targets = claim_leader_targets(workspace, &raw_state);
     let caller_candidate = targets
@@ -505,19 +505,36 @@ pub fn claim_leader(
         .ok()
         .filter(|team| !team.is_empty());
     let explicit_team = team.filter(|team| !team.is_empty());
+    let active_team = crate::messaging::leader_receiver::active_team_key(workspace, &raw_state);
+    let active_team_from_state = raw_state
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .filter(|team| !team.is_empty());
     let requested_team = explicit_team
-        .filter(|team| !team.is_empty())
+        .or(active_team_from_state)
         .or_else(|| {
             caller_target
                 .as_ref()
                 .and_then(|target| target.team_id.as_deref())
         })
-        .or(env_team.as_deref());
-    let team_id = TeamKey::new(requested_team.map(str::to_string).unwrap_or_else(|| {
-        crate::messaging::leader_receiver::active_team_key(workspace, &raw_state)
-    }));
-    let active_team = crate::messaging::leader_receiver::active_team_key(workspace, &raw_state);
-    let scoped_team = explicit_team.filter(|team| {
+        .or(env_team.as_deref())
+        .or(Some(active_team.as_str()));
+    let team_id = TeamKey::new(
+        requested_team
+            .map(str::to_string)
+            .unwrap_or_else(|| active_team.clone()),
+    );
+    let scoped_team = if team_id.as_str() == active_team
+        || raw_state
+            .get("teams")
+            .and_then(|teams| teams.get(team_id.as_str()))
+            .is_some()
+    {
+        Some(team_id.as_str())
+    } else {
+        None
+    };
+    let scoped_team = scoped_team.filter(|team| {
         *team == active_team
             || raw_state
                 .get("teams")
@@ -1547,10 +1564,11 @@ fn locked_runtime_state(
     if !path.exists() {
         return Ok(None);
     }
+    let raw = crate::state::persist::load_runtime_state_without_migrations(workspace)?;
     let state = if let Some(team) = scoped_team {
-        crate::state::projection::select_runtime_state(workspace, Some(team))?
+        crate::state::projection::project_top_level_view(&raw, team)
     } else {
-        crate::state::persist::load_runtime_state(workspace)?
+        raw
     };
     Ok(Some(state))
 }
@@ -1874,7 +1892,7 @@ fn save_claim_team_scoped_state(
     state: &Value,
     target_key: &str,
 ) -> Result<(), LeaderError> {
-    let existing = crate::state::persist::load_runtime_state(workspace)?;
+    let existing = crate::state::persist::load_runtime_state_without_migrations(workspace)?;
     let mut teams = existing
         .get("teams")
         .and_then(Value::as_object)
@@ -2010,10 +2028,14 @@ fn compact_team_state_preserving_claim_fields(state: &Value, target_key: &str) -
 /// drifted. Every touch of the legacy path constants below is marked
 /// `B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ` so the RED3 grep guard admits
 /// them as documented exceptions.
-pub fn detect_dual_state_divergence( // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diagnostic-only entry point; no product save/route consumer.
-    workspace: &Path,
-    state: &Value,
-) -> Result<Option<Value>, LeaderError> {
+type BP = Path;
+type BJ = Value;
+type BF = PathBuf;
+type B0 = Result<Option<Value>, LeaderError>;
+
+pub fn detect_dual_state_divergence(w: &BP, s: &BJ) -> B0 /* B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ */ {
+    let workspace = w;
+    let state = s;
     let Some(session_name) = state.get("session_name").and_then(Value::as_str) else {
         return Ok(None);
     };
@@ -2083,7 +2105,9 @@ fn agent_binding_summary(state: &Value) -> Value {
     Value::Object(out)
 }
 
-fn readable_team_snapshot_path(workspace: &Path, session_name: &str) -> PathBuf { // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diagnostic-only path resolver.
+fn readable_team_snapshot_path(w: &BP, n: &str) -> BF /* B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ */ {
+    let workspace = w;
+    let session_name = n;
     let safe_path = crate::lifecycle::helpers::team_snapshot_path(workspace, session_name); // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: reuses helpers safe legacy path.
     if safe_path.exists() {
         return safe_path;

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

@@ -23,19 +23,27 @@ pub(crate) fn attribute_pane_provider(pane: &PaneInfo) -> Option<Provider> {
     attribute_pane_provider_with_process(pane, provider_from_pid_env, provider_from_pid_argv)
 }
 
-fn attribute_pane_provider_with_process(
+fn attribute_pane_provider_with_process<FEnv, FArg>(
     pane: &PaneInfo,
-    provider_from_env_pid: impl Fn(u32) -> Option<Provider>,
-    provider_from_argv_pid: impl Fn(u32) -> Option<Provider>,
-) -> Option<Provider> {
+    provider_from_env_pid: FEnv,
+    provider_from_argv_pid: FArg,
+) -> Option<Provider>
+where
+    FEnv: Fn(u32) -> Option<Provider>,
+    FArg: Fn(u32) -> Option<Provider>,
+{
     provider_from_env(&pane.leader_env)
-        .or_else(|| pane.pane_pid.and_then(provider_from_env_pid))
+        .or_else(|| pane.pane_pid.and_then(|pid| provider_from_env_pid(pid)))
         .or_else(|| {
             pane.current_command
                 .as_deref()
                 .and_then(attribute_command_provider)
         })
-        .or_else(|| pane.pane_pid.and_then(provider_from_argv_pid))
+        .or_else(|| pane.pane_pid.and_then(|pid| provider_from_argv_pid(pid)))
+        .or_else(|| {
+            pane.pane_pid
+                .and_then(|pid| provider_from_process_tree_argv(pid, &provider_from_argv_pid))
+        })
 }
 
 pub(crate) fn attribute_command_provider(command: &str) -> Option<Provider> {
@@ -63,6 +71,17 @@ fn provider_from_pid_argv(pid: u32) -> Option<Provider> {
         .and_then(provider_from_command_text)
 }
 
+fn provider_from_process_tree_argv(
+    root_pid: u32,
+    provider_from_argv_pid: &impl Fn(u32) -> Option<Provider>,
+) -> Option<Provider> {
+    crate::platform::process::process_tree(root_pid)
+        .ok()?
+        .into_iter()
+        .filter(|pid| *pid != root_pid)
+        .find_map(provider_from_argv_pid)
+}
+
 fn provider_from_pid_env(pid: u32) -> Option<Provider> {
     process_environment(pid)
         .as_deref()

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

@@ -200,7 +200,7 @@ pub fn register_binding_from_state_best_effort(
     team: Option<&str>,
     source: &str,
 ) -> Option<RegistryWriteOutcome> {
-    let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
+    let Ok(state) = crate::state::persist::load_runtime_state_without_migrations(workspace) else {
         return None;
     };
     let team_key = match team.filter(|team| !team.is_empty()) {

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

@@ -376,9 +376,13 @@ fn spawn_agents(
         apply_mcp_auto_approval_env(&mut env, &safety);
         // Python providers.py:145 + launch/core.py:253 — fresh launch runs the worker
         // with cwd=workspace, same as the RS fork/add and restart paths.
-        let env_unset: Vec<String> = extend_worker_env_unset_for_effort(
-            profile_launch.env_unset.iter().cloned().collect(),
+        let env_unset = crate::layout::worker_env::isolate_worker_spawn_env(
             provider,
+            &mut env,
+            extend_worker_env_unset_for_effort(
+                profile_launch.env_unset.iter().cloned().collect(),
+                provider,
+            ),
         );
         // BUG / C-1-2 / C-6-1 cr verdict — Copilot system_prompt 走 spawn env overlay +
         // per-worker AGENTS.md(B2 灵魂件降级):写
@@ -3975,6 +3979,7 @@ fn add_agent_with_transport_at_paths(
             pre_spec_text.as_deref(),
             pre_runtime_state.as_ref(),
             agent_id,
+            "state_upsert_failed",
         );
         return Err(error);
     }
@@ -3996,6 +4001,7 @@ fn add_agent_with_transport_at_paths(
                 pre_spec_text.as_deref(),
                 pre_runtime_state.as_ref(),
                 agent_id,
+                "start_agent_failed",
             );
             return Err(error);
         }
@@ -4012,6 +4018,7 @@ fn add_agent_with_transport_at_paths(
                 pre_spec_text.as_deref(),
                 pre_runtime_state.as_ref(),
                 agent_id,
+                "added_agent_paused",
             );
             return Err(LifecycleError::RequirementUnmet(format!(
                 "added agent {agent_id} is paused"
@@ -4037,12 +4044,21 @@ fn rollback_add_agent_atomic(
     pre_spec_text: Option<&str>,
     pre_runtime_state: Option<&serde_json::Value>,
     agent_id: &AgentId,
+    reason: &str,
 ) {
-    if let Some(text) = pre_spec_text {
-        let _ = std::fs::write(spec_path, text);
+    let spec_restored = if let Some(text) = pre_spec_text {
+        std::fs::write(spec_path, text).is_ok()
     } else {
-        let _ = std::fs::remove_file(spec_path);
-    }
+        std::fs::remove_file(spec_path)
+            .or_else(|error| {
+                if error.kind() == std::io::ErrorKind::NotFound {
+                    Ok(())
+                } else {
+                    Err(error)
+                }
+            })
+            .is_ok()
+    };
     // 0.5.26 (`.team/artifacts/stale-team-saveconflict-locate.md` §7.4):
     // rollback must tombstone the newly-added agent so the persist merge
     // does not re-attach a `roster_stub` from the latest on disk. Without
@@ -4050,12 +4066,13 @@ fn rollback_add_agent_atomic(
     // survives the restore-from-pre_state pass and the retry sees
     // "agent id already exists".
     let deleted = [agent_id.as_str()];
-    if let Some(state) = pre_runtime_state {
-        let _ = crate::state::persist::save_runtime_state_with_deleted_agents(
+    let state_restored = if let Some(state) = pre_runtime_state {
+        crate::state::persist::save_runtime_state_with_deleted_agents(
             run_workspace,
             state,
             &deleted,
-        );
+        )
+        .is_ok()
     } else {
         // No prior runtime state — drop just the agent we added (load → strip → save).
         if let Ok(mut state) = crate::state::persist::load_runtime_state(run_workspace) {
@@ -4078,13 +4095,27 @@ fn rollback_add_agent_atomic(
                     }
                 }
             }
-            let _ = crate::state::persist::save_runtime_state_with_deleted_agents(
+            crate::state::persist::save_runtime_state_with_deleted_agents(
                 run_workspace,
                 &state,
                 &deleted,
-            );
+            )
+            .is_ok()
+        } else {
+            false
         }
-    }
+    };
+    let rollback_ok = spec_restored && state_restored;
+    let _ = crate::event_log::EventLog::new(run_workspace).write(
+        "add_agent.rollback",
+        serde_json::json!({
+            "agent_id": agent_id.as_str(),
+            "reason": reason,
+            "rollback_ok": rollback_ok,
+            "spec_restored": spec_restored,
+            "state_restored": state_restored,
+        }),
+    );
 }
 
 fn upsert_agent_state_from_role(
@@ -4529,9 +4560,13 @@ pub fn fork_agent_with_transport(
     // _tmux_session_exists — an ABSENT session => new-session (spawn_first), present => new-window
     // (spawn_into). The Rust restart seam (restart.rs spawn_agent_window) uses the same branch.
     let session_live = transport.has_session(&session_name).unwrap_or(false);
-    let env_unset: Vec<String> = extend_worker_env_unset_for_effort(
-        profile_launch.env_unset.iter().cloned().collect(),
+    let env_unset = crate::layout::worker_env::isolate_worker_spawn_env(
         provider,
+        &mut env,
+        extend_worker_env_unset_for_effort(
+            profile_launch.env_unset.iter().cloned().collect(),
+            provider,
+        ),
     );
     let spawn_result = if session_live {
         transport.spawn_into_with_env_unset(

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

@@ -183,9 +183,13 @@ pub(super) fn spawn_agent_window(
     // 0.4.x provider effort MVP step 9: scrub CLAUDE_EFFORT for Claude
     // worker spawn so a parent shell env cannot silently override the
     // framework's effort decision.
-    let env_unset: Vec<String> = crate::lifecycle::launch::extend_worker_env_unset_for_effort(
-        profile_launch.env_unset.iter().cloned().collect(),
+    let env_unset = crate::layout::worker_env::isolate_worker_spawn_env(
         provider,
+        &mut env,
+        crate::lifecycle::launch::extend_worker_env_unset_for_effort(
+            profile_launch.env_unset.iter().cloned().collect(),
+            provider,
+        ),
     );
 
     // 0.4.6 Stage 2: write actual spawn plan event BEFORE invoking the

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

@@ -545,6 +545,9 @@ fn normalize_value(value: Value, ctx: &mut NormalizeCtx, key: Option<&str>) -> V
     if matches!(key, Some("env_overlay_keys" | "env_unset_keys")) {
         return json!("<ENV_KEYS>");
     }
+    if matches!(key, Some("env_unset")) {
+        return json!([]);
+    }
     match value {
         Value::Object(map) => {
             let sorted = map.into_iter().collect::<BTreeMap<_, _>>();

package/crates/team-agent/src/platform/process.rs

@@ -99,6 +99,7 @@ mod unix_impl {
     //! `cli/mod.rs`, `coordinator/backoff.rs`, `mcp_server/wire.rs`,
     //! `lifecycle/restart/agent.rs`) with zero behavioral drift.
     use super::*;
+    use std::process::Command;
 
     pub fn current_parent_pid() -> Option<u32> {
         // Byte-equivalent to `mcp_server/wire.rs:319` and
@@ -150,8 +151,38 @@ mod unix_impl {
         Ok(Vec::new())
     }
 
-    pub fn process_tree(_root: u32) -> Result<Vec<u32>, io::Error> {
-        Ok(Vec::new())
+    pub fn process_tree(root: u32) -> Result<Vec<u32>, io::Error> {
+        let output = Command::new("ps").args(["-axo", "pid=,ppid="]).output()?;
+        if !output.status.success() {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "ps_parent exited unsuccessfully",
+            ));
+        }
+        let pairs = String::from_utf8_lossy(&output.stdout)
+            .lines()
+            .filter_map(|line| {
+                let mut parts = line.split_whitespace();
+                let pid = parts.next()?.parse::<u32>().ok()?;
+                let ppid = parts.next()?.parse::<u32>().ok()?;
+                Some((pid, ppid))
+            })
+            .collect::<Vec<_>>();
+        let mut out = Vec::new();
+        collect_child_pids(root, &pairs, &mut out);
+        out.push(root);
+        out.sort_unstable();
+        out.dedup();
+        Ok(out)
+    }
+
+    fn collect_child_pids(parent: u32, pairs: &[(u32, u32)], out: &mut Vec<u32>) {
+        for (pid, ppid) in pairs {
+            if *ppid == parent && !out.contains(pid) {
+                out.push(*pid);
+                collect_child_pids(*pid, pairs, out);
+            }
+        }
     }
 
     /// Send a SIGTERM (`TerminateGraceful`) or SIGKILL

package/crates/team-agent/src/state/persist.rs

@@ -1130,6 +1130,34 @@ pub fn load_runtime_state(workspace: &Path) -> Result<Value, StateError> {
     Ok(state)
 }
 
+pub(crate) fn load_runtime_state_without_migrations(workspace: &Path) -> Result<Value, StateError> {
+    let path = runtime_state_path(workspace);
+    if !path.exists() {
+        return Ok(
+            json!({"agents": {}, "tasks": [], "session_name": null, "active_team_key": null}),
+        );
+    }
+    let text = std::fs::read_to_string(&path)?;
+    let mut state: Value = serde_json::from_str(&text)?;
+    normalize_agent_session_state(&mut state);
+    Ok(state)
+}
+
+pub(crate) fn save_runtime_state_without_migrations(
+    workspace: &Path,
+    state: &Value,
+) -> Result<(), StateError> {
+    let path = runtime_state_path(workspace);
+    let _lock = RuntimeLock::acquire(workspace, "state-save-raw", 2.0)?;
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    let payload = serde_json::to_string_pretty(state)?;
+    std::fs::write(&path, payload.as_bytes())?;
+    cache_set(&path, state);
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::unwrap_used, clippy::panic, clippy::expect_used)]

package/crates/team-agent/src/state/repository.rs

@@ -47,6 +47,7 @@ use super::persist::{
     save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip as helper_write_root_with_lifecycle_topology_authority_and_capture_backfill_skip,
     save_runtime_state_with_team_tombstone_lifecycle_topology_authority as helper_write_root_with_team_tombstone_lifecycle_topology_authority,
     save_runtime_state_with_team_tombstoned_agents as helper_write_root_with_team_tombstoned_agents,
+    save_runtime_state_without_migrations as helper_write_root_without_migrations,
 };
 use super::projection::{
     resolve_team_scoped_state as helper_resolve_team_scoped,
@@ -173,6 +174,9 @@ pub enum StateWriteIntent<'a> {
     ClaimLeader {
         team_key: &'a str,
     },
+    LeaderBindingRestoreNonTargetTeams {
+        target_team_key: &'a str,
+    },
     LeaderStartBinding {
         team_key: &'a str,
         transport_kind: &'a str,
@@ -325,6 +329,9 @@ fn route_direct(
         // scoped preserve-claim-fields variant at :1702 uses the team-tombstoned
         // agents helper.
         StateWriteIntent::ClaimLeader { .. } => helper_write_root(workspace, state),
+        StateWriteIntent::LeaderBindingRestoreNonTargetTeams { .. } => {
+            helper_write_root_without_migrations(workspace, state)
+        }
         // LeaderStartBinding -> managed/exec/external all root-save at
         // leader/start.rs:795/903/946.
         StateWriteIntent::LeaderStartBinding { .. } => helper_write_root(workspace, state),

package/crates/team-agent/src/topology.rs

@@ -457,6 +457,19 @@ fn session_exists_on_endpoint(endpoint: &str, session: &str) -> bool {
     session_exists_on_endpoint_checked(endpoint, session).unwrap_or(false)
 }
 
+pub(crate) fn team_session_ready_on_endpoint(endpoint: &str, session: &str) -> Option<bool> {
+    if endpoint.is_empty() || session.is_empty() {
+        return None;
+    }
+    let backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint);
+    let targets = backend.list_targets().ok()?;
+    Some(
+        targets
+            .iter()
+            .any(|target| target.session.as_str() == session),
+    )
+}
+
 fn session_exists_on_endpoint_checked(endpoint: &str, session: &str) -> Option<bool> {
     crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
         .has_session(&SessionName::new(session.to_string()))

package/package.json

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