@team-agent/installer 0.5.77 → 0.5.78

package/crates/team-agent/src/mcp_server/wire.rs

@@ -185,7 +185,7 @@ fn run_stdio_loop<R: BufRead, W: Write>(
     let mut report = ServerRunReport::default();
     let marker = McpServerLifecycleMarker::from_env(workspace);
     marker.write_started();
-    let result = run_stdio_loop_inner(&tools, reader, &mut writer, &mut report);
+    let result = run_stdio_loop_inner(&tools, reader, &mut writer, &mut report, &marker);
     match &result {
         Ok(_) => marker.write_exit("stdin_eof", None),
         Err(error) => marker.write_exit("fatal_error", Some(&error.to_string())),
@@ -198,16 +198,20 @@ fn run_stdio_loop_inner<R: BufRead, W: Write>(
     reader: R,
     writer: &mut W,
     report: &mut ServerRunReport,
+    marker: &McpServerLifecycleMarker,
 ) -> Result<ServerRunReport, McpError> {
     for line in reader.lines() {
         let line = line?;
         report.requests_read = report.requests_read.saturating_add(1);
-        let frame = handle_stdin_line(tools, &line, report)?;
+        let (frame, tools_list_success) = handle_stdin_line(tools, &line, report)?;
         if let Some(value) = frame {
             let value = crate::redaction::redact_external_value(&value);
             serde_json::to_writer(&mut *writer, &value)?;
             writer.write_all(b"\n")?;
             writer.flush()?;
+            if tools_list_success {
+                marker.write_tools_list_response_written();
+            }
             report.responses_written = report.responses_written.saturating_add(1);
         }
     }
@@ -219,29 +223,34 @@ fn handle_stdin_line(
     tools: &TeamOrchestratorTools,
     line: &str,
     report: &mut ServerRunReport,
-) -> Result<Option<Value>, McpError> {
+) -> Result<(Option<Value>, bool), McpError> {
     let request: Value = match serde_json::from_str(line) {
         Ok(value) => value,
         Err(err) => {
             report.error_frames = report.error_frames.saturating_add(1);
-            return Ok(Some(error_response_value(
-                RpcId::Null,
-                -32700,
-                format!("parse error: {err}"),
-            )));
+            return Ok((
+                Some(error_response_value(
+                    RpcId::Null,
+                    -32700,
+                    format!("parse error: {err}"),
+                )),
+                false,
+            ));
         }
     };
     if request.get("jsonrpc").and_then(Value::as_str) == Some("2.0") {
+        let is_tools_list = request.get("method").and_then(Value::as_str) == Some("tools/list");
         match handle_mcp(tools, &request)? {
             Some(response) => {
+                let tools_list_success = is_tools_list && response.error.is_none();
                 if response.error.is_some() {
                     report.error_frames = report.error_frames.saturating_add(1);
                 }
-                Ok(Some(serde_json::to_value(response)?))
+                Ok((Some(serde_json::to_value(response)?), tools_list_success))
             }
             None => {
                 report.notifications_skipped = report.notifications_skipped.saturating_add(1);
-                Ok(None)
+                Ok((None, false))
             }
         }
     } else {
@@ -252,7 +261,7 @@ fn handle_stdin_line(
                 err.to_envelope()
             }
         };
-        Ok(Some(value))
+        Ok((Some(value), false))
     }
 }
 
@@ -301,6 +310,23 @@ impl McpServerLifecycleMarker {
         self.write("mcp.server_started", None, None);
     }
 
+    fn write_tools_list_response_written(&self) {
+        let _ = EventLog::new(&self.workspace).write(
+            "mcp.tools_list_response_written",
+            serde_json::json!({
+                "method": "tools/list",
+                "success": true,
+                "agent_id": self.agent_id.as_deref(),
+                "owner_team_id": self.owner_team_id.as_deref(),
+                "workspace": self.workspace.display().to_string(),
+                "pid": self.pid,
+                "ppid": self.ppid,
+                "spawn_epoch": null,
+                "spawn_epoch_source": "unavailable",
+            }),
+        );
+    }
+
     fn write_exit(&self, reason: &str, error: Option<&str>) {
         self.write("mcp.server_exit", Some(reason), error);
     }
@@ -798,6 +824,109 @@ mod e23_lifecycle_marker_tests {
         path
     }
 
+    #[test]
+    fn stdio_loop_logs_tools_list_after_flush_once_per_response() {
+        let ws = marker_ws("tools-list-success");
+        let input = std::io::Cursor::new(
+            br#"{"jsonrpc":"2.0","id":1,"method":"tools/list"}
+{"jsonrpc":"2.0","id":2,"method":"tools/list"}
+"#.to_vec(),
+        );
+        let mut output = Vec::new();
+
+        let report = run_stdio_loop(&ws, input, &mut output).unwrap();
+
+        assert_eq!(report.responses_written, 2);
+        assert_eq!(output.iter().filter(|byte| **byte == b'\n').count(), 2);
+        let events = EventLog::new(&ws).tail(0).unwrap();
+        let tool_events: Vec<_> = events
+            .iter()
+            .filter(|event| event["event"] == serde_json::json!("mcp.tools_list_response_written"))
+            .collect();
+        assert_eq!(tool_events.len(), 2, "one event per successful tools/list response");
+        for event in tool_events {
+            assert_eq!(event["method"], serde_json::json!("tools/list"));
+            assert_eq!(event["success"], serde_json::json!(true));
+            assert_eq!(event["workspace"], serde_json::json!(ws.display().to_string()));
+            assert_eq!(event["pid"], serde_json::json!(std::process::id()));
+            assert_eq!(event["spawn_epoch"], serde_json::Value::Null);
+        }
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn stdio_loop_does_not_log_tools_list_when_write_fails() {
+        struct FailingWriter;
+        impl Write for FailingWriter {
+            fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
+                Err(std::io::Error::other("simulated stdout write failure"))
+            }
+
+            fn flush(&mut self) -> std::io::Result<()> {
+                Ok(())
+            }
+        }
+
+        let ws = marker_ws("tools-list-write-fail");
+        let input = std::io::Cursor::new(
+            br#"{"jsonrpc":"2.0","id":1,"method":"tools/list"}"#.to_vec(),
+        );
+        let error = run_stdio_loop(&ws, input, FailingWriter).expect_err("write must fail");
+        assert!(error.to_string().contains("simulated stdout write failure"));
+        let events = EventLog::new(&ws).tail(0).unwrap();
+        assert!(!events
+            .iter()
+            .any(|event| event["event"] == serde_json::json!("mcp.tools_list_response_written")));
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn stdio_loop_does_not_log_tools_list_when_flush_fails() {
+        struct FlushFailWriter(Vec<u8>);
+        impl Write for FlushFailWriter {
+            fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+                self.0.extend_from_slice(buf);
+                Ok(buf.len())
+            }
+
+            fn flush(&mut self) -> std::io::Result<()> {
+                Err(std::io::Error::other("simulated stdout flush failure"))
+            }
+        }
+
+        let ws = marker_ws("tools-list-flush-fail");
+        let input = std::io::Cursor::new(
+            br#"{"jsonrpc":"2.0","id":1,"method":"tools/list"}"#.to_vec(),
+        );
+        let error = run_stdio_loop(&ws, input, FlushFailWriter(Vec::new()))
+            .expect_err("flush must fail");
+        assert!(error.to_string().contains("simulated stdout flush failure"));
+        let events = EventLog::new(&ws).tail(0).unwrap();
+        assert!(!events
+            .iter()
+            .any(|event| event["event"] == serde_json::json!("mcp.tools_list_response_written")));
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn stdio_loop_does_not_log_tools_list_for_initialize_or_notification() {
+        let ws = marker_ws("tools-list-not-applicable");
+        let input = std::io::Cursor::new(
+            br#"{"jsonrpc":"2.0","id":1,"method":"initialize"}
+{"jsonrpc":"2.0","method":"notifications/initialized"}
+"#.to_vec(),
+        );
+        let mut output = Vec::new();
+
+        run_stdio_loop(&ws, input, &mut output).unwrap();
+
+        let events = EventLog::new(&ws).tail(0).unwrap();
+        assert!(!events
+            .iter()
+            .any(|event| event["event"] == serde_json::json!("mcp.tools_list_response_written")));
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn stdio_loop_writes_started_and_stdin_eof_exit_markers() {
         let ws = marker_ws("eof");

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

@@ -31,9 +31,10 @@ use crate::provider::wire::{
     is_claude_family, parse_canonical_provider, parse_provider, provider_wire,
 };
 use crate::transport::{
-    submit_verification_wire, turn_verification_wire, CaptureRange, CaptureSampleOutcome,
-    InjectPayload, InjectReport, InjectVerification, InputSurfaceProbe, Key, PaneId, PaneInfo,
-    QueryOutcome, SessionName, SubmitObserver, SubmitVerification, Target, Transport, WindowName,
+    submit_verification_wire, turn_verification_wire, BusySignalKind, CaptureRange,
+    CaptureSampleOutcome, InjectPayload, InjectReport, InjectVerification, InputSurfaceProbe, Key,
+    PaneId, PaneInfo, QueryOutcome, SessionName, SubmitConsumptionReason, SubmitObserver,
+    SubmitVerification, Target, Transport, WindowName,
 };
 
 use super::helpers::{message_exists, MessageStatusShadow};
@@ -572,11 +573,11 @@ pub fn deliver_pending_message(
         canonical_owner_team_id.as_deref(),
         resolved.metadata.as_ref(),
     );
-    let recipient_single_enter = recipient_requires_single_enter(state, &message.recipient);
+    let recipient_cursor = recipient_is_cursor_agent(state, &message.recipient);
     let inject_attempt = crate::tmux_backend::with_paste_to_submit_floor(
         paste_to_submit_floor_for_recipient(state, &message.recipient),
         || {
-            crate::tmux_backend::with_cursor_single_enter(recipient_single_enter, || {
+            crate::tmux_backend::with_cursor_single_enter(recipient_cursor, || {
                 transport.inject_with_submit_observer(
                     &target,
                     &payload,
@@ -592,9 +593,7 @@ pub fn deliver_pending_message(
             // grok 忙时第一次回车只入显式队列。默认 send-now：只重按回车顶出去。
             // 无 `Enter:send now` 时零次额外按键，claude/codex 行为不变。
             // cursor：第二下 Enter 打断进行中回合，不走 flush。
-            if !crate::provider::submit_now::keep_provider_queue_requested()
-                && recipient_allows_explicit_queue_flush(state, &message.recipient)
-            {
+            if !crate::provider::submit_now::keep_provider_queue_requested() && !recipient_cursor {
                 match crate::provider::submit_now::flush_explicit_queue(transport, &target) {
                     Ok(flush) if flush.extra_enters > 0 => {
                         let _ = event_log.write(
@@ -1999,6 +1998,36 @@ fn merge_inject_readback_fields(
             .map(|d| d.last_capture_outcome.as_str())
             .unwrap_or(CaptureSampleOutcome::NotAttempted.as_str())),
     );
+    obj.insert(
+        "consumption_reason".to_string(),
+        serde_json::json!(diag
+            .map(|d| d.consumption_reason.as_str())
+            .unwrap_or("unknown")),
+    );
+    obj.insert(
+        "before_busy_signal_kind".to_string(),
+        serde_json::json!(diag.and_then(|d| d.before_busy_signal_kind.map(|kind| kind.as_str()))),
+    );
+    obj.insert(
+        "busy_signal_kind".to_string(),
+        serde_json::json!(diag.and_then(|d| d.busy_signal_kind.map(|kind| kind.as_str()))),
+    );
+    obj.insert(
+        "busy_line_from_bottom".to_string(),
+        serde_json::json!(diag.and_then(|d| d.busy_line_from_bottom)),
+    );
+    obj.insert(
+        "current_marker_in_bottom_15".to_string(),
+        serde_json::json!(diag.and_then(|d| d.current_marker_in_bottom_15)),
+    );
+    obj.insert(
+        "paste_identity_in_composer".to_string(),
+        serde_json::json!(diag.and_then(|d| d.paste_identity_in_composer)),
+    );
+    obj.insert(
+        "consumption_from_capture_result".to_string(),
+        serde_json::json!(diag.and_then(|d| d.consumption_from_capture_result)),
+    );
     obj.insert(
         "pane_command_basename".to_string(),
         diag.and_then(|d| d.pane_command_basename.as_deref())
@@ -2357,6 +2386,13 @@ fn recipient_provider(state: &serde_json::Value, recipient: &str) -> Option<Prov
         .and_then(parse_canonical_provider)
 }
 
+fn recipient_is_cursor_agent(state: &serde_json::Value, recipient: &str) -> bool {
+    matches!(
+        recipient_provider(state, recipient),
+        Some(Provider::CursorAgent)
+    )
+}
+
 /// ---
 /// purpose: paste→Enter 地板按收件人 provider 选择
 /// contract: CursorAgent 与 Grok 为 1s；其余（含 claude）为 ZERO
@@ -3391,6 +3427,13 @@ mod paste_floor_tests {
             turn_verification: crate::transport::TurnVerification::NotYetObserved,
             attempts: 1,
             submit_diagnostics: Some(crate::transport::SubmitDiagnostics {
+                consumption_reason: SubmitConsumptionReason::Unverified,
+                before_busy_signal_kind: Some(BusySignalKind::Working),
+                busy_signal_kind: Some(BusySignalKind::SpinnerGlyph),
+                busy_line_from_bottom: Some(2),
+                current_marker_in_bottom_15: Some(false),
+                paste_identity_in_composer: None,
+                consumption_from_capture_result: Some(false),
                 last_capture_outcome: CaptureSampleOutcome::Failed,
                 capture_err_count: 1,
                 capture_sample_count: 1,
@@ -3419,6 +3462,22 @@ mod paste_floor_tests {
             None,
         );
         assert_eq!(event["last_capture_outcome"], serde_json::json!("failed"));
+        assert_eq!(event["consumption_reason"], serde_json::json!("unverified"));
+        assert_eq!(
+            event["before_busy_signal_kind"],
+            serde_json::json!("working")
+        );
+        assert_eq!(event["busy_signal_kind"], serde_json::json!("spinner_glyph"));
+        assert_eq!(event["busy_line_from_bottom"], serde_json::json!(2));
+        assert_eq!(
+            event["current_marker_in_bottom_15"],
+            serde_json::json!(false)
+        );
+        assert_eq!(event["paste_identity_in_composer"], serde_json::Value::Null);
+        assert_eq!(
+            event["consumption_from_capture_result"],
+            serde_json::json!(false)
+        );
         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"));

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

@@ -229,3 +229,59 @@ fn string_field<'a>(value: &'a Value, key: &str) -> Option<&'a str> {
         .and_then(Value::as_str)
         .filter(|value| !value.is_empty())
 }
+
+#[cfg(test)]
+mod claim_rework_live_tests {
+    use super::*;
+    use crate::transport::test_support::OfflineTransport;
+    use crate::transport::{PaneId, PaneInfo, SessionName};
+    use serde_json::json;
+    use std::path::PathBuf;
+
+    #[test]
+    fn pending_receiver_is_not_a_live_channel() {
+        let workspace = PathBuf::from("/tmp/claim-rework-a3-pending");
+        let receiver = json!({
+            "mode": "direct_tmux",
+            "status": "pending",
+            "pane_id": "%1",
+            "tmux_socket": "/tmp/ta-offline.sock"
+        });
+        let transport = OfflineTransport::default().with_tmux_endpoint("/tmp/ta-offline.sock");
+        match resolve_live_leader_channel(&workspace, &receiver, &transport) {
+            LeaderChannelResolution::Unbound(LeaderChannelUnbound::ReceiverNotAttached) => {}
+            other => panic!("pending seed must not be live; got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn dead_pane_with_matching_endpoint_is_pane_not_live() {
+        let workspace = PathBuf::from("/tmp/claim-rework-a3-dead");
+        let endpoint = "/tmp/ta-claim-rework-a3.sock";
+        let receiver = json!({
+            "mode": "direct_tmux",
+            "status": "attached",
+            "pane_id": "%missing",
+            "tmux_socket": endpoint
+        });
+        let transport = OfflineTransport::default()
+            .with_tmux_endpoint(endpoint)
+            .with_targets(vec![PaneInfo {
+                pane_id: PaneId::new("%other"),
+                session: SessionName::new("team"),
+                window_index: None,
+                window_name: None,
+                pane_index: None,
+                tty: None,
+                current_command: None,
+                current_path: None,
+                active: true,
+                pane_pid: None,
+                leader_env: Default::default(),
+            }]);
+        match resolve_live_leader_channel(&workspace, &receiver, &transport) {
+            LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneNotLive) => {}
+            other => panic!("matching endpoint + missing pane must be PaneNotLive; got {other:?}"),
+        }
+    }
+}

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

@@ -3376,10 +3376,18 @@ fn gate054_status_surfaces_pending_leader_notifications() {
         entry.get("channel").and_then(serde_json::Value::as_str),
         Some("rebind_required")
     );
-    assert!(entry
+    let action = entry
         .get("action")
         .and_then(serde_json::Value::as_str)
-        .is_some_and(|action| action.contains("attach-leader") || action.contains("takeover")));
+        .unwrap_or("");
+    assert!(
+        action.contains("historical leader mailbox debt"),
+        "historical debt action must stay debt-scoped; action={action}"
+    );
+    assert!(
+        !action.contains("attach-leader") && !action.contains("takeover") && !action.contains("claim-leader"),
+        "historical debt must not authorize bind commands; action={action}"
+    );
 }
 
 #[test]

package/crates/team-agent/src/provider/adapters/cursor_agent.rs

@@ -15,10 +15,8 @@
 //! `.team/scripts/cursor_seat.sh` 实测一致：
 //!   `--trust --sandbox disabled --workspace <物理路径> [--force] [--model]`
 //! Role 不入 argv，写 `<workspace>/.cursor/rules/*.mdc` + `alwaysApply: true`。
-//! MCP 无 `--mcp-config`；身份必须写进 per-seat
-//! `provider-config/<id>/cursor/.cursor/mcp.json` 的 env 表
+//! MCP 无 `--mcp-config`；身份必须写进 `.cursor/mcp.json` 的 env 表
 //! （cursor 不把父进程 TEAM_AGENT_* 传给 MCP 子进程）。
-//! spawn 把 `--workspace` 指到该工程根，并用 `--add-dir` 挂上真 workspace。
 //!
 //! 隐藏 flag `--system-prompt` / `--allowed-tools` 实测存在但 help 未列，
 //! 随时可能消失。可以在注释里记录，代码里不许调。
@@ -75,8 +73,7 @@ pub(crate) fn cursor_agent_base_command(
     let _ = effort;
     // system_prompt 不入 argv（help 无 --rules / --append-system-prompt）。
     // launch 写 `<workspace>/.cursor/rules/team-agent-role-<agent_id>.mdc`。
-    // mcp_config 也不入 argv（无 --mcp-config）。launch 写
-    // `.team/runtime/provider-config/<id>/cursor/.cursor/mcp.json`
+    // mcp_config 也不入 argv（无 --mcp-config）。launch 写 `.cursor/mcp.json`
     // 并 `agent mcp enable team_orchestrator`。这里收下以免静默丢弃。
     let _ = (adapter, auth_mode, mcp_config, managed_mcp_config, system_prompt);
     argv.push("--workspace".to_string());

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

@@ -377,6 +377,7 @@ fn save_runtime_state_with_merge_options(
         exact_owner_seed_to_clear,
         None,
         None,
+        None,
     )
 }
 
@@ -399,6 +400,7 @@ pub(crate) fn save_runtime_state_with_receiver_authority_and_expected(
         None,
         Some((expected_owner, expected_receiver)),
         None,
+        None,
     )
 }
 
@@ -421,6 +423,38 @@ pub(crate) fn save_runtime_state_with_exact_owner_receiver_cleanup(
         None,
         None,
         Some((team_key, expected_owner, expected_receiver)),
+        None,
+    )
+}
+
+pub(crate) fn save_runtime_state_with_exact_owner_receiver_restore(
+    workspace: &Path,
+    state: &Value,
+    team_key: &str,
+    expected_owner: &Value,
+    expected_receiver: &Value,
+    previous_owner: &Value,
+    previous_receiver: &Value,
+) -> Result<(), StateError> {
+    persist_runtime_state_with_merge_options_and_expected(
+        workspace,
+        state,
+        &[],
+        None,
+        &[],
+        None,
+        &[],
+        Some(team_key),
+        None,
+        None,
+        None,
+        Some((
+            team_key,
+            expected_owner,
+            expected_receiver,
+            previous_owner,
+            previous_receiver,
+        )),
     )
 }
 
@@ -436,6 +470,7 @@ fn persist_runtime_state_with_merge_options_and_expected(
     exact_owner_seed_to_clear: Option<&Value>,
     expected_owner_receiver: Option<(&Value, &Value)>,
     exact_owner_receiver_to_clear: Option<(&str, &Value, &Value)>,
+    exact_owner_receiver_to_restore: Option<(&str, &Value, &Value, &Value, &Value)>,
 ) -> Result<(), StateError> {
     let path = runtime_state_path(workspace);
     // Python `state.py:497`:先对入参 state 跑 `_migrate_state_identity`(就地填缺失 leader uuid)。
@@ -459,7 +494,8 @@ fn persist_runtime_state_with_merge_options_and_expected(
     // and leave the seed, or skip copying a concurrent owner.
     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();
+        || exact_owner_receiver_to_clear.is_some()
+        || exact_owner_receiver_to_restore.is_some();
     if !skip_pre_lock_fast_path && cache_equals(&path, &migrated) {
         return Ok(());
     }
@@ -544,6 +580,7 @@ fn persist_runtime_state_with_merge_options_and_expected(
             &receiver_updates,
             receiver_update_team_key.zip(exact_owner_seed_to_clear),
             exact_owner_receiver_to_clear,
+            exact_owner_receiver_to_restore,
         )?;
     }
     // Stage 3 save-output strip second pass (defence-in-depth): after the
@@ -613,6 +650,7 @@ fn apply_persist_merge_contract(
     receiver_updates: &BTreeSet<String>,
     exact_owner_seed_to_clear: Option<(&str, &Value)>,
     exact_owner_receiver_to_clear: Option<(&str, &Value, &Value)>,
+    exact_owner_receiver_to_restore: Option<(&str, &Value, &Value, &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
@@ -745,6 +783,25 @@ fn apply_persist_merge_contract(
                     );
                 }
             }
+            if let Some((
+                restore_team,
+                expected_owner,
+                expected_receiver,
+                previous_owner,
+                previous_receiver,
+            )) = exact_owner_receiver_to_restore
+            {
+                if team == restore_team {
+                    apply_lock_held_exact_owner_receiver_restore(
+                        incoming_entry,
+                        latest_entry,
+                        expected_owner,
+                        expected_receiver,
+                        previous_owner,
+                        previous_receiver,
+                    );
+                }
+            }
             preserve_latest_endpoint_convergence_fields(incoming_entry, latest_entry);
         }
     }
@@ -919,6 +976,43 @@ fn apply_lock_held_exact_owner_receiver_cleanup(
     }
 }
 
+fn apply_lock_held_exact_owner_receiver_restore(
+    incoming: &mut Value,
+    latest: &Value,
+    expected_owner: &Value,
+    expected_receiver: &Value,
+    previous_owner: &Value,
+    previous_receiver: &Value,
+) {
+    let latest_owner = latest.get("team_owner");
+    let latest_receiver = latest.get("leader_receiver");
+    let Some(incoming_obj) = incoming.as_object_mut() else {
+        return;
+    };
+    if latest_owner == Some(expected_owner) && latest_receiver == Some(expected_receiver) {
+        incoming_obj.insert("team_owner".to_string(), previous_owner.clone());
+        incoming_obj.insert("leader_receiver".to_string(), previous_receiver.clone());
+        if let Some(epoch) = previous_owner
+            .get("owner_epoch")
+            .cloned()
+            .or_else(|| latest.get("owner_epoch").cloned())
+        {
+            incoming_obj.insert("owner_epoch".to_string(), epoch);
+        }
+        return;
+    }
+    for key in ["team_owner", "leader_receiver", "owner_epoch"] {
+        match latest.get(key) {
+            Some(value) => {
+                incoming_obj.insert(key.to_string(), value.clone());
+            }
+            None => {
+                incoming_obj.remove(key);
+            }
+        }
+    }
+}
+
 fn preserve_latest_endpoint_convergence_fields(incoming: &mut Value, latest: &Value) {
     if !latest_has_preferable_endpoint_convergence(incoming, latest) {
         return;
@@ -3113,6 +3207,7 @@ mod tests {
             &BTreeSet::new(),
             None,
             None,
+            None,
         )
         .unwrap();
 
@@ -3149,6 +3244,7 @@ mod tests {
             &receiver_updates,
             None,
             None,
+            None,
         )
         .unwrap();
 

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

@@ -52,6 +52,8 @@ use super::persist::{
         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_exact_owner_receiver_restore
+        as helper_write_root_with_exact_owner_receiver_restore,
     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,
@@ -224,9 +226,20 @@ pub enum StateWriteIntent<'a> {
         seed: &'a Value,
         expected_receiver: &'a Value,
     },
+    RestoreExactTeamOwnerAndReceiver {
+        team_key: &'a str,
+        expected_owner: &'a Value,
+        expected_receiver: &'a Value,
+        previous_owner: &'a Value,
+        previous_receiver: &'a Value,
+    },
     LeaderBindingRestoreNonTargetTeams {
         target_team_key: &'a str,
     },
+    /// Strip extra keys written by a failed or degraded quick-start bind attempt.
+    QuickStartBindingCleanup {
+        team_key: &'a str,
+    },
     LeaderStartBinding {
         team_key: &'a str,
         transport_kind: &'a str,
@@ -428,6 +441,22 @@ fn route_direct(
             seed,
             expected_receiver,
         ),
+        StateWriteIntent::RestoreExactTeamOwnerAndReceiver {
+            team_key,
+            expected_owner,
+            expected_receiver,
+            previous_owner,
+            previous_receiver,
+        } => helper_write_root_with_exact_owner_receiver_restore(
+            workspace,
+            state,
+            team_key,
+            expected_owner,
+            expected_receiver,
+            previous_owner,
+            previous_receiver,
+        ),
+        StateWriteIntent::QuickStartBindingCleanup { .. } => helper_write_root(workspace, state),
         StateWriteIntent::LeaderBindingRestoreNonTargetTeams { .. } => {
             helper_write_root_without_migrations(workspace, state)
         }