@team-agent/installer 0.5.42 → 0.5.44

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.42"
+version = "0.5.44"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.42"
+version = "0.5.44"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/adapters.rs

@@ -80,14 +80,15 @@ pub fn cmd_init(args: &InitArgs) -> Result<CmdResult, CliError> {
     if args.force || !state_path.exists() {
         std::fs::write(&state_path, INIT_STATE_TEMPLATE)?;
     }
-    crate::event_log::EventLog::new(&args.workspace).write(
-        "init",
-        json!({
-            "spec_path": spec_path.to_string_lossy().to_string(),
-            "state_path": state_path.to_string_lossy().to_string(),
-        }),
-    )
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    crate::event_log::EventLog::new(&args.workspace)
+        .write(
+            "init",
+            json!({
+                "spec_path": spec_path.to_string_lossy().to_string(),
+                "state_path": state_path.to_string_lossy().to_string(),
+            }),
+        )
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
     Ok(CmdResult::from_json(
         json!({
             "ok": true,
@@ -122,7 +123,10 @@ pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
         .and_then(|readiness| readiness.get("ready"))
         .and_then(Value::as_bool)
         .unwrap_or(true);
-    let status = value.get("status").and_then(Value::as_str).map(str::to_string);
+    let status = value
+        .get("status")
+        .and_then(Value::as_str)
+        .map(str::to_string);
     if args.json
         || value.get("ok").and_then(Value::as_bool) == Some(false)
         || session_capture_incomplete
@@ -173,8 +177,8 @@ fn append_reminder(text: String, reminder: &str) -> String {
 
 /// `cmd_compile`(`commands.py:42`)。
 pub fn cmd_compile(args: &CompileArgs) -> Result<CmdResult, CliError> {
-    let spec = crate::compiler::compile_team(&args.team)
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let spec =
+        crate::compiler::compile_team(&args.team).map_err(|e| CliError::Runtime(e.to_string()))?;
     warn_ignored_owner_team_id(&args.team);
     std::fs::write(&args.out, crate::model::yaml::dumps(&spec))?;
     Ok(CmdResult::from_json(
@@ -194,7 +198,10 @@ fn warn_ignored_owner_team_id(team_dir: &std::path::Path) {
     };
     let workspace = crate::model::paths::team_workspace(team_dir)
         .unwrap_or_else(|_| team_dir.parent().unwrap_or(team_dir).to_path_buf());
-    eprintln!("Warning: ignored TEAM.md {}={}", ignored.field, ignored.value);
+    eprintln!(
+        "Warning: ignored TEAM.md {}={}",
+        ignored.field, ignored.value
+    );
     eprintln!("Reason: owner identity is the canonical runtime team key, not TEAM.md front matter");
     eprintln!("Action: remove {} from TEAM.md", ignored.field);
     let fields = json!({
@@ -205,7 +212,9 @@ fn warn_ignored_owner_team_id(team_dir: &std::path::Path) {
         "reason": "owner identity is derived from the canonical runtime team key",
         "action": "remove owner_team_id from TEAM.md",
     });
-    if let Err(err) = crate::event_log::EventLog::new(&workspace).write("spec.field_ignored", fields) {
+    if let Err(err) =
+        crate::event_log::EventLog::new(&workspace).write("spec.field_ignored", fields)
+    {
         eprintln!("Warning: spec.field_ignored event write failed: {err}");
     }
 }
@@ -362,17 +371,17 @@ pub fn cmd_watch(args: &WatchArgs) -> Result<CmdResult, CliError> {
     }
     #[cfg(test)]
     {
-    let store = crate::message_store::MessageStore::open(&args.workspace)
+        let store = crate::message_store::MessageStore::open(&args.workspace)
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut cursor = crate::coordinator::WatchCursor::default();
+        let lines = crate::coordinator::collect_watch_lines(
+            &workspace,
+            &mut cursor,
+            &store,
+            args.team.as_deref(),
+        )
         .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let mut cursor = crate::coordinator::WatchCursor::default();
-    let lines = crate::coordinator::collect_watch_lines(
-        &workspace,
-        &mut cursor,
-        &store,
-        args.team.as_deref(),
-    )
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
-    Ok(CmdResult::human(lines.join("\n")))
+        Ok(CmdResult::human(lines.join("\n")))
     }
 }
 
@@ -494,7 +503,11 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
     )
     .map_err(|e| CliError::Runtime(e.to_string()))?;
     let state = selected.state;
-    let event_log = selected.run_workspace.join(".team").join("logs").join("events.jsonl");
+    let event_log = selected
+        .run_workspace
+        .join(".team")
+        .join("logs")
+        .join("events.jsonl");
     // 0.5.x Phase 1d Batch 3: factory-routed diagnose backend so
     // conpty teams get accurate `has_session` / capture from the shim
     // rather than a workspace tmux fallback (which would always miss
@@ -537,19 +550,13 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
 /// `cmd_preflight`(`parser.py:160`)。
 pub fn cmd_preflight(args: &PreflightArgs) -> Result<CmdResult, CliError> {
     let report = build_preflight_report(&args.team)?;
-    Ok(CmdResult::from_json(
-        report,
-        args.json,
-    ))
+    Ok(CmdResult::from_json(report, args.json))
 }
 
 /// `cmd_wait_ready`(`parser.py:171`)。
 pub fn cmd_wait_ready(args: &WaitReadyArgs) -> Result<CmdResult, CliError> {
     let report = build_wait_ready_report(&args.workspace, args.timeout, args.team.as_deref())?;
-    Ok(CmdResult::from_json(
-        report,
-        args.json,
-    ))
+    Ok(CmdResult::from_json(report, args.json))
 }
 
 /// `cmd_e2e`(`parser.py:449`)。
@@ -579,10 +586,15 @@ pub fn cmd_e2e(args: &E2eArgs) -> Result<CmdResult, CliError> {
 /// `cmd_peek`(`commands.py:118`)。
 pub fn cmd_peek(args: &PeekArgs) -> Result<CmdResult, CliError> {
     if !args.allow_raw_screen {
-        return Err(CliError::Usage("peek requires --allow-raw-screen".to_string()));
+        return Err(CliError::Usage(
+            "peek requires --allow-raw-screen".to_string(),
+        ));
     }
     let state = crate::state::persist::load_runtime_state(&args.workspace)?;
-    let Some(agent_state) = state.get("agents").and_then(|agents| agents.get(&args.agent)) else {
+    let Some(agent_state) = state
+        .get("agents")
+        .and_then(|agents| agents.get(&args.agent))
+    else {
         return Ok(CmdResult::from_json(
             json!({
                 "ok": false,
@@ -661,13 +673,29 @@ fn peek_unavailable(agent: &str, json: bool) -> CmdResult {
     )
 }
 
-fn agent_pane_id(state: &Value, agent: &str, agent_state: &Value) -> Option<(String, String, String)> {
-    let session = state.get("session_name").and_then(Value::as_str).filter(|s| !s.is_empty())?;
+fn agent_pane_id(
+    state: &Value,
+    agent: &str,
+    agent_state: &Value,
+) -> Option<(String, String, String)> {
+    let session = state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())?;
     let window = ["window", "window_name"]
         .iter()
-        .find_map(|key| agent_state.get(*key).and_then(Value::as_str).filter(|s| !s.is_empty()))
+        .find_map(|key| {
+            agent_state
+                .get(*key)
+                .and_then(Value::as_str)
+                .filter(|s| !s.is_empty())
+        })
         .unwrap_or(agent);
-    Some((session.to_string(), window.to_string(), format!("{session}:{window}")))
+    Some((
+        session.to_string(),
+        window.to_string(),
+        format!("{session}:{window}"),
+    ))
 }
 
 fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
@@ -787,7 +815,10 @@ fn command_on_path(command: &str) -> bool {
 }
 
 fn command_version(command: &str) -> Value {
-    match std::process::Command::new(command).arg("--version").output() {
+    match std::process::Command::new(command)
+        .arg("--version")
+        .output()
+    {
         Ok(output) if output.status.success() => {
             let text = String::from_utf8_lossy(&output.stdout).trim().to_string();
             if text.is_empty() {
@@ -959,7 +990,10 @@ tasks:
 
 fn sessions_overview(state: &Value, spec: Option<&crate::model::yaml::Value>) -> Value {
     let mut rows = Vec::new();
-    if let Some(agents) = spec.and_then(|v| v.get("agents")).and_then(crate::model::yaml::Value::as_list) {
+    if let Some(agents) = spec
+        .and_then(|v| v.get("agents"))
+        .and_then(crate::model::yaml::Value::as_list)
+    {
         for agent in agents {
             let Some(agent_id) = agent.get("id").and_then(crate::model::yaml::Value::as_str) else {
                 continue;
@@ -1015,7 +1049,10 @@ fn session_row(
 }
 
 fn yaml_str(value: &crate::model::yaml::Value, key: &str) -> Option<String> {
-    value.get(key).and_then(crate::model::yaml::Value::as_str).map(ToString::to_string)
+    value
+        .get(key)
+        .and_then(crate::model::yaml::Value::as_str)
+        .map(ToString::to_string)
 }
 
 fn field_or_null(value: &Value, keys: &[&str]) -> Value {
@@ -1041,7 +1078,11 @@ fn last_task_for_agent(state: &Value, agent_id: &str) -> Value {
                 .rev()
                 .find(|task| task.get("assignee").and_then(Value::as_str) == Some(agent_id))
         })
-        .and_then(|task| task.get("id").and_then(Value::as_str).map(ToString::to_string))
+        .and_then(|task| {
+            task.get("id")
+                .and_then(Value::as_str)
+                .map(ToString::to_string)
+        })
         .map(Value::String)
         .unwrap_or(Value::Null)
 }
@@ -1067,8 +1108,10 @@ fn window_target(agent_state: &Value, agent_id: &str) -> Value {
     }
 }
 
-
-fn load_team_spec_optional(workspace: &Path, state: &Value) -> Result<Option<crate::model::yaml::Value>, CliError> {
+fn load_team_spec_optional(
+    workspace: &Path,
+    state: &Value,
+) -> Result<Option<crate::model::yaml::Value>, CliError> {
     let spec_path = state
         .get("spec_path")
         .and_then(Value::as_str)
@@ -1196,7 +1239,10 @@ fn format_inbox_human(
     Ok(lines.join("\n"))
 }
 
-fn uncollected_result_count(workspace: &Path, owner_team_id: Option<&str>) -> Result<i64, CliError> {
+fn uncollected_result_count(
+    workspace: &Path,
+    owner_team_id: Option<&str>,
+) -> Result<i64, CliError> {
     let store = crate::message_store::MessageStore::open(workspace)
         .map_err(|e| CliError::Runtime(e.to_string()))?;
     let conn = crate::db::schema::open_db(store.db_path())
@@ -1401,10 +1447,16 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
         ));
     }
     if args.comms || matches!(args.gate, Some(DoctorGate::Comms)) {
-        let value = crate::diagnose::comms::doctor_comms_json(&args.workspace, args.team.as_deref(), Some("comms"))?;
+        let value = crate::diagnose::comms::doctor_comms_json(
+            &args.workspace,
+            args.team.as_deref(),
+            Some("comms"),
+        )?;
         if !args.json {
             let json_tail = serde_json::to_string_pretty(&sort_json(&value))?;
-            return Ok(CmdResult::human(format!("{COMMS_BOUNDARY_TEXT}\n{json_tail}")));
+            return Ok(CmdResult::human(format!(
+                "{COMMS_BOUNDARY_TEXT}\n{json_tail}"
+            )));
         }
         return Ok(CmdResult::from_json(value, true));
     }
@@ -1439,9 +1491,18 @@ mod tests {
         });
         let out = quickstart_human(&value);
         assert!(out.contains("team started"), "must keep summary; got {out}");
-        assert!(out.contains("attach:"), "must render attach block; got {out}");
-        assert!(out.contains("team-y:w1") && out.contains("team-y:w2"), "must list each attach cmd; got {out}");
-        assert!(out.ends_with(crate::cli::QUICK_START_REMINDER), "must append harness reminder; got {out}");
+        assert!(
+            out.contains("attach:"),
+            "must render attach block; got {out}"
+        );
+        assert!(
+            out.contains("team-y:w1") && out.contains("team-y:w2"),
+            "must list each attach cmd; got {out}"
+        );
+        assert!(
+            out.ends_with(crate::cli::QUICK_START_REMINDER),
+            "must append harness reminder; got {out}"
+        );
     }
 
     #[test]
@@ -1467,11 +1528,18 @@ mod tests {
                 "w1": {"pane_id": "%7", "window": "w1"}
             }
         });
-        let agent = state.get("agents").and_then(|agents| agents.get("w1")).unwrap();
+        let agent = state
+            .get("agents")
+            .and_then(|agents| agents.get("w1"))
+            .unwrap();
 
         assert_eq!(
             agent_pane_id(&state, "w1", agent).unwrap(),
-            ("team-x".to_string(), "w1".to_string(), "team-x:w1".to_string())
+            (
+                "team-x".to_string(),
+                "w1".to_string(),
+                "team-x:w1".to_string()
+            )
         );
     }
 
@@ -1483,11 +1551,18 @@ mod tests {
                 "w1": {"window": "worker-one"}
             }
         });
-        let agent = state.get("agents").and_then(|agents| agents.get("w1")).unwrap();
+        let agent = state
+            .get("agents")
+            .and_then(|agents| agents.get("w1"))
+            .unwrap();
 
         assert_eq!(
             agent_pane_id(&state, "w1", agent).unwrap(),
-            ("team-x".to_string(), "worker-one".to_string(), "team-x:worker-one".to_string())
+            (
+                "team-x".to_string(),
+                "worker-one".to_string(),
+                "team-x:worker-one".to_string()
+            )
         );
     }
 }

package/crates/team-agent/src/cli/diagnose.rs

@@ -57,8 +57,7 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
                 let error_str = error.to_string();
                 let issue_id = classify_tmux_server_error(&error_str);
                 issues.push(json!(issue_id));
-                let mut hint =
-                    recovery_hint(session_name, issue_id, "team-agent diagnose");
+                let mut hint = recovery_hint(session_name, issue_id, "team-agent diagnose");
                 if let Some(obj) = hint.as_object_mut() {
                     obj.insert("reason".to_string(), Value::String(error_str));
                 }

package/crates/team-agent/src/cli/emit.rs

@@ -1673,13 +1673,7 @@ mod tests {
     fn hidden_commands_not_in_default_help() {
         let top_help = command_help(None);
         let visible = visible_help_commands(&top_help);
-        for command in [
-            "leaders",
-            "doctor",
-            "e2e",
-            "peek",
-            "coordinator",
-        ] {
+        for command in ["leaders", "doctor", "e2e", "peek", "coordinator"] {
             assert!(
                 !visible.iter().any(|visible| visible == command),
                 "`{command}` must stay hidden from default help"

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

@@ -30,7 +30,9 @@ pub(crate) fn python_truthy(value: &Value) -> bool {
     match value {
         Value::Null => false,
         Value::Bool(b) => *b,
-        Value::Number(n) => n.as_i64().map(|v| v != 0)
+        Value::Number(n) => n
+            .as_i64()
+            .map(|v| v != 0)
             .or_else(|| n.as_u64().map(|v| v != 0))
             .or_else(|| n.as_f64().map(|v| v != 0.0))
             .unwrap_or(false),

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

@@ -30,7 +30,8 @@ pub fn leader_launcher_args(values: &[String]) -> Result<LeaderLauncherArgs, Cli
                     )));
                 }
             }
-            out.provider_args.extend(values.iter().skip(idx + 1).cloned());
+            out.provider_args
+                .extend(values.iter().skip(idx + 1).cloned());
             break;
         } else if token == "--attach" || token == "--attach-existing" {
             out.attach_existing = true;

package/crates/team-agent/src/cli/mod.rs

@@ -3347,8 +3347,7 @@ pub mod lifecycle_port {
                 let repair_team = team
                     .filter(|team| !team.is_empty())
                     .unwrap_or(session_name.as_str());
-                let shutdown_scoped =
-                    format!("team-agent shutdown --team {repair_team}");
+                let shutdown_scoped = format!("team-agent shutdown --team {repair_team}");
                 json!({
                     "ok": false,
                     "status": "refused_build_before_destroy",
@@ -4101,7 +4100,7 @@ pub mod leader_port {
                 "action": "rerun with --confirm to claim ownership of this team",
             }));
         }
-        let state = crate::state::persist::load_runtime_state(workspace)
+        let state = crate::state::persist::load_runtime_state_without_migrations(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let Some(team_id) = resolve_owner_team_id(&state, team) else {
             return Ok(json!({
@@ -4113,8 +4112,7 @@ pub mod leader_port {
             }));
         };
         let requested_team = team;
-        let explicit_team = requested_team.filter(|team| !team.is_empty());
-        let resolved_team = explicit_team.map(|_| team_id.as_str().to_string());
+        let resolved_team = Some(team_id.as_str().to_string());
         if !positive_caller_pane_env_present() {
             let bind = crate::leader::bind_owner_from_caller_pane(workspace, &team_id, None)
                 .map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -4125,9 +4123,21 @@ pub mod leader_port {
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let mut value = lease_value(result);
         insert_resolved_team(&mut value, requested_team, resolved_team.as_deref());
+        append_team_session_ready(workspace, resolved_team.as_deref(), &mut value);
         if value.get("ok").and_then(Value::as_bool) == Some(true) {
-            emit_topology_convergence_event(workspace, resolved_team.as_deref(), "takeover", &value);
-            register_after_binding_success(workspace, resolved_team.as_deref(), "takeover", &mut value);
+            emit_topology_convergence_event(
+                workspace,
+                resolved_team.as_deref(),
+                "takeover",
+                &value,
+            );
+            register_after_binding_success(
+                workspace,
+                resolved_team.as_deref(),
+                "takeover",
+                &mut value,
+            );
+            restore_non_target_teams(workspace, &state, resolved_team.as_deref());
         }
         Ok(value)
     }
@@ -4137,7 +4147,7 @@ pub mod leader_port {
         team: Option<&str>,
         confirm: bool,
     ) -> Result<Value, CliError> {
-        let state = crate::state::persist::load_runtime_state(workspace)
+        let state = crate::state::persist::load_runtime_state_without_migrations(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let Some(team_id) = resolve_owner_team_id(&state, team) else {
             return Ok(json!({
@@ -4156,15 +4166,26 @@ pub mod leader_port {
             }
             return Ok(owner_bind_value(bind));
         }
-        let explicit_team = team.filter(|team| !team.is_empty());
-        let resolved_team = explicit_team.map(|_| team_id.as_str().to_string());
+        let resolved_team = Some(team_id.as_str().to_string());
         let result = crate::leader::claim_leader(workspace, resolved_team.as_deref(), confirm)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let mut value = lease_value(result);
         insert_resolved_team(&mut value, team, resolved_team.as_deref());
+        append_team_session_ready(workspace, resolved_team.as_deref(), &mut value);
         if value.get("ok").and_then(Value::as_bool) == Some(true) {
-            emit_topology_convergence_event(workspace, resolved_team.as_deref(), "claim-leader", &value);
-            register_after_binding_success(workspace, resolved_team.as_deref(), "claim-leader", &mut value);
+            emit_topology_convergence_event(
+                workspace,
+                resolved_team.as_deref(),
+                "claim-leader",
+                &value,
+            );
+            register_after_binding_success(
+                workspace,
+                resolved_team.as_deref(),
+                "claim-leader",
+                &mut value,
+            );
+            restore_non_target_teams(workspace, &state, resolved_team.as_deref());
         }
         Ok(value)
     }
@@ -4260,6 +4281,7 @@ pub mod leader_port {
                 "owner_epoch": convergence.get("owner_epoch").cloned().unwrap_or(Value::Null),
                 "persisted": convergence.get("persisted").cloned().unwrap_or(Value::Bool(false)),
                 "checked_paths": convergence.get("checked_paths").cloned().unwrap_or_else(|| json!([])),
+                "team_session_ready": response.get("team_session_ready").cloned().unwrap_or(Value::Null),
             }),
         );
     }
@@ -4325,14 +4347,102 @@ pub mod leader_port {
                     | crate::state::projection::OwnerTeamResolution::Ambiguous { .. } => None,
                 }
             }
-            None => Some(TeamKey::new(crate::state::projection::team_state_key(
-                state,
-            ))),
+            None => Some(TeamKey::new(active_or_derived_team_key(state))),
+        }
+    }
+
+    fn active_or_derived_team_key(state: &Value) -> String {
+        state
+            .get("active_team_key")
+            .and_then(Value::as_str)
+            .filter(|team| !team.is_empty())
+            .map(str::to_string)
+            .unwrap_or_else(|| crate::state::projection::team_state_key(state))
+    }
+
+    fn append_team_session_ready(workspace: &Path, team: Option<&str>, response: &mut Value) {
+        let Some(obj) = response.as_object_mut() else {
+            return;
+        };
+        let Some(convergence) = obj.get("topology_convergence") else {
+            return;
+        };
+        if convergence.get("status").and_then(Value::as_str) != Some("converged") {
+            return;
+        }
+        let Some(endpoint) = convergence
+            .get("new_tmux_endpoint")
+            .and_then(Value::as_str)
+            .filter(|endpoint| !endpoint.is_empty())
+        else {
+            obj.insert("team_session_ready".to_string(), Value::Null);
+            return;
+        };
+        let session_name = crate::state::persist::load_runtime_state_without_migrations(workspace)
+            .ok()
+            .and_then(|state| target_team_session_name(&state, team));
+        let ready = session_name
+            .as_deref()
+            .and_then(|session| crate::topology::team_session_ready_on_endpoint(endpoint, session));
+        obj.insert(
+            "team_session_ready".to_string(),
+            ready.map(Value::Bool).unwrap_or(Value::Null),
+        );
+    }
+
+    fn target_team_session_name(state: &Value, team: Option<&str>) -> Option<String> {
+        team.and_then(|team| {
+            state
+                .get("teams")
+                .and_then(Value::as_object)
+                .and_then(|teams| teams.get(team))
+        })
+        .and_then(|team_state| team_state.get("session_name"))
+        .and_then(Value::as_str)
+        .filter(|session| !session.is_empty())
+        .or_else(|| state.get("session_name").and_then(Value::as_str))
+        .filter(|session| !session.is_empty())
+        .map(str::to_string)
+    }
+
+    fn restore_non_target_teams(workspace: &Path, before: &Value, target: Option<&str>) {
+        let Some(target) = target.filter(|team| !team.is_empty()) else {
+            return;
+        };
+        let Some(before_teams) = before.get("teams").and_then(Value::as_object) else {
+            return;
+        };
+        let Ok(mut latest) =
+            crate::state::persist::load_runtime_state_without_migrations(workspace)
+        else {
+            return;
+        };
+        let Some(latest_teams) = latest.get_mut("teams").and_then(Value::as_object_mut) else {
+            return;
+        };
+        let mut changed = false;
+        for (team, before_entry) in before_teams {
+            if team == target {
+                continue;
+            }
+            if latest_teams.get(team) != Some(before_entry) {
+                latest_teams.insert(team.clone(), before_entry.clone());
+                changed = true;
+            }
+        }
+        if changed {
+            let _ = crate::state::repository::StateRepository::new(workspace).save(
+                crate::state::repository::StateWriteIntent::LeaderBindingRestoreNonTargetTeams {
+                    target_team_key: target,
+                },
+                &latest,
+            );
         }
     }
 
     fn insert_resolved_team(value: &mut Value, requested: Option<&str>, resolved: Option<&str>) {
-        let (Some(requested), Some(resolved)) = (requested.filter(|team| !team.is_empty()), resolved)
+        let (Some(requested), Some(resolved)) =
+            (requested.filter(|team| !team.is_empty()), resolved)
         else {
             return;
         };

package/crates/team-agent/src/cli/named_address.rs

@@ -97,9 +97,15 @@ impl NamedAddressError {
         obj.insert("error".to_string(), Value::String(self.message.clone()));
         obj.insert("action".to_string(), Value::String(self.action.clone()));
         obj.insert("log".to_string(), Value::String(self.log.clone()));
-        obj.insert("candidates".to_string(), Value::Array(self.candidates.clone()));
+        obj.insert(
+            "candidates".to_string(),
+            Value::Array(self.candidates.clone()),
+        );
         if let Some(requested) = self.requested_team.as_deref() {
-            obj.insert("requested_team".to_string(), Value::String(requested.to_string()));
+            obj.insert(
+                "requested_team".to_string(),
+                Value::String(requested.to_string()),
+            );
         }
         if !self.available_team_keys.is_empty() {
             obj.insert(
@@ -113,7 +119,10 @@ impl NamedAddressError {
             );
         }
         if let Some(suggested) = self.suggested_name.as_deref() {
-            obj.insert("suggested_name".to_string(), Value::String(suggested.to_string()));
+            obj.insert(
+                "suggested_name".to_string(),
+                Value::String(suggested.to_string()),
+            );
         }
         Value::Object(obj)
     }
@@ -662,8 +671,8 @@ fn resolve_leader(
     // silently reused the `current` team's receiver and reported a stale
     // pane_id). Legacy single-team compat is preserved only when the state
     // has no `teams` map yet and the requested key equals `active_team_key`.
-    let receiver = resolve_team_scoped_leader_receiver(state, team, target_workspace)?
-        .ok_or_else(|| {
+    let receiver =
+        resolve_team_scoped_leader_receiver(state, team, target_workspace)?.ok_or_else(|| {
             let mut err = leader_not_attached_third_party(
                 target_workspace,
                 team,