@team-agent/installer 0.5.51 → 0.5.53

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

@@ -18,13 +18,15 @@ pub fn start_agent(
     team: Option<&str>,
 ) -> Result<StartAgentOutcome, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "start-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     start_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -54,9 +56,12 @@ pub fn start_agent_with_transport(
         Err(_) if team.is_none() => LifecyclePaths {
             run_workspace: workspace.to_path_buf(),
             spec_workspace: workspace.to_path_buf(),
+            selected: None,
         },
         Err(error) => return Err(error),
     };
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "start-agent",
@@ -778,13 +783,15 @@ pub fn stop_agent(
     team: Option<&str>,
 ) -> Result<StopAgentReport, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "stop-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     stop_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -801,6 +808,8 @@ pub fn stop_agent_with_transport(
     transport: &dyn crate::transport::Transport,
 ) -> Result<StopAgentReport, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "stop-agent",
@@ -840,9 +849,12 @@ pub(crate) fn start_agent_at_paths_for_recovery(
         Err(_) if team.is_none() => LifecyclePaths {
             run_workspace: workspace.to_path_buf(),
             spec_workspace: workspace.to_path_buf(),
+            selected: None,
         },
         Err(error) => return Err(RecoveryError::Lifecycle(error.to_string())),
     };
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     // Best-effort stop: if the live pane still exists we tear it down so the
     // subsequent start creates a fresh provider process instead of a Noop.
     // Stop errors are absorbed into the start attempt result — the important
@@ -1137,7 +1149,7 @@ fn mark_agent_started(
     }
     agent.insert(
         "spawned_at".to_string(),
-        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+        serde_json::json!(spawn.spawned_at.as_str()),
     );
     agent.insert(
         "spawn_cwd".to_string(),
@@ -1217,13 +1229,15 @@ pub fn reset_agent(
         });
     }
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "reset-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     reset_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -1249,6 +1263,8 @@ pub fn reset_agent_with_transport(
         });
     }
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "reset-agent",

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

@@ -2,6 +2,7 @@ use super::*;
 
 pub(super) struct SpawnedAgentWindow {
     pub spawn: crate::transport::SpawnResult,
+    pub spawned_at: String,
     pub plan: crate::provider::CommandPlan,
     pub profile_launch: crate::provider::ProviderProfileLaunch,
     pub layout_placement: Option<crate::lifecycle::launch::LayoutPlacement>,
@@ -327,6 +328,14 @@ pub(super) fn spawn_agent_window(
     );
     crate::lifecycle::launch::apply_profile_launch_env(&mut env, &profile_launch);
     crate::lifecycle::launch::apply_mcp_auto_approval_env(&mut env, safety);
+    if provider == crate::provider::Provider::Copilot {
+        crate::lifecycle::launch::apply_copilot_instructions_overlay(
+            workspace,
+            agent_id.as_str(),
+            &system_prompt,
+            &mut env,
+        )?;
+    }
     // 0.3.28 Step 3: per Python parity, worker spawn cwd is ALWAYS `workspace`.
     // The persisted-state `agent.spawn_cwd` override is ignored (it was a
     // Rust-only extension that drifted to `.team/runtime/<team_key>/` after
@@ -359,6 +368,7 @@ pub(super) fn spawn_agent_window(
     // failure can now be diagnosed from events.jsonl — the recorded
     // expected_session_id == state._pending_session_id (after
     // mark_agent_started persists the same plan tuple).
+    let spawned_at = crate::lifecycle::launch::spawn_timestamp();
     {
         let session_id_in_argv = plan
             .argv
@@ -385,6 +395,7 @@ pub(super) fn spawn_agent_window(
                 "env_unset": env_unset,
                 "tmux_start_mode": tmux_start_mode_pre_spawn,
                 "spawn_epoch": spawn_epoch,
+                "spawned_at": spawned_at.as_str(),
                 "source": "restart",
                 "tmux_endpoint": tmux_endpoint,
                 "tmux_endpoint_source": tmux_endpoint_source.unwrap_or("transport"),
@@ -521,6 +532,7 @@ pub(super) fn spawn_agent_window(
     }
     Ok(SpawnedAgentWindow {
         spawn,
+        spawned_at,
         plan,
         profile_launch,
         layout_placement: layout_placement.cloned(),

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

@@ -449,6 +449,15 @@ fn restart_with_selected_team_and_transport(
              moved leader to dedicated session)",
             session_name.as_str()
         );
+        let targets = vec![session_name.as_str().to_string()];
+        crate::kill_audit::pre_kill_audit(
+            &crate::event_log::EventLog::new(&selected.run_workspace),
+            transport,
+            "restart.stale_worker_session",
+            crate::kill_audit::KILL_SESSION,
+            &targets,
+        )
+        .map_err(|error| LifecycleError::Transport(format!("pre-kill audit failed: {error}")))?;
         transport
             .kill_session(&session_name)
             .map_err(|e| LifecycleError::Transport(e.to_string()))?;
@@ -1984,7 +1993,7 @@ fn mark_agent_respawned(
     }
     agent.insert(
         "spawned_at".to_string(),
-        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+        serde_json::json!(spawn.spawned_at.as_str()),
     );
     agent.insert(
         "spawn_cwd".to_string(),
@@ -2462,6 +2471,7 @@ impl Clone for ParallelSpawnResult {
         Self {
             spawn: SpawnedAgentWindow {
                 spawn: self.spawn.spawn.clone(),
+                spawned_at: self.spawn.spawned_at.clone(),
                 plan: self.spawn.plan.clone(),
                 profile_launch: self.spawn.profile_launch.clone(),
                 layout_placement: self.spawn.layout_placement.clone(),
@@ -3119,10 +3129,16 @@ fn restart_candidate_from_state(
         .filter(|s| !s.is_empty())
         .map(SessionName::new)
         .unwrap_or_else(|| SessionName::new(team_name));
+    let retired = retired_agent_ids(state);
     let mut agents = state
         .get("agents")
         .and_then(serde_json::Value::as_object)
-        .map(|map| map.keys().map(AgentId::new).collect::<Vec<_>>())
+        .map(|map| {
+            map.keys()
+                .filter(|agent_id| !retired.contains(agent_id.as_str()))
+                .map(AgentId::new)
+                .collect::<Vec<_>>()
+        })
         .unwrap_or_default();
     agents.sort_by(|a, b| a.as_str().cmp(b.as_str()));
     RestartCandidate {
@@ -3135,6 +3151,19 @@ fn restart_candidate_from_state(
     }
 }
 
+fn retired_agent_ids(state: &serde_json::Value) -> std::collections::BTreeSet<String> {
+    state
+        .get("agent_lifecycle")
+        .and_then(serde_json::Value::as_object)
+        .into_iter()
+        .flat_map(|lifecycle| lifecycle.iter())
+        .filter(|(_, entry)| {
+            entry.get("state").and_then(serde_json::Value::as_str) == Some("retired")
+        })
+        .map(|(agent_id, _)| agent_id.clone())
+        .collect()
+}
+
 /// E5 task#3 / RC-A6a:每次 restart 都以**角色定义**(team_dir 的 TEAM.md+agents/*.md)
 /// compile_team 重建 runtime spec(覆盖),保留运行期 override(session_name 必须延续,
 /// 否则 tmux session 对不上)。写到 .team/runtime/<team_key>/team.spec.yaml。
@@ -3204,6 +3233,7 @@ fn rebuild_runtime_spec_from_roles(
     // 静态 team_dir/agents/*.md + state 记录的 dynamic role source。缺文件 fail-closed
     // 三行式,不静默 prune 已 live 的 helper(persist SaveConflict 保护继续生效)。
     merge_state_dynamic_role_files(&mut spec, run_workspace, &team_dir, team_key, state)?;
+    filter_retired_agents_from_spec(&mut spec, &retired_agent_ids(state));
     // 写 runtime spec(覆盖,原子 tmp+rename;Bug2)。
     let spec_path = crate::model::paths::runtime_spec_path(run_workspace, team_key);
     crate::lifecycle::launch::write_spec_atomic(&spec_path, &spec)?;
@@ -3216,6 +3246,15 @@ fn rebuild_runtime_spec_from_roles(
     Ok(spec)
 }
 
+fn filter_retired_agents_from_spec(
+    spec: &mut YamlValue,
+    retired: &std::collections::BTreeSet<String>,
+) {
+    for agent_id in retired {
+        *spec = super::remove::spec_without_agent(spec, &AgentId::new(agent_id));
+    }
+}
+
 /// 0.5.30 (`add-agent-restart-saveconflict-locate.md` §4/§11): 把 add-agent
 /// 写入 `state.agents.<id>.dynamic_role_file` 的动态 role 文档合并回 restart
 /// 重建 spec。规则:
@@ -3418,6 +3457,76 @@ mod tests {
         TransportError,
     };
 
+    #[test]
+    fn retired_filter_clears_every_spec_reference_via_remove_primitive() {
+        let mut spec = crate::model::yaml::loads(
+            r#"
+name: retirement-filter
+agents:
+  - id: gone
+  - id: keep
+runtime:
+  startup_order:
+    - gone
+    - keep
+routing:
+  default_assignee: gone
+  rules:
+    - match: gone-task
+      assign_to: gone
+    - match: keep-task
+      assign_to: keep
+tasks:
+  - title: gone-task
+    assignee: gone
+  - title: keep-task
+    assignee: keep
+"#,
+        )
+        .expect("fixture spec");
+        let retired = std::collections::BTreeSet::from(["gone".to_string()]);
+
+        filter_retired_agents_from_spec(&mut spec, &retired);
+
+        let agents = spec
+            .get("agents")
+            .and_then(YamlValue::as_list)
+            .expect("agents");
+        assert!(agents.iter().all(|agent| {
+            agent.get("id").and_then(YamlValue::as_str) != Some("gone")
+        }));
+        let startup_order = spec
+            .get("runtime")
+            .and_then(|runtime| runtime.get("startup_order"))
+            .and_then(YamlValue::as_list)
+            .expect("startup_order");
+        assert!(startup_order
+            .iter()
+            .all(|agent_id| agent_id.as_str() != Some("gone")));
+        let routing = spec.get("routing").expect("routing");
+        assert_ne!(
+            routing
+                .get("default_assignee")
+                .and_then(YamlValue::as_str),
+            Some("gone"),
+            "spec_default_assignee must not return a retired agent"
+        );
+        let rules = routing
+            .get("rules")
+            .and_then(YamlValue::as_list)
+            .expect("routing rules");
+        assert!(rules.iter().all(|rule| {
+            rule.get("assign_to").and_then(YamlValue::as_str) != Some("gone")
+        }));
+        let tasks = spec
+            .get("tasks")
+            .and_then(YamlValue::as_list)
+            .expect("tasks");
+        assert!(tasks.iter().all(|task| {
+            task.get("assignee").and_then(YamlValue::as_str) != Some("gone")
+        }));
+    }
+
     #[test]
     fn resume_decision_event_uses_central_scrub_and_preserves_required_failure() {
         let marker = "synthetic-resume-decision-marker";
@@ -3590,6 +3699,7 @@ mod tests {
                 }
             }
         });
+        let before = chrono::Utc::now();
         let spawn = SpawnedAgentWindow {
             spawn: SpawnResult {
                 pane_id: PaneId::new("%new"),
@@ -3597,14 +3707,13 @@ mod tests {
                 window: WindowName::new("w1"),
                 child_pid: Some(2020),
             },
+            spawned_at: chrono::Utc::now().to_rfc3339(),
             plan: crate::provider::CommandPlan::argv_only(vec!["codex".to_string()]),
             profile_launch: crate::provider::ProviderProfileLaunch::default(),
             layout_placement: None,
             spawn_cwd: std::path::PathBuf::from("/tmp/team-epoch"),
             owner_team_id: None,
         };
-        let before = chrono::Utc::now();
-
         mark_agent_respawned(
             &mut state,
             &AgentId::new("w1"),

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

@@ -15,13 +15,15 @@ pub fn remove_agent(
     team: Option<&str>,
 ) -> Result<RemoveAgentOutcome, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "remove-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     remove_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -42,6 +44,8 @@ pub fn remove_agent_with_transport(
     transport: &dyn crate::transport::Transport,
 ) -> Result<RemoveAgentOutcome, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "remove-agent",
@@ -68,6 +72,8 @@ pub(crate) fn remove_agent_with_transport_locked(
     transport: &dyn crate::transport::Transport,
 ) -> Result<RemoveAgentOutcome, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     remove_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -94,6 +100,8 @@ impl ForceRecreateSnapshot {
         transport: &dyn crate::transport::Transport,
     ) -> Result<Self, LifecycleError> {
         let paths = lifecycle_paths(workspace, team)?;
+        let canonical_team = paths.canonical_team(team).map(str::to_string);
+        let team = canonical_team.as_deref();
         let seat = resolve_seat(
             &paths.run_workspace,
             &paths.spec_workspace,
@@ -215,7 +223,9 @@ pub fn remove_agent_flag_requirements(
     team: Option<&str>,
 ) -> Result<RemoveAgentFlagRequirements, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
+    let transport = paths.tmux_backend()?;
     Ok(remove_agent_preflight(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -564,14 +574,16 @@ fn remove_agent_inner(
     // (team projection) — NOT a raw save, so other teams in a multi-team workspace are preserved.
     let mut removed_state = working_state;
     remove_agent_from_state(&mut removed_state, agent_id)?;
-    crate::state::repository::StateRepository::new(paths.run_workspace).save(
-        crate::state::repository::StateWriteIntent::RemoveAgent {
-            team_key,
-            agent_id: agent_id.as_str(),
-        },
-        &removed_state,
-    )
-    .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    mark_agent_retired_in_state(&mut removed_state, agent_id)?;
+    crate::state::repository::StateRepository::new(paths.run_workspace)
+        .save(
+            crate::state::repository::StateWriteIntent::RemoveAgent {
+                team_key,
+                agent_id: agent_id.as_str(),
+            },
+            &removed_state,
+        )
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     cleared_locations.push(serde_json::json!("state.json:agents"));
     write_remove_step_event(
         paths.run_workspace,
@@ -783,6 +795,57 @@ fn remove_agent_from_state(
     }
 }
 
+pub(crate) fn mark_agent_retired_in_state(
+    state: &mut serde_json::Value,
+    agent_id: &AgentId,
+) -> Result<(), LifecycleError> {
+    let root = state.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist("runtime state root is not an object".to_string())
+    })?;
+    let lifecycle = root
+        .entry("agent_lifecycle".to_string())
+        .or_insert_with(|| serde_json::json!({}));
+    let lifecycle = lifecycle.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist("runtime state agent_lifecycle is not an object".to_string())
+    })?;
+    let entry = lifecycle
+        .entry(agent_id.as_str().to_string())
+        .or_insert_with(|| serde_json::json!({}));
+    if entry.get("state").and_then(serde_json::Value::as_str) == Some("retired") {
+        return Ok(());
+    }
+    let entry = entry.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist(format!(
+            "runtime state agent_lifecycle.{} is not an object",
+            agent_id.as_str()
+        ))
+    })?;
+    entry.insert("state".to_string(), serde_json::json!("retired"));
+    entry.insert(
+        "changed_at".to_string(),
+        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+    );
+    entry.insert("reason".to_string(), serde_json::json!("remove-agent"));
+    Ok(())
+}
+
+pub(crate) fn clear_agent_retirement_in_state(state: &mut serde_json::Value, agent_id: &AgentId) {
+    let Some(lifecycle) = state
+        .get_mut("agent_lifecycle")
+        .and_then(serde_json::Value::as_object_mut)
+    else {
+        return;
+    };
+    let is_retired = lifecycle
+        .get(agent_id.as_str())
+        .and_then(|entry| entry.get("state"))
+        .and_then(serde_json::Value::as_str)
+        == Some("retired");
+    if is_retired {
+        lifecycle.remove(agent_id.as_str());
+    }
+}
+
 /// Build the persisted spec after removing one worker. Besides deleting the worker and startup entry,
 /// prune routing references that would otherwise point at the removed worker.
 pub(crate) fn spec_without_agent(spec: &YamlValue, agent_id: &AgentId) -> YamlValue {

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

@@ -16,6 +16,29 @@ use super::*;
 struct LifecyclePaths {
     run_workspace: std::path::PathBuf,
     spec_workspace: std::path::PathBuf,
+    selected: Option<crate::state::selector::SelectedTeam>,
+}
+
+impl LifecyclePaths {
+    fn canonical_team<'a>(&'a self, requested: Option<&'a str>) -> Option<&'a str> {
+        self.selected
+            .as_ref()
+            .map(|selected| selected.team_key.as_str())
+            .or(requested)
+    }
+
+    fn tmux_backend(&self) -> Result<crate::tmux_backend::TmuxBackend, LifecycleError> {
+        match self.selected.as_ref() {
+            Some(selected) => common::lifecycle_worker_tmux_backend_selection_for_state(
+                &selected.run_workspace,
+                &selected.state,
+            )
+            .map(|selection| selection.backend),
+            None => Ok(crate::tmux_backend::TmuxBackend::for_workspace(
+                &self.run_workspace,
+            )),
+        }
+    }
 }
 
 struct LifecyclePathRefs<'a> {
@@ -115,8 +138,9 @@ fn lifecycle_paths(workspace: &Path, team: Option<&str>) -> Result<LifecyclePath
             LifecycleError::TeamSelect("active team spec workspace not found".to_string())
         })?;
     Ok(LifecyclePaths {
-        run_workspace: selected.run_workspace,
+        run_workspace: selected.run_workspace.clone(),
         spec_workspace,
+        selected: Some(selected),
     })
 }