@team-agent/installer 0.5.42 → 0.5.44

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

@@ -23,19 +23,27 @@ pub(crate) fn attribute_pane_provider(pane: &PaneInfo) -> Option<Provider> {
     attribute_pane_provider_with_process(pane, provider_from_pid_env, provider_from_pid_argv)
 }
 
-fn attribute_pane_provider_with_process(
+fn attribute_pane_provider_with_process<FEnv, FArg>(
     pane: &PaneInfo,
-    provider_from_env_pid: impl Fn(u32) -> Option<Provider>,
-    provider_from_argv_pid: impl Fn(u32) -> Option<Provider>,
-) -> Option<Provider> {
+    provider_from_env_pid: FEnv,
+    provider_from_argv_pid: FArg,
+) -> Option<Provider>
+where
+    FEnv: Fn(u32) -> Option<Provider>,
+    FArg: Fn(u32) -> Option<Provider>,
+{
     provider_from_env(&pane.leader_env)
-        .or_else(|| pane.pane_pid.and_then(provider_from_env_pid))
+        .or_else(|| pane.pane_pid.and_then(|pid| provider_from_env_pid(pid)))
         .or_else(|| {
             pane.current_command
                 .as_deref()
                 .and_then(attribute_command_provider)
         })
-        .or_else(|| pane.pane_pid.and_then(provider_from_argv_pid))
+        .or_else(|| pane.pane_pid.and_then(|pid| provider_from_argv_pid(pid)))
+        .or_else(|| {
+            pane.pane_pid
+                .and_then(|pid| provider_from_process_tree_argv(pid, &provider_from_argv_pid))
+        })
 }
 
 pub(crate) fn attribute_command_provider(command: &str) -> Option<Provider> {
@@ -63,6 +71,17 @@ fn provider_from_pid_argv(pid: u32) -> Option<Provider> {
         .and_then(provider_from_command_text)
 }
 
+fn provider_from_process_tree_argv(
+    root_pid: u32,
+    provider_from_argv_pid: &impl Fn(u32) -> Option<Provider>,
+) -> Option<Provider> {
+    crate::platform::process::process_tree(root_pid)
+        .ok()?
+        .into_iter()
+        .filter(|pid| *pid != root_pid)
+        .find_map(provider_from_argv_pid)
+}
+
 fn provider_from_pid_env(pid: u32) -> Option<Provider> {
     process_environment(pid)
         .as_deref()

package/crates/team-agent/src/leader/rediscover/tests.rs

@@ -206,8 +206,14 @@ fn rediscover_updates_unique_env_triple_match() {
     let ws = ws("rediscover");
     let mut env = BTreeMap::new();
     env.insert("TEAM_AGENT_LEADER_PANE_ID".to_string(), "%r".to_string());
-    env.insert("TEAM_AGENT_LEADER_PROVIDER".to_string(), "codex".to_string());
-    env.insert("TEAM_AGENT_MACHINE_FINGERPRINT".to_string(), "fp".to_string());
+    env.insert(
+        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+        "codex".to_string(),
+    );
+    env.insert(
+        "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
+        "fp".to_string(),
+    );
     let target = PaneInfo {
         pane_id: PaneId::new("%r"),
         session: SessionName::new("sess"),
@@ -235,10 +241,14 @@ fn rediscover_updates_unique_env_triple_match() {
     });
     let event_log = crate::event_log::EventLog::new(&ws);
 
-    let out = rediscover_leader_receiver_from_targets(&ws, &mut state, &[target], &event_log).unwrap();
+    let out =
+        rediscover_leader_receiver_from_targets(&ws, &mut state, &[target], &event_log).unwrap();
 
     assert_eq!(out["status"], json!("updated"));
-    assert!(out.get("ok").is_none(), "golden rediscover result has no ok wrapper");
+    assert!(
+        out.get("ok").is_none(),
+        "golden rediscover result has no ok wrapper"
+    );
     assert_eq!(out["owner_identity"]["pane_id"], json!("%r"));
     // Stage 3d: receiver lives at canonical teams.<team_key>.leader_receiver.
     let team_key = crate::state::projection::team_state_key(&state);
@@ -255,9 +265,15 @@ fn rediscover_updates_unique_env_triple_match() {
     assert!(rebound.get("reason").is_some_and(Value::is_null));
     assert_eq!(rebound["old_pane_id"], json!("%r"));
     assert_eq!(rebound["new_pane_id"], json!("%r"));
-    assert_eq!(rebound["owner_identity"]["machine_fingerprint"], json!("fp"));
+    assert_eq!(
+        rebound["owner_identity"]["machine_fingerprint"],
+        json!("fp")
+    );
     assert_eq!(rebound["uuid_prefix"], json!("OWNERUUI"));
-    assert_eq!(receiver["discovery"], json!("stale_rediscovery_unique_candidate"));
+    assert_eq!(
+        receiver["discovery"],
+        json!("stale_rediscovery_unique_candidate")
+    );
 }
 
 #[test]
@@ -276,8 +292,14 @@ fn rediscover_owner_identity_passthrough_sets_discovery_and_reason() {
         pane_pid: None,
         leader_env: BTreeMap::from([
             ("TEAM_AGENT_LEADER_PANE_ID".to_string(), "%raw".to_string()),
-            ("TEAM_AGENT_LEADER_PROVIDER".to_string(), "codex".to_string()),
-            ("TEAM_AGENT_MACHINE_FINGERPRINT".to_string(), "fp".to_string()),
+            (
+                "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+                "codex".to_string(),
+            ),
+            (
+                "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
+                "fp".to_string(),
+            ),
         ]),
     };
     let raw_identity = json!({
@@ -305,8 +327,14 @@ fn rediscover_owner_identity_passthrough_sets_discovery_and_reason() {
     // Stage 3d: receiver lives at canonical teams.<team_key>.leader_receiver.
     let team_key = crate::state::projection::team_state_key(&state);
     let receiver = &state["teams"][&team_key]["leader_receiver"];
-    assert_eq!(receiver["discovery"], json!("stale_rediscovery_owner_identity"));
-    let rebound = event_named(&event_log.tail(10).unwrap(), "leader_receiver.rebind_applied");
+    assert_eq!(
+        receiver["discovery"],
+        json!("stale_rediscovery_owner_identity")
+    );
+    let rebound = event_named(
+        &event_log.tail(10).unwrap(),
+        "leader_receiver.rebind_applied",
+    );
     assert_eq!(rebound["reason"], json!("stale_receiver"));
     assert_eq!(rebound["owner_identity"], raw_identity);
     assert_eq!(rebound["uuid_prefix"], json!("RAWUUID1"));
@@ -328,16 +356,23 @@ fn rediscover_missing_and_ambiguous_use_golden_status_names() {
             "claimed_via": "claim-leader"
         }
     });
-    let missing = rediscover_leader_receiver_from_targets(&ws, &mut state, &[], &event_log).unwrap();
+    let missing =
+        rediscover_leader_receiver_from_targets(&ws, &mut state, &[], &event_log).unwrap();
     assert_eq!(missing["status"], json!("missing"));
     assert!(missing.get("ok").is_none());
     assert_eq!(missing["owner_identity"]["pane_id"], json!("%owner"));
-    let missing_event = event_named(&event_log.tail(10).unwrap(), "leader_receiver.rediscover_missing");
+    let missing_event = event_named(
+        &event_log.tail(10).unwrap(),
+        "leader_receiver.rediscover_missing",
+    );
     assert_eq!(missing_event["owner_identity"]["pane_id"], json!("%owner"));
     assert_eq!(missing_event["provider"], json!("codex"));
     assert_eq!(missing_event["old_target"], json!("%owner"));
     assert_eq!(missing_event["candidate_count"], json!(0));
-    let missing_rebind = last_event_named(&event_log.tail(10).unwrap(), "leader_receiver.rebind_required");
+    let missing_rebind = last_event_named(
+        &event_log.tail(10).unwrap(),
+        "leader_receiver.rebind_required",
+    );
     assert!(missing_rebind.get("reason").is_some_and(Value::is_null));
     assert_eq!(missing_rebind["provider"], json!("codex"));
     assert_eq!(missing_rebind["team_id"], json!("sess"));
@@ -350,9 +385,18 @@ fn rediscover_missing_and_ambiguous_use_golden_status_names() {
     assert!(missing_rebind.get("invalidation_reason").is_none());
 
     let mut env = BTreeMap::new();
-    env.insert("TEAM_AGENT_LEADER_PANE_ID".to_string(), "%owner".to_string());
-    env.insert("TEAM_AGENT_LEADER_PROVIDER".to_string(), "codex".to_string());
-    env.insert("TEAM_AGENT_MACHINE_FINGERPRINT".to_string(), "fp".to_string());
+    env.insert(
+        "TEAM_AGENT_LEADER_PANE_ID".to_string(),
+        "%owner".to_string(),
+    );
+    env.insert(
+        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+        "codex".to_string(),
+    );
+    env.insert(
+        "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
+        "fp".to_string(),
+    );
     let mk = |pane: &str, window: u32, pane_index: u32, tty: &str| PaneInfo {
         pane_id: PaneId::new(pane),
         session: SessionName::new("sess"),
@@ -375,18 +419,29 @@ fn rediscover_missing_and_ambiguous_use_golden_status_names() {
     .unwrap();
     assert_eq!(ambiguous["status"], json!("ambiguous"));
     assert!(ambiguous.get("ok").is_none());
-    assert_eq!(ambiguous["owner_candidates"].as_array().map(Vec::len), Some(2));
+    assert_eq!(
+        ambiguous["owner_candidates"].as_array().map(Vec::len),
+        Some(2)
+    );
     assert_eq!(ambiguous["owner_candidates"][0]["pane_id"], json!("%a"));
     assert_eq!(ambiguous["owner_candidates"][0]["window_index"], json!(1));
     assert_eq!(ambiguous["owner_candidates"][0]["pane_index"], json!(0));
-    assert_eq!(ambiguous["owner_candidates"][0]["pane_tty"], json!("/ttys001"));
-    assert_eq!(ambiguous["owner_candidates"][0]["current_command"], json!("codex"));
+    assert_eq!(
+        ambiguous["owner_candidates"][0]["pane_tty"],
+        json!("/ttys001")
+    );
+    assert_eq!(
+        ambiguous["owner_candidates"][0]["current_command"],
+        json!("codex")
+    );
     assert_eq!(ambiguous["owner_candidates"][0]["fingerprint"], json!("fp"));
     assert!(ambiguous["owner_candidates"][0]["current_path"]
         .as_str()
         .is_some_and(|path| path.contains("rediscover-%a")));
     assert!(ambiguous.get("incident").is_none());
-    assert!(ambiguous["incident_id"].as_str().is_some_and(|id| id.starts_with("rediscover_")));
+    assert!(ambiguous["incident_id"]
+        .as_str()
+        .is_some_and(|id| id.starts_with("rediscover_")));
     assert_eq!(ambiguous["deduped"], json!(false));
     let events = event_log.tail(20).unwrap();
     let ambiguous_event = event_named(&events, "leader_receiver.rediscover_ambiguous");
@@ -398,7 +453,10 @@ fn rediscover_missing_and_ambiguous_use_golden_status_names() {
     assert_eq!(candidates_event["provider"], json!("codex"));
     assert_eq!(candidates_event["team_id"], json!("sess"));
     assert_eq!(candidates_event["uuid_prefix"], json!("OWNERUUI"));
-    assert_eq!(candidates_event["debounce_bucket"], ambiguous["incident_id"]);
+    assert_eq!(
+        candidates_event["debounce_bucket"],
+        ambiguous["incident_id"]
+    );
     assert_eq!(candidates_event["reason"], json!("force_confirm_required"));
     assert_eq!(candidates_event["queued"].as_array().map(Vec::len), Some(2));
 }
@@ -538,19 +596,25 @@ fn rediscover_failed_uses_golden_status_and_rebind_shape() {
     .unwrap();
 
     assert_eq!(out["status"], json!("failed"));
-    assert!(out["error"].as_str().is_some_and(|error| error.contains("scan failed")));
+    assert!(out["error"]
+        .as_str()
+        .is_some_and(|error| error.contains("scan failed")));
     assert!(out.get("ok").is_none());
     let events = event_log.tail(10).unwrap();
     let failed = event_named(&events, "leader_receiver.rediscover_failed");
     assert_eq!(failed["provider"], json!("codex"));
-    assert!(failed["error"].as_str().is_some_and(|error| error.contains("scan failed")));
+    assert!(failed["error"]
+        .as_str()
+        .is_some_and(|error| error.contains("scan failed")));
     let rebind = event_named(&events, "leader_receiver.rebind_required");
     assert_eq!(rebind["old_pane_id"], json!("%old"));
     assert_eq!(rebind["reason"], json!("stale_receiver"));
     assert_eq!(rebind["provider"], json!("codex"));
     assert_eq!(rebind["team_id"], json!("sess"));
     assert_eq!(rebind["rediscovery_status"], json!("failed"));
-    assert!(rebind["error"].as_str().is_some_and(|error| error.contains("scan failed")));
+    assert!(rebind["error"]
+        .as_str()
+        .is_some_and(|error| error.contains("scan failed")));
     assert!(rebind.get("owner_identity").is_none());
     assert!(rebind.get("uuid_prefix").is_none());
     assert!(rebind.get("invalidation_reason").is_none());

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

@@ -6,11 +6,13 @@ use std::path::{Path, PathBuf};
 use serde_json::{json, Value};
 
 use crate::model::ids::{LeaderSessionUuid, OwnerEpoch};
-use crate::provider::Provider;
 use crate::provider::wire::provider_wire;
+use crate::provider::Provider;
 use crate::transport::{PaneId, PaneInfo, SessionName, Transport, WindowName};
 
-use super::helpers::{get_path_str, now_ts, parse_provider, prefix, resolve_workspace_for_hash, sha1_hex_prefix};
+use super::helpers::{
+    get_path_str, now_ts, parse_provider, prefix, resolve_workspace_for_hash, sha1_hex_prefix,
+};
 use super::{
     ClaimedVia, Discovery, LeaderError, LeaderEvent, LeaderReceiver, LeaseSource, ReceiverMode,
     ReceiverStatus, TeamOwner,
@@ -56,8 +58,21 @@ pub fn try_readopt_leader_pane(
         .or_else(|| owner_record.and_then(|owner| owner.leader_session_uuid.clone()))
         .or_else(|| receiver.leader_session_uuid.clone());
     let provider = candidate.provider.unwrap_or(receiver_provider);
-    let rebound = receiver_from_candidate(&candidate, receiver, provider, uuid.clone(), owner_epoch, Discovery::AttachReadopt);
-    let owner = owner_from_candidate(&candidate, provider, uuid, owner_epoch, ClaimedVia::AttachLeader);
+    let rebound = receiver_from_candidate(
+        &candidate,
+        receiver,
+        provider,
+        uuid.clone(),
+        owner_epoch,
+        Discovery::AttachReadopt,
+    );
+    let owner = owner_from_candidate(
+        &candidate,
+        provider,
+        uuid,
+        owner_epoch,
+        ClaimedVia::AttachLeader,
+    );
     let mut owner_identity = OwnerIdentity::from_state(workspace, state)?;
     if let Some(record) = owner_record {
         owner_identity.pane_id = Some(record.pane_id.as_str().to_string());
@@ -123,7 +138,9 @@ pub fn rediscover_leader_receiver(
     event_log: &crate::event_log::EventLog,
 ) -> Result<Value, LeaderError> {
     let identity = OwnerIdentity::from_state(workspace, state)?;
-    rediscover_leader_receiver_with_identity(workspace, state, transport, event_log, &identity, None)
+    rediscover_leader_receiver_with_identity(
+        workspace, state, transport, event_log, &identity, None,
+    )
 }
 
 pub fn rediscover_leader_receiver_with_owner_identity(
@@ -164,7 +181,13 @@ fn rediscover_leader_receiver_with_identity(
                     "error": error.as_str(),
                 }),
             )?;
-            emit_failed_rebind_required(event_log, state, identity, invalidation_reason, error.as_str())?;
+            emit_failed_rebind_required(
+                event_log,
+                state,
+                identity,
+                invalidation_reason,
+                error.as_str(),
+            )?;
             return Ok(json!({
                 "status": "failed",
                 "error": error,
@@ -189,12 +212,7 @@ pub fn rediscover_leader_receiver_from_targets(
 ) -> Result<Value, LeaderError> {
     let identity = OwnerIdentity::from_state(workspace, state)?;
     rediscover_leader_receiver_from_targets_with_identity(
-        workspace,
-        state,
-        targets,
-        event_log,
-        &identity,
-        None,
+        workspace, state, targets, event_log, &identity, None,
     )
 }
 
@@ -268,7 +286,14 @@ fn rediscover_leader_receiver_from_targets_with_identity(
             )?;
         }
         if has_owner_identity {
-            emit_rebind_required(event_log, "ambiguous", state, identity, invalidation_reason, "confirm rediscover leader receiver")?;
+            emit_rebind_required(
+                event_log,
+                "ambiguous",
+                state,
+                identity,
+                invalidation_reason,
+                "confirm rediscover leader receiver",
+            )?;
             return Ok(json!({
             "status": "ambiguous",
             "owner_candidates": candidate_values(&candidates, identity.from_caller),
@@ -504,13 +529,16 @@ impl OwnerIdentity {
     }
 
     fn has_match_identity(&self) -> bool {
-        self.pane_id.is_some() || self.leader_session_uuid.is_some() || !self.machine_fingerprint.is_empty()
+        self.pane_id.is_some()
+            || self.leader_session_uuid.is_some()
+            || !self.machine_fingerprint.is_empty()
     }
 }
 
 fn target_from_value(value: &Value) -> Option<LeaderTarget> {
     let pane_id = get_str(value, "pane_id").or_else(|| get_str(value, "pane"))?;
-    let current_command = get_str(value, "pane_current_command").or_else(|| get_str(value, "current_command"));
+    let current_command =
+        get_str(value, "pane_current_command").or_else(|| get_str(value, "current_command"));
     let leader_env = map_env(value.get("leader_env").or_else(|| value.get("env")));
     let pane_pid = get_u32(value, "pane_pid");
     let provider = super::attribute_pane_provider(&PaneInfo {
@@ -553,7 +581,8 @@ fn target_from_value(value: &Value) -> Option<LeaderTarget> {
         leader_env,
         provider,
         leader_session_uuid,
-        fingerprint: get_str(value, "fingerprint").or_else(|| get_str(value, "machine_fingerprint")),
+        fingerprint: get_str(value, "fingerprint")
+            .or_else(|| get_str(value, "machine_fingerprint")),
     })
 }
 
@@ -648,7 +677,13 @@ fn candidate_pane_ids(candidates: &[LeaderTarget]) -> Vec<String> {
 
 fn ambiguous_incident_id(identity: &OwnerIdentity, panes: &[String]) -> String {
     let mut bytes = Vec::new();
-    bytes.extend_from_slice(identity.provider.map(provider_wire).unwrap_or("").as_bytes());
+    bytes.extend_from_slice(
+        identity
+            .provider
+            .map(provider_wire)
+            .unwrap_or("")
+            .as_bytes(),
+    );
     bytes.push(0);
     bytes.extend_from_slice(identity.team_id.as_bytes());
     bytes.push(0);
@@ -752,7 +787,8 @@ fn ambiguous_candidates_already_broadcast(
     incident_id: &str,
 ) -> Result<bool, LeaderError> {
     Ok(event_log.tail(200)?.iter().any(|event| {
-        event.get("event").and_then(Value::as_str) == Some(LeaderEvent::ReceiverAmbiguousCandidates.name())
+        event.get("event").and_then(Value::as_str)
+            == Some(LeaderEvent::ReceiverAmbiguousCandidates.name())
             && event.get("incident_id").and_then(Value::as_str) == Some(incident_id)
     }))
 }
@@ -915,11 +951,15 @@ fn env_triple_matches(target: &LeaderTarget, identity: &OwnerIdentity) -> bool {
         && target
             .leader_env
             .get("TEAM_AGENT_LEADER_PROVIDER")
-            .is_some_and(|value| identity.provider.is_some_and(|provider| value == provider_wire(provider)))
+            .is_some_and(|value| {
+                identity
+                    .provider
+                    .is_some_and(|provider| value == provider_wire(provider))
+            })
         && target
-        .leader_env
-        .get("TEAM_AGENT_MACHINE_FINGERPRINT")
-        .is_some_and(|value| value == &identity.machine_fingerprint)
+            .leader_env
+            .get("TEAM_AGENT_MACHINE_FINGERPRINT")
+            .is_some_and(|value| value == &identity.machine_fingerprint)
 }
 
 fn different_live_owner_uuid_mismatch(
@@ -984,7 +1024,12 @@ fn owner_from_candidate(
         machine_fingerprint: candidate
             .fingerprint
             .clone()
-            .or_else(|| candidate.leader_env.get("TEAM_AGENT_MACHINE_FINGERPRINT").cloned())
+            .or_else(|| {
+                candidate
+                    .leader_env
+                    .get("TEAM_AGENT_MACHINE_FINGERPRINT")
+                    .cloned()
+            })
             .unwrap_or_default(),
         leader_session_uuid: uuid,
         owner_epoch: epoch,
@@ -1067,7 +1112,9 @@ fn write_readopt_state(
         *state = json!({});
     }
     if !state.is_object() {
-        return Err(LeaderError::Validation("state root is not an object".to_string()));
+        return Err(LeaderError::Validation(
+            "state root is not an object".to_string(),
+        ));
     }
     let team_key = crate::state::projection::team_state_key(state);
     let record = crate::state::ownership::OwnershipWrite::new()
@@ -1086,7 +1133,9 @@ fn write_receiver_state(
         *state = json!({});
     }
     if !state.is_object() {
-        return Err(LeaderError::Validation("state root is not an object".to_string()));
+        return Err(LeaderError::Validation(
+            "state root is not an object".to_string(),
+        ));
     }
     let team_key = crate::state::projection::team_state_key(state);
     let record = crate::state::ownership::OwnershipWrite::new()

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

@@ -200,7 +200,7 @@ pub fn register_binding_from_state_best_effort(
     team: Option<&str>,
     source: &str,
 ) -> Option<RegistryWriteOutcome> {
-    let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
+    let Ok(state) = crate::state::persist::load_runtime_state_without_migrations(workspace) else {
         return None;
     };
     let team_key = match team.filter(|team| !team.is_empty()) {