@team-agent/installer 0.5.42 → 0.5.44

package/crates/team-agent/src/compiler.rs

@@ -70,11 +70,9 @@ pub fn read_front_matter(path: &Path) -> Result<(Value, String), ModelError> {
     let after_meta = rest.get(close..).ok_or_else(|| {
         ModelError::Validation(format!("{}: unterminated front matter", path.display()))
     })?;
-    let after_marker = after_meta
-        .strip_prefix("\n---")
-        .ok_or_else(|| {
-            ModelError::Validation(format!("{}: unterminated front matter", path.display()))
-        })?;
+    let after_marker = after_meta.strip_prefix("\n---").ok_or_else(|| {
+        ModelError::Validation(format!("{}: unterminated front matter", path.display()))
+    })?;
     let meta = if raw_meta.trim().is_empty() {
         Value::Map(Vec::new())
     } else {
@@ -89,7 +87,9 @@ pub fn read_front_matter(path: &Path) -> Result<(Value, String), ModelError> {
     Ok((meta, after_marker.trim_start_matches('\n').to_string()))
 }
 
-pub fn ignored_owner_team_id_from_team_md(team_dir: &Path) -> Result<Option<IgnoredTeamField>, ModelError> {
+pub fn ignored_owner_team_id_from_team_md(
+    team_dir: &Path,
+) -> Result<Option<IgnoredTeamField>, ModelError> {
     let team_md = team_dir.join("TEAM.md");
     if !team_md.exists() {
         return Ok(None);
@@ -138,8 +138,8 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
         for entry in fs::read_dir(&agents_dir)
             .map_err(|e| ModelError::Runtime(format!("{}: {e}", agents_dir.display())))?
         {
-            let entry = entry
-                .map_err(|e| ModelError::Runtime(format!("{}: {e}", agents_dir.display())))?;
+            let entry =
+                entry.map_err(|e| ModelError::Runtime(format!("{}: {e}", agents_dir.display())))?;
             let path = entry.path();
             if path.extension().and_then(|s| s.to_str()) == Some("md") {
                 role_paths.push(path);
@@ -156,7 +156,8 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
 
     let workspace = paths::team_workspace(team_dir)?;
     let workspace_s = workspace.display().to_string();
-    let team_name = string_field(&team_meta, "name").unwrap_or_else(|| team_dir_parent_name(team_dir));
+    let team_name =
+        string_field(&team_meta, "name").unwrap_or_else(|| team_dir_parent_name(team_dir));
     let objective = string_field(&team_meta, "objective")
         .or_else(|| non_empty_trimmed(&team_body))
         .unwrap_or_else(|| "Team Agent document-driven team.".to_string());
@@ -180,7 +181,10 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
         .map(|id| {
             map(vec![
                 ("id", Value::Str(format!("route-{id}"))),
-                ("match", map(vec![("assignee", list_str(vec![id.as_str()]))])),
+                (
+                    "match",
+                    map(vec![("assignee", list_str(vec![id.as_str()]))]),
+                ),
                 ("assign_to", Value::Str(id.clone())),
                 ("priority", Value::Int(10)),
             ])
@@ -250,9 +254,15 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
             map(vec![
                 ("protocol", Value::Str("mcp_inbox".to_string())),
                 ("topology", Value::Str("leader_centered".to_string())),
-                ("worker_to_worker", bool_field(&team_meta, "worker_to_worker", true)),
+                (
+                    "worker_to_worker",
+                    bool_field(&team_meta, "worker_to_worker", true),
+                ),
                 ("ack_timeout_sec", Value::Int(60)),
-                ("result_format", Value::Str("result_envelope_v1".to_string())),
+                (
+                    "result_format",
+                    Value::Str("result_envelope_v1".to_string()),
+                ),
                 (
                     "message_store",
                     map(vec![
@@ -273,19 +283,34 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
                             .unwrap_or_else(|| "adaptive".to_string()),
                     ),
                 ),
-                ("session_name", Value::Str(session_name(&team_meta, &team_name))),
+                (
+                    "session_name",
+                    Value::Str(session_name(&team_meta, &team_name)),
+                ),
                 ("auto_launch", Value::Bool(true)),
                 ("require_user_approval_before_launch", Value::Bool(true)),
-                ("max_active_agents", Value::Int(max_active_agents(agent_ids.len()))),
+                (
+                    "max_active_agents",
+                    Value::Int(max_active_agents(agent_ids.len())),
+                ),
                 ("startup_order", list_str(agent_ids)),
                 (
                     "dangerous_auto_approve",
                     bool_field(&team_meta, "dangerous_auto_approve", false),
                 ),
                 ("fast", bool_field(&team_meta, "fast", false)),
-                ("tick_interval_sec", int_field(&team_meta, "tick_interval_sec", 2)),
-                ("push_min_interval_sec", int_field(&team_meta, "push_min_interval_sec", 60)),
-                ("stuck_timeout_sec", int_field(&team_meta, "stuck_timeout_sec", 300)),
+                (
+                    "tick_interval_sec",
+                    int_field(&team_meta, "tick_interval_sec", 2),
+                ),
+                (
+                    "push_min_interval_sec",
+                    int_field(&team_meta, "push_min_interval_sec", 60),
+                ),
+                (
+                    "stuck_timeout_sec",
+                    int_field(&team_meta, "stuck_timeout_sec", 300),
+                ),
             ]),
         ),
         (
@@ -310,11 +335,17 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
             "tasks",
             Value::List(vec![map(vec![
                 ("id", Value::Str("task_initial".to_string())),
-                ("title", Value::Str("Initial document-driven team task".to_string())),
+                (
+                    "title",
+                    Value::Str("Initial document-driven team task".to_string()),
+                ),
                 ("type", Value::Str("implementation".to_string())),
                 ("assignee", Value::Str(default_assignee)),
                 ("deps", Value::List(Vec::new())),
-                ("acceptance", list_str(vec!["Worker reports valid result_envelope_v1"])),
+                (
+                    "acceptance",
+                    list_str(vec!["Worker reports valid result_envelope_v1"]),
+                ),
                 ("status", Value::Str("pending".to_string())),
                 ("requires_tools", list_str(vec!["mcp_team"])),
                 ("files", Value::List(Vec::new())),
@@ -451,7 +482,9 @@ where
 }
 
 fn string_field(meta: &Value, key: &str) -> Option<String> {
-    meta.get(key).and_then(Value::as_str).map(ToString::to_string)
+    meta.get(key)
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
 }
 
 fn required_string(meta: &Value, path: &Path, key: &str) -> Result<String, ModelError> {
@@ -524,8 +557,8 @@ fn resolve_model(role_meta: &Value, team_meta: &Value, provider: &str) -> Value
     if let Some(model) = string_field(role_meta, "model") {
         return Value::Str(model);
     }
-    if let Some(model) = provider_model(team_meta, provider)
-        .or_else(|| string_field(team_meta, "default_model"))
+    if let Some(model) =
+        provider_model(team_meta, provider).or_else(|| string_field(team_meta, "default_model"))
     {
         return Value::Str(model);
     }

package/crates/team-agent/src/conpty/backend.rs

@@ -53,9 +53,9 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use crate::model::enums::PaneLiveness;
 use crate::transport::{
     AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport,
-    InjectStage, InjectVerification, Key, PaneField, PaneId, PaneInfo, SessionName,
-    SetEnvOutcome, SpawnResult, SubmitVerification, Target, Transport, TransportError,
-    TurnVerification, WindowName,
+    InjectStage, InjectVerification, Key, PaneField, PaneId, PaneInfo, SessionName, SetEnvOutcome,
+    SpawnResult, SubmitVerification, Target, Transport, TransportError, TurnVerification,
+    WindowName,
 };
 
 use conpty_transport::{
@@ -164,8 +164,8 @@ impl ConPtyBackend {
                 detail: format!("hello failed: {:?}", resp.error),
             });
         }
-        let hello: HelloResult = serde_json::from_value(resp.result)
-            .map_err(|e| TransportError::MuxUnavailable {
+        let hello: HelloResult =
+            serde_json::from_value(resp.result).map_err(|e| TransportError::MuxUnavailable {
                 backend: BackendKind::ConPty,
                 detail: format!("hello response malformed: {e}"),
             })?;
@@ -303,12 +303,11 @@ impl ConPtyBackend {
             source: std::io::Error::other(e),
         })?;
         let resp = self.dispatch(Op::Spawn, payload)?;
-        let spawn: ProtoSpawnResult = serde_json::from_value(resp.result).map_err(|e| {
-            TransportError::Spawn {
+        let spawn: ProtoSpawnResult =
+            serde_json::from_value(resp.result).map_err(|e| TransportError::Spawn {
                 backend: BackendKind::ConPty,
                 source: std::io::Error::other(e),
-            }
-        })?;
+            })?;
         Ok(SpawnResult {
             pane_id: PaneId::new(spawn.pane_id),
             session: SessionName::new(spawn.session),
@@ -368,13 +367,17 @@ fn map_protocol_error(err: Option<&ProtocolError>) -> TransportError {
             backend: BackendKind::ConPty,
             detail: format!("pipe_token_mismatch: {message}"),
         },
-        ProtocolError::SchemaSkew { message, sent, expected } => TransportError::MuxUnavailable {
+        ProtocolError::SchemaSkew {
+            message,
+            sent,
+            expected,
+        } => TransportError::MuxUnavailable {
             backend: BackendKind::ConPty,
             detail: format!("schema_skew sent={sent} expected={expected}: {message}"),
         },
-        ProtocolError::TargetNotFound { message } => {
-            TransportError::TargetNotFound { target: message.clone() }
-        }
+        ProtocolError::TargetNotFound { message } => TransportError::TargetNotFound {
+            target: message.clone(),
+        },
         ProtocolError::Spawn { message } => TransportError::Spawn {
             backend: BackendKind::ConPty,
             source: std::io::Error::other(message.clone()),
@@ -556,11 +559,10 @@ impl Transport for ConPtyBackend {
             source: std::io::Error::other(e),
         })?;
         let resp = self.dispatch(Op::Capture, payload)?;
-        let cap: protocol::CaptureResult = serde_json::from_value(resp.result).map_err(|e| {
-            TransportError::Capture {
+        let cap: protocol::CaptureResult =
+            serde_json::from_value(resp.result).map_err(|e| TransportError::Capture {
                 source: std::io::Error::other(e),
-            }
-        })?;
+            })?;
         Ok(CapturedText {
             text: cap.text,
             range,
@@ -572,10 +574,7 @@ impl Transport for ConPtyBackend {
     }
 
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
-        let resp = self.dispatch(
-            Op::Liveness,
-            serde_json::json!({"pane_id": pane.as_str()}),
-        )?;
+        let resp = self.dispatch(Op::Liveness, serde_json::json!({"pane_id": pane.as_str()}))?;
         let known = resp.result["known"].as_bool().unwrap_or(false);
         let alive = resp.result["alive"].as_bool().unwrap_or(false);
         Ok(match (known, alive) {
@@ -645,10 +644,7 @@ impl Transport for ConPtyBackend {
     }
 
     fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
-        let resp = self.dispatch(
-            Op::HasPane,
-            serde_json::json!({"pane_id": pane.as_str()}),
-        )?;
+        let resp = self.dispatch(Op::HasPane, serde_json::json!({"pane_id": pane.as_str()}))?;
         Ok(Some(resp.result["present"].as_bool().unwrap_or(false)))
     }
 
@@ -673,10 +669,7 @@ impl Transport for ConPtyBackend {
     fn kill_window(&self, target: &Target) -> Result<(), TransportError> {
         match target {
             Target::Pane(pane) => {
-                self.dispatch(
-                    Op::KillPane,
-                    serde_json::json!({"pane_id": pane.as_str()}),
-                )?;
+                self.dispatch(Op::KillPane, serde_json::json!({"pane_id": pane.as_str()}))?;
             }
             Target::SessionWindow { session, window } => {
                 self.dispatch(
@@ -692,10 +685,7 @@ impl Transport for ConPtyBackend {
     }
 
     fn kill_pane(&self, pane: &PaneId) -> Result<(), TransportError> {
-        self.dispatch(
-            Op::KillPane,
-            serde_json::json!({"pane_id": pane.as_str()}),
-        )?;
+        self.dispatch(Op::KillPane, serde_json::json!({"pane_id": pane.as_str()}))?;
         Ok(())
     }
 

package/crates/team-agent/src/coordinator/backoff.rs

@@ -350,11 +350,7 @@ fn run_daemon_body_with_panic_marker(
         );
         match run_tick_with_panic_marker(&event_log, || coordinator.tick()) {
             Ok(report) => {
-                let status = if report.stop {
-                    "stop_requested"
-                } else {
-                    "ok"
-                };
+                let status = if report.stop { "stop_requested" } else { "ok" };
                 let _ = write_coordinator_heartbeat(
                     &args.workspace,
                     pid,
@@ -584,8 +580,7 @@ pub enum DaemonError {
 static SIGNAL_STOP_REQUESTED: std::sync::atomic::AtomicBool =
     std::sync::atomic::AtomicBool::new(false);
 #[cfg(unix)]
-static SIGNAL_STOP_NUMBER: std::sync::atomic::AtomicI32 =
-    std::sync::atomic::AtomicI32::new(0);
+static SIGNAL_STOP_NUMBER: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);
 
 #[cfg(unix)]
 extern "C" fn coordinator_signal_handler(signal: libc::c_int) {

package/crates/team-agent/src/coordinator/conpty_shim.rs

@@ -120,26 +120,31 @@ impl Drop for ShimHandle {
 
 #[derive(Debug, thiserror::Error)]
 pub enum ShimError {
-    #[error("windows-shim binary not found: expected `{expected}` alongside team-agent.exe; \
-             action: reinstall team-agent so the shim exe sits next to the main binary")]
+    #[error(
+        "windows-shim binary not found: expected `{expected}` alongside team-agent.exe; \
+             action: reinstall team-agent so the shim exe sits next to the main binary"
+    )]
     BinaryMissing { expected: String },
-    #[error("windows-shim spawn failed: {source} (pipe_name={pipe_name}); \
-             action: check windows-shim.exe permissions and PATH")]
+    #[error(
+        "windows-shim spawn failed: {source} (pipe_name={pipe_name}); \
+             action: check windows-shim.exe permissions and PATH"
+    )]
     Spawn {
         pipe_name: String,
         #[source]
         source: std::io::Error,
     },
-    #[error("windows-shim connect timed out after {attempts} attempts (pipe_name={pipe_name}); \
+    #[error(
+        "windows-shim connect timed out after {attempts} attempts (pipe_name={pipe_name}); \
              action: check shim.err.log for CreateNamedPipeW / ACL errors, \
-             then re-run team-agent quick-start")]
-    ConnectTimeout {
-        attempts: u32,
-        pipe_name: String,
-    },
-    #[error("windows-shim hello handshake failed: {reason} (pipe_name={pipe_name}); \
+             then re-run team-agent quick-start"
+    )]
+    ConnectTimeout { attempts: u32, pipe_name: String },
+    #[error(
+        "windows-shim hello handshake failed: {reason} (pipe_name={pipe_name}); \
              action: ensure team-agent.exe and windows-shim.exe are the same build \
-             (`sha256sum team-agent.exe windows-shim.exe` matches CI tracking)")]
+             (`sha256sum team-agent.exe windows-shim.exe` matches CI tracking)"
+    )]
     HelloFailed { pipe_name: String, reason: String },
     #[error("state persistence failed after shim spawn: {source}")]
     StatePersist {
@@ -191,7 +196,11 @@ fn fresh_pipe_token() -> String {
         .duration_since(std::time::UNIX_EPOCH)
         .map(|d| d.as_nanos())
         .unwrap_or(0);
-    format!("{:08x}{:024x}", pid, nanos & 0xffff_ffff_ffff_ffff_ffff_ffff)
+    format!(
+        "{:08x}{:024x}",
+        pid,
+        nanos & 0xffff_ffff_ffff_ffff_ffff_ffff
+    )
 }
 
 /// Coordinator hook: spawn `windows-shim.exe` for the given
@@ -305,10 +314,7 @@ pub fn spawn_shim_and_handshake(
                         let mut child = child;
                         let _ = child.kill();
                         let _ = child.wait();
-                        return Err(ShimError::HelloFailed {
-                            pipe_name,
-                            reason,
-                        });
+                        return Err(ShimError::HelloFailed { pipe_name, reason });
                     }
                 }
             }
@@ -401,12 +407,14 @@ fn finalize(
         json!({})
     };
     // CR C-1: token NOT stored. Only pid/pipe_name/pipe_ready.
-    let obj = state.as_object_mut().ok_or_else(|| ShimError::StatePersist {
-        source: StateError::Io(std::io::Error::new(
-            std::io::ErrorKind::InvalidData,
-            "state.json root not an object",
-        )),
-    })?;
+    let obj = state
+        .as_object_mut()
+        .ok_or_else(|| ShimError::StatePersist {
+            source: StateError::Io(std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "state.json root not an object",
+            )),
+        })?;
     let transport = obj
         .entry("transport".to_string())
         .or_insert_with(|| json!({}));
@@ -540,12 +548,11 @@ pub fn reconnect_recorded_shim(
     team_key: &str,
     _workspace_hash: &str,
 ) -> Result<ShimHandle, ShimError> {
-    let pipe_name = recorded_shim_pipe_name(workspace).ok_or_else(|| {
-        ShimError::ConnectTimeout {
+    let pipe_name =
+        recorded_shim_pipe_name(workspace).ok_or_else(|| ShimError::ConnectTimeout {
             attempts: 0,
             pipe_name: "<state.transport.shim.pipe_name missing>".to_string(),
-        }
-    })?;
+        })?;
     // For reconnect we don't have the original pipe_token (CR C-1:
     // token was never persisted). Hello is designed to accept any
     // token from the client and echo back the shim's own token, so
@@ -561,24 +568,19 @@ pub fn reconnect_recorded_shim(
     let mut last_err: Option<ShimError> = None;
     for attempt in 1..=CONNECT_ATTEMPTS {
         match NamedPipeClient::connect(&pipe_name, 500) {
-            Ok(mut client) => {
-                match reconnect_hello(&mut client, team_key) {
-                    Ok(()) => {
-                        return Ok(ShimHandle {
-                            child: None,
-                            pid: recorded_shim_pid(workspace).unwrap_or(0),
-                            pipe_name,
-                            client: Some(client),
-                        });
-                    }
-                    Err(reason) => {
-                        return Err(ShimError::HelloFailed {
-                            pipe_name,
-                            reason,
-                        });
-                    }
+            Ok(mut client) => match reconnect_hello(&mut client, team_key) {
+                Ok(()) => {
+                    return Ok(ShimHandle {
+                        child: None,
+                        pid: recorded_shim_pid(workspace).unwrap_or(0),
+                        pipe_name,
+                        client: Some(client),
+                    });
                 }
-            }
+                Err(reason) => {
+                    return Err(ShimError::HelloFailed { pipe_name, reason });
+                }
+            },
             Err(err) => {
                 let _ = attempt;
                 let _ = placeholder_token;
@@ -599,10 +601,7 @@ pub fn reconnect_recorded_shim(
 /// Reconnect Hello: the client sends Hello with the current workspace/
 /// team scope; the shim replies with its OWN pipe_token (which the
 /// client doesn't know yet). We just validate `resp.ok`.
-fn reconnect_hello(
-    client: &mut NamedPipeClient,
-    team_key: &str,
-) -> Result<(), String> {
+fn reconnect_hello(client: &mut NamedPipeClient, team_key: &str) -> Result<(), String> {
     use conpty_transport::{Op, PipeClient, Request};
     let req = Request::new(
         "coord-reconnect-hello",
@@ -633,15 +632,10 @@ fn reconnect_hello(
 /// The Windows-only `#[cfg]` gate is at the mod level (see
 /// `coordinator/mod.rs`); on Unix this file isn't compiled, so
 /// downstream callers must cfg-gate their reference themselves.
-pub fn mark_transport_unavailable(
-    workspace: &Path,
-    reason: &str,
-) -> Result<(), StateError> {
+pub fn mark_transport_unavailable(workspace: &Path, reason: &str) -> Result<(), StateError> {
     // Best-effort event emission — a failed event write should not
     // fail the caller. The state-clearing step below is authoritative.
-    if let Ok(event_log) = std::panic::catch_unwind(|| {
-        crate::event_log::EventLog::new(workspace)
-    }) {
+    if let Ok(event_log) = std::panic::catch_unwind(|| crate::event_log::EventLog::new(workspace)) {
         let _ = event_log.write(
             "transport.conpty_shim_unavailable",
             serde_json::json!({
@@ -659,16 +653,10 @@ pub fn mark_transport_unavailable(
     }
     let text = std::fs::read_to_string(&state_path).map_err(StateError::from)?;
     let mut state: Value = serde_json::from_str(&text).unwrap_or_else(|_| serde_json::json!({}));
-    if let Some(transport) = state
-        .get_mut("transport")
-        .and_then(|t| t.as_object_mut())
-    {
+    if let Some(transport) = state.get_mut("transport").and_then(|t| t.as_object_mut()) {
         if let Some(shim) = transport.get_mut("shim").and_then(|s| s.as_object_mut()) {
             shim.insert("pipe_ready".to_string(), serde_json::json!(false));
-            shim.insert(
-                "unavailable_reason".to_string(),
-                serde_json::json!(reason),
-            );
+            shim.insert("unavailable_reason".to_string(), serde_json::json!(reason));
         }
     }
     save_runtime_state(workspace, &state)
@@ -687,9 +675,7 @@ mod tests {
         let src = include_str!("conpty_shim.rs");
         // Locate the `finalize` fn body and grep for pipe_token
         // insertion.
-        let (_, finalize_and_after) = src
-            .split_once("fn finalize(")
-            .expect("finalize fn present");
+        let (_, finalize_and_after) = src.split_once("fn finalize(").expect("finalize fn present");
         let finalize_body = finalize_and_after
             .split_once("\n}")
             .map(|(body, _)| body)
@@ -711,7 +697,9 @@ mod tests {
         // {pid, pipe_name, pipe_ready}. If a future edit adds a 4th
         // key that carries a secret, this test fires.
         let src = include_str!("conpty_shim.rs");
-        let (_, after) = src.split_once("\"shim\".to_string(),").expect("shim insert");
+        let (_, after) = src
+            .split_once("\"shim\".to_string(),")
+            .expect("shim insert");
         let block_end = after.find("}),").unwrap_or(after.len());
         let block = &after[..block_end];
         for expected in ["pid", "pipe_name", "pipe_ready"] {

package/crates/team-agent/src/coordinator/health.rs

@@ -178,13 +178,12 @@ pub fn start_coordinator_with_team(
             action: None,
         });
     }
-    let rotation_reason = if matches!(health.status, CoordinatorHealthStatus::Running)
-        && !health.metadata_ok
-    {
-        health.metadata_mismatch_reason.clone()
-    } else {
-        None
-    };
+    let rotation_reason =
+        if matches!(health.status, CoordinatorHealthStatus::Running) && !health.metadata_ok {
+            health.metadata_mismatch_reason.clone()
+        } else {
+            None
+        };
     if matches!(health.status, CoordinatorHealthStatus::Running) && !health.metadata_ok {
         crate::event_log::EventLog::new(workspace.as_path()).write(
             "coordinator.rotation_required",
@@ -215,7 +214,10 @@ pub fn start_coordinator_with_team(
                 binary_identity_relation: health.binary_identity_relation,
                 log: None,
                 schema_error: None,
-                action: Some("refusing to rotate coordinator metadata that points at the caller process".to_string()),
+                action: Some(
+                    "refusing to rotate coordinator metadata that points at the caller process"
+                        .to_string(),
+                ),
             });
         }
         match stop_coordinator(workspace) {
@@ -413,8 +415,7 @@ fn discover_coordinator_pids(workspace: &WorkspacePath) -> Vec<Pid> {
         Command::new("ps").args(["-axo", "pid=,command="]),
         "ps_table",
         None,
-    )
-    {
+    ) {
         Ok(output) if output.status.success() => output,
         _ => return Vec::new(),
     };
@@ -432,9 +433,7 @@ fn discover_coordinator_pids(workspace: &WorkspacePath) -> Vec<Pid> {
 
 fn parse_ps_command_line(line: &str) -> Option<(u32, &str)> {
     let line = line.trim_start();
-    let split = line
-        .find(char::is_whitespace)
-        .unwrap_or(line.len());
+    let split = line.find(char::is_whitespace).unwrap_or(line.len());
     let pid = line.get(..split)?.trim().parse::<u32>().ok()?;
     let command = line.get(split..)?.trim();
     Some((pid, command))
@@ -455,9 +454,13 @@ fn coordinator_command_matches_workspace(command: &str, workspaces: &[String]) -
     command
         .split_whitespace()
         .any(|token| token == "team-agent" || token.ends_with("/team-agent"))
-        && command.split_whitespace().any(|token| token == "coordinator")
+        && command
+            .split_whitespace()
+            .any(|token| token == "coordinator")
         && command.contains("--workspace")
-        && workspaces.iter().any(|workspace| command.contains(workspace))
+        && workspaces
+            .iter()
+            .any(|workspace| command.contains(workspace))
 }
 
 fn terminate_pid(pid: Pid) -> bool {
@@ -505,17 +508,17 @@ fn process_tree_pids(root: Pid) -> Vec<Pid> {
         "ps_parent",
         None,
     )
-        .ok()
-        .map(|out| String::from_utf8_lossy(&out.stdout).to_string())
-        .unwrap_or_default()
-        .lines()
-        .filter_map(|line| {
-            let mut parts = line.split_whitespace();
-            let pid = parts.next()?.parse::<u32>().ok()?;
-            let ppid = parts.next()?.parse::<u32>().ok()?;
-            Some((pid, ppid))
-        })
-        .collect::<Vec<_>>();
+    .ok()
+    .map(|out| String::from_utf8_lossy(&out.stdout).to_string())
+    .unwrap_or_default()
+    .lines()
+    .filter_map(|line| {
+        let mut parts = line.split_whitespace();
+        let pid = parts.next()?.parse::<u32>().ok()?;
+        let ppid = parts.next()?.parse::<u32>().ok()?;
+        Some((pid, ppid))
+    })
+    .collect::<Vec<_>>();
     let mut out = Vec::new();
     collect_child_pids(root_pid, &pairs, &mut out);
     out.push(root_pid);
@@ -718,11 +721,17 @@ fn coordinator_binary_identity_mismatch_reason(
     let Some(metadata) = metadata else {
         return Some(CoordinatorMetadataMismatchReason::MetadataMissing);
     };
-    let Some(binary_version) = metadata.binary_version.as_deref().filter(|value| !value.is_empty())
+    let Some(binary_version) = metadata
+        .binary_version
+        .as_deref()
+        .filter(|value| !value.is_empty())
     else {
         return Some(CoordinatorMetadataMismatchReason::BinaryIdentityMissing);
     };
-    let Some(binary_path) = metadata.binary_path.as_deref().filter(|value| !value.is_empty())
+    let Some(binary_path) = metadata
+        .binary_path
+        .as_deref()
+        .filter(|value| !value.is_empty())
     else {
         return Some(CoordinatorMetadataMismatchReason::BinaryIdentityMissing);
     };
@@ -928,7 +937,9 @@ fn collect_event_lines(
     let archive_signature = file_signature(&archive_path)?;
     let mut lines = Vec::new();
 
-    let size = std::fs::metadata(&events_path).map(|m| m.len()).unwrap_or(0);
+    let size = std::fs::metadata(&events_path)
+        .map(|m| m.len())
+        .unwrap_or(0);
     let rotated = cursor.initialized
         && (cursor.archive_signature != archive_signature || cursor.event_offset > size);
     if rotated {
@@ -1004,7 +1015,10 @@ fn collect_result_lines(
         let mut summary = crate::message_store::result_summary_from_row(&row)
             .unwrap_or_else(|| serde_json::json!({}));
         if let Some(obj) = summary.as_object_mut() {
-            obj.insert("event".to_string(), Value::String("result_received".to_string()));
+            obj.insert(
+                "event".to_string(),
+                Value::String("result_received".to_string()),
+            );
         }
         if let Some(rendered) = render_event_line(&summary) {
             lines.push(rendered);
@@ -1100,7 +1114,8 @@ fn file_signature(path: &Path) -> Result<Option<(u64, i128)>, WatchError> {
 }
 
 fn first_field<'a>(event: &'a Value, keys: &[&str]) -> Option<&'a str> {
-    keys.iter().find_map(|key| event.get(*key).and_then(Value::as_str))
+    keys.iter()
+        .find_map(|key| event.get(*key).and_then(Value::as_str))
 }
 
 fn clean_field(event: &Value, keys: &[&str], default: &str) -> String {