@team-agent/installer 0.5.41 → 0.5.43

package/crates/team-agent/src/coordinator/tests/main_preserved.rs

@@ -1,5 +1,5 @@
-use super::*;
 use super::spine::{message_status, DeliveringTransport};
+use super::*;
 
 // ═════════════════════════════════════════════════════════════════════════
 // P0 REGRESSION (root cause pinned) — a per-agent capture/health-check FAILURE must not abort the
@@ -31,20 +31,42 @@ struct CaptureFailsDeliverTransport {
 }
 impl CaptureFailsDeliverTransport {
     fn new() -> Self {
-        Self { inner: DeliveringTransport::new() }
+        Self {
+            inner: DeliveringTransport::new(),
+        }
     }
 }
 impl Transport for CaptureFailsDeliverTransport {
     fn kind(&self) -> BackendKind {
         self.inner.kind()
     }
-    fn spawn_first(&self, s: &SessionName, w: &WindowName, a: &[String], c: &std::path::Path, e: &std::collections::BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+    fn spawn_first(
+        &self,
+        s: &SessionName,
+        w: &WindowName,
+        a: &[String],
+        c: &std::path::Path,
+        e: &std::collections::BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
         self.inner.spawn_first(s, w, a, c, e)
     }
-    fn spawn_into(&self, s: &SessionName, w: &WindowName, a: &[String], c: &std::path::Path, e: &std::collections::BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+    fn spawn_into(
+        &self,
+        s: &SessionName,
+        w: &WindowName,
+        a: &[String],
+        c: &std::path::Path,
+        e: &std::collections::BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
         self.inner.spawn_into(s, w, a, c, e)
     }
-    fn inject(&self, t: &Target, p: &InjectPayload, submit: Key, bracketed: bool) -> Result<InjectReport, TransportError> {
+    fn inject(
+        &self,
+        t: &Target,
+        p: &InjectPayload,
+        submit: Key,
+        bracketed: bool,
+    ) -> Result<InjectReport, TransportError> {
         self.inner.inject(t, p, submit, bracketed)
     }
     fn send_keys(&self, t: &Target, k: &[Key]) -> Result<(), TransportError> {
@@ -52,7 +74,9 @@ impl Transport for CaptureFailsDeliverTransport {
     }
     fn capture(&self, _t: &Target, _r: CaptureRange) -> Result<CapturedText, TransportError> {
         // the agent's window is gone — capture fails (tmux can't find the target).
-        Err(TransportError::TargetNotFound { target: "window gone (stopped agent)".to_string() })
+        Err(TransportError::TargetNotFound {
+            target: "window gone (stopped agent)".to_string(),
+        })
     }
     fn query(&self, t: &Target, f: PaneField) -> Result<Option<String>, TransportError> {
         self.inner.query(t, f)
@@ -69,7 +93,12 @@ impl Transport for CaptureFailsDeliverTransport {
     fn list_windows(&self, s: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         self.inner.list_windows(s)
     }
-    fn set_session_env(&self, s: &SessionName, k: &str, v: &str) -> Result<SetEnvOutcome, TransportError> {
+    fn set_session_env(
+        &self,
+        s: &SessionName,
+        k: &str,
+        v: &str,
+    ) -> Result<SetEnvOutcome, TransportError> {
         self.inner.set_session_env(s, k, v)
     }
     fn kill_session(&self, s: &SessionName) -> Result<(), TransportError> {
@@ -87,7 +116,10 @@ fn tick_swallows_capture_failure_and_still_delivers_to_other_agent() {
     let dir = std::env::temp_dir().join(format!(
         "team-agent-coord-stopreg-{}-{}",
         std::process::id(),
-        std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
     ));
     std::fs::create_dir_all(&dir).unwrap();
     // w1 STOPPED (window gone -> capture fails), w2 ACTIVE — w2 keeps the tmux session alive.
@@ -104,14 +136,32 @@ fn tick_swallows_capture_failure_and_still_delivers_to_other_agent() {
     .unwrap();
     let store = MessageStore::open(&dir).unwrap();
     let mid = store
-        .create_message(Some("task-1"), "leader", "w2", "after stop", None, true, None)
+        .create_message(
+            Some("task-1"),
+            "leader",
+            "w2",
+            "after stop",
+            None,
+            true,
+            None,
+        )
         .unwrap();
     drop(store);
-    assert_eq!(message_status(&dir, &mid), "accepted", "precondition: a fresh message is 'accepted'");
+    assert_eq!(
+        message_status(&dir, &mid),
+        "accepted",
+        "precondition: a fresh message is 'accepted'"
+    );
     let ws = WorkspacePath::new(dir.clone());
     let reg: Box<dyn ProviderRegistry> = Box::new(MockRegistry::new(&[], &[]));
     // capture() ERRORS (window gone) but inject delivers + session present.
-    let coord = Coordinator::for_test(ws, reg, Box::new(CaptureFailsDeliverTransport::new()), None, None);
+    let coord = Coordinator::for_test(
+        ws,
+        reg,
+        Box::new(CaptureFailsDeliverTransport::new()),
+        None,
+        None,
+    );
     let result = coord.tick();
     // (a) a per-agent capture failure must NOT abort the whole tick.
     assert!(

package/crates/team-agent/src/coordinator/tests/mod.rs

@@ -68,10 +68,16 @@ struct MapMarkerStore {
 }
 impl MapMarkerStore {
     fn ok() -> Self {
-        Self { markers: Default::default(), fail: false }
+        Self {
+            markers: Default::default(),
+            fail: false,
+        }
     }
     fn failing() -> Self {
-        Self { markers: Default::default(), fail: true }
+        Self {
+            markers: Default::default(),
+            fail: true,
+        }
     }
 }
 impl MarkerStore for MapMarkerStore {
@@ -159,19 +165,11 @@ impl Transport for MockTransport {
         self.record("send_keys");
         self.inner.send_keys(t, keys)
     }
-    fn capture(
-        &self,
-        t: &Target,
-        range: CaptureRange,
-    ) -> Result<CapturedText, TransportError> {
+    fn capture(&self, t: &Target, range: CaptureRange) -> Result<CapturedText, TransportError> {
         self.record("capture");
         self.inner.capture(t, range)
     }
-    fn query(
-        &self,
-        t: &Target,
-        f: PaneField,
-    ) -> Result<Option<String>, TransportError> {
+    fn query(&self, t: &Target, f: PaneField) -> Result<Option<String>, TransportError> {
         self.record("query");
         self.inner.query(t, f)
     }
@@ -187,10 +185,7 @@ impl Transport for MockTransport {
         self.record("has_session");
         self.inner.has_session(s)
     }
-    fn list_windows(
-        &self,
-        s: &SessionName,
-    ) -> Result<Vec<WindowName>, TransportError> {
+    fn list_windows(&self, s: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         self.record("list_windows");
         self.inner.list_windows(s)
     }
@@ -211,10 +206,7 @@ impl Transport for MockTransport {
         self.record("kill_window");
         self.inner.kill_window(t)
     }
-    fn attach_session(
-        &self,
-        s: &SessionName,
-    ) -> Result<AttachOutcome, TransportError> {
+    fn attach_session(&self, s: &SessionName) -> Result<AttachOutcome, TransportError> {
         self.record("attach_session");
         self.inner.attach_session(s)
     }
@@ -229,7 +221,10 @@ fn coord_for_test(
     session_present: bool,
     save_hook: Option<SaveHook>,
     recorder: Option<OrderRecorder>,
-) -> (Coordinator, std::sync::Arc<std::sync::Mutex<Vec<&'static str>>>) {
+) -> (
+    Coordinator,
+    std::sync::Arc<std::sync::Mutex<Vec<&'static str>>>,
+) {
     let dir = std::env::temp_dir().join(format!(
         "team-agent-coord-tick-{}-{}",
         std::process::id(),
@@ -243,13 +238,7 @@ fn coord_for_test(
     let reg: Box<dyn ProviderRegistry> = Box::new(MockRegistry::new(&[], &[]));
     let transport = MockTransport::new(session_present);
     let calls = std::sync::Arc::clone(&transport.calls);
-    let coord = Coordinator::for_test(
-        ws,
-        reg,
-        Box::new(transport),
-        save_hook,
-        recorder,
-    );
+    let coord = Coordinator::for_test(ws, reg, Box::new(transport), save_hook, recorder);
     (coord, calls)
 }
 
@@ -261,7 +250,10 @@ fn coord_for_test(
 fn coord_for_test_with_session(
     session_present: bool,
     session_name: &str,
-) -> (Coordinator, std::sync::Arc<std::sync::Mutex<Vec<&'static str>>>) {
+) -> (
+    Coordinator,
+    std::sync::Arc<std::sync::Mutex<Vec<&'static str>>>,
+) {
     let dir = std::env::temp_dir().join(format!(
         "team-agent-coord-tick-sess-{}-{}",
         std::process::id(),
@@ -296,21 +288,23 @@ fn failing_save_hook() -> SaveHook {
 fn read_event_log_dir(dir: &std::path::Path) -> Vec<serde_json::Value> {
     let path = crate::model::paths::logs_dir(dir).join("events.jsonl");
     match std::fs::read_to_string(&path) {
-        Ok(text) => text.lines().filter_map(|l| serde_json::from_str(l).ok()).collect(),
+        Ok(text) => text
+            .lines()
+            .filter_map(|l| serde_json::from_str(l).ok())
+            .collect(),
         Err(_) => Vec::new(),
     }
 }
 
-
-mod basics;
+mod a0_lostupdate;
 mod abnormal;
-mod watch;
-mod tick_core;
-mod spine;
-mod health_sync;
-mod takeover;
+mod api_error_recovery;
+mod basics;
 mod daemon;
 mod energy;
+mod health_sync;
 mod main_preserved;
-mod a0_lostupdate;
-mod api_error_recovery;
+mod spine;
+mod takeover;
+mod tick_core;
+mod watch;

package/crates/team-agent/src/coordinator/tests/spine.rs

@@ -18,7 +18,9 @@ pub(super) struct DeliveringTransport {
 }
 impl DeliveringTransport {
     pub(super) fn new() -> Self {
-        Self { inner: MockTransport::new(true) }
+        Self {
+            inner: MockTransport::new(true),
+        }
     }
 }
 impl Transport for DeliveringTransport {
@@ -56,7 +58,8 @@ impl Transport for DeliveringTransport {
         Ok(InjectReport {
             stage_reached: crate::transport::InjectStage::Submit,
             inject_verification: crate::transport::InjectVerification::CaptureContainsToken,
-            submit_verification: crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
+            submit_verification:
+                crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
             turn_verification: crate::transport::TurnVerification::NotYetObserved,
             attempts: 1,
             submit_diagnostics: None,
@@ -83,7 +86,12 @@ impl Transport for DeliveringTransport {
     fn list_windows(&self, s: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         self.inner.list_windows(s)
     }
-    fn set_session_env(&self, s: &SessionName, k: &str, v: &str) -> Result<SetEnvOutcome, TransportError> {
+    fn set_session_env(
+        &self,
+        s: &SessionName,
+        k: &str,
+        v: &str,
+    ) -> Result<SetEnvOutcome, TransportError> {
         self.inner.set_session_env(s, k, v)
     }
     fn kill_session(&self, s: &SessionName) -> Result<(), TransportError> {
@@ -146,8 +154,12 @@ fn seed_due_health_ping(dir: &std::path::Path) -> i64 {
 fn scheduled_status(dir: &std::path::Path, id: i64) -> String {
     let store = MessageStore::open(dir).unwrap();
     let conn = crate::db::schema::open_db(store.db_path()).unwrap();
-    conn.query_row("select status from scheduled_events where id = ?1", [id], |r| r.get::<_, String>(0))
-        .unwrap()
+    conn.query_row(
+        "select status from scheduled_events where id = ?1",
+        [id],
+        |r| r.get::<_, String>(0),
+    )
+    .unwrap()
 }
 
 pub(super) fn message_status(dir: &std::path::Path, message_id: &str) -> String {
@@ -167,7 +179,11 @@ pub(super) fn message_status(dir: &std::path::Path, message_id: &str) -> String
 fn spine_tick_fires_due_scheduled_event_and_marks_db_done() {
     let (coord, dir) = seeded_spine_coord(Box::new(MockTransport::new(true)), None);
     let id = seed_due_health_ping(&dir);
-    assert_eq!(scheduled_status(&dir, id), "pending", "precondition: the seeded row starts pending");
+    assert_eq!(
+        scheduled_status(&dir, id),
+        "pending",
+        "precondition: the seeded row starts pending"
+    );
 
     let report = coord.tick().expect("tick returns a typed report");
 
@@ -189,14 +205,23 @@ fn spine_tick_fires_due_scheduled_event_and_marks_db_done() {
 // mutation — AFTER the real obligation side-effects, not after no-op probes.
 #[test]
 fn spine_tick_save_failure_still_persists_real_scheduled_mutation() {
-    let (coord, dir) = seeded_spine_coord(Box::new(MockTransport::new(true)), Some(failing_save_hook()));
+    let (coord, dir) = seeded_spine_coord(
+        Box::new(MockTransport::new(true)),
+        Some(failing_save_hook()),
+    );
     let id = seed_due_health_ping(&dir);
 
-    let report = coord.tick().expect("a degraded tick is Ok(TickReport), not Err");
+    let report = coord
+        .tick()
+        .expect("a degraded tick is Ok(TickReport), not Err");
 
     // degraded report shape (bug-084: save failure → ok=false / persisted=false, NOT Err).
     assert!(!report.ok, "save failure → ok=false");
-    assert_eq!(report.persisted, Some(false), "save failure → persisted=Some(false)");
+    assert_eq!(
+        report.persisted,
+        Some(false),
+        "save failure → persisted=Some(false)"
+    );
     assert_eq!(report.reason, Some(TickStopReason::PersistenceDegraded));
     // the REAL db side-effect happened BEFORE the (failed) save.
     assert_eq!(
@@ -221,10 +246,22 @@ fn spine_tick_delivers_pending_message_drives_real_db_or_report() {
     let (coord, dir) = seeded_spine_coord(Box::new(DeliveringTransport::new()), None);
     let store = MessageStore::open(&dir).unwrap();
     let mid = store
-        .create_message(Some("task-1"), "leader", "w1", "do the thing", None, true, None)
+        .create_message(
+            Some("task-1"),
+            "leader",
+            "w1",
+            "do the thing",
+            None,
+            true,
+            None,
+        )
         .unwrap();
     drop(store);
-    assert_eq!(message_status(&dir, &mid), "accepted", "precondition: a fresh message is 'accepted'");
+    assert_eq!(
+        message_status(&dir, &mid),
+        "accepted",
+        "precondition: a fresh message is 'accepted'"
+    );
 
     let report = coord.tick().expect("tick returns a typed report");
 
@@ -251,7 +288,10 @@ fn spine_tick_session_missing_emits_event() {
     // tmux gate fire → the tick stops. The gate must ALSO emit coordinator.session_missing.
     let (coord, dir) = seeded_spine_coord(Box::new(MockTransport::new(false)), None);
     let report = coord.tick().expect("tick returns a typed report");
-    assert!(report.stop, "precondition: a missing session stops the tick");
+    assert!(
+        report.stop,
+        "precondition: a missing session stops the tick"
+    );
     let events = read_event_log_dir(&dir);
     assert!(
         events

package/crates/team-agent/src/coordinator/tests/takeover.rs

@@ -21,18 +21,40 @@ impl Transport for CountingCaptureTransport {
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
     }
-    fn spawn_first(&self, _s: &SessionName, _w: &WindowName, _a: &[String], _c: &std::path::Path, _e: &std::collections::BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+    fn spawn_first(
+        &self,
+        _s: &SessionName,
+        _w: &WindowName,
+        _a: &[String],
+        _c: &std::path::Path,
+        _e: &std::collections::BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
         unimplemented!("not reached")
     }
-    fn spawn_into(&self, _s: &SessionName, _w: &WindowName, _a: &[String], _c: &std::path::Path, _e: &std::collections::BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+    fn spawn_into(
+        &self,
+        _s: &SessionName,
+        _w: &WindowName,
+        _a: &[String],
+        _c: &std::path::Path,
+        _e: &std::collections::BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
         unimplemented!("not reached")
     }
-    fn inject(&self, _t: &Target, _p: &InjectPayload, _s: Key, _b: bool) -> Result<InjectReport, TransportError> {
-        self.injects.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    fn inject(
+        &self,
+        _t: &Target,
+        _p: &InjectPayload,
+        _s: Key,
+        _b: bool,
+    ) -> Result<InjectReport, TransportError> {
+        self.injects
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
         Ok(InjectReport {
             stage_reached: crate::transport::InjectStage::Submit,
             inject_verification: crate::transport::InjectVerification::CaptureContainsToken,
-            submit_verification: crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
+            submit_verification:
+                crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
             turn_verification: crate::transport::TurnVerification::NotYetObserved,
             attempts: 1,
             submit_diagnostics: None,
@@ -42,7 +64,10 @@ impl Transport for CountingCaptureTransport {
         Ok(())
     }
     fn capture(&self, _t: &Target, range: CaptureRange) -> Result<CapturedText, TransportError> {
-        Ok(CapturedText { text: self.scrollback.clone(), range })
+        Ok(CapturedText {
+            text: self.scrollback.clone(),
+            range,
+        })
     }
     fn query(&self, _t: &Target, _f: PaneField) -> Result<Option<String>, TransportError> {
         Ok(None)
@@ -59,7 +84,12 @@ impl Transport for CountingCaptureTransport {
     fn list_windows(&self, _s: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         Ok(Vec::new())
     }
-    fn set_session_env(&self, _s: &SessionName, _k: &str, _v: &str) -> Result<SetEnvOutcome, TransportError> {
+    fn set_session_env(
+        &self,
+        _s: &SessionName,
+        _k: &str,
+        _v: &str,
+    ) -> Result<SetEnvOutcome, TransportError> {
         Ok(SetEnvOutcome::Applied)
     }
     fn kill_session(&self, _s: &SessionName) -> Result<(), TransportError> {
@@ -76,17 +106,30 @@ impl Transport for CountingCaptureTransport {
 fn slice2b_dir() -> std::path::PathBuf {
     use std::sync::atomic::{AtomicU64, Ordering};
     static N: AtomicU64 = AtomicU64::new(0);
-    let dir = std::env::temp_dir().join(format!("ta-rs-2b-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
+    let dir = std::env::temp_dir().join(format!(
+        "ta-rs-2b-{}-{}",
+        std::process::id(),
+        N.fetch_add(1, Ordering::Relaxed)
+    ));
     std::fs::create_dir_all(&dir).unwrap();
     dir
 }
 
 /// Build a coordinator over a workspace seeded with `state` (verbatim) + a counting transport.
-fn takeover_coord(state: serde_json::Value) -> (Coordinator, std::path::PathBuf, std::sync::Arc<std::sync::atomic::AtomicUsize>) {
+fn takeover_coord(
+    state: serde_json::Value,
+) -> (
+    Coordinator,
+    std::path::PathBuf,
+    std::sync::Arc<std::sync::atomic::AtomicUsize>,
+) {
     let dir = slice2b_dir();
     crate::state::persist::save_runtime_state(&dir, &state).unwrap();
     let injects = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
-    let transport = CountingCaptureTransport { scrollback: String::new(), injects: std::sync::Arc::clone(&injects) };
+    let transport = CountingCaptureTransport {
+        scrollback: String::new(),
+        injects: std::sync::Arc::clone(&injects),
+    };
     let ws = WorkspacePath::new(dir.clone());
     let reg: Box<dyn ProviderRegistry> = Box::new(MockRegistry::new(&[], &[]));
     let coord = Coordinator::for_test(ws, reg, Box::new(transport), None, None);
@@ -94,7 +137,13 @@ fn takeover_coord(state: serde_json::Value) -> (Coordinator, std::path::PathBuf,
 }
 
 /// Seed an agent_health row (real DB) — what sync_health writes and detect_stuck/detect_deadlocks read.
-fn seed_agent_health(dir: &std::path::Path, agent_id: &str, status: &str, last_output_at: &str, owner_team_id: Option<&str>) {
+fn seed_agent_health(
+    dir: &std::path::Path,
+    agent_id: &str,
+    status: &str,
+    last_output_at: &str,
+    owner_team_id: Option<&str>,
+) {
     let store = MessageStore::open(dir).unwrap();
     let conn = crate::db::schema::open_db(store.db_path()).unwrap();
     conn.execute(
@@ -106,7 +155,9 @@ fn seed_agent_health(dir: &std::path::Path, agent_id: &str, status: &str, last_o
 }
 
 fn has_event(dir: &std::path::Path, name: &str) -> bool {
-    read_event_log_dir(dir).iter().any(|e| e.get("event").and_then(|v| v.as_str()) == Some(name))
+    read_event_log_dir(dir)
+        .iter()
+        .any(|e| e.get("event").and_then(|v| v.as_str()) == Some(name))
 }
 
 // #236 nag_removal (N35) — detect_stuck no longer synthesized in coordinator tick.
@@ -123,7 +174,9 @@ fn slice2b_detect_stuck_no_longer_synthesized_by_framework_n35() {
     }));
     seed_agent_health(&dir, "w1", "RUNNING", &stale, Some("team-h"));
     let store = MessageStore::open(&dir).unwrap();
-    let _ = store.create_message(Some("t"), "leader", "w1", "do work", None, true, None).unwrap();
+    let _ = store
+        .create_message(Some("t"), "leader", "w1", "do work", None, true, None)
+        .unwrap();
     drop(store);
 
     let report = coord.tick().expect("tick");
@@ -148,7 +201,9 @@ fn slice2b_detect_deadlocks_no_longer_synthesized_by_framework_n35() {
     }));
     seed_agent_health(&dir, "w1", "IDLE", &now, Some("team-h"));
     let store = MessageStore::open(&dir).unwrap();
-    let _ = store.create_message(Some("t"), "w2", "w1", "are you done?", None, true, None).unwrap();
+    let _ = store
+        .create_message(Some("t"), "w2", "w1", "are you done?", None, true, None)
+        .unwrap();
     drop(store);
 
     let report = coord.tick().expect("tick");
@@ -199,7 +254,10 @@ fn slice2b_takeover_unarmed_idle_worker_is_never_pinged() {
         // NO coordinator.idle_takeover_monitor → not armed → reason not_armed_no_worker_turn.
     }));
     coord.tick().expect("tick");
-    assert!(!has_event(&dir, "idle_takeover.reminder"), "a NOT-armed worker must never be pinged (§121)");
+    assert!(
+        !has_event(&dir, "idle_takeover.reminder"),
+        "a NOT-armed worker must never be pinged (§121)"
+    );
     assert_eq!(
         injects.load(std::sync::atomic::Ordering::Relaxed),
         0,