@team-agent/installer 0.5.41 → 0.5.43

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

@@ -74,7 +74,9 @@ pub fn leader_identity_context(
     }
     if let Some(state_uuid) = state
         .and_then(|s| get_path_str(s, &["team_owner", "leader_session_uuid"]))
-        .or_else(|| state.and_then(|s| get_path_str(s, &["leader_receiver", "leader_session_uuid"])))
+        .or_else(|| {
+            state.and_then(|s| get_path_str(s, &["leader_receiver", "leader_session_uuid"]))
+        })
     {
         return Ok(LeaderIdentity {
             leader_session_uuid: serde_json::from_value(Value::String(state_uuid))?,
@@ -144,7 +146,13 @@ pub fn bind_owner_from_caller_pane(
     let os_user = std::env::var("USER")
         .or_else(|_| std::env::var("USERNAME"))
         .unwrap_or_default();
-    let identity = family_a_identity(workspace, team_id, override_uuid, &machine_fingerprint, &os_user)?;
+    let identity = family_a_identity(
+        workspace,
+        team_id,
+        override_uuid,
+        &machine_fingerprint,
+        &os_user,
+    )?;
     let owner = TeamOwner {
         pane_id: PaneId::new(pane.clone()),
         provider,
@@ -281,19 +289,23 @@ fn tmux_pane_info(workspace: &Path, pane: &str) -> Option<PaneInfo> {
         .ok()?
         .into_iter()
         .find(|info| info.pane_id == target)
-        .or_else(|| tmux_pane_current_command(workspace, pane).ok().map(|command| PaneInfo {
-            pane_id: target,
-            session: SessionName::new(""),
-            window_index: None,
-            window_name: None,
-            pane_index: None,
-            tty: None,
-            current_command: (!command.is_empty()).then_some(command),
-            current_path: None,
-            active: true,
-            pane_pid: None,
-            leader_env: Default::default(),
-        }))
+        .or_else(|| {
+            tmux_pane_current_command(workspace, pane)
+                .ok()
+                .map(|command| PaneInfo {
+                    pane_id: target,
+                    session: SessionName::new(""),
+                    window_index: None,
+                    window_name: None,
+                    pane_index: None,
+                    tty: None,
+                    current_command: (!command.is_empty()).then_some(command),
+                    current_path: None,
+                    active: true,
+                    pane_pid: None,
+                    leader_env: Default::default(),
+                })
+        })
 }
 
 // NOTE: `derive_leader_session_uuid`(`leader_binding.py:146`)已由
@@ -308,16 +320,31 @@ mod e11_provider_bind_tests {
     // E11 层2:copilot leader 命令必须绑成 Provider::Copilot(此前缺臂 → _ => Codex 误绑)。
     #[test]
     fn copilot_command_binds_copilot_not_codex() {
-        assert_eq!(super::super::attribute_command_provider("copilot --banner -C /ws"), Some(Provider::Copilot));
-        assert_eq!(super::super::attribute_command_provider("/opt/homebrew/bin/copilot"), Some(Provider::Copilot));
+        assert_eq!(
+            super::super::attribute_command_provider("copilot --banner -C /ws"),
+            Some(Provider::Copilot)
+        );
+        assert_eq!(
+            super::super::attribute_command_provider("/opt/homebrew/bin/copilot"),
+            Some(Provider::Copilot)
+        );
         assert_eq!(owner_bind_provider_wire("copilot --banner"), "copilot");
     }
 
     #[test]
     fn known_commands_map_via_single_source() {
-        assert_eq!(super::super::attribute_command_provider("claude"), Some(Provider::ClaudeCode));
-        assert_eq!(super::super::attribute_command_provider("codex"), Some(Provider::Codex));
-        assert_eq!(super::super::attribute_command_provider("fake"), Some(Provider::Fake));
+        assert_eq!(
+            super::super::attribute_command_provider("claude"),
+            Some(Provider::ClaudeCode)
+        );
+        assert_eq!(
+            super::super::attribute_command_provider("codex"),
+            Some(Provider::Codex)
+        );
+        assert_eq!(
+            super::super::attribute_command_provider("fake"),
+            Some(Provider::Fake)
+        );
         assert_eq!(owner_bind_provider_wire("claude"), "claude");
         assert_eq!(owner_bind_provider_wire("codex"), "codex");
     }
@@ -325,8 +352,14 @@ mod e11_provider_bind_tests {
     // E11 层2:未知命令不再静默默认 codex —— attribution → None,wire → ""。
     #[test]
     fn unknown_command_is_none_not_silent_codex() {
-        assert_eq!(super::super::attribute_command_provider("node /some/thing.js"), None);
-        assert_eq!(super::super::attribute_command_provider("totally-unknown"), None);
+        assert_eq!(
+            super::super::attribute_command_provider("node /some/thing.js"),
+            None
+        );
+        assert_eq!(
+            super::super::attribute_command_provider("totally-unknown"),
+            None
+        );
         assert_eq!(owner_bind_provider_wire("totally-unknown"), "");
     }
 }

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()