@team-agent/installer 0.3.1 → 0.3.2

package/crates/team-agent/src/messaging/results.rs

@@ -10,6 +10,7 @@ use crate::message_store::MessageStore;
 use super::helpers::{next_result_id, required_str, validate_result_envelope};
 use super::types::SEND_RETRY_MAX_ATTEMPTS;
 use crate::model::ids::TaskId;
+use crate::state::projection::OwnerTeamResolution;
 use super::watchers::retry_result_deliveries;
 use super::MessagingError;
 
@@ -19,26 +20,65 @@ pub fn collect(
     workspace: &Path,
     result_file: Option<&Path>,
     ensure_coordinator: bool,
+) -> Result<serde_json::Value, MessagingError> {
+    collect_scoped(workspace, result_file, ensure_coordinator, None)
+}
+
+pub fn collect_for_team(
+    workspace: &Path,
+    result_file: Option<&Path>,
+    ensure_coordinator: bool,
+    owner_team_id: Option<&str>,
+) -> Result<serde_json::Value, MessagingError> {
+    collect_scoped(workspace, result_file, ensure_coordinator, owner_team_id)
+}
+
+fn collect_scoped(
+    workspace: &Path,
+    result_file: Option<&Path>,
+    ensure_coordinator: bool,
+    owner_team_id: Option<&str>,
 ) -> Result<serde_json::Value, MessagingError> {
     let _ = ensure_coordinator;
     let paths = collect_paths(workspace)?;
-    let spec_path = paths.spec_workspace.join("team.spec.yaml");
+    let log = EventLog::new(&paths.run_workspace);
+    let resolved_owner_team_id = match owner_team_id.filter(|team| !team.is_empty()) {
+        Some(team) => Some(resolve_owner_team_for_read(&paths.run_workspace, team, Some(&log))?),
+        None => None,
+    };
+    let owner_team_id = resolved_owner_team_id.as_deref();
+    let mut state = match owner_team_id {
+        Some(team) => crate::state::projection::select_runtime_state(&paths.run_workspace, Some(team))?,
+        None => crate::state::persist::load_runtime_state(&paths.run_workspace)?,
+    };
+    let spec_workspace = owner_team_id
+        .and_then(|_| state_spec_workspace_from_value(&state))
+        .unwrap_or_else(|| paths.spec_workspace.clone());
+    let spec_path = spec_workspace.join("team.spec.yaml");
     if !spec_path.exists() {
         return Err(MessagingError::Validation(format!("Cannot read {}", spec_path.display())));
     }
     let store = MessageStore::open(&paths.run_workspace)?;
     let conn = crate::db::schema::open_db(store.db_path())?;
     if let Some(path) = result_file {
-        ingest_result_file(&conn, path)?;
+        ingest_result_file(&conn, path, owner_team_id)?;
     }
-    let mut stmt = conn.prepare(
-        "select result_id, task_id, agent_id, envelope, status, created_at
-         from results
-         where status not in ('collected', 'invalid')
-         order by created_at, result_id",
-    )?;
-    let rows = stmt
-        .query_map([], |row| {
+    let sql = match owner_team_id {
+        Some(_) => {
+            "select result_id, task_id, agent_id, envelope, status, created_at
+             from results
+             where status not in ('collected', 'invalid') and owner_team_id = ?1
+             order by created_at, result_id"
+        }
+        None => {
+            "select result_id, task_id, agent_id, envelope, status, created_at
+             from results
+             where status not in ('collected', 'invalid')
+             order by created_at, result_id"
+        }
+    };
+    let mut stmt = conn.prepare(sql)?;
+    let row_mapper = |row: &rusqlite::Row<'_>| {
             Ok(StoredResult {
                 result_id: row.get(0)?,
                 task_id: row.get(1)?,
@@ -47,16 +87,18 @@ pub fn collect(
                 status: row.get(4)?,
                 created_at: row.get(5)?,
             })
-        })?
+        };
+    let rows = match owner_team_id {
+        Some(team) => stmt.query_map(params![team], row_mapper),
+        None => stmt.query_map([], row_mapper),
+    }?
         .collect::<Result<Vec<_>, _>>()?;
     drop(stmt);
 
-    let mut state = crate::state::persist::load_runtime_state(&paths.run_workspace)?;
     let mut collected = Vec::new();
     let mut collected_results = Vec::new();
     let mut invalid_results = Vec::new();
     let mut state_dirty = false;
-    let log = EventLog::new(&paths.run_workspace);
     for row in rows {
         let envelope: serde_json::Value = match serde_json::from_str(&row.envelope) {
             Ok(envelope) => envelope,
@@ -83,7 +125,7 @@ pub fn collect(
         }
         let scope = if task_exists(&state, &row.task_id) {
             "task"
-        } else if is_message_scoped_result(&conn, &row.task_id, &row.agent_id)? {
+        } else if is_message_scoped_result(&conn, &row.task_id, &row.agent_id, owner_team_id)? {
             "message"
         } else {
             record_invalid_result(
@@ -95,10 +137,20 @@ pub fn collect(
             )?;
             continue;
         };
-        conn.execute(
-            "update results set status = 'collected' where result_id = ?1",
-            params![row.result_id.as_str()],
-        )?;
+        match owner_team_id {
+            Some(team) => {
+                conn.execute(
+                    "update results set status = 'collected' where result_id = ?1 and owner_team_id = ?2",
+                    params![row.result_id.as_str(), team],
+                )?;
+            }
+            None => {
+                conn.execute(
+                    "update results set status = 'collected' where result_id = ?1",
+                    params![row.result_id.as_str()],
+                )?;
+            }
+        }
         if scope == "task" {
             mark_task_done(&mut state, &row.task_id, &row.result_id);
             state_dirty = true;
@@ -129,9 +181,13 @@ pub fn collect(
         collected_results.push(summary);
     }
     if state_dirty {
-        crate::state::persist::save_runtime_state(&paths.run_workspace, &state)?;
+        if owner_team_id.is_some() {
+            crate::state::projection::save_team_scoped_state(&paths.run_workspace, &state)?;
+        } else {
+            crate::state::persist::save_runtime_state(&paths.run_workspace, &state)?;
+        }
     }
-    let counts = result_counts(&conn)?;
+    let counts = result_counts(&conn, owner_team_id)?;
     Ok(serde_json::json!({
         "ok": invalid_results.is_empty(),
         "collected": collected,
@@ -139,7 +195,7 @@ pub fn collect(
         "delivered_messages": [],
         "invalid_results": invalid_results,
         "results": counts,
-        "state_file": paths.spec_workspace.join("team_state.md").to_string_lossy().to_string(),
+        "state_file": spec_workspace.join("team_state.md").to_string_lossy().to_string(),
         "coordinator": {
             "ok": false,
             "status": "not_required",
@@ -147,12 +203,48 @@ pub fn collect(
     }))
 }
 
+fn resolve_owner_team_for_read(
+    workspace: &Path,
+    requested: &str,
+    event_log: Option<&EventLog>,
+) -> Result<String, MessagingError> {
+    let state = crate::state::persist::load_runtime_state(workspace)?;
+    match crate::state::projection::resolve_owner_team_id(&state, requested) {
+        OwnerTeamResolution::Canonical(canonical) => Ok(canonical),
+        OwnerTeamResolution::LegacyAlias { requested, canonical } => {
+            crate::messaging::delivery::normalize_owner_team_id_rows(
+                workspace,
+                &requested,
+                &canonical,
+                None,
+                event_log,
+            )?;
+            Ok(canonical)
+        }
+        OwnerTeamResolution::Unresolved { requested } => {
+            Err(MessagingError::Routing(format!("owner_team_unresolved: {requested}")))
+        }
+        OwnerTeamResolution::Ambiguous { requested, matches } => {
+            Err(MessagingError::Routing(format!(
+                "owner_team_ambiguous: {requested} matches {}",
+                matches.join(",")
+            )))
+        }
+    }
+}
+
 struct CollectPaths {
     run_workspace: PathBuf,
     spec_workspace: PathBuf,
 }
 
 fn collect_paths(workspace: &Path) -> Result<CollectPaths, MessagingError> {
+    if collect_input_has_no_local_team_context(workspace) {
+        return Ok(CollectPaths {
+            run_workspace: workspace.to_path_buf(),
+            spec_workspace: workspace.to_path_buf(),
+        });
+    }
     let run_workspace = crate::model::paths::canonical_run_workspace(workspace)
         .map_err(|e| MessagingError::Routing(e.to_string()))?;
     let spec_workspace = if workspace.join("team.spec.yaml").exists() {
@@ -168,8 +260,24 @@ fn collect_paths(workspace: &Path) -> Result<CollectPaths, MessagingError> {
     })
 }
 
+fn collect_input_has_no_local_team_context(workspace: &Path) -> bool {
+    !workspace.join("team.spec.yaml").exists()
+        && !workspace.join(".team").exists()
+        && !crate::state::persist::runtime_state_path(workspace).exists()
+        && workspace.file_name().and_then(|s| s.to_str()) != Some(".team")
+        && workspace
+            .parent()
+            .and_then(|p| p.file_name())
+            .and_then(|s| s.to_str())
+            != Some(".team")
+}
+
 fn state_spec_workspace(run_workspace: &Path) -> Option<PathBuf> {
     let state = crate::state::persist::load_runtime_state(run_workspace).ok()?;
+    state_spec_workspace_from_value(&state)
+}
+
+fn state_spec_workspace_from_value(state: &serde_json::Value) -> Option<PathBuf> {
     if let Some(spec_path) = state.get("spec_path").and_then(serde_json::Value::as_str) {
         return PathBuf::from(spec_path).parent().map(Path::to_path_buf);
     }
@@ -200,7 +308,11 @@ fn record_invalid_result(
     Ok(())
 }
 
-fn ingest_result_file(conn: &rusqlite::Connection, path: &Path) -> Result<(), MessagingError> {
+fn ingest_result_file(
+    conn: &rusqlite::Connection,
+    path: &Path,
+    owner_team_id: Option<&str>,
+) -> Result<(), MessagingError> {
     let raw = std::fs::read_to_string(path)?;
     let mut envelope: serde_json::Value = serde_json::from_str(&raw)?;
     validate_result_envelope(&envelope)?;
@@ -226,7 +338,7 @@ fn ingest_result_file(conn: &rusqlite::Connection, path: &Path) -> Result<(), Me
         agent_id,
         &envelope.to_string(),
         status,
-        None,
+        owner_team_id,
     )?;
     Ok(())
 }
@@ -273,39 +385,55 @@ fn is_message_scoped_result(
     conn: &rusqlite::Connection,
     task_id: &str,
     agent_id: &str,
+    owner_team_id: Option<&str>,
 ) -> Result<bool, MessagingError> {
     if !task_id.starts_with("msg_") {
         return Ok(false);
     }
-    let count: i64 = conn.query_row(
-        "select count(*) from messages where message_id = ?1 and recipient = ?2",
-        params![task_id, agent_id],
-        |row| row.get(0),
-    )?;
+    let count: i64 = match owner_team_id {
+        Some(team) => conn.query_row(
+            "select count(*) from messages where message_id = ?1 and recipient = ?2 and owner_team_id = ?3",
+            params![task_id, agent_id, team],
+            |row| row.get(0),
+        )?,
+        None => conn.query_row(
+            "select count(*) from messages where message_id = ?1 and recipient = ?2",
+            params![task_id, agent_id],
+            |row| row.get(0),
+        )?,
+    };
     Ok(count > 0)
 }
 
-fn result_counts(conn: &rusqlite::Connection) -> Result<serde_json::Value, MessagingError> {
-    let total: i64 = conn.query_row("select count(*) from results", [], |row| row.get(0))?;
-    let collected: i64 = conn.query_row(
-        "select count(*) from results where status = 'collected'",
-        [],
-        |row| row.get(0),
-    )?;
-    let invalid: i64 = conn.query_row(
-        "select count(*) from results where status = 'invalid'",
-        [],
-        |row| row.get(0),
-    )?;
+fn result_counts(
+    conn: &rusqlite::Connection,
+    owner_team_id: Option<&str>,
+) -> Result<serde_json::Value, MessagingError> {
+    let total: i64 = count_results(conn, owner_team_id, None)?;
+    let collected: i64 = count_results(conn, owner_team_id, Some("collected"))?;
+    let invalid: i64 = count_results(conn, owner_team_id, Some("invalid"))?;
     let uncollected = total - collected - invalid;
     let mut by_status = serde_json::Map::new();
-    let mut stmt = conn.prepare(
-        "select status, count(*) from results
-         where status not in ('collected', 'invalid')
-         group by status
-         order by status",
-    )?;
-    let rows = stmt.query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?)))?;
+    let sql = match owner_team_id {
+        Some(_) => {
+            "select status, count(*) from results
+             where status not in ('collected', 'invalid') and owner_team_id = ?1
+             group by status
+             order by status"
+        }
+        None => {
+            "select status, count(*) from results
+             where status not in ('collected', 'invalid')
+             group by status
+             order by status"
+        }
+    };
+    let mut stmt = conn.prepare(sql)?;
+    let row_mapper = |row: &rusqlite::Row<'_>| Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?));
+    let rows = match owner_team_id {
+        Some(team) => stmt.query_map(params![team], row_mapper),
+        None => stmt.query_map([], row_mapper),
+    }?;
     for row in rows {
         let (status, count) = row?;
         by_status.insert(status, serde_json::Value::Number(count.into()));
@@ -319,6 +447,31 @@ fn result_counts(conn: &rusqlite::Connection) -> Result<serde_json::Value, Messa
     }))
 }
 
+fn count_results(
+    conn: &rusqlite::Connection,
+    owner_team_id: Option<&str>,
+    status: Option<&str>,
+) -> Result<i64, MessagingError> {
+    match (owner_team_id, status) {
+        (Some(team), Some(status)) => Ok(conn.query_row(
+            "select count(*) from results where owner_team_id = ?1 and status = ?2",
+            params![team, status],
+            |row| row.get(0),
+        )?),
+        (Some(team), None) => Ok(conn.query_row(
+            "select count(*) from results where owner_team_id = ?1",
+            params![team],
+            |row| row.get(0),
+        )?),
+        (None, Some(status)) => Ok(conn.query_row(
+            "select count(*) from results where status = ?1",
+            params![status],
+            |row| row.get(0),
+        )?),
+        (None, None) => Ok(conn.query_row("select count(*) from results", [], |row| row.get(0))?),
+    }
+}
+
 /// `report_result` (`results.py:191`):worker 报结果 —— 校验 envelope、存 result、ack 任务消息、
 /// **排队** send 事件通知 leader、推进 orchestrator (软依赖,失败仅记 `orchestrator.advance_skipped`)。
 /// MCP `report_result` 工具调。

package/crates/team-agent/src/provider/adapter.rs

@@ -277,15 +277,19 @@ impl ProviderAdapter for BasicProviderAdapter {
         spawn_cwd: &Path,
         _timeout_s: u64,
     ) -> Result<Option<CapturedSession>, ProviderError> {
-        let candidates = candidate_session_files(spawn_cwd, agent_id)?;
-        for path in candidates {
+        let candidates = candidate_session_files(self.provider, spawn_cwd, agent_id)?;
+        for candidate in candidates {
+            let path = candidate.path;
             let Ok(text) = std::fs::read_to_string(&path) else {
                 continue;
             };
-            let records = parse_jsonl_records(&text);
+            let records = parse_session_records(&text);
             if records.is_empty() {
                 continue;
             }
+            if candidate.requires_cwd_match && !provider_home_records_match_spawn_cwd(&records, spawn_cwd) {
+                continue;
+            }
             let session_id = records.iter().find_map(find_session_id);
             if matches!(self.provider, Provider::Claude | Provider::ClaudeCode)
                 && session_id.is_some()
@@ -518,18 +522,56 @@ fn command_on_path(name: &str) -> bool {
     std::env::split_paths(&path).any(|dir| dir.join(name).is_file())
 }
 
-fn candidate_session_files(spawn_cwd: &Path, agent_id: &str) -> Result<Vec<PathBuf>, ProviderError> {
+struct SessionCandidate {
+    path: PathBuf,
+    requires_cwd_match: bool,
+}
+
+fn candidate_session_files(
+    provider: Provider,
+    spawn_cwd: &Path,
+    agent_id: &str,
+) -> Result<Vec<SessionCandidate>, ProviderError> {
     let mut out = Vec::new();
-    collect_candidate_files(spawn_cwd, agent_id, 0, &mut out)?;
-    out.sort_by(|a, b| a.to_string_lossy().cmp(&b.to_string_lossy()));
+    collect_candidate_files(spawn_cwd, agent_id, 0, false, &mut out)?;
+    if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
+        match provider {
+            Provider::Codex => {
+                collect_optional_candidate_files(&home.join(".codex").join("sessions"), agent_id, &mut out)?;
+            }
+            Provider::Claude | Provider::ClaudeCode => {
+                collect_optional_candidate_files(&home.join(".claude").join("sessions"), agent_id, &mut out)?;
+                collect_optional_candidate_files(&home.join(".claude").join("projects"), agent_id, &mut out)?;
+            }
+            Provider::GeminiCli | Provider::Fake => {}
+        }
+    }
+    out.sort_by(|a, b| {
+        a.requires_cwd_match
+            .cmp(&b.requires_cwd_match)
+            .then_with(|| a.path.to_string_lossy().cmp(&b.path.to_string_lossy()))
+    });
+    out.dedup_by(|a, b| a.path == b.path && a.requires_cwd_match == b.requires_cwd_match);
     Ok(out)
 }
 
+fn collect_optional_candidate_files(
+    dir: &Path,
+    agent_id: &str,
+    out: &mut Vec<SessionCandidate>,
+) -> Result<(), ProviderError> {
+    if dir.exists() {
+        let _ = collect_candidate_files(dir, agent_id, 0, true, out);
+    }
+    Ok(())
+}
+
 fn collect_candidate_files(
     dir: &Path,
     agent_id: &str,
     depth: usize,
-    out: &mut Vec<PathBuf>,
+    requires_cwd_match: bool,
+    out: &mut Vec<SessionCandidate>,
 ) -> Result<(), ProviderError> {
     if depth > 4 {
         return Ok(());
@@ -545,9 +587,12 @@ fn collect_candidate_files(
         };
         let path = entry.path();
         if path.is_dir() {
-            collect_candidate_files(&path, agent_id, depth.saturating_add(1), out)?;
+            collect_candidate_files(&path, agent_id, depth.saturating_add(1), requires_cwd_match, out)?;
         } else if looks_like_session_file(&path, agent_id) {
-            out.push(path);
+            out.push(SessionCandidate {
+                path,
+                requires_cwd_match,
+            });
         }
     }
     Ok(())
@@ -572,6 +617,46 @@ fn looks_like_session_file(path: &Path, agent_id: &str) -> bool {
         || (!agent_id.is_empty() && name.contains(agent_id))
 }
 
+fn parse_session_records(text: &str) -> Vec<serde_json::Value> {
+    match serde_json::from_str::<serde_json::Value>(text) {
+        Ok(serde_json::Value::Array(items)) => items,
+        Ok(value) => vec![value],
+        Err(_) => parse_jsonl_records(text),
+    }
+}
+
+fn provider_home_records_match_spawn_cwd(records: &[serde_json::Value], spawn_cwd: &Path) -> bool {
+    let cwd_values: Vec<String> = records.iter().filter_map(record_cwd).collect();
+    !cwd_values.is_empty()
+        && cwd_values
+            .iter()
+            .any(|cwd| paths_equivalent(Path::new(cwd), spawn_cwd))
+}
+
+fn record_cwd(record: &serde_json::Value) -> Option<String> {
+    record
+        .get("cwd")
+        .and_then(serde_json::Value::as_str)
+        .or_else(|| {
+            record
+                .get("session_meta")
+                .and_then(|v| v.get("payload"))
+                .or_else(|| record.get("payload"))
+                .and_then(|v| v.get("cwd"))
+                .and_then(serde_json::Value::as_str)
+        })
+        .map(ToString::to_string)
+}
+
+fn paths_equivalent(left: &Path, right: &Path) -> bool {
+    if left == right {
+        return true;
+    }
+    let left = std::fs::canonicalize(left).unwrap_or_else(|_| left.to_path_buf());
+    let right = std::fs::canonicalize(right).unwrap_or_else(|_| right.to_path_buf());
+    left == right || left.starts_with(&right)
+}
+
 /// `true` iff any path component is `.team` (the Team Agent runtime/logs root) — used
 /// to gate session-file detection so `<workspace>/.team/logs/events.jsonl`,
 /// `.team/runtime/team.db`, etc. are NEVER mistaken for a provider transcript.
@@ -790,7 +875,7 @@ fn current_team_agent_command() -> String {
 }
 
 fn has_cwd_field(record: &serde_json::Value) -> bool {
-    record.get("cwd").and_then(serde_json::Value::as_str).is_some()
+    record_cwd(record).is_some()
 }
 
 fn next_session_token() -> String {

package/crates/team-agent/src/provider/helpers.rs

@@ -22,9 +22,18 @@ pub(crate) fn find_session_id(record: &serde_json::Value) -> Option<String> {
     if let Some(s) = record.get("sessionId").and_then(serde_json::Value::as_str) {
         return Some(s.to_string());
     }
-    record
+    if let Some(s) = record
         .get("session_id")
         .and_then(serde_json::Value::as_str)
+    {
+        return Some(s.to_string());
+    }
+    record
+        .get("session_meta")
+        .and_then(|v| v.get("payload"))
+        .or_else(|| record.get("payload"))
+        .and_then(|v| v.get("id"))
+        .and_then(serde_json::Value::as_str)
         .map(ToString::to_string)
 }
 

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,101 @@ 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);
+
+    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,
+            );
+        }
+    }
+    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);
+        }
+    }
+}
+
+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,