@team-agent/installer 0.3.13 → 0.3.14

package/crates/team-agent/src/leader/start.rs

@@ -2,12 +2,12 @@
 
 use std::collections::BTreeMap;
 use std::io::IsTerminal;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
 use crate::provider::{get_adapter, Provider};
 use crate::tmux_backend::TmuxBackend;
-use crate::transport::{SessionName, Transport};
+use crate::transport::{PaneId, SessionName, Target, Transport};
 
 use super::helpers::{
     provider_wire, resolve_workspace_for_hash, sanitize_session_folder, sha1_hex_prefix,
@@ -125,7 +125,10 @@ pub(crate) fn leader_env_for_identity(
         identity.team_id.as_str().to_string(),
     );
     if provider == Provider::Copilot {
-        leader_env.insert("COPILOT_DISABLE_TERMINAL_TITLE".to_string(), "1".to_string());
+        leader_env.insert(
+            "COPILOT_DISABLE_TERMINAL_TITLE".to_string(),
+            "1".to_string(),
+        );
     }
     leader_env
 }
@@ -171,7 +174,7 @@ pub fn execute_leader_plan(
     let detached = plan.mode == LeaderStartMode::NewTmuxSession
         && !std::io::stdin().is_terminal()
         && insert_detach_flag(&mut argv);
-    let status = run_leader_argv(&argv, &plan.leader_env)?;
+    let status = run_leader_argv(&argv, &plan.leader_env, plan, workspace)?;
     let code = status.code();
     if !status.success() {
         return Err(LeaderError::Start(format!(
@@ -294,6 +297,8 @@ fn insert_detach_flag(argv: &mut Vec<String>) -> bool {
 fn run_leader_argv(
     argv: &[String],
     env: &BTreeMap<String, String>,
+    plan: &LeaderStartPlan,
+    workspace: &Path,
 ) -> Result<std::process::ExitStatus, LeaderError> {
     let Some(program) = argv.first() else {
         return Err(LeaderError::Start(
@@ -307,9 +312,84 @@ fn run_leader_argv(
         .stdout(Stdio::inherit())
         .stderr(Stdio::inherit())
         .spawn()?;
+    if plan.mode == LeaderStartMode::ExecProvider {
+        spawn_exec_provider_startup_prompt_handler(plan.provider, workspace.to_path_buf());
+    }
     child.wait().map_err(LeaderError::Io)
 }
 
+fn spawn_exec_provider_startup_prompt_handler(provider: Provider, workspace: PathBuf) {
+    let Some(pane_id) = std::env::var("TMUX_PANE")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+    else {
+        write_leader_startup_prompt_event(
+            &workspace,
+            "leader.startup_prompt_skipped",
+            serde_json::json!({
+                "provider": provider_wire(provider),
+                "reason": "tmux_pane_missing",
+                "action": "skip",
+            }),
+        );
+        return;
+    };
+    std::thread::spawn(move || {
+        let transport = tmux_transport_for_current_pane();
+        let _ = handle_exec_provider_startup_prompts(
+            provider, &workspace, &pane_id, &transport, 30, 0.5,
+        );
+    });
+}
+
+fn tmux_transport_for_current_pane() -> TmuxBackend {
+    crate::tmux_backend::socket_name_from_tmux_env()
+        .map(|endpoint| TmuxBackend::for_tmux_endpoint(&endpoint))
+        .unwrap_or_else(TmuxBackend::new)
+}
+
+pub fn handle_exec_provider_startup_prompts(
+    provider: Provider,
+    workspace: &Path,
+    pane_id: &str,
+    transport: &dyn Transport,
+    checks: usize,
+    sleep_s: f64,
+) -> crate::provider::StartupPromptOutcome {
+    let target = Target::Pane(PaneId::new(pane_id.to_string()));
+    let outcome =
+        get_adapter(provider).handle_startup_prompts_outcome(transport, &target, checks, sleep_s);
+    for handled in &outcome.handled {
+        write_leader_startup_prompt_event(
+            workspace,
+            "leader.startup_prompt_handled",
+            serde_json::json!({
+                "provider": provider_wire(provider),
+                "pane_id": pane_id,
+                "prompt": handled.prompt,
+                "action": handled.action,
+            }),
+        );
+    }
+    if let Some(error) = &outcome.capture_error {
+        write_leader_startup_prompt_event(
+            workspace,
+            "leader.startup_prompt_capture_failed",
+            serde_json::json!({
+                "provider": provider_wire(provider),
+                "pane_id": pane_id,
+                "action": "capture",
+                "error": error,
+            }),
+        );
+    }
+    outcome
+}
+
+fn write_leader_startup_prompt_event(workspace: &Path, event: &str, fields: serde_json::Value) {
+    let _ = crate::event_log::EventLog::new(workspace).write(event, fields);
+}
+
 fn ensure_tmux_installed() -> Result<(), LeaderError> {
     match Command::new("tmux").arg("-V").output() {
         Ok(output) if output.status.success() => Ok(()),
@@ -388,3 +468,198 @@ fn shlex_quote(raw: &str) -> String {
         format!("'{}'", raw.replace('\'', "'\"'\"'"))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+    use std::path::Path;
+    use std::sync::Mutex;
+
+    use crate::model::enums::PaneLiveness;
+    use crate::provider::{Provider, COPILOT_READY_MARKER, COPILOT_TRUST_PROMPT_MARKER};
+    use crate::transport::{
+        AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport,
+        InjectStage, InjectVerification, Key, PaneField, PaneId, PaneInfo, SessionName,
+        SetEnvOutcome, SpawnResult, SubmitVerification, Target, Transport, TransportError,
+        TurnVerification, WindowName,
+    };
+
+    use super::handle_exec_provider_startup_prompts;
+
+    struct ScriptedTransport {
+        screens: Mutex<Vec<String>>,
+        sent: Mutex<Vec<(Target, Vec<Key>)>>,
+    }
+
+    impl ScriptedTransport {
+        fn new(screens: Vec<String>) -> Self {
+            Self {
+                screens: Mutex::new(screens),
+                sent: Mutex::new(Vec::new()),
+            }
+        }
+
+        fn sent(&self) -> Vec<(Target, Vec<Key>)> {
+            match self.sent.lock() {
+                Ok(guard) => guard.clone(),
+                Err(poisoned) => poisoned.into_inner().clone(),
+            }
+        }
+    }
+
+    impl Transport for ScriptedTransport {
+        fn kind(&self) -> BackendKind {
+            BackendKind::Tmux
+        }
+
+        fn spawn_first(
+            &self,
+            _session: &SessionName,
+            _window: &WindowName,
+            _argv: &[String],
+            _cwd: &Path,
+            _env: &BTreeMap<String, String>,
+        ) -> Result<SpawnResult, TransportError> {
+            Err(TransportError::Io(std::io::Error::other(
+                "spawn_first not used by startup-prompt test",
+            )))
+        }
+
+        fn spawn_into(
+            &self,
+            _session: &SessionName,
+            _window: &WindowName,
+            _argv: &[String],
+            _cwd: &Path,
+            _env: &BTreeMap<String, String>,
+        ) -> Result<SpawnResult, TransportError> {
+            Err(TransportError::Io(std::io::Error::other(
+                "spawn_into not used by startup-prompt test",
+            )))
+        }
+
+        fn inject(
+            &self,
+            _target: &Target,
+            _payload: &InjectPayload,
+            _submit: Key,
+            _bracketed: bool,
+        ) -> Result<InjectReport, TransportError> {
+            Ok(InjectReport {
+                stage_reached: InjectStage::Submit,
+                inject_verification: InjectVerification::CaptureContainsToken,
+                submit_verification: SubmitVerification::EnterSentWithoutPlaceholderCheck,
+                turn_verification: TurnVerification::NotRequired,
+                attempts: 1,
+            })
+        }
+
+        fn send_keys(&self, target: &Target, keys: &[Key]) -> Result<(), TransportError> {
+            match self.sent.lock() {
+                Ok(mut guard) => guard.push((target.clone(), keys.to_vec())),
+                Err(poisoned) => poisoned.into_inner().push((target.clone(), keys.to_vec())),
+            }
+            Ok(())
+        }
+
+        fn capture(
+            &self,
+            _target: &Target,
+            range: CaptureRange,
+        ) -> Result<CapturedText, TransportError> {
+            let text = match self.screens.lock() {
+                Ok(mut guard) => {
+                    if guard.is_empty() {
+                        String::new()
+                    } else {
+                        guard.remove(0)
+                    }
+                }
+                Err(poisoned) => {
+                    let mut guard = poisoned.into_inner();
+                    if guard.is_empty() {
+                        String::new()
+                    } else {
+                        guard.remove(0)
+                    }
+                }
+            };
+            Ok(CapturedText { text, range })
+        }
+
+        fn query(
+            &self,
+            _target: &Target,
+            _field: PaneField,
+        ) -> Result<Option<String>, TransportError> {
+            Ok(None)
+        }
+
+        fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
+            Ok(PaneLiveness::Unknown)
+        }
+
+        fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
+            Ok(Vec::new())
+        }
+
+        fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
+            Ok(false)
+        }
+
+        fn list_windows(&self, _session: &SessionName) -> Result<Vec<WindowName>, TransportError> {
+            Ok(Vec::new())
+        }
+
+        fn set_session_env(
+            &self,
+            _session: &SessionName,
+            _key: &str,
+            _value: &str,
+        ) -> Result<SetEnvOutcome, TransportError> {
+            Ok(SetEnvOutcome::Applied)
+        }
+
+        fn kill_session(&self, _session: &SessionName) -> Result<(), TransportError> {
+            Ok(())
+        }
+
+        fn kill_window(&self, _target: &Target) -> Result<(), TransportError> {
+            Ok(())
+        }
+
+        fn attach_session(&self, _session: &SessionName) -> Result<AttachOutcome, TransportError> {
+            Ok(AttachOutcome::Unsupported {
+                reason: "not used by startup-prompt test".to_string(),
+            })
+        }
+    }
+
+    #[test]
+    fn exec_provider_leader_startup_prompt_handler_reuses_copilot_adapter() {
+        let transport = ScriptedTransport::new(vec![
+            COPILOT_TRUST_PROMPT_MARKER.to_string(),
+            COPILOT_READY_MARKER.to_string(),
+        ]);
+        let workspace =
+            std::env::temp_dir().join(format!("ta_rs_red2_leader_startup_{}", std::process::id()));
+        let _ = std::fs::create_dir_all(&workspace);
+
+        let outcome = handle_exec_provider_startup_prompts(
+            Provider::Copilot,
+            &workspace,
+            "%0",
+            &transport,
+            5,
+            0.0,
+        );
+
+        assert_eq!(outcome.handled.len(), 1);
+        assert_eq!(outcome.handled[0].prompt, "copilot_workspace_trust");
+        assert_eq!(outcome.handled[0].action, "sent_enter_yes_session");
+        let sent = transport.sent();
+        assert_eq!(sent.len(), 1);
+        assert_eq!(sent[0].0, Target::Pane(PaneId::new("%0")));
+        assert_eq!(sent[0].1, vec![Key::Enter]);
+    }
+}

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

@@ -1059,23 +1059,13 @@ fn unbound_launched_provider(launched: &serde_json::Value) -> Option<String> {
     {
         return Some(provider);
     }
-    let workspace = launched
-        .get("workspace")
-        .and_then(serde_json::Value::as_str)
-        .filter(|workspace| !workspace.is_empty())?;
     let pane = launched
         .get("team_owner")
         .and_then(|owner| owner.get("pane_id"))
         .and_then(serde_json::Value::as_str)
         .filter(|pane| !pane.is_empty())?;
     let target = PaneId::new(pane);
-    crate::tmux_backend::TmuxBackend::for_workspace(Path::new(workspace))
-        .list_targets()
-        .ok()?
-        .into_iter()
-        .find(|info| info.pane_id == target)
-        .and_then(|info| crate::leader::attribute_pane_provider(&info))
-        .and_then(provider_wire_string)
+    attributed_provider_for_pane_across_tmux_sockets(&target).and_then(provider_wire_string)
 }
 
 fn provider_wire_string(provider: Provider) -> Option<String> {
@@ -1084,9 +1074,38 @@ fn provider_wire_string(provider: Provider) -> Option<String> {
         .and_then(|value| value.as_str().map(str::to_string))
 }
 
+fn attributed_provider_for_pane_across_tmux_sockets(pane: &PaneId) -> Option<Provider> {
+    crate::tmux_backend::tmux_socket_endpoints()
+        .into_iter()
+        .filter_map(|endpoint| {
+            crate::tmux_backend::TmuxBackend::for_tmux_endpoint(&endpoint)
+                .list_targets()
+                .ok()
+        })
+        .flatten()
+        .find(|info| info.pane_id == *pane)
+        .and_then(|info| crate::leader::attribute_pane_provider(&info))
+}
+
+fn caller_provider_for_seed_with_lookup(
+    caller: &crate::state::owner_gate::CallerIdentity,
+    lookup_pane_provider: impl Fn(&PaneId) -> Option<Provider>,
+) -> Option<String> {
+    if !caller.provider.is_empty() {
+        if let Some(provider) = parse_provider(&caller.provider).and_then(provider_wire_string) {
+            return Some(provider);
+        }
+    }
+    (!caller.pane_id.is_empty())
+        .then(|| PaneId::new(&caller.pane_id))
+        .and_then(|pane| lookup_pane_provider(&pane))
+        .and_then(provider_wire_string)
+}
+
 #[cfg(test)]
 mod e22_unbound_owner_provider_tests {
     use super::*;
+    use crate::state::owner_gate::CallerIdentity;
 
     #[test]
     fn unbound_owner_preserves_explicit_copilot_provider() {
@@ -1137,6 +1156,83 @@ mod e22_unbound_owner_provider_tests {
             "unattributed unbound owner must not silently become codex: {launched}"
         );
     }
+
+    fn caller(provider: &str, pane_id: &str) -> CallerIdentity {
+        CallerIdentity {
+            pane_id: pane_id.to_string(),
+            provider: provider.to_string(),
+            machine_fingerprint: "machine".to_string(),
+            leader_session_uuid: "leader-uuid".to_string(),
+            leader_session_uuid_source: "derived".to_string(),
+        }
+    }
+
+    #[test]
+    fn env_seed_attributes_in_tmux_node_form_copilot_from_caller_pane() {
+        let mut state = serde_json::json!({
+            "workspace": "/tmp/team-agent-e22",
+            "leader": {"provider": "copilot"},
+        });
+
+        assert!(seed_launched_owner_from_caller_with_provider_lookup(
+            &mut state,
+            caller("", "%0"),
+            |pane| (pane.as_str() == "%0").then_some(Provider::Copilot),
+        ));
+
+        assert_eq!(
+            state
+                .pointer("/team_owner/provider")
+                .and_then(serde_json::Value::as_str),
+            Some("copilot")
+        );
+        assert_eq!(
+            state
+                .pointer("/leader_receiver/provider")
+                .and_then(serde_json::Value::as_str),
+            Some("copilot")
+        );
+    }
+
+    #[test]
+    fn env_seed_unknown_caller_pane_does_not_default_codex() {
+        let mut state = serde_json::json!({
+            "workspace": "/tmp/team-agent-e22",
+            "leader": {"provider": "copilot"},
+        });
+
+        assert!(seed_launched_owner_from_caller_with_provider_lookup(
+            &mut state,
+            caller("", "%0"),
+            |_| None,
+        ));
+        assert_eq!(
+            state
+                .pointer("/team_owner/pane_id")
+                .and_then(serde_json::Value::as_str),
+            Some("%0")
+        );
+        assert_eq!(
+            state
+                .pointer("/leader_receiver/pane_id")
+                .and_then(serde_json::Value::as_str),
+            Some("%0")
+        );
+        assert!(
+            state
+                .pointer("/leader_receiver/provider")
+                .and_then(serde_json::Value::as_str)
+                != Some("codex"),
+            "unknown caller pane must not silently seed a codex receiver: {state}"
+        );
+        assert!(
+            state
+                .pointer("/team_owner/provider")
+                .and_then(serde_json::Value::as_str)
+                != Some("codex"),
+            "unknown caller pane must not silently become codex: {state}"
+        );
+    }
 }
 
 fn owner_pane_belongs_to_other_team(
@@ -3711,19 +3807,26 @@ fn seed_launched_owner_from_env(state: &mut serde_json::Value) -> bool {
     ) else {
         return false;
     };
-    let provider = if caller.provider.is_empty() {
-        "codex".to_string()
-    } else {
-        caller.provider
-    };
-    let pane_id = caller.pane_id;
-    if pane_id.is_empty() {
+    seed_launched_owner_from_caller_with_provider_lookup(
+        state,
+        caller,
+        attributed_provider_for_pane_across_tmux_sockets,
+    )
+}
+
+fn seed_launched_owner_from_caller_with_provider_lookup(
+    state: &mut serde_json::Value,
+    caller: crate::state::owner_gate::CallerIdentity,
+    lookup_pane_provider: impl Fn(&PaneId) -> Option<Provider>,
+) -> bool {
+    if caller.pane_id.is_empty() {
         return false;
     }
+    let provider = caller_provider_for_seed_with_lookup(&caller, lookup_pane_provider);
+    let pane_id = caller.pane_id;
     let owner_epoch = 1u64;
-    let owner = serde_json::json!({
+    let mut owner = serde_json::json!({
         "pane_id": pane_id,
-        "provider": provider.clone(),
         "machine_fingerprint": caller.machine_fingerprint,
         "leader_session_uuid": caller.leader_session_uuid,
         "owner_epoch": owner_epoch,
@@ -3733,17 +3836,23 @@ fn seed_launched_owner_from_env(state: &mut serde_json::Value) -> bool {
             .or_else(|_| std::env::var("USERNAME"))
             .unwrap_or_default(),
     });
-    let receiver = serde_json::json!({
+    let mut receiver = serde_json::json!({
         "mode": "direct_tmux",
         "status": "attached",
-        "provider": provider,
         "pane_id": owner.get("pane_id").cloned().unwrap_or(serde_json::Value::Null),
         "pane": owner.get("pane_id").cloned().unwrap_or(serde_json::Value::Null),
         "leader_session_uuid": owner.get("leader_session_uuid").cloned().unwrap_or(serde_json::Value::Null),
         "owner_epoch": owner_epoch,
         "discovery": "quick_start",
     });
-    let mut receiver = receiver;
+    if let Some(provider) = provider.as_ref() {
+        if let Some(owner) = owner.as_object_mut() {
+            owner.insert("provider".to_string(), serde_json::json!(provider));
+        }
+        if let Some(receiver) = receiver.as_object_mut() {
+            receiver.insert("provider".to_string(), serde_json::json!(provider));
+        }
+    }
     if let (Some(receiver), Some(socket)) = (
         receiver.as_object_mut(),
         crate::tmux_backend::socket_name_from_tmux_env(),

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

@@ -36,12 +36,11 @@ pub(super) fn spawn_agent_window(
         detected_safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn()?;
         &detected_safety
     };
-    let command_agent =
-        crate::lifecycle::worker_command_context::WorkerCommandAgent::from_json(
-            agent,
-            Some(agent_id.as_str()),
-            provider,
-        );
+    let command_agent = crate::lifecycle::worker_command_context::WorkerCommandAgent::from_json(
+        agent,
+        Some(agent_id.as_str()),
+        provider,
+    );
     let system_prompt =
         crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
     let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(
@@ -60,7 +59,8 @@ pub(super) fn spawn_agent_window(
         .and_then(|v| v.as_str())
         .map(str::to_string)
         .or_else(|| {
-            let key = crate::messaging::leader_receiver::active_team_key(workspace, &state_for_team);
+            let key =
+                crate::messaging::leader_receiver::active_team_key(workspace, &state_for_team);
             (!key.is_empty()).then_some(key)
         });
     let mcp_config = adapter
@@ -72,8 +72,11 @@ pub(super) fn spawn_agent_window(
         agent_id.as_str(),
         team_id.as_deref().unwrap_or(""),
     );
-    let mcp_config_path =
-        crate::lifecycle::launch::write_worker_mcp_config(workspace, agent_id.as_str(), &mcp_config)?;
+    let mcp_config_path = crate::lifecycle::launch::write_worker_mcp_config(
+        workspace,
+        agent_id.as_str(),
+        &mcp_config,
+    )?;
     let profile_launch =
         crate::lifecycle::profile_launch::prepare_provider_profile_launch_from_json(
             workspace,
@@ -81,11 +84,7 @@ pub(super) fn spawn_agent_window(
             agent,
             Some(&mcp_config),
         )?;
-    let command_model = profile_launch
-        .command_overrides
-        .model
-        .as_deref()
-        .or(model);
+    let command_model = profile_launch.command_overrides.model.as_deref().or(model);
     let context = crate::provider::ProviderCommandContext {
         auth_mode,
         mcp_config: Some(&mcp_config),
@@ -252,19 +251,30 @@ pub(super) fn resume_backing_exists_for_agent(
     rollout_path: Option<&RolloutPath>,
 ) -> bool {
     match provider {
+        provider if !provider_supports_resume(provider) => {
+            let _ = (workspace, agent_id, agent, session_id, rollout_path);
+            false
+        }
         Provider::Codex => rollout_path_exists(rollout_path),
         Provider::Claude | Provider::ClaudeCode => {
             rollout_path_exists(rollout_path)
                 || event_log_transcript_exists(workspace, agent_id.as_str(), session_id.as_str())
         }
         Provider::Copilot => copilot_session_store_has_session(session_id.as_str()),
-        Provider::GeminiCli | Provider::Fake => {
-            let _ = agent;
-            true
-        }
+        Provider::GeminiCli | Provider::Fake => false,
     }
 }
 
+pub(super) fn provider_supports_resume(provider: Provider) -> bool {
+    crate::provider::get_adapter(provider).caps().resume
+}
+
+pub(super) fn provider_wire_supports_resume(provider: &str) -> bool {
+    parse_provider(provider)
+        .map(provider_supports_resume)
+        .unwrap_or(false)
+}
+
 fn rollout_path_exists(rollout_path: Option<&RolloutPath>) -> bool {
     rollout_path
         .as_ref()
@@ -308,13 +318,12 @@ fn copilot_session_store_has_session(session_id: &str) -> bool {
     ) else {
         return false;
     };
-    conn
-        .query_row(
-            "select 1 from sessions where id = ?1 limit 1",
-            [session_id],
-            |_| Ok(()),
-        )
-        .is_ok()
+    conn.query_row(
+        "select 1 from sessions where id = ?1 limit 1",
+        [session_id],
+        |_| Ok(()),
+    )
+    .is_ok()
 }
 
 pub(crate) fn refresh_missing_provider_sessions(
@@ -469,7 +478,10 @@ pub(super) fn load_team_spec(workspace: &Path) -> Result<YamlValue, LifecycleErr
     yaml::loads(&text).map_err(|e| LifecycleError::Compile(e.to_string()))
 }
 
-pub(super) fn find_spec_agent<'a>(spec: &'a YamlValue, agent_id: &AgentId) -> Option<&'a YamlValue> {
+pub(super) fn find_spec_agent<'a>(
+    spec: &'a YamlValue,
+    agent_id: &AgentId,
+) -> Option<&'a YamlValue> {
     let leader_is_agent = spec
         .get("leader")
         .and_then(|v| v.get("id"))
@@ -479,23 +491,23 @@ pub(super) fn find_spec_agent<'a>(spec: &'a YamlValue, agent_id: &AgentId) -> Op
     if leader_is_agent {
         return None;
     }
-    spec.get("agents")?
-        .as_list()?
-        .iter()
-        .find(|agent| {
-            agent
-                .get("id")
-                .and_then(YamlValue::as_str)
-                .map(|id| id == agent_id.as_str())
-                .unwrap_or(false)
-        })
+    spec.get("agents")?.as_list()?.iter().find(|agent| {
+        agent
+            .get("id")
+            .and_then(YamlValue::as_str)
+            .map(|id| id == agent_id.as_str())
+            .unwrap_or(false)
+    })
 }
 
 pub(super) fn unknown_worker(agent_id: &AgentId) -> LifecycleError {
     LifecycleError::RequirementUnmet(format!("unknown worker agent id: {agent_id}"))
 }
 
-pub(super) fn state_session_name_from_spec(state: &serde_json::Value, spec: &YamlValue) -> SessionName {
+pub(super) fn state_session_name_from_spec(
+    state: &serde_json::Value,
+    spec: &YamlValue,
+) -> SessionName {
     state
         .get("session_name")
         .and_then(|v| v.as_str())
@@ -709,9 +721,7 @@ pub(super) fn agent_is_running(
     agent_id: &AgentId,
     transport: &dyn crate::transport::Transport,
 ) -> bool {
-    let agent_state = state
-        .get("agents")
-        .and_then(|v| v.get(agent_id.as_str()));
+    let agent_state = state.get("agents").and_then(|v| v.get(agent_id.as_str()));
     let status = agent_state
         .and_then(|v| v.get("status"))
         .and_then(|v| v.as_str())