@team-agent/installer 0.5.42 → 0.5.44

package/crates/team-agent/src/provider/classify.rs

@@ -3,8 +3,8 @@
 
 use super::helpers::parse_jsonl_records;
 use super::types::{
-    ClassifyResult, ClassifySource, FactKind, FaultFact, NoPingReason, ProcessLiveness, ProviderError,
-    RemindResult, Signature, TurnId, TurnState,
+    ClassifyResult, ClassifySource, FactKind, FaultFact, NoPingReason, ProcessLiveness,
+    ProviderError, RemindResult, Signature, TurnId, TurnState,
 };
 use super::Provider;
 
@@ -116,14 +116,20 @@ fn collect_background_open_ids(value: &serde_json::Value, out: &mut Vec<String>)
     match value {
         serde_json::Value::String(s) => {
             for piece in s.split(MARKER).skip(1) {
-                let id: String = piece.chars().take_while(|c| !c.is_whitespace() && *c != '\n').collect();
+                let id: String = piece
+                    .chars()
+                    .take_while(|c| !c.is_whitespace() && *c != '\n')
+                    .collect();
                 if !id.is_empty() {
                     out.push(id);
                 }
             }
         }
         serde_json::Value::Object(map) => {
-            if let Some(id) = map.get("backgroundTaskId").and_then(serde_json::Value::as_str) {
+            if let Some(id) = map
+                .get("backgroundTaskId")
+                .and_then(serde_json::Value::as_str)
+            {
                 if !id.is_empty() {
                     out.push(id.to_string());
                 }
@@ -147,9 +153,15 @@ fn collect_background_close_ids(value: &serde_json::Value, out: &mut Vec<String>
     // Form B: <task-notification> wrapper in a string with a status tag.
     if let serde_json::Value::Object(map) = value {
         if let Some(bash) = map.get("bashOutput").and_then(serde_json::Value::as_object) {
-            let status = bash.get("status").and_then(serde_json::Value::as_str).unwrap_or("");
+            let status = bash
+                .get("status")
+                .and_then(serde_json::Value::as_str)
+                .unwrap_or("");
             if matches!(status, "completed" | "failed" | "killed") {
-                if let Some(id) = bash.get("backgroundTaskId").and_then(serde_json::Value::as_str) {
+                if let Some(id) = bash
+                    .get("backgroundTaskId")
+                    .and_then(serde_json::Value::as_str)
+                {
                     if !id.is_empty() {
                         out.push(id.to_string());
                     }
@@ -236,37 +248,90 @@ pub fn evaluate_takeover_reminder(
                 }
             }
             TurnState::Working => {
-                return Ok(remind(false, NoPingReason::Node(TurnState::Working), Vec::new(), None));
+                return Ok(remind(
+                    false,
+                    NoPingReason::Node(TurnState::Working),
+                    Vec::new(),
+                    None,
+                ));
             }
             TurnState::BlockedOnHuman => {
-                return Ok(remind(false, NoPingReason::Node(TurnState::BlockedOnHuman), Vec::new(), None));
+                return Ok(remind(
+                    false,
+                    NoPingReason::Node(TurnState::BlockedOnHuman),
+                    Vec::new(),
+                    None,
+                ));
             }
             TurnState::Abnormal => {
-                return Ok(remind(false, NoPingReason::Node(TurnState::Abnormal), Vec::new(), None));
+                return Ok(remind(
+                    false,
+                    NoPingReason::Node(TurnState::Abnormal),
+                    Vec::new(),
+                    None,
+                ));
             }
             TurnState::Unknown => {
-                return Ok(remind(false, NoPingReason::Node(TurnState::Unknown), Vec::new(), None));
+                return Ok(remind(
+                    false,
+                    NoPingReason::Node(TurnState::Unknown),
+                    Vec::new(),
+                    None,
+                ));
             }
         }
     }
 
     let Some(ms) = monitor_state else {
-        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+        return Ok(remind(
+            false,
+            NoPingReason::NotArmedNoWorkerTurn,
+            Vec::new(),
+            None,
+        ));
     };
-    if ms.get("opened_worker_turn_since_ack").and_then(serde_json::Value::as_bool) != Some(true) {
-        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+    if ms
+        .get("opened_worker_turn_since_ack")
+        .and_then(serde_json::Value::as_bool)
+        != Some(true)
+    {
+        return Ok(remind(
+            false,
+            NoPingReason::NotArmedNoWorkerTurn,
+            Vec::new(),
+            None,
+        ));
     }
     if ms.get("suppressed").and_then(serde_json::Value::as_bool) == Some(true) {
         return Ok(remind(false, NoPingReason::Acknowledged, Vec::new(), None));
     }
     let Some(all_idle_since) = ms.get("all_idle_since").and_then(serde_json::Value::as_f64) else {
-        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+        return Ok(remind(
+            false,
+            NoPingReason::NotArmedNoWorkerTurn,
+            Vec::new(),
+            None,
+        ));
     };
-    if ms.get("pinged_for_episode").and_then(serde_json::Value::as_f64) == Some(all_idle_since) {
-        return Ok(remind(false, NoPingReason::AlreadyPingedThisEpisode, Vec::new(), None));
+    if ms
+        .get("pinged_for_episode")
+        .and_then(serde_json::Value::as_f64)
+        == Some(all_idle_since)
+    {
+        return Ok(remind(
+            false,
+            NoPingReason::AlreadyPingedThisEpisode,
+            Vec::new(),
+            None,
+        ));
     }
     if now_monotonic - all_idle_since < debounce_seconds {
-        return Ok(remind(false, NoPingReason::DebounceActive, Vec::new(), None));
+        return Ok(remind(
+            false,
+            NoPingReason::DebounceActive,
+            Vec::new(),
+            None,
+        ));
     }
     Ok(remind(
         true,
@@ -301,7 +366,10 @@ fn classify_result(
     }
 }
 
-fn extract_lifecycle_facts(provider: Provider, records: &[serde_json::Value]) -> Vec<LifecycleFact> {
+fn extract_lifecycle_facts(
+    provider: Provider,
+    records: &[serde_json::Value],
+) -> Vec<LifecycleFact> {
     records
         .iter()
         .filter_map(|record| match provider {
@@ -328,7 +396,9 @@ fn codex_latest_explicit_error_fact(record: &serde_json::Value) -> Option<FaultF
     }
     Some(FaultFact::new(
         Signature::new("turn_failed"),
-        turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+        turn.get("id")
+            .and_then(serde_json::Value::as_str)
+            .map(TurnId::new),
         FactKind::Failed,
     ))
 }
@@ -431,29 +501,43 @@ fn claude_lifecycle_fact(record: &serde_json::Value) -> Option<LifecycleFact> {
         ));
     }
     if record_type == Some("assistant") {
-        let turn_id = record.get("requestId").and_then(serde_json::Value::as_str).map(TurnId::new);
+        let turn_id = record
+            .get("requestId")
+            .and_then(serde_json::Value::as_str)
+            .map(TurnId::new);
         let Some(stop_reason) = record
             .get("message")
             .and_then(|m| m.get("stop_reason"))
-            .and_then(serde_json::Value::as_str) else {
-                if record
-                    .get("message")
-                    .and_then(|m| m.get("content"))
-                    .and_then(serde_json::Value::as_array)
-                    .is_some()
-                {
-                    return Some(lifecycle(
-                        FactKind::TurnOpen,
-                        turn_id,
-                        "assistant_in_flight",
-                        vec!["assistant_in_flight".to_string()],
-                    ));
-                }
-                return None;
-            };
+            .and_then(serde_json::Value::as_str)
+        else {
+            if record
+                .get("message")
+                .and_then(|m| m.get("content"))
+                .and_then(serde_json::Value::as_array)
+                .is_some()
+            {
+                return Some(lifecycle(
+                    FactKind::TurnOpen,
+                    turn_id,
+                    "assistant_in_flight",
+                    vec!["assistant_in_flight".to_string()],
+                ));
+            }
+            return None;
+        };
         return match stop_reason {
-            "tool_use" => Some(lifecycle(FactKind::TurnOpen, turn_id, "open_turn", Vec::new())),
-            "end_turn" => Some(lifecycle(FactKind::TurnComplete, turn_id, "end_turn", Vec::new())),
+            "tool_use" => Some(lifecycle(
+                FactKind::TurnOpen,
+                turn_id,
+                "open_turn",
+                Vec::new(),
+            )),
+            "end_turn" => Some(lifecycle(
+                FactKind::TurnComplete,
+                turn_id,
+                "end_turn",
+                Vec::new(),
+            )),
             "stop_sequence" => Some(lifecycle(
                 FactKind::TurnComplete,
                 turn_id,
@@ -466,7 +550,10 @@ fn claude_lifecycle_fact(record: &serde_json::Value) -> Option<LifecycleFact> {
     if record_type == Some("user") && claude_user_interrupted(record) {
         return Some(lifecycle(
             FactKind::Interrupted,
-            record.get("uuid").and_then(serde_json::Value::as_str).map(TurnId::new),
+            record
+                .get("uuid")
+                .and_then(serde_json::Value::as_str)
+                .map(TurnId::new),
             "user_interrupt",
             vec!["interrupted".to_string()],
         ));
@@ -585,9 +672,7 @@ fn claude_user_interrupted(record: &serde_json::Value) -> bool {
         .is_some_and(|items| {
             items.iter().any(|item| {
                 item.get("type").and_then(serde_json::Value::as_str) == Some("text")
-                    && item
-                        .get("text")
-                        .and_then(serde_json::Value::as_str)
+                    && item.get("text").and_then(serde_json::Value::as_str)
                         == Some("[Request interrupted by user]")
             })
         })

package/crates/team-agent/src/provider/faults.rs

@@ -38,7 +38,9 @@ pub(crate) fn claude_explicit_error_fact(record: &serde_json::Value) -> Option<F
                 FactKind::Error,
             )
             .with_api_error_details(
-                record.get("apiErrorStatus").and_then(serde_json::Value::as_i64),
+                record
+                    .get("apiErrorStatus")
+                    .and_then(serde_json::Value::as_i64),
                 non_empty_string_field(record, "error"),
                 non_empty_string_field(record, "requestId"),
                 non_empty_string_field(record, "uuid"),
@@ -58,7 +60,9 @@ fn codex_explicit_error_fact(record: &serde_json::Value) -> Option<FaultFact> {
     }
     Some(FaultFact::new(
         Signature::new("turn_failed"),
-        turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+        turn.get("id")
+            .and_then(serde_json::Value::as_str)
+            .map(TurnId::new),
         FactKind::Failed,
     ))
 }
@@ -126,8 +130,14 @@ fn claude_record_is_assistant_api_error(record: &serde_json::Value) -> bool {
             .and_then(|message| message.get("role"))
             .and_then(serde_json::Value::as_str)
             == Some("assistant")
-        && record.get("isApiErrorMessage").and_then(serde_json::Value::as_bool) == Some(true)
-        && (record.get("apiErrorStatus").and_then(serde_json::Value::as_i64).is_some()
+        && record
+            .get("isApiErrorMessage")
+            .and_then(serde_json::Value::as_bool)
+            == Some(true)
+        && (record
+            .get("apiErrorStatus")
+            .and_then(serde_json::Value::as_i64)
+            .is_some()
             || non_empty_string_field(record, "error").is_some()
             || non_empty_string_field(record, "requestId").is_some())
 }
@@ -156,7 +166,9 @@ fn codex_fault_fact(record: &serde_json::Value) -> Option<FaultFact> {
         if turn.get("status").and_then(serde_json::Value::as_str) == Some("failed") {
             return Some(FaultFact::new(
                 Signature::new("turn_failed"),
-                turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+                turn.get("id")
+                    .and_then(serde_json::Value::as_str)
+                    .map(TurnId::new),
                 FactKind::Failed,
             ));
         }

package/crates/team-agent/src/provider/helpers.rs

@@ -22,10 +22,7 @@ pub(crate) fn find_session_id(record: &serde_json::Value) -> Option<String> {
     if let Some(s) = record.get("sessionId").and_then(serde_json::Value::as_str) {
         return Some(s.to_string());
     }
-    if let Some(s) = record
-        .get("session_id")
-        .and_then(serde_json::Value::as_str)
-    {
+    if let Some(s) = record.get("session_id").and_then(serde_json::Value::as_str) {
         return Some(s.to_string());
     }
     record
@@ -37,7 +34,11 @@ pub(crate) fn find_session_id(record: &serde_json::Value) -> Option<String> {
         .map(ToString::to_string)
 }
 
-pub(crate) fn patterns(idle: &str, processing: &str, error: &str) -> Result<StatusPatterns, ProviderError> {
+pub(crate) fn patterns(
+    idle: &str,
+    processing: &str,
+    error: &str,
+) -> Result<StatusPatterns, ProviderError> {
     Ok(StatusPatterns {
         idle: compile_regex(idle)?,
         processing: compile_regex(processing)?,

package/crates/team-agent/src/provider/startup_prompt.rs

@@ -28,10 +28,8 @@ const CLAUDE_TRUST_MARKERS: &[&str] = &[
     "Enter to confirm",
 ];
 const CLAUDE_READY_MARKERS: &[&str] = &["Claude Code"];
-pub const COPILOT_TRUST_PROMPT_MARKER: &str =
-    include_str!("testdata/copilot-trust-prompt.txt");
-pub const COPILOT_READY_MARKER: &str =
-    include_str!("testdata/copilot-ready-marker.txt");
+pub const COPILOT_TRUST_PROMPT_MARKER: &str = include_str!("testdata/copilot-trust-prompt.txt");
+pub const COPILOT_READY_MARKER: &str = include_str!("testdata/copilot-ready-marker.txt");
 const COPILOT_TRUST_MARKERS: &[&str] = &[COPILOT_TRUST_PROMPT_MARKER];
 const COPILOT_READY_MARKERS: &[&str] = &[COPILOT_READY_MARKER];
 const COPILOT_TRUST_TITLE: &str = "Confirm folder trust";
@@ -173,13 +171,9 @@ fn has_active_claude_yes_trust_shape(output: &str) -> bool {
     {
         return false;
     }
-    output
-        .lines()
-        .map(str::trim_start)
-        .any(|line| {
-            line == "❯ 1. Yes, I trust this folder"
-                || line == "> 1. Yes, I trust this folder"
-        })
+    output.lines().map(str::trim_start).any(|line| {
+        line == "❯ 1. Yes, I trust this folder" || line == "> 1. Yes, I trust this folder"
+    })
 }
 
 fn has_claude_ready_shape(output: &str) -> bool {
@@ -352,7 +346,10 @@ pub fn codex_handle_startup_prompts(
             StartupScreenDecision::KeepPolling => sleep_between_polls(sleep_s),
         }
     }
-    StartupPromptOutcome { handled, capture_error }
+    StartupPromptOutcome {
+        handled,
+        capture_error,
+    }
 }
 
 pub fn claude_handle_startup_prompts(
@@ -386,7 +383,10 @@ pub fn claude_handle_startup_prompts(
             }
         }
     }
-    StartupPromptOutcome { handled, capture_error }
+    StartupPromptOutcome {
+        handled,
+        capture_error,
+    }
 }
 
 pub fn copilot_handle_startup_prompts(
@@ -420,11 +420,17 @@ pub fn copilot_handle_startup_prompts(
             }
         }
     }
-    StartupPromptOutcome { handled, capture_error }
+    StartupPromptOutcome {
+        handled,
+        capture_error,
+    }
 }
 
 fn max_rfind(output: &str, needles: &[&str]) -> Option<usize> {
-    needles.iter().filter_map(|needle| output.rfind(needle)).max()
+    needles
+        .iter()
+        .filter_map(|needle| output.rfind(needle))
+        .max()
 }
 
 fn is_more_recent(prompt_pos: Option<usize>, ready_pos: Option<usize>) -> bool {
@@ -449,8 +455,8 @@ mod tests {
     use crate::model::enums::PaneLiveness;
     use crate::transport::{
         AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport, Key,
-        PaneField, PaneId, PaneInfo, SessionName, SetEnvOutcome, SpawnResult, Target, TransportError,
-        WindowName,
+        PaneField, PaneId, PaneInfo, SessionName, SetEnvOutcome, SpawnResult, Target,
+        TransportError, WindowName,
     };
     use std::collections::BTreeMap;
     use std::path::Path;
@@ -483,7 +489,8 @@ mod tests {
     fn stale_trust_above_ready_is_not_answered_ready_wins() {
         // trust prompt FIRST, then a ready marker LATER => trust_pos < ready_pos => do NOT answer.
         // This is the positional-recency命门 a naive substring port gets wrong (would re-send Enter).
-        let screen = format!("{TRUST_DIR}\n[trusted earlier]\n{READY_BANNER} ready\n{READY_PROMPT} ");
+        let screen =
+            format!("{TRUST_DIR}\n[trusted earlier]\n{READY_BANNER} ready\n{READY_PROMPT} ");
         assert_eq!(
             classify_codex_startup_screen(&screen),
             StartupScreenDecision::Ready,
@@ -519,7 +526,10 @@ mod tests {
     #[test]
     fn stale_update_above_ready_is_not_skipped_ready_wins() {
         let screen = format!("{UPDATE_AVAIL}\n{READY_BANNER}\n{READY_PROMPT} ");
-        assert_eq!(classify_codex_startup_screen(&screen), StartupScreenDecision::Ready);
+        assert_eq!(
+            classify_codex_startup_screen(&screen),
+            StartupScreenDecision::Ready
+        );
     }
 
     // ── golden ORDER — update is checked BEFORE trust (both more recent) -> SkipUpdatePrompt wins ─────
@@ -528,7 +538,10 @@ mod tests {
         // both update + trust appear after the ready marker; golden runs maybe_skip_update_prompt
         // FIRST each iteration -> the screen resolves to SkipUpdatePrompt, not AnswerWorkspaceTrust.
         let screen = format!("{READY_BANNER}\n{TRUST_DIR}\n{UPDATE_AVAIL}\n");
-        assert_eq!(classify_codex_startup_screen(&screen), StartupScreenDecision::SkipUpdatePrompt);
+        assert_eq!(
+            classify_codex_startup_screen(&screen),
+            StartupScreenDecision::SkipUpdatePrompt
+        );
     }
 
     // ── ready-only / neither ─────────────────────────────────────────────────────────────────────────
@@ -601,22 +614,50 @@ mod tests {
         fn kind(&self) -> BackendKind {
             BackendKind::Tmux
         }
-        fn spawn_first(&self, _s: &SessionName, _w: &WindowName, _a: &[String], _c: &Path, _e: &BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+        fn spawn_first(
+            &self,
+            _s: &SessionName,
+            _w: &WindowName,
+            _a: &[String],
+            _c: &Path,
+            _e: &BTreeMap<String, String>,
+        ) -> Result<SpawnResult, TransportError> {
             unimplemented!("not reached by startup-prompt loop")
         }
-        fn spawn_into(&self, _s: &SessionName, _w: &WindowName, _a: &[String], _c: &Path, _e: &BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+        fn spawn_into(
+            &self,
+            _s: &SessionName,
+            _w: &WindowName,
+            _a: &[String],
+            _c: &Path,
+            _e: &BTreeMap<String, String>,
+        ) -> Result<SpawnResult, TransportError> {
             unimplemented!("not reached by startup-prompt loop")
         }
-        fn inject(&self, _t: &Target, _p: &InjectPayload, _submit: Key, _b: bool) -> Result<InjectReport, TransportError> {
+        fn inject(
+            &self,
+            _t: &Target,
+            _p: &InjectPayload,
+            _submit: Key,
+            _b: bool,
+        ) -> Result<InjectReport, TransportError> {
             unimplemented!("not reached")
         }
         fn send_keys(&self, _t: &Target, keys: &[Key]) -> Result<(), TransportError> {
             self.sent.lock().unwrap().push(keys.to_vec());
             Ok(())
         }
-        fn capture(&self, _t: &Target, range: CaptureRange) -> Result<CapturedText, TransportError> {
+        fn capture(
+            &self,
+            _t: &Target,
+            range: CaptureRange,
+        ) -> Result<CapturedText, TransportError> {
             let mut q = self.screens.lock().unwrap();
-            let text = if q.is_empty() { String::new() } else { q.remove(0) };
+            let text = if q.is_empty() {
+                String::new()
+            } else {
+                q.remove(0)
+            };
             Ok(CapturedText { text, range })
         }
         fn query(&self, _t: &Target, _f: PaneField) -> Result<Option<String>, TransportError> {
@@ -634,7 +675,12 @@ mod tests {
         fn list_windows(&self, _s: &SessionName) -> Result<Vec<WindowName>, TransportError> {
             unimplemented!("not reached")
         }
-        fn set_session_env(&self, _s: &SessionName, _k: &str, _v: &str) -> Result<SetEnvOutcome, TransportError> {
+        fn set_session_env(
+            &self,
+            _s: &SessionName,
+            _k: &str,
+            _v: &str,
+        ) -> Result<SetEnvOutcome, TransportError> {
             unimplemented!("not reached")
         }
         fn kill_session(&self, _s: &SessionName) -> Result<(), TransportError> {
@@ -700,7 +746,9 @@ mod tests {
         );
         let sent = t.sent.lock().unwrap();
         assert_eq!(
-            sent.iter().filter(|keys| keys.as_slice() == [Key::Enter]).count(),
+            sent.iter()
+                .filter(|keys| keys.as_slice() == [Key::Enter])
+                .count(),
             1,
             "copilot trust prompt must choose option 1 with one Enter; got {sent:?}"
         );

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

@@ -1130,6 +1130,34 @@ pub fn load_runtime_state(workspace: &Path) -> Result<Value, StateError> {
     Ok(state)
 }
 
+pub(crate) fn load_runtime_state_without_migrations(workspace: &Path) -> Result<Value, StateError> {
+    let path = runtime_state_path(workspace);
+    if !path.exists() {
+        return Ok(
+            json!({"agents": {}, "tasks": [], "session_name": null, "active_team_key": null}),
+        );
+    }
+    let text = std::fs::read_to_string(&path)?;
+    let mut state: Value = serde_json::from_str(&text)?;
+    normalize_agent_session_state(&mut state);
+    Ok(state)
+}
+
+pub(crate) fn save_runtime_state_without_migrations(
+    workspace: &Path,
+    state: &Value,
+) -> Result<(), StateError> {
+    let path = runtime_state_path(workspace);
+    let _lock = RuntimeLock::acquire(workspace, "state-save-raw", 2.0)?;
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    let payload = serde_json::to_string_pretty(state)?;
+    std::fs::write(&path, payload.as_bytes())?;
+    cache_set(&path, state);
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::unwrap_used, clippy::panic, clippy::expect_used)]

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

@@ -47,6 +47,7 @@ use super::persist::{
     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_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,
 };
 use super::projection::{
     resolve_team_scoped_state as helper_resolve_team_scoped,
@@ -173,6 +174,9 @@ pub enum StateWriteIntent<'a> {
     ClaimLeader {
         team_key: &'a str,
     },
+    LeaderBindingRestoreNonTargetTeams {
+        target_team_key: &'a str,
+    },
     LeaderStartBinding {
         team_key: &'a str,
         transport_kind: &'a str,
@@ -325,6 +329,9 @@ fn route_direct(
         // scoped preserve-claim-fields variant at :1702 uses the team-tombstoned
         // agents helper.
         StateWriteIntent::ClaimLeader { .. } => helper_write_root(workspace, state),
+        StateWriteIntent::LeaderBindingRestoreNonTargetTeams { .. } => {
+            helper_write_root_without_migrations(workspace, state)
+        }
         // LeaderStartBinding -> managed/exec/external all root-save at
         // leader/start.rs:795/903/946.
         StateWriteIntent::LeaderStartBinding { .. } => helper_write_root(workspace, state),
@@ -338,9 +345,7 @@ fn route_direct(
         // intent lives under `coordinator.abnormal_api_error_recovery`, a
         // root-scoped bookkeeping namespace that must survive across team
         // boundaries; use the same helper family as CoordinatorConptyShim.
-        StateWriteIntent::CoordinatorApiErrorRecovery { .. } => {
-            helper_write_root(workspace, state)
-        }
+        StateWriteIntent::CoordinatorApiErrorRecovery { .. } => helper_write_root(workspace, state),
         // McpAssignTask uses the reapply variant today; direct save routes
         // to the root helper for parity.
         StateWriteIntent::McpAssignTask { .. } => helper_write_root(workspace, state),