@team-agent/installer 0.5.74 → 0.5.75

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

@@ -31,9 +31,9 @@ use crate::provider::wire::{
     is_claude_family, parse_canonical_provider, parse_provider, provider_wire,
 };
 use crate::transport::{
-    submit_verification_wire, turn_verification_wire, CaptureRange, InjectPayload, InjectReport,
-    InjectVerification, Key, PaneId, PaneInfo, SessionName, SubmitObserver, SubmitVerification,
-    Target, Transport, WindowName,
+    submit_verification_wire, turn_verification_wire, CaptureRange, CaptureSampleOutcome,
+    InjectPayload, InjectReport, InjectVerification, InputSurfaceProbe, Key, PaneId, PaneInfo,
+    QueryOutcome, SessionName, SubmitObserver, SubmitVerification, Target, Transport, WindowName,
 };
 
 use super::helpers::{message_exists, MessageStatusShadow};
@@ -749,16 +749,20 @@ pub fn deliver_pending_message(
         // are preserved byte-for-byte for grep compatibility; new keys are
         // ADDITIONAL.
         let submit_attempts_detail = render_submit_diagnostics(&inject_report);
-        event_log.write(
-            "send.unverified",
-            serde_json::json!({
-                "message_id": message_id,
-                "recipient": message.recipient,
-                "reason": reason,
-                "attempts": inject_report.attempts,
-                "submit_attempts_detail": submit_attempts_detail,
-            }),
-        )?;
+        let mut unverified = serde_json::json!({
+            "message_id": message_id,
+            "recipient": message.recipient,
+            "reason": reason,
+            "attempts": inject_report.attempts,
+            "submit_attempts_detail": submit_attempts_detail,
+        });
+        merge_inject_readback_fields(
+            &mut unverified,
+            &inject_report,
+            Some(&target),
+            resolved.metadata.as_ref(),
+        );
+        event_log.write("send.unverified", unverified)?;
         if inject_report.attempts >= u32::from(SEND_RETRY_MAX_ATTEMPTS) {
             store.mark(message_id, "failed", Some("send_unverified_exhausted"))?;
             emit_send_failed_exhausted(
@@ -1070,7 +1074,7 @@ fn persist_submit_verification(workspace: &Path, message_id: &str, report: &Inje
     if std::fs::create_dir_all(&dir).is_err() {
         return;
     }
-    let body = serde_json::json!({
+    let mut body = serde_json::json!({
         "message_id": message_id,
         "submit_verification": format!("{:?}", report.submit_verification),
         "inject_verification": format!("{:?}", report.inject_verification),
@@ -1078,6 +1082,7 @@ fn persist_submit_verification(workspace: &Path, message_id: &str, report: &Inje
         "submit_verified": inject_submit_verified(report),
         "attempts": report.attempts,
     });
+    merge_inject_readback_fields(&mut body, report, None, None);
     let _ = std::fs::write(dir.join("submit-verification.json"), format!("{body}\n"));
 }
 
@@ -1914,6 +1919,116 @@ fn render_submit_diagnostics(report: &InjectReport) -> serde_json::Value {
     )
 }
 
+fn json_opt_bool(value: Option<bool>) -> serde_json::Value {
+    match value {
+        Some(flag) => serde_json::Value::Bool(flag),
+        None => serde_json::Value::Null,
+    }
+}
+
+fn inject_pane_id(target: &Target) -> Option<&str> {
+    match target {
+        Target::Pane(pane) => Some(pane.as_str()),
+        Target::SessionWindow { .. } => None,
+    }
+}
+
+fn merge_inject_readback_fields(
+    event: &mut serde_json::Value,
+    report: &InjectReport,
+    target: Option<&Target>,
+    metadata: Option<&TargetMetadata>,
+) {
+    if let Some(metadata) = metadata {
+        append_target_metadata(event, metadata);
+    }
+    let Some(obj) = event.as_object_mut() else {
+        return;
+    };
+    let inject_pane = target.and_then(inject_pane_id);
+    if let Some(pane) = inject_pane {
+        obj.insert(
+            "inject_target_pane_id".to_string(),
+            serde_json::json!(pane),
+        );
+    }
+    let resolved_pane = metadata.map(|meta| meta.target_pane_id.as_str());
+    obj.insert(
+        "target_pane_matched".to_string(),
+        json_opt_bool(match (inject_pane, resolved_pane) {
+            (Some(left), Some(right)) => Some(left == right),
+            _ => None,
+        }),
+    );
+    let inject_endpoint = metadata.and_then(|meta| meta.tmux_endpoint.as_deref());
+    // metadata.tmux_endpoint is the transport used to resolve; compare to
+    // itself is tautological. Equality vs inject target id is the pane check
+    // above. Socket equality is recorded when both sides exist on metadata.
+    obj.insert(
+        "resolved_tmux_endpoint_present".to_string(),
+        serde_json::Value::Bool(inject_endpoint.is_some()),
+    );
+    let diag = report.submit_diagnostics.as_ref();
+    obj.insert(
+        "token_seen_before_paste".to_string(),
+        json_opt_bool(diag.and_then(|d| d.token_seen_before_paste)),
+    );
+    obj.insert(
+        "token_seen_after_paste".to_string(),
+        json_opt_bool(diag.and_then(|d| d.token_seen_after_paste)),
+    );
+    obj.insert(
+        "token_seen_after_enter".to_string(),
+        json_opt_bool(diag.and_then(|d| d.token_seen_after_enter)),
+    );
+    obj.insert(
+        "capture_ok_count".to_string(),
+        serde_json::json!(diag.map(|d| d.capture_ok_count).unwrap_or(0)),
+    );
+    obj.insert(
+        "capture_err_count".to_string(),
+        serde_json::json!(diag.map(|d| d.capture_err_count).unwrap_or(0)),
+    );
+    obj.insert(
+        "capture_sample_count".to_string(),
+        serde_json::json!(diag.map(|d| d.capture_sample_count).unwrap_or(0)),
+    );
+    obj.insert(
+        "last_capture_outcome".to_string(),
+        serde_json::json!(diag
+            .map(|d| d.last_capture_outcome.as_str())
+            .unwrap_or(CaptureSampleOutcome::NotAttempted.as_str())),
+    );
+    obj.insert(
+        "pane_command_basename".to_string(),
+        diag.and_then(|d| d.pane_command_basename.as_deref())
+            .map(|name| serde_json::json!(name))
+            .unwrap_or(serde_json::Value::Null),
+    );
+    obj.insert(
+        "pane_command_query".to_string(),
+        serde_json::json!(diag
+            .map(|d| d.pane_command_query.as_str())
+            .unwrap_or(QueryOutcome::Unavailable.as_str())),
+    );
+    obj.insert(
+        "input_surface".to_string(),
+        serde_json::json!(diag
+            .map(|d| d.input_surface.as_str())
+            .unwrap_or(InputSurfaceProbe::Unavailable.as_str())),
+    );
+    obj.insert(
+        "diag_target_pane_id".to_string(),
+        diag.and_then(|d| d.target_pane_id.as_deref())
+            .map(|pane| serde_json::json!(pane))
+            .unwrap_or(serde_json::Value::Null),
+    );
+    obj.insert(
+        "diag_target_pane_query_matched".to_string(),
+        json_opt_bool(diag.and_then(|d| d.target_pane_query_matched)),
+    );
+}
+
 #[allow(clippy::too_many_arguments)]
 fn emit_send_failed_exhausted(
     workspace: &Path,
@@ -1944,21 +2059,22 @@ fn emit_send_failed_exhausted(
         .and_then(|r| r.submit_diagnostics.as_ref())
         .and_then(|d| d.attempts_detail.last())
         .map(|a| a.pane_tail_excerpt.clone());
-    event_log.write(
-        "send.failed",
-        serde_json::json!({
-            "message_id": message_id,
-            "recipient": recipient,
-            "attempts": attempts,
-            "max_attempts": SEND_RETRY_MAX_ATTEMPTS,
-            "reason": failure_reason,
-            "verification": verification,
-            "submit_attempts_detail": submit_attempts_detail,
-            "total_elapsed_ms": total_elapsed_ms,
-            "last_matched_literal": last_matched_literal,
-            "last_pane_tail_excerpt": last_pane_tail_excerpt,
-        }),
-    )?;
+    let mut failed = serde_json::json!({
+        "message_id": message_id,
+        "recipient": recipient,
+        "attempts": attempts,
+        "max_attempts": SEND_RETRY_MAX_ATTEMPTS,
+        "reason": failure_reason,
+        "verification": verification,
+        "submit_attempts_detail": submit_attempts_detail,
+        "total_elapsed_ms": total_elapsed_ms,
+        "last_matched_literal": last_matched_literal,
+        "last_pane_tail_excerpt": last_pane_tail_excerpt,
+    });
+    if let Some(report) = inject_report {
+        merge_inject_readback_fields(&mut failed, report, None, None);
+    }
+    event_log.write("send.failed", failed)?;
     let content = format!(
         "send.failed\nerror: send to {recipient} failed with {failure_reason} after {attempts}/{SEND_RETRY_MAX_ATTEMPTS} attempts\naction: inspect the target pane and retry the send\nlog: .team/logs/events.jsonl"
     );
@@ -3266,4 +3382,59 @@ mod paste_floor_tests {
             Duration::ZERO
         );
     }
+
+    fn empty_report() -> InjectReport {
+        InjectReport {
+            stage_reached: crate::transport::InjectStage::Submit,
+            inject_verification: InjectVerification::CaptureMissingToken,
+            submit_verification: SubmitVerification::SubmitConsumptionUnverified,
+            turn_verification: crate::transport::TurnVerification::NotYetObserved,
+            attempts: 1,
+            submit_diagnostics: Some(crate::transport::SubmitDiagnostics {
+                last_capture_outcome: CaptureSampleOutcome::Failed,
+                capture_err_count: 1,
+                capture_sample_count: 1,
+                pane_command_basename: Some("grok".to_string()),
+                pane_command_query: QueryOutcome::Observed,
+                input_surface: InputSurfaceProbe::Input,
+                target_pane_id: Some("%9".to_string()),
+                target_pane_query_matched: Some(true),
+                token_seen_after_paste: None,
+                ..crate::transport::SubmitDiagnostics::default()
+            }),
+        }
+    }
+
+    #[test]
+    fn inject_readback_fields_are_safe_scalars_and_keep_attempts_array() {
+        let report = empty_report();
+        let mut event = serde_json::json!({
+            "message_id": "msg_x",
+            "submit_attempts_detail": [{"matched": false}],
+        });
+        merge_inject_readback_fields(
+            &mut event,
+            &report,
+            Some(&Target::Pane(PaneId::new("%9"))),
+            None,
+        );
+        assert_eq!(event["last_capture_outcome"], serde_json::json!("failed"));
+        assert_eq!(event["token_seen_after_paste"], serde_json::Value::Null);
+        assert_eq!(event["pane_command_basename"], serde_json::json!("grok"));
+        assert_eq!(event["input_surface"], serde_json::json!("input"));
+        assert_eq!(event["inject_target_pane_id"], serde_json::json!("%9"));
+        assert!(event["submit_attempts_detail"].is_array());
+        assert!(event.get("pane_tail_excerpt").is_none());
+        let dump = event.to_string();
+        assert!(
+            !dump.contains("--help") && !dump.contains("argv"),
+            "readback fields must not leak argv: {dump}"
+        );
+        assert_eq!(
+            report.inject_verification,
+            InjectVerification::CaptureMissingToken
+        );
+        assert!(!inject_submit_verified(&report));
+        assert!(!pane_readback_verified(&report));
+    }
 }

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

@@ -7,6 +7,11 @@ use crate::codex_app_server::AppServerBinding;
 use crate::model::pane_authority_refusal::PaneWorkspaceMismatchFacts;
 use crate::transport::{PaneInfo, Transport};
 
+/// Scope authority written by a fresh quick-start caller binding. It is distinct
+/// from an operator-initiated explicit claim, but uses the same pane-instance
+/// nonce and exact workspace checks at delivery.
+pub(crate) const FRESH_CALLER_SCOPE_AUTHORITY: &str = "fresh_caller";
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum LiveLeaderChannel {
     DirectTmux(DirectTmuxLeaderChannel),
@@ -117,7 +122,7 @@ pub fn resolve_live_leader_channel(
     };
     if let Some(observed_pane_workspace) = observed.current_path.clone() {
         if !path_is_in_workspace(&observed_pane_workspace, workspace)
-            && !explicit_claim_authority_matches(workspace, receiver, &observed)
+            && !scoped_authority_matches(workspace, receiver, &observed)
         {
             return LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch(
                 PaneWorkspaceMismatchFacts {
@@ -138,12 +143,16 @@ pub fn resolve_live_leader_channel(
     }))
 }
 
-fn explicit_claim_authority_matches(
+fn scoped_authority_matches(
     workspace: &Path,
     receiver: &Value,
     observed: &PaneInfo,
 ) -> bool {
-    if string_field(receiver, "scope_authority") != Some("explicit_claim") {
+    let authority = string_field(receiver, "scope_authority");
+    if !matches!(
+        authority,
+        Some("explicit_claim") | Some(FRESH_CALLER_SCOPE_AUTHORITY)
+    ) {
         return false;
     }
     let Some(authorized_workspace) = string_field(receiver, "authorized_team_workspace") else {

package/crates/team-agent/src/state/persist.rs

@@ -364,6 +364,78 @@ fn save_runtime_state_with_merge_options(
     topology_update_agent_ids: &[&str],
     receiver_update_team_key: Option<&str>,
     exact_owner_seed_to_clear: Option<&Value>,
+) -> Result<(), StateError> {
+    persist_runtime_state_with_merge_options_and_expected(
+        workspace,
+        state,
+        deleted_agent_ids,
+        skip_capture_backfill_team_key,
+        skip_capture_backfill_agent_ids,
+        topology_update_team_key,
+        topology_update_agent_ids,
+        receiver_update_team_key,
+        exact_owner_seed_to_clear,
+        None,
+        None,
+    )
+}
+
+pub(crate) fn save_runtime_state_with_receiver_authority_and_expected(
+    workspace: &Path,
+    state: &Value,
+    receiver_team_key: &str,
+    expected_owner: &Value,
+    expected_receiver: &Value,
+) -> Result<(), StateError> {
+    persist_runtime_state_with_merge_options_and_expected(
+        workspace,
+        state,
+        &[],
+        None,
+        &[],
+        None,
+        &[],
+        Some(receiver_team_key),
+        None,
+        Some((expected_owner, expected_receiver)),
+        None,
+    )
+}
+
+pub(crate) fn save_runtime_state_with_exact_owner_receiver_cleanup(
+    workspace: &Path,
+    state: &Value,
+    team_key: &str,
+    expected_owner: &Value,
+    expected_receiver: &Value,
+) -> Result<(), StateError> {
+    persist_runtime_state_with_merge_options_and_expected(
+        workspace,
+        state,
+        &[],
+        None,
+        &[],
+        None,
+        &[],
+        Some(team_key),
+        None,
+        None,
+        Some((team_key, expected_owner, expected_receiver)),
+    )
+}
+
+fn persist_runtime_state_with_merge_options_and_expected(
+    workspace: &Path,
+    state: &Value,
+    deleted_agent_ids: &[&str],
+    skip_capture_backfill_team_key: Option<&str>,
+    skip_capture_backfill_agent_ids: &[&str],
+    topology_update_team_key: Option<&str>,
+    topology_update_agent_ids: &[&str],
+    receiver_update_team_key: Option<&str>,
+    exact_owner_seed_to_clear: Option<&Value>,
+    expected_owner_receiver: Option<(&Value, &Value)>,
+    exact_owner_receiver_to_clear: Option<(&str, &Value, &Value)>,
 ) -> Result<(), StateError> {
     let path = runtime_state_path(workspace);
     // Python `state.py:497`:先对入参 state 跑 `_migrate_state_identity`(就地填缺失 leader uuid)。
@@ -385,7 +457,9 @@ fn save_runtime_state_with_merge_options(
     // Exact-seed cleanup must observe lock-held disk, not a pre-lock cache or
     // byte-equality hit. A matching in-memory document would otherwise no-op
     // and leave the seed, or skip copying a concurrent owner.
-    let skip_pre_lock_fast_path = exact_owner_seed_to_clear.is_some();
+    let skip_pre_lock_fast_path = exact_owner_seed_to_clear.is_some()
+        || expected_owner_receiver.is_some()
+        || exact_owner_receiver_to_clear.is_some();
     if !skip_pre_lock_fast_path && cache_equals(&path, &migrated) {
         return Ok(());
     }
@@ -418,7 +492,21 @@ fn save_runtime_state_with_merge_options(
     if let Some(parent) = path.parent() {
         std::fs::create_dir_all(parent)?;
     }
-    if let Some(latest) = read_latest_state_under_lock(workspace, &path) {
+    let latest = read_latest_state_under_lock(workspace, &path);
+    if let Some((expected_owner, expected_receiver)) = expected_owner_receiver {
+        let expected_matches = latest.as_ref().is_some_and(|latest| {
+            latest_team_owner_receiver(latest, receiver_update_team_key)
+                .is_some_and(|(owner, receiver)| {
+                    owner == expected_owner && receiver == expected_receiver
+                })
+        });
+        if !expected_matches {
+            return Err(StateError::SaveConflict(
+                "fresh caller owner/receiver changed before commit".to_string(),
+            ));
+        }
+    }
+    if let Some(latest) = latest {
         let deleted = deleted_agent_ids
             .iter()
             .copied()
@@ -455,6 +543,7 @@ fn save_runtime_state_with_merge_options(
             &topology_updates,
             &receiver_updates,
             receiver_update_team_key.zip(exact_owner_seed_to_clear),
+            exact_owner_receiver_to_clear,
         )?;
     }
     // Stage 3 save-output strip second pass (defence-in-depth): after the
@@ -523,6 +612,7 @@ fn apply_persist_merge_contract(
     topology_updates: &BTreeSet<(String, String)>,
     receiver_updates: &BTreeSet<String>,
     exact_owner_seed_to_clear: Option<(&str, &Value)>,
+    exact_owner_receiver_to_clear: Option<(&str, &Value, &Value)>,
 ) -> Result<(), StateError> {
     // A0/R1: the projection gate only guards the TOP-LEVEL passes (top-level agents and
     // the top-level<->active-team cross projections depend on which team is active); the
@@ -645,6 +735,16 @@ fn apply_persist_merge_contract(
                     apply_lock_held_exact_owner_cleanup(incoming_entry, latest_entry, seed);
                 }
             }
+            if let Some((clear_team, seed, expected_receiver)) = exact_owner_receiver_to_clear {
+                if team == clear_team {
+                    apply_lock_held_exact_owner_receiver_cleanup(
+                        incoming_entry,
+                        latest_entry,
+                        seed,
+                        Some(expected_receiver),
+                    );
+                }
+            }
             preserve_latest_endpoint_convergence_fields(incoming_entry, latest_entry);
         }
     }
@@ -776,14 +876,26 @@ fn preserve_latest_ownership_fields(
 }
 
 fn apply_lock_held_exact_owner_cleanup(incoming: &mut Value, latest: &Value, seed: &Value) {
-    // Compare the lock-held disk owner to the attempt-local seed. Equal-epoch
-    // concurrent owners must survive; only the exact seed is cleared, and the
-    // epoch is not bumped so a same-epoch takeover cannot be overwritten.
+    apply_lock_held_exact_owner_receiver_cleanup(incoming, latest, seed, None);
+}
+
+fn apply_lock_held_exact_owner_receiver_cleanup(
+    incoming: &mut Value,
+    latest: &Value,
+    seed: &Value,
+    expected_receiver: Option<&Value>,
+) {
+    // Compare the lock-held disk owner and, when supplied, receiver to the
+    // attempt-local grant. A same-owner receiver update is a concurrent
+    // winner and must survive cleanup just like a different owner/epoch.
     let latest_owner = latest.get("team_owner");
+    let receiver_matches = expected_receiver.is_none_or(|expected| {
+        latest.get("leader_receiver") == Some(expected)
+    });
     let Some(incoming_obj) = incoming.as_object_mut() else {
         return;
     };
-    if latest_owner == Some(seed) {
+    if latest_owner == Some(seed) && receiver_matches {
         incoming_obj.insert("team_owner".to_string(), Value::Null);
         incoming_obj.insert("leader_receiver".to_string(), Value::Null);
         if let Some(epoch) = latest
@@ -873,6 +985,21 @@ fn latest_has_preferable_ownership(
         && (ownership_attached(latest) || !ownership_attached(incoming))
 }
 
+fn latest_team_owner_receiver<'a>(
+    latest: &'a Value,
+    team_key: Option<&str>,
+) -> Option<(&'a Value, &'a Value)> {
+    let entry = if let Some(team_key) = team_key {
+        latest
+            .get("teams")
+            .and_then(Value::as_object)
+            .and_then(|teams| teams.get(team_key))?
+    } else {
+        latest
+    };
+    Some((entry.get("team_owner")?, entry.get("leader_receiver")?))
+}
+
 fn ownership_epoch(state: &Value) -> u64 {
     state
         .get("owner_epoch")
@@ -2985,6 +3112,7 @@ mod tests {
             &BTreeSet::new(),
             &BTreeSet::new(),
             None,
+            None,
         )
         .unwrap();
 
@@ -3020,6 +3148,7 @@ mod tests {
             &BTreeSet::new(),
             &receiver_updates,
             None,
+            None,
         )
         .unwrap();
 
@@ -3219,6 +3348,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn lock_held_exact_seed_receiver_cleanup_preserves_same_owner_receiver_update() {
+        let ws = temp_ws();
+        save_runtime_state(
+            &ws,
+            &team_state_with_binding(&ws, seed_owner(1), seed_receiver(1), 1),
+        )
+        .unwrap();
+        let seed = persisted_fresh_owner(&ws);
+        let seeded_receiver = load_runtime_state(&ws).unwrap()["teams"]["fresh"]
+            ["leader_receiver"]
+            .clone();
+        let mut winner = team_state_with_binding(&ws, seed_owner(1), takeover_receiver(1), 1);
+        winner["teams"]["fresh"]["team_owner"] = seed.clone();
+        save_runtime_state_with_receiver_authority(&ws, &winner, "fresh", None).unwrap();
+        save_runtime_state_with_exact_owner_receiver_cleanup(
+            &ws,
+            &tombstone_incoming(&ws, 1),
+            "fresh",
+            &seed,
+            &seeded_receiver,
+        )
+        .unwrap();
+        assert_fresh_binding(
+            &load_runtime_state(&ws).unwrap(),
+            &seed,
+            &takeover_receiver(1),
+            1,
+        );
+    }
+
     #[test]
     fn lock_held_exact_seed_cleanup_preserves_epoch2_takeover_binding() {
         let ws = temp_ws();

package/crates/team-agent/src/state/repository.rs

@@ -48,6 +48,10 @@ use super::persist::{
     save_runtime_state_with_lifecycle_topology_authority as helper_write_root_with_lifecycle_topology_authority,
     save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip as helper_write_root_with_lifecycle_topology_authority_and_capture_backfill_skip,
     save_runtime_state_with_receiver_authority as helper_write_root_with_receiver_authority,
+    save_runtime_state_with_receiver_authority_and_expected
+        as helper_write_root_with_receiver_authority_and_expected,
+    save_runtime_state_with_exact_owner_receiver_cleanup
+        as helper_write_root_with_exact_owner_receiver_cleanup,
     save_runtime_state_with_team_tombstone_lifecycle_topology_authority as helper_write_root_with_team_tombstone_lifecycle_topology_authority,
     save_runtime_state_with_team_tombstoned_agents as helper_write_root_with_team_tombstoned_agents,
     save_runtime_state_without_migrations as helper_write_root_without_migrations,
@@ -206,10 +210,20 @@ pub enum StateWriteIntent<'a> {
     ClaimLeader {
         team_key: &'a str,
     },
+    ClaimLeaderFreshCaller {
+        team_key: &'a str,
+        expected_owner: &'a Value,
+        expected_receiver: &'a Value,
+    },
     ClearExactTeamOwner {
         team_key: &'a str,
         seed: &'a Value,
     },
+    ClearExactTeamOwnerAndReceiver {
+        team_key: &'a str,
+        seed: &'a Value,
+        expected_receiver: &'a Value,
+    },
     LeaderBindingRestoreNonTargetTeams {
         target_team_key: &'a str,
     },
@@ -389,9 +403,31 @@ fn route_direct(
         StateWriteIntent::ClaimLeader { team_key } => {
             helper_write_root_with_receiver_authority(workspace, state, team_key, None)
         }
+        StateWriteIntent::ClaimLeaderFreshCaller {
+            team_key,
+            expected_owner,
+            expected_receiver,
+        } => helper_write_root_with_receiver_authority_and_expected(
+            workspace,
+            state,
+            team_key,
+            expected_owner,
+            expected_receiver,
+        ),
         StateWriteIntent::ClearExactTeamOwner { team_key, seed } => {
             helper_write_root_with_receiver_authority(workspace, state, team_key, Some(seed))
         }
+        StateWriteIntent::ClearExactTeamOwnerAndReceiver {
+            team_key,
+            seed,
+            expected_receiver,
+        } => helper_write_root_with_exact_owner_receiver_cleanup(
+            workspace,
+            state,
+            team_key,
+            seed,
+            expected_receiver,
+        ),
         StateWriteIntent::LeaderBindingRestoreNonTargetTeams { .. } => {
             helper_write_root_without_migrations(workspace, state)
         }