@team-agent/installer 0.5.50 → 0.5.52

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

@@ -22,6 +22,8 @@ use crate::state::persist::{
     save_runtime_state_with_team_tombstoned_agents,
 };
 
+pub(crate) const CURRENT_TEAM_ALIAS: &str = "current";
+
 /// `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 {
@@ -283,6 +285,14 @@ pub(crate) fn team_is_alive_candidate(team: &Value) -> bool {
     if let Some(status) = status_raw {
         return status.eq_ignore_ascii_case("alive");
     }
+    if !team
+        .get("agents")
+        .and_then(Value::as_object)
+        .is_some_and(|agents| !agents.is_empty())
+        && team_has_live_leader_binding(team)
+    {
+        return false;
+    }
     if all_present_agents_terminal(team) && !team_has_live_leader_binding(team) {
         return false;
     }
@@ -302,6 +312,20 @@ fn team_has_live_leader_binding(team: &Value) -> bool {
     is_non_null_object("leader_receiver") || is_non_null_object("team_owner")
 }
 
+fn team_has_attached_leader_receiver(team: &Value) -> bool {
+    let Some(receiver) = team.get("leader_receiver").and_then(Value::as_object) else {
+        return false;
+    };
+    receiver
+        .get("status")
+        .and_then(Value::as_str)
+        .is_some_and(|status| status.eq_ignore_ascii_case("attached"))
+        && receiver
+            .get("pane_id")
+            .and_then(Value::as_str)
+            .is_some_and(|pane| !pane.is_empty())
+}
+
 fn all_present_agents_terminal(team: &Value) -> bool {
     let Some(agents) = team.get("agents").and_then(Value::as_object) else {
         return false;
@@ -458,15 +482,71 @@ pub fn project_top_level_view(state: &Value, team_key: &str) -> Value {
     Value::Object(p)
 }
 
-/// `select_runtime_state`(`state.py:193`):读 state → 按 `team` 选候选 → 投影顶层视图。
-/// 歧义/未找到 → `Err(StateError::TeamSelect(msg))`(msg == Python `str(RuntimeError)`)。
-pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Value, StateError> {
+#[derive(Debug, Clone)]
+pub struct TeamScopeResolution {
+    pub canonical_team_key: String,
+    pub state: Value,
+}
+
+/// Resolve a requested team selector once, returning both the canonical map key and its
+/// projected state. Callers must carry `canonical_team_key` forward rather than deriving team
+/// identity again from the projection or the original alias.
+pub fn resolve_runtime_team_scope(
+    workspace: &Path,
+    team: Option<&str>,
+) -> Result<TeamScopeResolution, StateError> {
     let state = load_runtime_state(workspace)?;
     let alive = team_state_candidates(&state);
     // Python `if team:` —— 空串 falsy,等同无 team(对抗 P1:此前 Some("") 误入 team 分支,空
     // team_dir 匹配致歧义/未找到错误串漂移)。
     let team = team.filter(|t| !t.is_empty());
     if let Some(team) = team {
+        // Intentional semantic split with `persist::apply_persist_merge_contract`:
+        // selector resolution validates the active team against the alive/terminal
+        // view, while the lock-held merge cannot depend on that mutable view. A
+        // change to either CURRENT_TEAM_ALIAS mapping must evaluate the other.
+        let canonical_request = if team.eq_ignore_ascii_case(CURRENT_TEAM_ALIAS) {
+            let teams = state.get("teams").and_then(Value::as_object);
+            state
+                .get("active_team_key")
+                .and_then(Value::as_str)
+                .filter(|active| {
+                    alive.contains_key(*active)
+                        || teams.is_none_or(Map::is_empty)
+                        || teams
+                            .and_then(|teams| teams.get(*active))
+                            .is_some_and(team_has_attached_leader_receiver)
+                })
+                .map(str::to_string)
+                .or_else(|| {
+                    teams
+                        .is_none_or(Map::is_empty)
+                        .then(|| team_state_key(&state))
+                        .filter(|derived| derived != "current")
+                })
+                .ok_or_else(|| {
+                    StateError::TeamSelect(format!(
+                        "team 'current' not found among alive teams. Use --team <team-key> with an explicit team key to address a terminal team. {}",
+                        format_team_candidates(&alive)
+                    ))
+                })?
+        } else {
+            team.to_string()
+        };
+        let team = canonical_request.as_str();
+        // An exact canonical key is authoritative even when the team is terminal or excluded from
+        // the default alive-candidate set. Explicit lifecycle operations must still be able to
+        // address a shutdown team without falling back to the raw root projection.
+        if state
+            .get("teams")
+            .and_then(Value::as_object)
+            .is_some_and(|teams| teams.contains_key(team))
+        {
+            return Ok(TeamScopeResolution {
+                canonical_team_key: team.to_string(),
+                state: project_top_level_view(&state, team),
+            });
+        }
         // 无 alive 但 team 命中 active_team_key / 派生 key → 直接以全量 state 投影。
         if alive.is_empty() {
             let active = state
@@ -484,32 +564,22 @@ pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Valu
                     }
                     None => projection = json!({ "active_team_key": team }),
                 }
-                return Ok(projection);
+                return Ok(TeamScopeResolution {
+                    canonical_team_key: team.to_string(),
+                    state: projection,
+                });
             }
         }
-        if alive.contains_key(team) {
-            return Ok(project_top_level_view(&state, team));
-        }
-        // 0.5.26 (`.team/artifacts/stale-team-saveconflict-locate.md` §7.1):
-        // 显式 `--team X` 命中 `state.teams` 里的键(即使被标 shutdown/终态)
-        // 仍应投影出来,支持「shutdown 后再 restart --team X」多队场景
-        // (E2E-REST-014 家族)。走 project_top_level_view 保证顶层 agents
-        // 与 teams[key].agents 收敛(E2E-REST-002 依赖 projection clobber
-        // 顶层注入的 session_id)。
-        if state
-            .get("teams")
-            .and_then(Value::as_object)
-            .is_some_and(|teams| teams.contains_key(team))
-        {
-            return Ok(project_top_level_view(&state, team));
-        }
         let matches: Vec<&String> = alive
             .iter()
             .filter(|(key, value)| team_selector_matches(team, key, value))
             .map(|(k, _)| k)
             .collect();
         if matches.len() == 1 {
-            return Ok(project_top_level_view(&state, matches[0]));
+            return Ok(TeamScopeResolution {
+                canonical_team_key: matches[0].clone(),
+                state: project_top_level_view(&state, matches[0]),
+            });
         }
         if matches.len() > 1 {
             return Err(StateError::TeamSelect(
@@ -529,12 +599,18 @@ pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Valu
         .filter(|s| !s.is_empty());
     if let Some(active) = active {
         if alive.contains_key(active) {
-            return Ok(project_top_level_view(&state, active));
+            return Ok(TeamScopeResolution {
+                canonical_team_key: active.to_string(),
+                state: project_top_level_view(&state, active),
+            });
         }
     }
     if alive.len() == 1 {
         let only = alive.keys().next().cloned().unwrap_or_default();
-        return Ok(project_top_level_view(&state, &only));
+        return Ok(TeamScopeResolution {
+            canonical_team_key: only.clone(),
+            state: project_top_level_view(&state, &only),
+        });
     }
     if alive.is_empty() {
         // 0.5.26 (`.team/artifacts/stale-team-saveconflict-locate.md` §7.1):
@@ -547,10 +623,22 @@ pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Valu
                 .and_then(Value::as_object)
                 .is_some_and(|teams| teams.contains_key(active_key))
             {
-                return Ok(project_top_level_view(&state, active_key));
+                return Ok(TeamScopeResolution {
+                    canonical_team_key: active_key.to_string(),
+                    state: project_top_level_view(&state, active_key),
+                });
             }
         }
-        return Ok(state);
+        let canonical_team_key = state
+            .get("active_team_key")
+            .and_then(Value::as_str)
+            .filter(|key| !key.is_empty())
+            .map(str::to_string)
+            .unwrap_or_else(|| team_state_key(&state));
+        return Ok(TeamScopeResolution {
+            canonical_team_key,
+            state,
+        });
     }
     Err(StateError::TeamSelect(
         "multiple teams found in this workspace; pass --team <team> to choose. ".to_string()
@@ -558,6 +646,11 @@ pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Valu
     ))
 }
 
+/// `select_runtime_state`(`state.py:193`):compatibility projection wrapper.
+pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Value, StateError> {
+    resolve_runtime_team_scope(workspace, team).map(|resolved| resolved.state)
+}
+
 fn team_selector_matches(team: &str, key: &str, value: &Value) -> bool {
     if team == key {
         return true;
@@ -678,22 +771,41 @@ pub(crate) fn save_team_scoped_state_with_deleted_agents(
 pub(crate) fn save_team_scoped_state_with_tombstone_lifecycle_topology_authority(
     workspace: &Path,
     team_state: &Value,
+    topology_team_key: &str,
     agent_ids: &[&str],
 ) -> Result<(), StateError> {
-    save_team_scoped_state_with_merge_options(workspace, team_state, &[], agent_ids, &[], agent_ids)
+    save_team_scoped_state_with_merge_options(
+        workspace,
+        team_state,
+        &[],
+        agent_ids,
+        &[],
+        Some(topology_team_key),
+        agent_ids,
+    )
 }
 
 pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority(
     workspace: &Path,
     team_state: &Value,
+    topology_team_key: &str,
     agent_ids: &[&str],
 ) -> Result<(), StateError> {
-    save_team_scoped_state_with_merge_options(workspace, team_state, &[], &[], &[], agent_ids)
+    save_team_scoped_state_with_merge_options(
+        workspace,
+        team_state,
+        &[],
+        &[],
+        &[],
+        Some(topology_team_key),
+        agent_ids,
+    )
 }
 
 pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
     workspace: &Path,
     team_state: &Value,
+    topology_team_key: &str,
     skip_capture_backfill_agent_ids: &[&str],
     topology_agent_ids: &[&str],
 ) -> Result<(), StateError> {
@@ -703,6 +815,7 @@ pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority_and_captu
         &[],
         &[],
         skip_capture_backfill_agent_ids,
+        Some(topology_team_key),
         topology_agent_ids,
     )
 }
@@ -719,6 +832,7 @@ fn save_team_scoped_state_with_merge_exceptions(
         deleted_agent_ids,
         tombstoned_agent_ids,
         &[],
+        None,
         &[],
     )
 }
@@ -729,6 +843,7 @@ fn save_team_scoped_state_with_merge_options(
     deleted_agent_ids: &[&str],
     tombstoned_agent_ids: &[&str],
     skip_capture_backfill_agent_ids: &[&str],
+    topology_team_key: Option<&str>,
     topology_agent_ids: &[&str],
 ) -> Result<(), StateError> {
     let target_key = team_state_key(team_state);
@@ -768,7 +883,7 @@ fn save_team_scoped_state_with_merge_options(
                 return save_runtime_state_with_team_tombstone_lifecycle_topology_authority(
                     workspace,
                     &merged,
-                    &target_key,
+                    topology_team_key.unwrap_or(&target_key),
                     topology_agent_ids,
                 );
             }
@@ -776,7 +891,7 @@ fn save_team_scoped_state_with_merge_options(
                 return save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
                     workspace,
                     &merged,
-                    &target_key,
+                    topology_team_key.unwrap_or(&target_key),
                     skip_capture_backfill_agent_ids,
                     topology_agent_ids,
                 );
@@ -784,6 +899,7 @@ fn save_team_scoped_state_with_merge_options(
             return save_runtime_state_with_lifecycle_topology_authority(
                 workspace,
                 &merged,
+                topology_team_key.unwrap_or(&target_key),
                 topology_agent_ids,
             );
         }
@@ -834,7 +950,7 @@ fn save_team_scoped_state_with_merge_options(
                 save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
                     workspace,
                     &Value::Object(merged),
-                    &target_key,
+                    topology_team_key.unwrap_or(&target_key),
                     skip_capture_backfill_agent_ids,
                     topology_agent_ids,
                 )
@@ -842,6 +958,7 @@ fn save_team_scoped_state_with_merge_options(
                 save_runtime_state_with_lifecycle_topology_authority(
                     workspace,
                     &Value::Object(merged),
+                    topology_team_key.unwrap_or(&target_key),
                     topology_agent_ids,
                 )
             }
@@ -1113,6 +1230,104 @@ mod tests {
         );
     }
 
+    #[test]
+    fn resolve_runtime_team_scope_current_uses_valid_active_key() {
+        let ws = temp_ws_with_state(&json!({
+            "active_team_key": "alpha",
+            "teams": {
+                "alpha": {"status": "alive", "session_name": "team-alpha", "agents": {"worker": {}}},
+                "old-team": {"team_owner": {"pane_id": "%9"}}
+            }
+        }));
+        let resolved = resolve_runtime_team_scope(&ws, Some("current")).unwrap();
+        assert_eq!(resolved.canonical_team_key, "alpha");
+        assert_eq!(
+            resolved.state.get("active_team_key").and_then(Value::as_str),
+            Some("alpha")
+        );
+    }
+
+    #[test]
+    fn resolve_runtime_team_scope_current_accepts_attached_receiver_recovery() {
+        let ws = temp_ws_with_state(&json!({
+            "active_team_key": "alpha",
+            "teams": {
+                "alpha": {
+                    "agents": {},
+                    "leader_receiver": {"status": "attached", "pane_id": "%9"}
+                }
+            }
+        }));
+        let resolved = resolve_runtime_team_scope(&ws, Some("current")).unwrap();
+        assert_eq!(resolved.canonical_team_key, "alpha");
+    }
+
+    #[test]
+    fn resolve_runtime_team_scope_current_accepts_shutdown_receiver_recovery() {
+        let ws = temp_ws_with_state(&json!({
+            "active_team_key": "alpha",
+            "teams": {
+                "alpha": {
+                    "status": "shutdown",
+                    "agents": {"worker": {"status": "stopped"}},
+                    "leader_receiver": {"status": "attached", "pane_id": "%9"}
+                }
+            }
+        }));
+        let resolved = resolve_runtime_team_scope(&ws, Some("current")).unwrap();
+        assert_eq!(resolved.canonical_team_key, "alpha");
+    }
+
+    #[test]
+    fn resolve_runtime_team_scope_current_rejects_owner_only_stub() {
+        let ws = temp_ws_with_state(&json!({
+            "active_team_key": "old-team",
+            "teams": {
+                "old-team": {"agents": {}, "team_owner": {"pane_id": "%9"}}
+            }
+        }));
+        let error = resolve_runtime_team_scope(&ws, Some("current")).unwrap_err();
+        assert!(error.to_string().contains("team 'current' not found"));
+    }
+
+    #[test]
+    fn resolve_runtime_team_scope_current_fails_without_valid_active_key() {
+        let ws = temp_ws_with_state(&json!({
+            "active_team_key": "missing",
+            "teams": {
+                "alpha": {"status": "alive", "session_name": "team-alpha", "agents": {"worker": {}}}
+            }
+        }));
+        let error = resolve_runtime_team_scope(&ws, Some("current")).unwrap_err();
+        assert!(error.to_string().contains("team 'current' not found"));
+    }
+
+    #[test]
+    fn resolve_runtime_team_scope_current_keeps_legacy_single_team_state() {
+        let ws = temp_ws_with_state(&json!({
+            "active_team_key": "legacy",
+            "team_key": "legacy",
+            "session_name": "team-legacy",
+            "agents": {"worker": {"status": "running"}}
+        }));
+        let resolved = resolve_runtime_team_scope(&ws, Some("current")).unwrap();
+        assert_eq!(resolved.canonical_team_key, "legacy");
+        assert_eq!(resolved.state["active_team_key"], json!("legacy"));
+    }
+
+    #[test]
+    fn resolve_runtime_team_scope_current_rejects_empty_workspace_bootstrap() {
+        let ws = temp_ws_with_state(&json!({}));
+        let error = resolve_runtime_team_scope(&ws, Some("current")).unwrap_err();
+        assert!(error.to_string().contains("team 'current' not found"));
+        let saved = load_runtime_state(&ws).unwrap();
+        assert_ne!(
+            saved.get("active_team_key").and_then(Value::as_str),
+            Some("current")
+        );
+        assert!(!crate::model::paths::runtime_spec_path(&ws, "current").exists());
+    }
+
     // 对抗 P1:空串 team 必须走「无 team」分支(Python `if team:` falsy),报「multiple teams」
     // 而非「team selector is ambiguous」(后者是非空 team 多匹配)。
     #[test]

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

@@ -0,0 +1,13 @@
+use super::StateWriteIntent;
+
+impl<'a> StateWriteIntent<'a> {
+    pub(crate) fn launch_team_or_add_agent(
+        team_key: &'a str,
+        added_agent_id: Option<&'a str>,
+    ) -> Self {
+        match added_agent_id {
+            Some(agent_id) => Self::AddAgent { team_key, agent_id },
+            None => Self::LaunchTeam { team_key },
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+use super::{reapply_scope, ReapplyScope, StateWriteIntent};
+
+#[test]
+fn mcp_reapply_scope_matches_legacy_helpers() {
+    assert!(
+        reapply_scope(&StateWriteIntent::McpUpdateStateNote {
+            team_key: Some("team-a"),
+        }) == ReapplyScope::Team
+    );
+    assert!(
+        reapply_scope(&StateWriteIntent::McpAssignTask {
+            team_key: Some("team-a"),
+            task_id: "task-a",
+        }) == ReapplyScope::Root
+    );
+}
+
+#[test]
+fn optional_unmigrated_read_preserves_missing_corrupt_and_valid_shapes(
+) -> Result<(), Box<dyn std::error::Error>> {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)?
+        .as_nanos();
+    let workspace = std::env::temp_dir().join(format!("state-repository-read-{nonce}"));
+    let repository = super::StateRepository::new(&workspace);
+    assert!(repository
+        .load_workspace_if_exists_without_migrations()?
+        .is_none());
+
+    let path = super::helper_workspace_path(&workspace);
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    std::fs::write(&path, b"{not-json")?;
+    assert!(matches!(
+        repository.load_workspace_if_exists_without_migrations(),
+        Err(super::StateError::Json(_))
+    ));
+
+    std::fs::write(&path, br#"{"legacy":true}"#)?;
+    assert_eq!(
+        repository.load_workspace_if_exists_without_migrations()?,
+        Some(serde_json::json!({"legacy": true}))
+    );
+    std::fs::remove_dir_all(workspace)?;
+    Ok(())
+}