@team-agent/installer 0.5.41 → 0.5.43

package/crates/team-agent/src/messaging/selftest.rs

@@ -2,8 +2,8 @@
 
 use std::path::Path;
 
-use crate::model::ids::TeamKey;
 use crate::message_store::MessageStore;
+use crate::model::ids::TeamKey;
 
 use super::helpers::next_run_id;
 use super::{
@@ -42,11 +42,22 @@ pub fn run_comms_selftest(
                 .collect::<Vec<_>>()
         })
         .unwrap_or_default();
-    let receiver_status = if mismatches.is_empty() { CheckStatus::Pass } else { CheckStatus::Fail };
+    let receiver_status = if mismatches.is_empty() {
+        CheckStatus::Pass
+    } else {
+        CheckStatus::Fail
+    };
     let calls = driver.provider_sdk_calls();
-    let provider_status = if calls.is_zero() { CheckStatus::Pass } else { CheckStatus::Fail };
+    let provider_status = if calls.is_zero() {
+        CheckStatus::Pass
+    } else {
+        CheckStatus::Fail
+    };
     let contract_checks = run_contract_suite(workspace, team, &run_id);
-    let contract_status = if contract_checks.iter().all(|check| check.status == CheckStatus::Pass) {
+    let contract_status = if contract_checks
+        .iter()
+        .all(|check| check.status == CheckStatus::Pass)
+    {
         CheckStatus::Pass
     } else {
         CheckStatus::Fail
@@ -54,12 +65,17 @@ pub fn run_comms_selftest(
     let receiver_binding = SelftestCheck {
         status: receiver_status,
         verifies: CheckKind::ReceiverBinding,
-        evidence: CheckEvidence::Binding { mismatches, details: binding },
+        evidence: CheckEvidence::Binding {
+            mismatches,
+            details: binding,
+        },
     };
     let contract_suite = SelftestCheck {
         status: contract_status,
         verifies: CheckKind::ContractSuite,
-        evidence: CheckEvidence::ContractSuite { checks: contract_checks },
+        evidence: CheckEvidence::ContractSuite {
+            checks: contract_checks,
+        },
     };
     let provider_sdk_calls = SelftestCheck {
         status: provider_status,
@@ -71,7 +87,11 @@ pub fn run_comms_selftest(
         && provider_sdk_calls.status == CheckStatus::Pass;
     Ok(SelftestReport {
         ok,
-        status: if ok { CheckStatus::Pass } else { CheckStatus::Fail },
+        status: if ok {
+            CheckStatus::Pass
+        } else {
+            CheckStatus::Fail
+        },
         run_id,
         scope: "binding_consistency".to_string(),
         boundary: "messaging".to_string(),
@@ -86,15 +106,17 @@ fn run_contract_suite(
     team: Option<&TeamKey>,
     run_id: &str,
 ) -> Vec<ContractSuiteCheck> {
-    let scratch = std::env::temp_dir().join(format!(
-        "ta-comms-contract-{run_id}-{}",
-        std::process::id()
-    ));
+    let scratch =
+        std::env::temp_dir().join(format!("ta-comms-contract-{run_id}-{}", std::process::id()));
     let _ = std::fs::remove_dir_all(&scratch);
     let mut checks = Vec::new();
     let mut scratch_store = match MessageStore::open(&scratch) {
         Ok(store) => {
-            checks.push(contract_check("message_store_schema", CheckStatus::Pass, None));
+            checks.push(contract_check(
+                "message_store_schema",
+                CheckStatus::Pass,
+                None,
+            ));
             Some(store)
         }
         Err(error) => {
@@ -127,7 +149,11 @@ fn run_contract_suite(
             let token = format!("[team-agent-token:{message_id}]");
             checks.push(contract_check(
                 "message_token_shape",
-                if rendered.ends_with(&token) { CheckStatus::Pass } else { CheckStatus::Fail },
+                if rendered.ends_with(&token) {
+                    CheckStatus::Pass
+                } else {
+                    CheckStatus::Fail
+                },
                 (!rendered.ends_with(&token)).then(|| "rendered token suffix missing".to_string()),
             ));
         }
@@ -195,10 +221,11 @@ fn run_contract_suite(
             );
             match outcome {
                 Ok(outcome) => {
-                    let actual_owner = outcome
-                        .message_id
-                        .as_deref()
-                        .and_then(|message_id| message_owner_team(store.db_path(), message_id).ok().flatten());
+                    let actual_owner = outcome.message_id.as_deref().and_then(|message_id| {
+                        message_owner_team(store.db_path(), message_id)
+                            .ok()
+                            .flatten()
+                    });
                     checks.push(contract_check(
                         "leader_projection_owner_team",
                         if actual_owner.as_deref() == Some(owner_team.as_str()) {
@@ -237,11 +264,7 @@ fn run_contract_suite(
     checks
 }
 
-fn contract_check(
-    name: &str,
-    status: CheckStatus,
-    reason: Option<String>,
-) -> ContractSuiteCheck {
+fn contract_check(name: &str, status: CheckStatus, reason: Option<String>) -> ContractSuiteCheck {
     ContractSuiteCheck {
         name: name.to_string(),
         status,
@@ -249,10 +272,7 @@ fn contract_check(
     }
 }
 
-fn message_owner_team(
-    db_path: &Path,
-    message_id: &str,
-) -> Result<Option<String>, MessagingError> {
+fn message_owner_team(db_path: &Path, message_id: &str) -> Result<Option<String>, MessagingError> {
     let conn = crate::db::schema::open_db(db_path)?;
     let owner = conn.query_row(
         "select owner_team_id from messages where message_id = ?1",

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

@@ -20,29 +20,46 @@ fn stuck_cancel_snapshot_delivered_message_ids_uses_golden_status_set() {
     .unwrap();
     let store = crate::message_store::MessageStore::open(&ws).unwrap();
     // golden-delivered (must be IN delivered_message_ids): acknowledged + visible.
-    let m_ack = store.create_message(None, "leader", "w1", "ack-me", None, true, Some("teamX")).unwrap();
+    let m_ack = store
+        .create_message(None, "leader", "w1", "ack-me", None, true, Some("teamX"))
+        .unwrap();
     store.mark(&m_ack, "acknowledged", None).unwrap();
-    let m_vis = store.create_message(None, "leader", "w1", "vis", None, true, Some("teamX")).unwrap();
+    let m_vis = store
+        .create_message(None, "leader", "w1", "vis", None, true, Some("teamX"))
+        .unwrap();
     store.mark(&m_vis, "visible", None).unwrap();
     // NOT golden-delivered (must be EXCLUDED): injected.
-    let m_inj = store.create_message(None, "leader", "w1", "inj", None, true, Some("teamX")).unwrap();
+    let m_inj = store
+        .create_message(None, "leader", "w1", "inj", None, true, Some("teamX"))
+        .unwrap();
     store.mark(&m_inj, "injected", None).unwrap();
     drop(store);
     let _ = stuck_cancel(&ws, "w1", None, "leader").unwrap();
     let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    let snapshot = &state["coordinator"]["suppressed_idle_alerts"]["teamX"]["w1"]["stuck"]["snapshot"];
-    assert!(snapshot.get("assigned_task_ids").is_some(), "F1: snapshot must carry assigned_task_ids; got {snapshot}");
+    let snapshot =
+        &state["coordinator"]["suppressed_idle_alerts"]["teamX"]["w1"]["stuck"]["snapshot"];
+    assert!(
+        snapshot.get("assigned_task_ids").is_some(),
+        "F1: snapshot must carry assigned_task_ids; got {snapshot}"
+    );
     let delivered = snapshot
         .get("delivered_message_ids")
         .and_then(serde_json::Value::as_array)
-        .map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_string)).collect::<Vec<_>>())
+        .map(|a| {
+            a.iter()
+                .filter_map(|v| v.as_str().map(str::to_string))
+                .collect::<Vec<_>>()
+        })
         .unwrap_or_else(|| panic!("F1: snapshot must carry delivered_message_ids; got {snapshot}"));
     assert!(
         delivered.contains(&m_ack),
         "F1: golden _DELIVERED_MESSAGE_STATUSES includes 'acknowledged' — the acknowledged message must be \
          in delivered_message_ids; the Rust set omits it. got {delivered:?}"
     );
-    assert!(delivered.contains(&m_vis), "F1: 'visible' is delivered (golden); got {delivered:?}");
+    assert!(
+        delivered.contains(&m_vis),
+        "F1: 'visible' is delivered (golden); got {delivered:?}"
+    );
     assert!(
         !delivered.contains(&m_inj),
         "F1: 'injected' is NOT in golden _DELIVERED_MESSAGE_STATUSES — it must be EXCLUDED; the Rust set \
@@ -50,7 +67,10 @@ fn stuck_cancel_snapshot_delivered_message_ids_uses_golden_status_set() {
     );
     let mut sorted = delivered.clone();
     sorted.sort();
-    assert_eq!(delivered, sorted, "F1: delivered_message_ids must be sorted (golden sorts); got {delivered:?}");
+    assert_eq!(
+        delivered, sorted,
+        "F1: delivered_message_ids must be sorted (golden sorts); got {delivered:?}"
+    );
 }
 // ── collect --result-file INGEST SEMANTIC (golden results.py:58-73) ──────────────────────────────
 // Golden `collect(result_file=…)` INDEPENDENTLY INGESTS a standalone result: a valid result_envelope_v1
@@ -77,7 +97,11 @@ fn collect_result_file_ingests_valid_known_task_envelope_into_results() {
     )
     .unwrap();
     let spec = crate::compiler::compile_team(&team).expect("compile collect team");
-    std::fs::write(team.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    std::fs::write(
+        team.join("team.spec.yaml"),
+        crate::model::yaml::dumps(&spec),
+    )
+    .unwrap();
     // seed runtime state with a KNOWN task "task-1" so the collection loop accepts the ingested result.
     crate::state::persist::save_runtime_state(
         &team,
@@ -100,8 +124,14 @@ fn collect_result_file_ingests_valid_known_task_envelope_into_results() {
     let out = collect(&team, Some(rf.as_path()), false)
         .expect("collect with a valid --result-file must not error");
     // golden: a valid standalone envelope is ingested + collected, ok=true (NOT a silent exit-1).
-    assert_eq!(out["ok"], serde_json::json!(true), "valid --result-file collect must be ok:true; got {out}");
-    let collected = out["collected_results"].as_array().expect("collected_results array");
+    assert_eq!(
+        out["ok"],
+        serde_json::json!(true),
+        "valid --result-file collect must be ok:true; got {out}"
+    );
+    let collected = out["collected_results"]
+        .as_array()
+        .expect("collected_results array");
     assert_eq!(
         collected.len(),
         1,
@@ -117,6 +147,11 @@ fn collect_result_file_ingests_valid_known_task_envelope_into_results() {
         "the ingested result must persist in the results table (counts.total=1); a no-op ingest yields 0. got {}",
         out["results"]
     );
-    assert_eq!(out["results"]["collected"], serde_json::json!(1), "the ingested result must be marked collected; got {}", out["results"]);
+    assert_eq!(
+        out["results"]["collected"],
+        serde_json::json!(1),
+        "the ingested result must be marked collected; got {}",
+        out["results"]
+    );
     let _ = std::fs::remove_dir_all(&team);
 }

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1454,13 +1454,33 @@ impl Transport for ReadbackMissingTransport {
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
     }
-    fn spawn_first(&self, _: &SessionName, _: &WindowName, _: &[String], _: &Path, _: &BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+    fn spawn_first(
+        &self,
+        _: &SessionName,
+        _: &WindowName,
+        _: &[String],
+        _: &Path,
+        _: &BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
         unimplemented!("not reached in delivery")
     }
-    fn spawn_into(&self, _: &SessionName, _: &WindowName, _: &[String], _: &Path, _: &BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+    fn spawn_into(
+        &self,
+        _: &SessionName,
+        _: &WindowName,
+        _: &[String],
+        _: &Path,
+        _: &BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
         unimplemented!("not reached in delivery")
     }
-    fn inject(&self, _: &Target, _: &InjectPayload, _: Key, _: bool) -> Result<InjectReport, TransportError> {
+    fn inject(
+        &self,
+        _: &Target,
+        _: &InjectPayload,
+        _: Key,
+        _: bool,
+    ) -> Result<InjectReport, TransportError> {
         Ok(InjectReport {
             stage_reached: crate::transport::InjectStage::Submit,
             // submit verified, but the token never appeared in the pane → readback missing.
@@ -1477,7 +1497,10 @@ impl Transport for ReadbackMissingTransport {
         Ok(())
     }
     fn capture(&self, _: &Target, range: CaptureRange) -> Result<CapturedText, TransportError> {
-        Ok(CapturedText { text: String::new(), range })
+        Ok(CapturedText {
+            text: String::new(),
+            range,
+        })
     }
     fn query(&self, _: &Target, _: PaneField) -> Result<Option<String>, TransportError> {
         Ok(None)
@@ -1494,7 +1517,12 @@ impl Transport for ReadbackMissingTransport {
     fn list_windows(&self, _: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         Ok(Vec::new())
     }
-    fn set_session_env(&self, _: &SessionName, _: &str, _: &str) -> Result<SetEnvOutcome, TransportError> {
+    fn set_session_env(
+        &self,
+        _: &SessionName,
+        _: &str,
+        _: &str,
+    ) -> Result<SetEnvOutcome, TransportError> {
         Ok(SetEnvOutcome::Applied)
     }
     fn kill_session(&self, _: &SessionName) -> Result<(), TransportError> {
@@ -2848,8 +2876,8 @@ fn gate054_rebind_required_status_refuses_leader_delivery_without_cross_server_p
     // The transport we pass is the "main"/default server backend which does
     // have a live `%1`. If the fix regresses and delivery falls back cross-
     // server by pane id, it would inject here.
-    let default_backend = OfflineTransport::new()
-        .with_targets(vec![pane_info("%1", "team-main", "leader")]);
+    let default_backend =
+        OfflineTransport::new().with_targets(vec![pane_info("%1", "team-main", "leader")]);
 
     let out = deliver_pending_message(&ws, &store, &default_backend, &message_id, &log, &state)
         .expect("status guard must be a business refusal, not panic");
@@ -2904,8 +2932,11 @@ fn gate054_attached_status_still_delivers_when_pane_is_live() {
     let message_id = store
         .create_message(None, "w1", "leader", "hi", None, false, None)
         .unwrap();
-    let transport = OfflineTransport::new()
-        .with_targets(vec![pane_info("%leader", "team-gate054ok", "leader")]);
+    let transport = OfflineTransport::new().with_targets(vec![pane_info(
+        "%leader",
+        "team-gate054ok",
+        "leader",
+    )]);
 
     let out = deliver_pending_message(&ws, &store, &transport, &message_id, &log, &state)
         .expect("attached leader must still deliver");
@@ -2948,7 +2979,15 @@ fn gate054_fallback_pane_socket_recorded_does_not_cross_to_default_server() {
     });
     crate::state::persist::save_runtime_state(&ws, &state).unwrap();
     let message_id = store
-        .create_message(None, "coordinator", "leader", "fallback payload", None, false, None)
+        .create_message(
+            None,
+            "coordinator",
+            "leader",
+            "fallback payload",
+            None,
+            false,
+            None,
+        )
         .unwrap();
 
     let outcome = deliver_to_leader_fallback_pane(
@@ -2978,12 +3017,10 @@ fn gate054_fallback_pane_socket_recorded_does_not_cross_to_default_server() {
     // Audit noise: fallback_pane_attempt + fallback_pane_failed with the
     // recorded socket_bound=true forensic field.
     let events = log.tail(0).unwrap();
-    let attempt = events
-        .iter()
-        .find(|e| {
-            e.get("event").and_then(serde_json::Value::as_str)
-                == Some("leader_receiver.fallback_pane_attempt")
-        });
+    let attempt = events.iter().find(|e| {
+        e.get("event").and_then(serde_json::Value::as_str)
+            == Some("leader_receiver.fallback_pane_attempt")
+    });
     assert!(
         attempt.is_some(),
         "fallback_pane_attempt audit must fire even on socket-bounded refusal; events={events:?}"
@@ -3051,10 +3088,9 @@ fn gate054_rebind_replay_requeues_failed_leader_message_on_attach() {
     // it must flip the blocked leader row back to accepted.
     let team = TeamKey::new(team_id);
     let new_pane = PaneId::new("%1"); // new leader window on the private socket
-    let notices = crate::messaging::requeue_delivery_exhausted_watchers(
-        &ws, &store, &log, &team, &new_pane,
-    )
-    .unwrap();
+    let notices =
+        crate::messaging::requeue_delivery_exhausted_watchers(&ws, &store, &log, &team, &new_pane)
+            .unwrap();
     assert!(
         notices.is_empty(),
         "no exhausted watchers seeded → no watcher notices; only the message row should have been requeued"
@@ -3159,8 +3195,7 @@ fn gate054_status_surfaces_pending_leader_notifications() {
     assert!(entry
         .get("action")
         .and_then(serde_json::Value::as_str)
-        .is_some_and(|action| action.contains("attach-leader")
-            || action.contains("takeover")));
+        .is_some_and(|action| action.contains("attach-leader") || action.contains("takeover")));
 }
 
 #[test]