@team-agent/installer 0.3.1 → 0.3.3

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

@@ -20,7 +20,7 @@
 //! (`identity::migrate_state_identity`,补 leader_session_uuid)→ `_migrate_active_team_key`
 //! (seed active 指针);任一改动 → `save_runtime_state` 回写。不存在且命中缓存 → 返回缓存 deepcopy。
 
-use std::collections::HashMap;
+use std::collections::{BTreeSet, HashMap};
 use std::io;
 use std::path::{Path, PathBuf};
 use std::sync::{LazyLock, Mutex};
@@ -170,6 +170,14 @@ impl Drop for RuntimeLock {
 /// `save_runtime_state`(bug-084)。`state` 是 state.json 的内存 Value(插入序保留)。
 /// 注:Python 在此还调 `_migrate_state_identity`(identity slice 落地后接入;本 slice 不改 state 内容)。
 pub fn save_runtime_state(workspace: &Path, state: &Value) -> Result<(), StateError> {
+    save_runtime_state_with_deleted_agents(workspace, state, &[])
+}
+
+pub(crate) fn save_runtime_state_with_deleted_agents(
+    workspace: &Path,
+    state: &Value,
+    deleted_agent_ids: &[&str],
+) -> Result<(), StateError> {
     let path = runtime_state_path(workspace);
     if cache_equals(&path, state) {
         return Ok(());
@@ -203,6 +211,15 @@ pub fn save_runtime_state(workspace: &Path, state: &Value) -> Result<(), StateEr
     if let Some(parent) = path.parent() {
         std::fs::create_dir_all(parent)?;
     }
+    if let Some(latest) = read_latest_state_under_lock(workspace, &path) {
+        let deleted = deleted_agent_ids
+            .iter()
+            .copied()
+            .filter(|id| !id.is_empty())
+            .map(str::to_string)
+            .collect::<BTreeSet<_>>();
+        preserve_latest_roster_entries(&mut migrated, &latest, &deleted);
+    }
     // 字节对拍 Python json.dumps(indent=2, ensure_ascii=False)(无尾换行)。
     let payload = serde_json::to_string_pretty(&migrated)?;
     let delays = [0.05_f64, 0.2, 0.5];
@@ -243,6 +260,158 @@ pub fn save_runtime_state(workspace: &Path, state: &Value) -> Result<(), StateEr
     Err(StateError::SaveFailed("retry loop exhausted without return".to_string()))
 }
 
+fn read_latest_state_under_lock(workspace: &Path, path: &Path) -> Option<Value> {
+    let text = std::fs::read_to_string(path).ok()?;
+    let mut latest = serde_json::from_str::<Value>(&text).ok()?;
+    normalize_agent_session_state(&mut latest);
+    let _ = migrate_state_identity(&mut latest, &SystemEnv, workspace);
+    let _ = migrate_active_team_key(&mut latest);
+    Some(latest)
+}
+
+fn preserve_latest_roster_entries(incoming: &mut Value, latest: &Value, deleted_agent_ids: &BTreeSet<String>) {
+    if !same_runtime_projection(incoming, latest) {
+        return;
+    }
+    preserve_missing_agents(incoming.get_mut("agents"), latest.get("agents"), deleted_agent_ids);
+    preserve_latest_ownership_fields(incoming, latest);
+
+    let active_team = active_team_key(incoming).or_else(|| active_team_key(latest));
+    if let Some(active_team) = active_team.as_deref() {
+        let latest_active_agents = latest
+            .get("teams")
+            .and_then(Value::as_object)
+            .and_then(|teams| teams.get(active_team))
+            .and_then(|entry| entry.get("agents"));
+        preserve_missing_agents(incoming.get_mut("agents"), latest_active_agents, deleted_agent_ids);
+    }
+
+    let latest_teams = latest.get("teams").and_then(Value::as_object);
+    let Some(incoming_teams) = incoming.get_mut("teams").and_then(Value::as_object_mut) else {
+        return;
+    };
+    if let Some(latest_teams) = latest_teams {
+        for (team, latest_entry) in latest_teams {
+            let Some(incoming_entry) = incoming_teams.get_mut(team) else {
+                continue;
+            };
+            preserve_missing_agents(
+                incoming_entry.get_mut("agents"),
+                latest_entry.get("agents"),
+                deleted_agent_ids,
+            );
+            preserve_latest_ownership_fields(incoming_entry, latest_entry);
+        }
+    }
+    if let Some(active_team) = active_team.as_deref() {
+        let latest_top_agents = latest.get("agents");
+        if let Some(incoming_entry) = incoming_teams.get_mut(active_team) {
+            preserve_missing_agents(incoming_entry.get_mut("agents"), latest_top_agents, deleted_agent_ids);
+            preserve_latest_ownership_fields(incoming_entry, latest);
+        }
+    }
+}
+
+fn preserve_latest_ownership_fields(incoming: &mut Value, latest: &Value) {
+    if !latest_has_preferable_ownership(incoming, latest) {
+        return;
+    }
+    let Some(incoming_obj) = incoming.as_object_mut() else {
+        return;
+    };
+    for key in ["leader_receiver", "team_owner", "owner_epoch"] {
+        if let Some(value) = latest.get(key).filter(|value| json_truthy(value)) {
+            incoming_obj.insert(key.to_string(), value.clone());
+        }
+    }
+}
+
+fn latest_has_preferable_ownership(incoming: &Value, latest: &Value) -> bool {
+    let latest_epoch = ownership_epoch(latest);
+    let incoming_epoch = ownership_epoch(incoming);
+    if latest_epoch > incoming_epoch {
+        return true;
+    }
+    latest_epoch == incoming_epoch
+        && !ownership_attached(incoming)
+        && ownership_attached(latest)
+}
+
+fn ownership_epoch(state: &Value) -> u64 {
+    state
+        .get("owner_epoch")
+        .and_then(Value::as_u64)
+        .or_else(|| {
+            state
+                .get("team_owner")
+                .and_then(|owner| owner.get("owner_epoch"))
+                .and_then(Value::as_u64)
+        })
+        .or_else(|| {
+            state
+                .get("leader_receiver")
+                .and_then(|receiver| receiver.get("owner_epoch"))
+                .and_then(Value::as_u64)
+        })
+        .unwrap_or(0)
+}
+
+fn ownership_attached(state: &Value) -> bool {
+    ["leader_receiver", "team_owner"].into_iter().any(|key| {
+        state
+            .get(key)
+            .and_then(|value| value.get("pane_id"))
+            .and_then(Value::as_str)
+            .is_some_and(|pane| !pane.is_empty() && pane != "__team_agent_unbound__")
+    })
+}
+
+fn preserve_missing_agents(
+    incoming_agents: Option<&mut Value>,
+    latest_agents: Option<&Value>,
+    deleted_agent_ids: &BTreeSet<String>,
+) {
+    let Some(incoming_agents) = incoming_agents else {
+        return;
+    };
+    let Some(incoming_map) = incoming_agents.as_object_mut() else {
+        return;
+    };
+    let Some(latest_map) = latest_agents.and_then(Value::as_object) else {
+        return;
+    };
+    for (agent_id, latest_agent) in latest_map {
+        if deleted_agent_ids.contains(agent_id) {
+            continue;
+        }
+        incoming_map
+            .entry(agent_id.clone())
+            .or_insert_with(|| latest_agent.clone());
+    }
+}
+
+fn same_runtime_projection(left: &Value, right: &Value) -> bool {
+    let left_session = left.get("session_name").and_then(Value::as_str);
+    let right_session = right.get("session_name").and_then(Value::as_str);
+    if left_session.is_some() && right_session.is_some() && left_session != right_session {
+        return false;
+    }
+    let left_team = active_team_key(left);
+    let right_team = active_team_key(right);
+    if left_team.is_some() && right_team.is_some() && left_team != right_team {
+        return false;
+    }
+    true
+}
+
+fn active_team_key(state: &Value) -> Option<String> {
+    state
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .filter(|team| !team.is_empty() && *team != "current")
+        .map(str::to_string)
+}
+
 /// `_self_heal_runtime_state`:重建 inode(heal-tmp + backup-rename),绝不 in-place truncate。
 fn self_heal(
     workspace: &Path,

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

@@ -14,11 +14,18 @@ use std::path::Path;
 use serde_json::{json, Map, Value};
 
 use super::StateError;
-use crate::state::persist::{load_runtime_state, save_runtime_state};
+use crate::state::persist::{load_runtime_state, save_runtime_state_with_deleted_agents};
 
 /// `team_state_key`(`state.py:93`):从 team_dir(.name)/spec_path(.parent.name)派生 team key,
 /// 跳过 `.team`/`runtime`;兜底 `session_name` 或 `"current"`。
 pub fn team_state_key(state: &Value) -> String {
+    if let Some(team_key) = state
+        .get("team_key")
+        .and_then(Value::as_str)
+        .filter(|key| !key.is_empty())
+    {
+        return team_key.to_string();
+    }
     for field in ["team_dir", "spec_path"] {
         // Python `if not value: continue` —— None/空串 falsy 跳过。
         let value = match state.get(field).and_then(Value::as_str) {
@@ -43,6 +50,105 @@ pub fn team_state_key(state: &Value) -> String {
         .map_or_else(|| "current".to_string(), str::to_string)
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum OwnerTeamResolution {
+    Canonical(String),
+    LegacyAlias { requested: String, canonical: String },
+    Unresolved { requested: String },
+    Ambiguous { requested: String, matches: Vec<String> },
+}
+
+impl OwnerTeamResolution {
+    pub fn canonical_key(&self) -> Option<&str> {
+        match self {
+            OwnerTeamResolution::Canonical(key)
+            | OwnerTeamResolution::LegacyAlias { canonical: key, .. } => Some(key),
+            OwnerTeamResolution::Unresolved { .. } | OwnerTeamResolution::Ambiguous { .. } => None,
+        }
+    }
+}
+
+pub fn resolve_owner_team_id(state: &Value, owner_team_id: &str) -> OwnerTeamResolution {
+    let requested = owner_team_id.trim();
+    if requested.is_empty() {
+        return OwnerTeamResolution::Unresolved { requested: owner_team_id.to_string() };
+    }
+    let teams = state.get("teams").and_then(Value::as_object);
+    if teams.is_some_and(|teams| teams.contains_key(requested)) {
+        return OwnerTeamResolution::Canonical(requested.to_string());
+    }
+    if teams.is_none_or(Map::is_empty) {
+        let active = state.get("active_team_key").and_then(Value::as_str).unwrap_or("");
+        let derived = team_state_key(state);
+        if active == requested || derived == requested {
+            return OwnerTeamResolution::Canonical(requested.to_string());
+        }
+        if !active.is_empty() {
+            return OwnerTeamResolution::LegacyAlias {
+                requested: requested.to_string(),
+                canonical: active.to_string(),
+            };
+        }
+        if derived != "current" {
+            return OwnerTeamResolution::LegacyAlias {
+                requested: requested.to_string(),
+                canonical: derived,
+            };
+        }
+        return OwnerTeamResolution::Canonical(requested.to_string());
+    }
+    let Some(teams) = teams else {
+        return OwnerTeamResolution::Unresolved { requested: requested.to_string() };
+    };
+    let mut matches = Vec::new();
+    for (key, entry) in teams {
+        if legacy_owner_team_aliases(entry).any(|alias| alias == requested) {
+            matches.push(key.clone());
+        }
+    }
+    matches.sort();
+    matches.dedup();
+    match matches.len() {
+        0 => OwnerTeamResolution::Unresolved { requested: requested.to_string() },
+        1 => OwnerTeamResolution::LegacyAlias {
+            requested: requested.to_string(),
+            canonical: matches.remove(0),
+        },
+        _ => OwnerTeamResolution::Ambiguous { requested: requested.to_string(), matches },
+    }
+}
+
+fn legacy_owner_team_aliases(entry: &Value) -> impl Iterator<Item = String> + '_ {
+    let scalar_paths = [
+        "/team/name",
+        "/team/id",
+        "/name",
+        "/team_name",
+        "/team_id",
+        "/spec_name",
+        "/legacy_owner_team_id",
+        "/legacy_team_id",
+        "/legacy_team_name",
+        "/legacy_alias",
+    ];
+    let list_paths = ["/legacy_aliases", "/legacy_team_aliases", "/legacy_owner_team_ids", "/aliases"];
+    let scalars = scalar_paths
+        .into_iter()
+        .filter_map(|path| entry.pointer(path).and_then(Value::as_str));
+    let lists = list_paths.into_iter().flat_map(|path| {
+        entry
+            .pointer(path)
+            .and_then(Value::as_array)
+            .into_iter()
+            .flatten()
+            .filter_map(Value::as_str)
+    });
+    scalars
+        .chain(lists)
+        .filter(|alias| !alias.is_empty())
+        .map(str::to_string)
+}
+
 /// `compact_team_state`(`state.py:105`):剔除 `teams`(team entry 不嵌套全量 teams),保序。
 pub fn compact_team_state(state: &Value) -> Value {
     match state.as_object() {
@@ -241,11 +347,7 @@ pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Valu
         }
         let matches: Vec<&String> = alive
             .iter()
-            .filter(|(key, value)| {
-                let session = value.get("session_name").and_then(Value::as_str).unwrap_or("");
-                let dir = value.get("team_dir").and_then(Value::as_str).unwrap_or("");
-                team == key.as_str() || team == session || team == dir
-            })
+            .filter(|(key, value)| team_selector_matches(team, key, value))
             .map(|(k, _)| k)
             .collect();
         if matches.len() == 1 {
@@ -282,6 +384,29 @@ pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Valu
     ))
 }
 
+fn team_selector_matches(team: &str, key: &str, value: &Value) -> bool {
+    if team == key {
+        return true;
+    }
+    let session = value.get("session_name").and_then(Value::as_str).unwrap_or("");
+    if team == session {
+        return true;
+    }
+    if let Some(stripped) = session.strip_prefix("team-") {
+        if team == stripped {
+            return true;
+        }
+    }
+    let dir = value.get("team_dir").and_then(Value::as_str).unwrap_or("");
+    if team == dir {
+        return true;
+    }
+    std::path::Path::new(dir)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| team == name)
+}
+
 /// `ambiguous_team_target_result`(`state.py:226`):无显式 team 且多候选 → 拒绝 dict;否则 None。
 pub fn ambiguous_team_target_result(state: &Value) -> Option<Value> {
     let alive = team_state_candidates(state);
@@ -339,6 +464,14 @@ pub fn resolve_team_scoped_state(
 /// 纯 `save_runtime_state`(字节等价);多 team 时把本 team 落到 `teams[target_key]=compact(...)`,顶层
 /// 视图按 golden 的 `existing_primary_key` 逻辑择 incoming/existing。§10:无 unwrap/panic。
 pub fn save_team_scoped_state(workspace: &Path, team_state: &Value) -> Result<(), StateError> {
+    save_team_scoped_state_with_deleted_agents(workspace, team_state, &[])
+}
+
+pub(crate) fn save_team_scoped_state_with_deleted_agents(
+    workspace: &Path,
+    team_state: &Value,
+    deleted_agent_ids: &[&str],
+) -> Result<(), StateError> {
     let target_key = team_state_key(team_state);
     let existing = load_runtime_state(workspace)?;
     // existing_primary_key = team_state_key(existing) if existing.get("session_name") else None
@@ -367,7 +500,7 @@ pub fn save_team_scoped_state(workspace: &Path, team_state: &Value) -> Result<()
     // not existing_teams and existing_primary_key == target_key → 纯 save(剔 teams)。
     if existing_teams.is_empty() && existing_primary_key.as_deref() == Some(target_key.as_str()) {
         let merged = compact_team_state(team_state);
-        return save_runtime_state(workspace, &merged);
+        return save_runtime_state_with_deleted_agents(workspace, &merged, deleted_agent_ids);
     }
     // teams = deepcopy(incoming_teams or existing_teams)
     let mut teams = match incoming_teams {
@@ -387,7 +520,7 @@ pub fn save_team_scoped_state(workspace: &Path, team_state: &Value) -> Result<()
     if merged.get("teams").and_then(Value::as_object).is_some_and(Map::is_empty) {
         merged.remove("teams");
     }
-    save_runtime_state(workspace, &Value::Object(merged))
+    save_runtime_state_with_deleted_agents(workspace, &Value::Object(merged), deleted_agent_ids)
 }
 
 // ---- helpers ----

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

@@ -98,8 +98,11 @@ fn spec_workspace_from_state(state: &Value) -> Option<PathBuf> {
 }
 
 fn selected_team_key(state: &Value, team: Option<&str>) -> String {
-    team.filter(|s| !s.is_empty())
+    state
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
         .map(ToString::to_string)
-        .or_else(|| state.get("active_team_key").and_then(Value::as_str).filter(|s| !s.is_empty()).map(ToString::to_string))
+        .or_else(|| team.filter(|s| !s.is_empty()).map(ToString::to_string))
         .unwrap_or_else(|| team_state_key(state))
 }