@team-agent/installer 0.5.41 → 0.5.43

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

@@ -174,7 +174,10 @@ fn prepare_profile_launch(
         claude_config_dir = Some(dir);
     }
 
-    env_overlay.extend(compatible_api_network_exports(agent.auth_mode, &loaded.values));
+    env_overlay.extend(compatible_api_network_exports(
+        agent.auth_mode,
+        &loaded.values,
+    ));
     if agent.auth_mode == AuthMode::CompatibleApi && profile_proxy_mode(&loaded.values) == "direct"
     {
         for key in COMPATIBLE_NETWORK_ENV_KEYS {
@@ -307,7 +310,11 @@ fn validate_profile(
     {
         let profile_model = profile_model(&loaded.values);
         if let Some(profile_model) = profile_model {
-            if agent.model.as_deref().is_some_and(|model| model != profile_model) {
+            if agent
+                .model
+                .as_deref()
+                .is_some_and(|model| model != profile_model)
+            {
                 return Err(LifecycleError::RequirementUnmet(format!(
                     "role/team model does not match profile MODEL in {}",
                     loaded.path.display()
@@ -320,8 +327,7 @@ fn validate_profile(
         if key == &"API_KEY" {
             continue;
         }
-        if !profile_value_or_alternate(&loaded.values, key).is_some_and(|value| !value.is_empty())
-        {
+        if !profile_value_or_alternate(&loaded.values, key).is_some_and(|value| !value.is_empty()) {
             missing.push(*key);
         }
     }
@@ -393,16 +399,24 @@ fn provider_env_exports(
         // Subscription/OfficialApi 不导出 COPILOT_PROVIDER_*(避免误改 auth 通道)。
         Provider::Copilot => {
             if auth_mode == AuthMode::CompatibleApi {
-                if let Some(value) = value_or_alternate(values, "COPILOT_PROVIDER_BASE_URL", "BASE_URL") {
+                if let Some(value) =
+                    value_or_alternate(values, "COPILOT_PROVIDER_BASE_URL", "BASE_URL")
+                {
                     exports.insert("COPILOT_PROVIDER_BASE_URL".to_string(), value.to_string());
                 }
-                if let Some(value) = value_or_alternate(values, "COPILOT_PROVIDER_TYPE", "PROVIDER_TYPE") {
+                if let Some(value) =
+                    value_or_alternate(values, "COPILOT_PROVIDER_TYPE", "PROVIDER_TYPE")
+                {
                     exports.insert("COPILOT_PROVIDER_TYPE".to_string(), value.to_string());
                 }
-                if let Some(value) = value_or_alternate(values, "COPILOT_PROVIDER_API_KEY", "API_KEY") {
+                if let Some(value) =
+                    value_or_alternate(values, "COPILOT_PROVIDER_API_KEY", "API_KEY")
+                {
                     exports.insert("COPILOT_PROVIDER_API_KEY".to_string(), value.to_string());
                 }
-                if let Some(value) = value_or_alternate(values, "COPILOT_PROVIDER_WIRE_API", "WIRE_API") {
+                if let Some(value) =
+                    value_or_alternate(values, "COPILOT_PROVIDER_WIRE_API", "WIRE_API")
+                {
                     exports.insert("COPILOT_PROVIDER_WIRE_API".to_string(), value.to_string());
                 }
                 if let Some(value) = value_or_alternate(values, "COPILOT_MODEL", "MODEL") {
@@ -505,8 +519,8 @@ fn provider_command_overrides(
     // Python provider_env.py:62-79 (_provider_command_overrides codex branch).
     match agent.provider {
         Provider::Codex => {
-            codex_profile = value_or_alternate(values, "CODEX_PROFILE", "NATIVE_PROFILE")
-                .map(str::to_string);
+            codex_profile =
+                value_or_alternate(values, "CODEX_PROFILE", "NATIVE_PROFILE").map(str::to_string);
             let model_provider = values.get("MODEL_PROVIDER").filter(|v| !v.is_empty());
             let base_url = values.get("BASE_URL").filter(|v| !v.is_empty());
             if agent.auth_mode == AuthMode::CompatibleApi {
@@ -620,8 +634,14 @@ fn ensure_compatible_claude_config(dir: &Path, workspace: &Path) -> Result<(), L
         "skipDangerousModePermissionPrompt",
         serde_json::json!(true),
     );
-    settings.insert("hasCompletedOnboarding".to_string(), serde_json::json!(true));
-    settings.insert("hasTrustDialogAccepted".to_string(), serde_json::json!(true));
+    settings.insert(
+        "hasCompletedOnboarding".to_string(),
+        serde_json::json!(true),
+    );
+    settings.insert(
+        "hasTrustDialogAccepted".to_string(),
+        serde_json::json!(true),
+    );
     insert_if_missing(
         &mut settings,
         "lastOnboardingVersion",
@@ -642,7 +662,10 @@ fn ensure_compatible_claude_config(dir: &Path, workspace: &Path) -> Result<(), L
 
     let state_path = dir.join(".claude.json");
     let mut state = read_json_object(&state_path)?;
-    state.insert("hasCompletedOnboarding".to_string(), serde_json::json!(true));
+    state.insert(
+        "hasCompletedOnboarding".to_string(),
+        serde_json::json!(true),
+    );
     insert_if_missing(
         &mut state,
         "lastOnboardingVersion",
@@ -665,8 +688,14 @@ fn ensure_compatible_claude_mcp_config(
 ) -> Result<(), LifecycleError> {
     let state_path = dir.join(".claude.json");
     let mut state = read_json_object(&state_path)?;
-    state.insert("hasCompletedOnboarding".to_string(), serde_json::json!(true));
-    state.insert("hasTrustDialogAccepted".to_string(), serde_json::json!(true));
+    state.insert(
+        "hasCompletedOnboarding".to_string(),
+        serde_json::json!(true),
+    );
+    state.insert(
+        "hasTrustDialogAccepted".to_string(),
+        serde_json::json!(true),
+    );
     insert_if_missing(
         &mut state,
         "projectOnboardingSeenCount",
@@ -686,7 +715,10 @@ fn ensure_claude_projects(
     workspace: &Path,
     mcp_servers: Option<&serde_json::Value>,
 ) {
-    if !state.get("projects").is_some_and(serde_json::Value::is_object) {
+    if !state
+        .get("projects")
+        .is_some_and(serde_json::Value::is_object)
+    {
         state.insert("projects".to_string(), serde_json::json!({}));
     }
     let Some(projects) = state
@@ -703,7 +735,10 @@ fn ensure_claude_projects(
         let Some(project) = entry.as_object_mut() else {
             continue;
         };
-        project.insert("hasTrustDialogAccepted".to_string(), serde_json::json!(true));
+        project.insert(
+            "hasTrustDialogAccepted".to_string(),
+            serde_json::json!(true),
+        );
         insert_if_missing(project, "projectOnboardingSeenCount", serde_json::json!(1));
         if let Some(mcp_servers) = mcp_servers {
             insert_if_missing(project, "allowedTools", serde_json::json!([]));
@@ -892,22 +927,26 @@ pub(crate) fn profile_value_or_alternate<'a>(
         .get(key)
         .filter(|value| !value.is_empty())
         .map(String::as_str)
-        .or_else(|| match key {
-            "API_KEY" => values
-                .get("ANTHROPIC_API_KEY")
-                .or_else(|| values.get("ANTHROPIC_AUTH_TOKEN"))
-                .or_else(|| values.get("AUTH_TOKEN"))
-                .or_else(|| values.get("CLAUDE_API_KEY"))
-                .or_else(|| values.get("CLAUDE_AUTH_TOKEN"))
-                .or_else(|| values.get("BEARER_TOKEN"))
-                .or_else(|| values.get("TEAM_AGENT_PROVIDER_API_KEY"))
-                .or_else(|| values.get("OPENAI_API_KEY")),
-            "BASE_URL" => values.get("ANTHROPIC_BASE_URL").or_else(|| values.get("OPENAI_BASE_URL")),
-            "MODEL" => values.get("ANTHROPIC_MODEL"),
-            _ => None,
-        }
-        .filter(|value| !value.is_empty())
-        .map(String::as_str))
+        .or_else(|| {
+            match key {
+                "API_KEY" => values
+                    .get("ANTHROPIC_API_KEY")
+                    .or_else(|| values.get("ANTHROPIC_AUTH_TOKEN"))
+                    .or_else(|| values.get("AUTH_TOKEN"))
+                    .or_else(|| values.get("CLAUDE_API_KEY"))
+                    .or_else(|| values.get("CLAUDE_AUTH_TOKEN"))
+                    .or_else(|| values.get("BEARER_TOKEN"))
+                    .or_else(|| values.get("TEAM_AGENT_PROVIDER_API_KEY"))
+                    .or_else(|| values.get("OPENAI_API_KEY")),
+                "BASE_URL" => values
+                    .get("ANTHROPIC_BASE_URL")
+                    .or_else(|| values.get("OPENAI_BASE_URL")),
+                "MODEL" => values.get("ANTHROPIC_MODEL"),
+                _ => None,
+            }
+            .filter(|value| !value.is_empty())
+            .map(String::as_str)
+        })
 }
 
 pub(crate) fn value_or_alternate<'a>(
@@ -926,7 +965,11 @@ pub(crate) fn profile_model(values: &BTreeMap<String, String>) -> Option<&str> {
     values
         .get("MODEL")
         .filter(|value| !value.is_empty())
-        .or_else(|| values.get("ANTHROPIC_MODEL").filter(|value| !value.is_empty()))
+        .or_else(|| {
+            values
+                .get("ANTHROPIC_MODEL")
+                .filter(|value| !value.is_empty())
+        })
         .map(String::as_str)
 }
 

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

@@ -187,7 +187,9 @@ impl SmokeTarget {
             }
             // C-7-1 cr verdict: copilot 一期 subscription-only,无 BYOK HTTP smoke
             // 入口;同 GeminiCli/Fake 走 unsupported_provider_smoke_skipped。
-            Provider::Copilot | Provider::GeminiCli | Provider::Fake => Err("unsupported_provider_smoke_skipped"),
+            Provider::Copilot | Provider::GeminiCli | Provider::Fake => {
+                Err("unsupported_provider_smoke_skipped")
+            }
         }
     }
 

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

@@ -826,12 +826,7 @@ pub(crate) fn start_agent_at_paths_for_recovery(
     // subsequent start creates a fresh provider process instead of a Noop.
     // Stop errors are absorbed into the start attempt result — the important
     // invariant is that a successful start returns Running, never Noop.
-    let _ = stop_agent_with_transport(
-        &paths.run_workspace,
-        agent_id,
-        team,
-        transport,
-    );
+    let _ = stop_agent_with_transport(&paths.run_workspace, agent_id, team, transport);
     let start_result = start_agent_with_transport(
         &paths.run_workspace,
         agent_id,

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

@@ -26,10 +26,7 @@ pub fn halt_plan(
 }
 
 /// `plan_status(workspace, plan_id)`(`orchestrator/__init__.py:177`)。读 plan 持久态。
-pub fn plan_status(
-    workspace: &Path,
-    plan_id: &PlanId,
-) -> Result<PlanState, LifecycleError> {
+pub fn plan_status(workspace: &Path, plan_id: &PlanId) -> Result<PlanState, LifecycleError> {
     let path = plan_state_path(workspace, plan_id);
     if !path.exists() {
         return Err(LifecycleError::InvalidPlan(format!(

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

@@ -37,11 +37,12 @@ impl SessionPreflight {
 /// kill is safe. Pure: no I/O, no mutation.
 pub fn check_session_preflight(state: &serde_json::Value) -> SessionPreflight {
     let sessions = RuntimeSessions::from_state(state);
-    if let Some(anomaly) = sessions
-        .anomalies
-        .iter()
-        .find(|a| matches!(a, RuntimeSessionAnomaly::WorkerSessionNameIsLeaderPrefixed { .. }))
-    {
+    if let Some(anomaly) = sessions.anomalies.iter().find(|a| {
+        matches!(
+            a,
+            RuntimeSessionAnomaly::WorkerSessionNameIsLeaderPrefixed { .. }
+        )
+    }) {
         if let RuntimeSessionAnomaly::WorkerSessionNameIsLeaderPrefixed { value } = anomaly {
             return SessionPreflight::WorkerSessionIsLeaderSession {
                 session_name: value.clone(),

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

@@ -523,7 +523,10 @@ fn restart_with_selected_team_and_transport(
         // as pre-0.5.38 (fake harness + missing agent branches). Where a
         // parallel Some(Ok(spawn)) is present we skip the transport spawn
         // and jump straight to verify + mark.
-        let parallel_result = parallel_outcomes.get(decision_index).cloned().unwrap_or(None);
+        let parallel_result = parallel_outcomes
+            .get(decision_index)
+            .cloned()
+            .unwrap_or(None);
         if let Some(parallel_result) = parallel_result {
             match parallel_result {
                 Ok(pspawn) => {
@@ -642,11 +645,7 @@ fn restart_with_selected_team_and_transport(
                     "tmux_server_crashed: session {} disappeared during replacement build; refusing to touch original agent state",
                     session_name.as_str()
                 );
-                failed_agents.push(restart_failed_agent(
-                    decision,
-                    "tmux_server_crashed",
-                    error,
-                ));
+                failed_agents.push(restart_failed_agent(decision, "tmux_server_crashed", error));
                 continue;
             }
             if let Some(previous) = successful_agents.pop() {
@@ -741,10 +740,9 @@ fn restart_with_selected_team_and_transport(
             continue;
         }
         let pane_verify_ms = u64::try_from(verify_start.elapsed().as_millis()).unwrap_or(u64::MAX);
-        let transport_spawn_ms = u64::try_from(
-            (verify_start.saturating_duration_since(spawn_start)).as_millis(),
-        )
-        .unwrap_or(u64::MAX);
+        let transport_spawn_ms =
+            u64::try_from((verify_start.saturating_duration_since(spawn_start)).as_millis())
+                .unwrap_or(u64::MAX);
         // 0.5.38 Step 1: per-worker spawn timing so operators can identify
         // whether wall time is spent in command-plan compilation, transport
         // spawn, pane verification, or provider startup prompts.
@@ -1096,7 +1094,11 @@ fn restart_with_selected_team_and_transport(
     drop(lifecycle_lock);
     let coordinator =
         start_coordinator_for_workspace(&selected.run_workspace, Some(&selected.team_key))?;
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "coordinator_start");
+    phase_timer.emit(
+        &selected.run_workspace,
+        "restart.phase",
+        "coordinator_start",
+    );
     let coordinator_started = coordinator.ok;
     phase_timer.emit(&selected.run_workspace, "restart.phase", "readiness_wait");
     wait_restart_readiness_or_timeout(
@@ -2420,12 +2422,11 @@ fn run_bounded_parallel_worker_spawns(
     let _ = concurrency_placeholder(inputs_len); // reserved for future config
     let inputs_shared: Vec<Option<SpawnInput>> = inputs.into_iter().map(Some).collect();
     let inputs_shared = std::sync::Arc::new(std::sync::Mutex::new(inputs_shared));
-    let next_submit_slot = std::sync::Arc::new((
-        std::sync::Mutex::new(0usize),
-        std::sync::Condvar::new(),
-    ));
-    let results: std::sync::Arc<std::sync::Mutex<Vec<(usize, Result<ParallelSpawnResult, String>)>>> =
-        std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
+    let next_submit_slot =
+        std::sync::Arc::new((std::sync::Mutex::new(0usize), std::sync::Condvar::new()));
+    let results: std::sync::Arc<
+        std::sync::Mutex<Vec<(usize, Result<ParallelSpawnResult, String>)>>,
+    > = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     std::thread::scope(|scope| {
         for slot in 0..inputs_len {
             let inputs_shared = std::sync::Arc::clone(&inputs_shared);
@@ -2530,8 +2531,8 @@ fn apply_marked_respawn(
     fatal_resume_failure: &mut bool,
 ) {
     let verify_start = std::time::Instant::now();
-    if let Err(error) = verify_spawned_agent_live(&decision.agent_id, spawn, transport)
-        .and_then(|_| {
+    if let Err(error) =
+        verify_spawned_agent_live(&decision.agent_id, spawn, transport).and_then(|_| {
             mark_agent_respawned(
                 state,
                 &decision.agent_id,
@@ -2553,9 +2554,12 @@ fn apply_marked_respawn(
         return;
     }
     let pane_verify_ms = u64::try_from(verify_start.elapsed().as_millis()).unwrap_or(u64::MAX);
-    let transport_spawn_ms =
-        u64::try_from(verify_start.saturating_duration_since(spawn_start).as_millis())
-            .unwrap_or(u64::MAX);
+    let transport_spawn_ms = u64::try_from(
+        verify_start
+            .saturating_duration_since(spawn_start)
+            .as_millis(),
+    )
+    .unwrap_or(u64::MAX);
     write_worker_spawn_timing_event(
         run_workspace,
         phase_timer.elapsed_ms(),

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

@@ -1,7 +1,9 @@
-use super::*;
-use super::agent::{resolve_team_scoped_state_or_refuse, start_agent_at_paths, stop_agent_at_paths};
+use super::agent::{
+    resolve_team_scoped_state_or_refuse, start_agent_at_paths, stop_agent_at_paths,
+};
 use super::common::*;
 use super::team_state::write_team_state;
+use super::*;
 use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
 
 /// `remove_agent(workspace, agent_id, from_spec, force, team)`(`lifecycle/agents.py:22`)。
@@ -21,8 +23,7 @@ pub fn remove_agent(
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport =
-        lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
     remove_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -66,8 +67,7 @@ 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 transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
     Ok(remove_agent_preflight(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -207,7 +207,8 @@ fn remove_agent_at_paths(
             // golden agents.py:110-133: restore is best-effort (collects per-artifact errors, restores ALL),
             // and the ORIGINAL operation error is ALWAYS re-raised, annotated with rollback_ok — a
             // restore-step failure only flips rollback_ok, it never replaces the surfaced cause.
-            let restore_errors = rollback.restore(paths.run_workspace, paths.spec_workspace, team, transport);
+            let restore_errors =
+                rollback.restore(paths.run_workspace, paths.spec_workspace, team, transport);
             let rollback_ok = restore_errors.is_empty();
             let rollback_event = RemoveRollbackEvent {
                 agent_id,
@@ -243,7 +244,13 @@ fn remove_agent_inner(
     let mut stopped = false;
     let mut cleared_locations = Vec::new();
     if force && agent_is_running(&working_state, agent_id, transport) {
-        let stop = stop_agent_at_paths(paths.run_workspace, paths.spec_workspace, agent_id, team, transport)?;
+        let stop = stop_agent_at_paths(
+            paths.run_workspace,
+            paths.spec_workspace,
+            agent_id,
+            team,
+            transport,
+        )?;
         stopped = stop.stopped;
         write_remove_step_event(
             paths.run_workspace,
@@ -265,7 +272,7 @@ fn remove_agent_inner(
         &removed_state,
         &[agent_id.as_str()],
     )
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     cleared_locations.push(serde_json::json!("state.json:agents"));
     write_remove_step_event(
         paths.run_workspace,
@@ -282,7 +289,9 @@ fn remove_agent_inner(
     }
     // golden agents.py:96-100,157: state_file = the team_state.md path written from removed_spec/state.
     let team_state_path = write_team_state(paths.spec_workspace, &removed_spec, &removed_state)?;
-    cleared_locations.push(serde_json::json!(team_state_path.to_string_lossy().to_string()));
+    cleared_locations.push(serde_json::json!(team_state_path
+        .to_string_lossy()
+        .to_string()));
     write_remove_step_event(
         paths.run_workspace,
         agent_id,
@@ -290,8 +299,11 @@ fn remove_agent_inner(
         &team_state_path.to_string_lossy(),
         None,
     )?;
-    std::fs::write(paths.spec_workspace.join("team.spec.yaml"), yaml::dumps(&removed_spec))
-        .map_err(|e| LifecycleError::StatePersist(format!("write spec: {e}")))?;
+    std::fs::write(
+        paths.spec_workspace.join("team.spec.yaml"),
+        yaml::dumps(&removed_spec),
+    )
+    .map_err(|e| LifecycleError::StatePersist(format!("write spec: {e}")))?;
     cleared_locations.push(serde_json::json!("team.spec.yaml"));
     write_remove_step_event(
         paths.run_workspace,
@@ -519,7 +531,11 @@ fn runtime_without_startup_agent(runtime: &YamlValue, agent_id: &AgentId) -> Yam
                 .map(|items| {
                     items
                         .iter()
-                        .filter(|item| item.as_str().map(|id| id != agent_id.as_str()).unwrap_or(true))
+                        .filter(|item| {
+                            item.as_str()
+                                .map(|id| id != agent_id.as_str())
+                                .unwrap_or(true)
+                        })
                         .cloned()
                         .collect::<Vec<_>>()
                 })
@@ -538,9 +554,7 @@ fn routing_without_agent(routing: &YamlValue, agent_id: &AgentId) -> YamlValue {
     };
     let mut out = Vec::new();
     for (key, value) in pairs {
-        if key == "default_assignee"
-            && value.as_str().is_some_and(|id| id == agent_id.as_str())
-        {
+        if key == "default_assignee" && value.as_str().is_some_and(|id| id == agent_id.as_str()) {
             out.push((key.clone(), YamlValue::Str(String::new())));
         } else if key == "rules" {
             let rules = value
@@ -549,8 +563,7 @@ fn routing_without_agent(routing: &YamlValue, agent_id: &AgentId) -> YamlValue {
                     items
                         .iter()
                         .filter(|rule| {
-                            rule
-                                .get("assign_to")
+                            rule.get("assign_to")
                                 .and_then(YamlValue::as_str)
                                 .map(|id| id != agent_id.as_str())
                                 .unwrap_or(true)
@@ -587,11 +600,7 @@ fn task_without_agent_assignee(task: &YamlValue, agent_id: &AgentId) -> YamlValu
         pairs
             .iter()
             .map(|(key, value)| {
-                if key == "assignee"
-                    && value
-                        .as_str()
-                        .is_some_and(|id| id == agent_id.as_str())
-                {
+                if key == "assignee" && value.as_str().is_some_and(|id| id == agent_id.as_str()) {
                     (key.clone(), YamlValue::Str(String::new()))
                 } else {
                     (key.clone(), value.clone())
@@ -601,18 +610,12 @@ fn task_without_agent_assignee(task: &YamlValue, agent_id: &AgentId) -> YamlValu
     )
 }
 
-fn remove_dynamic_role_file(
-    path: &Path,
-    required: bool,
-) -> Result<bool, LifecycleError> {
+fn remove_dynamic_role_file(path: &Path, required: bool) -> Result<bool, LifecycleError> {
     match std::fs::remove_file(path) {
         Ok(()) => Ok(true),
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound && required => {
-            Err(LifecycleError::StatePersist(format!(
-                "dynamic role file missing: {}",
-                path.display()
-            )))
-        }
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound && required => Err(
+            LifecycleError::StatePersist(format!("dynamic role file missing: {}", path.display())),
+        ),
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(false),
         Err(e) => Err(LifecycleError::StatePersist(format!(
             "remove role file {}: {e}",
@@ -660,7 +663,10 @@ fn delete_agent_health(workspace: &Path, agent_id: &AgentId) -> Result<bool, Lif
     let conn = crate::db::schema::open_db(store.db_path())
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     let changed = conn
-        .execute("delete from agent_health where agent_id = ?1", [agent_id.as_str()])
+        .execute(
+            "delete from agent_health where agent_id = ?1",
+            [agent_id.as_str()],
+        )
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     Ok(changed > 0)
 }
@@ -739,7 +745,11 @@ impl RemoveRollback {
         let team_state_text = match std::fs::read_to_string(&team_state_path) {
             Ok(text) => Some(text),
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
-            Err(e) => return Err(LifecycleError::StatePersist(format!("read team_state: {e}"))),
+            Err(e) => {
+                return Err(LifecycleError::StatePersist(format!(
+                    "read team_state: {e}"
+                )))
+            }
         };
         let dynamic_role_path = dynamic_role_file_path(workspace, state, agent_id);
         let dynamic_role_bytes = match std::fs::read(&dynamic_role_path) {