@team-agent/installer 0.3.1 → 0.3.2

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

@@ -31,6 +31,12 @@ pub fn restart_with_transport(
     team: Option<&str>,
     transport: &dyn crate::transport::Transport,
 ) -> Result<RestartReport, LifecycleError> {
+    if crate::lifecycle::restart::input_has_no_local_team_context(workspace) {
+        return Err(LifecycleError::TeamSelect(format!(
+            "missing spec for restart: {}",
+            workspace.join("team.spec.yaml").display()
+        )));
+    }
     let run_candidate = crate::model::paths::canonical_run_workspace(workspace)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     if !workspace.join("team.spec.yaml").exists()
@@ -47,7 +53,7 @@ pub fn restart_with_transport(
         crate::state::selector::SelectorMode::RequireSpec,
     )
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
-    let state = selected.state;
+    let mut state = selected.state;
     crate::lifecycle::launch::ensure_owner_allowed_for_state(&state, None)?;
     let spec_workspace = selected
         .spec_workspace
@@ -55,6 +61,10 @@ pub fn restart_with_transport(
         .ok_or_else(|| LifecycleError::TeamSelect("active team spec workspace not found".to_string()))?;
     let spec = load_team_spec(spec_workspace)?;
     let safety = crate::lifecycle::launch::effective_runtime_config(&spec)?;
+    if refresh_missing_provider_sessions(&mut state)? {
+        crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
+            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    }
     let plan = classify_restart_plan(&state, allow_fresh)?;
     write_restart_resume_decision_events(&selected.run_workspace, &state, allow_fresh, &plan.decisions)?;
     if !plan.corrupt_entries.is_empty() {
@@ -117,7 +127,6 @@ fn write_restart_resume_decision_events(
     allow_fresh: bool,
     decisions: &[RestartedAgent],
 ) -> Result<(), LifecycleError> {
-    let log = crate::event_log::EventLog::new(workspace);
     for decision in decisions {
         let agent = state
             .get("agents")
@@ -134,23 +143,56 @@ fn write_restart_resume_decision_events(
             ResumeDecision::FreshStart => "fresh_start",
             ResumeDecision::Refuse => "refuse",
         };
-        log.write(
-            crate::lifecycle::types::event_names::RESTART_RESUME_DECISION,
-            serde_json::json!({
-                "worker_id": decision.agent_id.as_str(),
-                "has_first_send_at": first_send_at.is_some(),
-                "has_session_id": session_id.is_some(),
-                "allow_fresh": allow_fresh,
-                "decision": decision_wire,
-                "first_send_at": first_send_at,
-                "session_id": session_id,
-            }),
-        )
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+        write_restart_resume_decision_event(
+            workspace,
+            decision.agent_id.as_str(),
+            first_send_at,
+            session_id,
+            allow_fresh,
+            decision_wire,
+        )?;
     }
     Ok(())
 }
 
+fn write_restart_resume_decision_event(
+    workspace: &Path,
+    worker_id: &str,
+    first_send_at: Option<String>,
+    session_id: Option<String>,
+    allow_fresh: bool,
+    decision: &str,
+) -> Result<(), LifecycleError> {
+    use std::io::Write as _;
+
+    let path = workspace.join(".team").join("logs").join("events.jsonl");
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    }
+    let event = serde_json::json!({
+        "ts": chrono::Utc::now().to_rfc3339(),
+        "event": crate::lifecycle::types::event_names::RESTART_RESUME_DECISION,
+        "worker_id": worker_id,
+        "has_first_send_at": first_send_at.is_some(),
+        "has_session_id": session_id.is_some(),
+        "allow_fresh": allow_fresh,
+        "decision": decision,
+        "first_send_at": first_send_at,
+        "session_id": session_id,
+    });
+    let line = serde_json::to_string(&event)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    let mut file = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    file.write_all(line.as_bytes())
+        .and_then(|_| file.write_all(b"\n"))
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
+}
+
 /// `restart_candidates(workspace)`(`restart/selection.py:12`)。从 snapshot + active
 /// state 收集可重启 team。
 pub fn restart_candidates(workspace: &Path) -> Result<Vec<RestartCandidate>, LifecycleError> {

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

@@ -169,7 +169,11 @@ 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::projection::save_team_scoped_state(paths.run_workspace, &removed_state)
+    crate::state::projection::save_team_scoped_state_with_deleted_agents(
+        paths.run_workspace,
+        &removed_state,
+        &[agent_id.as_str()],
+    )
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     cleared_locations.push(serde_json::json!("state.json:agents"));
     write_remove_step_event(

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

@@ -33,6 +33,7 @@ mod team_state;
 
 pub use agent::{reset_agent, reset_agent_with_transport, start_agent, start_agent_with_transport, stop_agent, stop_agent_with_transport};
 pub(crate) use agent::start_agent_at_paths;
+pub(crate) use common::refresh_missing_provider_sessions;
 pub use orchestrator::{halt_plan, plan_status};
 pub use rebuild::{restart, restart_candidates, restart_with_transport, select_restart_state};
 pub use remove::{remove_agent, remove_agent_with_transport};
@@ -45,6 +46,13 @@ pub(crate) fn lifecycle_run_workspace(workspace: &Path) -> Result<std::path::Pat
 }
 
 fn lifecycle_paths(workspace: &Path, team: Option<&str>) -> Result<LifecyclePaths, LifecycleError> {
+    if input_has_no_local_team_context(workspace) {
+        return Err(LifecycleError::TeamSelect(format!(
+            "active team spec not found: input_workspace={} expected_spec_path={}",
+            workspace.display(),
+            workspace.join("team.spec.yaml").display()
+        )));
+    }
     let selected = crate::state::selector::resolve_active_team(
         workspace,
         team,
@@ -60,6 +68,18 @@ fn lifecycle_paths(workspace: &Path, team: Option<&str>) -> Result<LifecyclePath
     })
 }
 
+pub(crate) fn 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 selected_state_spec_workspace(state: &serde_json::Value) -> Option<std::path::PathBuf> {
     state
         .get("spec_path")