@team-agent/installer 0.5.77 → 0.5.80

package/crates/team-agent/src/lifecycle/tests/pi_catalog_red.rs

@@ -8,6 +8,77 @@ use crate::model::enums::ProviderEffort;
 use crate::provider::adapters::pi::{build_pi_command_argv, PiCommandRequest, PiSessionSelector};
 
 const CATALOG: &[u8] = include_bytes!("fixtures/pi_list_models_g0.stdout.txt");
+// Public pi --list-models rows captured for issue #186, preserving column widths.
+const SPACED_IDS_CATALOG: &[u8] = include_bytes!("fixtures/pi_list_models_spaced_ids.stdout.txt");
+
+#[test]
+fn pi_catalog_preserves_spaced_ids_and_qualified_slug_variants() {
+    let models = parse_pi_list_models_table(SPACED_IDS_CATALOG).expect("public catalog rows");
+    assert_eq!(
+        models,
+        vec![
+            "cursor/claude-opus-4-7@1m:fast",
+            "cursor/claude-opus-4-7@1m:slow",
+            "openai-codex/gpt-5.6-luna",
+            "team-agent/Claude Opus 4.6 (Thinking)",
+            "team-agent/Claude Sonnet 4.6 (Thinking)",
+            "team-agent/Gemini 3.8 Flash",
+            "team-agent/gpt-5.6-luna",
+            "team-agent/qwen3.8-27b",
+        ]
+    );
+    for exact in &models {
+        assert_eq!(select_exact_pi_model(&models, exact).unwrap(), *exact);
+        assert!(argv_has_pair(&command_for_model(exact), "--model", exact));
+    }
+}
+
+#[test]
+fn pi_catalog_still_rejects_duplicate_complete_spaced_ids() {
+    let text = std::str::from_utf8(SPACED_IDS_CATALOG).unwrap();
+    let repeated = text
+        .lines()
+        .find(|line| line.contains("Claude Opus 4.6 (Thinking)"))
+        .unwrap();
+    let duplicate = format!("{text}{repeated}\n");
+    let error = parse_pi_list_models_table(duplicate.as_bytes()).unwrap_err();
+    assert!(error
+        .to_string()
+        .contains("duplicate exact id \"team-agent/Claude Opus 4.6 (Thinking)\""));
+    let exact = "team-agent/Claude Opus 4.6 (Thinking)";
+    assert!(select_exact_pi_model(&[exact.into(), exact.into()], exact).is_err());
+}
+
+#[test]
+fn pi_catalog_preserves_internal_whitespace_with_compact_and_full_headers() {
+    for catalog in [
+        "provider model\r\nteam-agent\tClaude  Opus 4.6 (Thinking)  \r\n",
+        "provider model context max-out thinking images\r\nteam-agent\tClaude  Opus 4.6 (Thinking)\t200K  32.8K\tyes  yes  \r\n",
+    ] {
+        assert_eq!(
+            parse_pi_list_models_table(catalog.as_bytes()).unwrap(),
+            vec!["team-agent/Claude  Opus 4.6 (Thinking)"]
+        );
+    }
+}
+
+#[test]
+fn pi_catalog_rejects_rows_without_model_or_required_trailing_fields() {
+    for row in [
+        "team-agent",
+        "team-agent 200K 32.8K yes yes",
+        "team-agent gpt-5.6-luna 200K 32.8K yes",
+    ] {
+        let catalog = format!("provider model context max-out thinking images\n{row}\n");
+        assert!(
+            parse_pi_list_models_table(catalog.as_bytes())
+                .unwrap_err()
+                .to_string()
+                .contains("row 2 is malformed"),
+            "missing model or capability fields must refuse: {row}"
+        );
+    }
+}
 
 fn argv_has_pair(argv: &[String], flag: &str, value: &str) -> bool {
     argv.windows(2)

package/crates/team-agent/src/lifecycle/tests/pi_dual_entry_red.rs

@@ -428,6 +428,84 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
         "dynamic add must not create a second tmux session"
     );
 
+    let pi_provider_root = hermetic.workspace("pi-add-provider");
+    let pi_bin = pi_provider_root.join("bin");
+    let pi_package = pi_provider_root.join("pi-mcp-adapter");
+    std::fs::create_dir_all(&pi_bin).expect("create Pi test bin");
+    std::fs::create_dir_all(&pi_package).expect("create Pi test adapter");
+    let pi_real = pi_provider_root.join("pi-cli");
+    std::fs::write(
+        &pi_real,
+        format!(
+            "#!/bin/sh\ncase \"$1\" in\n  --version) printf '0.84.4\\n' ;;\n  --list-models) printf 'provider model\\nteam-agent qwen3.8-27b\\n' ;;\n  list) printf 'npm:pi-mcp-adapter\\n{}\\n' ;;\n  *) exit 64 ;;\nesac\n",
+            pi_package.display()
+        ),
+    )
+    .expect("write protocol-capable Pi test executable");
+    std::fs::set_permissions(
+        &pi_real,
+        std::os::unix::fs::PermissionsExt::from_mode(0o755),
+    )
+    .expect("make Pi test executable");
+    std::os::unix::fs::symlink(&pi_real, pi_bin.join("pi")).expect("link Pi test executable");
+    std::fs::write(
+        pi_package.join("package.json"),
+        br#"{"name":"pi-mcp-adapter","version":"2.30.0","pi":{"extensions":["./index.ts"]}}"#,
+    )
+    .expect("write Pi test adapter package");
+    std::fs::write(
+        pi_package.join("index.ts"),
+        b"export const createMcpAdapter = () => {};\n",
+    )
+    .expect("write Pi test adapter entry");
+    let _pi_path = EnvVarGuard::set("PATH", pi_bin.as_os_str());
+    let pi_success_role = "---\nname: mate\nrole: Pi Dynamic Worker\nprovider: pi\nmodel: team-agent/qwen3.8-27b\nauth_mode: subscription\neffort: max\ntools:\n  - mcp_team\ndangerously_skip_permissions: true\n---\n\ndynamic pi\n";
+    let (pi_success_team, pi_success_role_path) =
+        dynamic_add_fixture(&dynamic_root, "dynamic-pi-success", pi_success_role);
+    let pi_success_transport = OfflineTransport::new().with_session_present(true);
+    crate::lifecycle::add_agent_with_transport(
+        &pi_success_team,
+        &AgentId::new("mate"),
+        &pi_success_role_path,
+        false,
+        None,
+        &pi_success_transport,
+    )
+    .expect("Pi dynamic add must commit after spawning its materialized plan");
+    let pi_spawn = pi_success_transport.spawn_records();
+    assert_eq!(pi_spawn.len(), 1, "Pi dynamic add must spawn exactly once");
+    let pi_state = crate::state::persist::load_runtime_state(&pi_success_team)
+        .expect("load successful Pi add state");
+    assert_eq!(
+        pi_state
+            .pointer("/agents/mate/status")
+            .and_then(serde_json::Value::as_str),
+        Some("running"),
+        "successful Pi add must commit the running seat"
+    );
+    let pi_events = crate::event_log::EventLog::new(&pi_success_team)
+        .tail(50)
+        .expect("read successful Pi add events");
+    let pi_start_event = pi_events
+        .iter()
+        .find(|event| {
+            event.get("event").and_then(serde_json::Value::as_str)
+                == Some("start_agent.agent_start")
+        })
+        .expect("successful Pi add must emit start event");
+    let pi_event_command = pi_start_event
+        .get("command")
+        .and_then(serde_json::Value::as_array)
+        .expect("successful Pi start event command")
+        .iter()
+        .map(|value| value.as_str().expect("Pi argv string").to_string())
+        .collect::<Vec<_>>();
+    assert_eq!(
+        pi_event_command, pi_spawn[0].1,
+        "Pi start event must record the exact materialized plan that was spawned"
+    );
+    drop(_pi_path);
+
     let (rollback_team, rollback_role) =
         dynamic_add_fixture(&dynamic_root, "dynamic-rollback", fake_role);
     let events_path = rollback_team.join(".team/logs/events.jsonl");

package/crates/team-agent/src/lifecycle/tests/team_in_team_identity_scope_red.rs

@@ -35,6 +35,9 @@ use team_agent::transport::{
 #[test]
 #[serial(env)]
 fn quick_start_team_id_persists_requested_team_key_for_lifecycle_selection() {
+    let hermetic = hermetic_guard::HermeticTestEnv::enter("team-in-team-requested-key");
+    hermetic.scrub_tmux();
+    hermetic.assert_no_real_tmux();
     let _env = EnvGuard::unset();
     let root = tmp_dir("team-id-key");
     seed_healthy_coordinator(&root);

package/crates/team-agent/src/lifecycle/tests/test_isolation_escape_contract.rs

@@ -131,18 +131,46 @@ fn r5_restart_auto_attach_registers_isolated_live_leader_entry() {
     case.seed_restartable_workspace();
     seed_healthy_coordinator(&case.workspace);
 
-    let report = restart_with_transport_with_readiness_deadline(
-        &case.workspace,
-        true,
-        Some(TEAM_KEY),
-        &RestartAutoAttachTransport::new(),
-        Some(1_000),
+    let live = crate::transport::test_support::OfflineTransport::default()
+        .with_tmux_endpoint(TMUX_SOCKET)
+        .with_targets(vec![PaneInfo {
+            pane_id: PaneId::new(CALLER_PANE),
+            session: SessionName::new("team-agent-leader-0515"),
+            window_index: Some(0),
+            window_name: Some(WindowName::new("leader")),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("codex".to_string()),
+            current_path: Some(case.workspace.clone()),
+            active: true,
+            pane_pid: None,
+            leader_env: Default::default(),
+        }]);
+    let report = crate::transport_factory::with_leader_endpoint_transport(
+        TMUX_SOCKET,
+        live,
+        || {
+            restart_with_transport_with_readiness_deadline(
+                &case.workspace,
+                true,
+                Some(TEAM_KEY),
+                &RestartAutoAttachTransport::new(),
+                Some(1_000),
+            )
+        },
     )
     .expect("R5 setup: restart should complete against fake transport");
-    assert!(
-        matches!(report, RestartReport::Restarted { .. }),
-        "R5 setup: restart must succeed before checking registry side effects; report={report:?}"
-    );
+    match &report {
+        RestartReport::Restarted {
+            leader_bind_ok, ..
+        } => {
+            assert!(
+                *leader_bind_ok,
+                "R5: public restart bind must be ok; report={report:?}"
+            );
+        }
+        other => panic!("R5 setup: restart must succeed before checking registry side effects; report={other:?}"),
+    }
     let state = load_runtime_state(&case.workspace).expect("read state after restart");
     assert_eq!(
         canonical_leader_receiver(&state)
@@ -527,6 +555,19 @@ impl RestartAutoAttachCase {
                         "session_name": "team-ctxteam",
                         "tmux_endpoint": TMUX_SOCKET,
                         "tmux_socket": TMUX_SOCKET,
+                        "team_owner": {
+                            "pane_id": CALLER_PANE,
+                            "owner_epoch": 1,
+                            "provider": "codex"
+                        },
+                        "leader_receiver": {
+                            "mode": "direct_tmux",
+                            "status": "attached",
+                            "pane_id": CALLER_PANE,
+                            "owner_epoch": 1,
+                            "provider": "codex",
+                            "tmux_socket": TMUX_SOCKET
+                        },
                         "agents": { WORKER: worker }
                     }
                 }

package/crates/team-agent/src/lifecycle/tests/verify_rs031_window_consistency_red.rs

@@ -103,13 +103,37 @@ fn worker_mcp_owner_team_scope_must_match_runtime_team_key_not_spec_name() {
 fn quick_start_preserves_external_leader_receiver_when_worker_pane_id_collides_across_tmux_sockets()
 {
     let hermetic = HermeticTestEnv::enter("rs031-external-pane-collision");
-    let _tmux = hermetic.with_env("TMUX", "/tmp/default-tmux-socket,123,0");
+    let caller_endpoint = "/tmp/default-tmux-socket";
+    let _tmux = hermetic.with_env("TMUX", &format!("{caller_endpoint},123,0"));
     let _pane = hermetic.with_env("TMUX_PANE", "%0");
+    let _provider = hermetic.with_env("TEAM_AGENT_LEADER_PROVIDER", "codex");
     let team = codex_only_team_dir(&hermetic, "external-pane-collision");
-    let transport = RecordingTransport::new().with_windows(vec![WindowName::new("codexer")]);
+    let workspace = team.parent().expect("teamdir has parent workspace");
+    let caller = PaneInfo {
+        pane_id: PaneId::new("%0"),
+        session: SessionName::new("leader"),
+        window_index: Some(0),
+        window_name: Some(WindowName::new("leader")),
+        pane_index: Some(0),
+        tty: None,
+        current_command: Some("codex".to_string()),
+        current_path: Some(workspace.to_path_buf()),
+        active: true,
+        pane_pid: None,
+        leader_env: Default::default(),
+    };
+    let transport = RecordingTransport::new()
+        .with_windows(vec![WindowName::new("codexer")])
+        .with_tmux_endpoint(caller_endpoint)
+        .with_targets(vec![caller.clone()]);
+    let live = crate::transport::test_support::OfflineTransport::default()
+        .with_tmux_endpoint(caller_endpoint)
+        .with_targets(vec![caller]);
     let launch = ready_launch(
-        quick_start_with_transport(&team, None, true, None, &transport)
-            .expect("quick-start should reach worker spawn path"),
+        crate::transport_factory::with_leader_endpoint_transport(caller_endpoint, live, || {
+            quick_start_with_transport(&team, None, true, None, &transport)
+        })
+        .expect("quick-start should reach worker spawn path"),
     );
     let worker_pane = launch
         .started
@@ -122,7 +146,6 @@ fn quick_start_preserves_external_leader_receiver_when_worker_pane_id_collides_a
         "fixture precondition: first worker in the product -L socket receives bare pane id %0"
     );
 
-    let workspace = team.parent().expect("teamdir has parent workspace");
     let state = load_runtime_state(workspace).expect("runtime state written by launch");
     let top_receiver_pane = state
         .get("leader_receiver")
@@ -765,6 +788,7 @@ struct RecordingState {
     spawn_argvs: Vec<Vec<String>>,
     liveness: BTreeMap<String, PaneLiveness>,
     targets: Vec<PaneInfo>,
+    tmux_endpoint: Option<String>,
 }
 
 impl RecordingTransport {
@@ -789,6 +813,11 @@ impl RecordingTransport {
         self
     }
 
+    fn with_tmux_endpoint(self, endpoint: impl Into<String>) -> Self {
+        self.with_state(|state| state.tmux_endpoint = Some(endpoint.into()));
+        self
+    }
+
     fn inject_targets(&self) -> Vec<Target> {
         self.with_state(|state| state.inject_targets.clone())
     }
@@ -812,6 +841,10 @@ impl Transport for RecordingTransport {
         BackendKind::Tmux
     }
 
+    fn tmux_endpoint(&self) -> Option<String> {
+        self.with_state(|state| state.tmux_endpoint.clone())
+    }
+
     fn spawn_first(
         &self,
         session: &SessionName,
@@ -875,8 +908,18 @@ impl Transport for RecordingTransport {
         })
     }
 
-    fn query(&self, _target: &Target, _field: PaneField) -> Result<Option<String>, TransportError> {
-        Ok(None)
+    fn query(&self, _target: &Target, field: PaneField) -> Result<Option<String>, TransportError> {
+        match field {
+            PaneField::PaneCurrentCommand => Ok(Some("codex".to_string())),
+            PaneField::PaneCurrentPath => Ok(self.with_state(|state| {
+                state
+                    .targets
+                    .first()
+                    .and_then(|target| target.current_path.as_ref())
+                    .map(|path| path.to_string_lossy().into_owned())
+            })),
+            _ => Ok(None),
+        }
     }
 
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {

package/crates/team-agent/src/lifecycle/tests/worker_spawn_env_red.rs

@@ -95,6 +95,103 @@ fn worker_spawn_inherits_parent_process_env_for_proxy_and_ca() {
     );
 }
 
+#[test]
+#[serial(env)]
+fn cursor_subscription_proxy_profile_reaches_fresh_and_restart_transport_final_env() {
+    let _guard = EnvGuard::set([
+        ("HTTPS_PROXY", "https://upper-https:1"),
+        ("HTTP_PROXY", "http://upper-http:1"),
+        ("ALL_PROXY", "socks5://upper-all:1"),
+        ("https_proxy", "https://lower-https:1"),
+        ("http_proxy", "http://lower-http:1"),
+        ("all_proxy", "socks5://lower-all:1"),
+        ("NO_PROXY", "localhost,127.0.0.1"),
+        ("no_proxy", "localhost,127.0.0.1"),
+        ("GLOBAL_AGENT_HTTPS_PROXY", "https://global-https:1"),
+        ("GLOBAL_AGENT_HTTP_PROXY", "http://global-http:1"),
+    ]);
+
+    let launch_direct = compiled_cursor_profile_team("cursor-direct-launch", "direct");
+    let launch_transport = RecordingTransport::new().with_session_present(false);
+    launch_with_transport(
+        &launch_direct.join("team.spec.yaml"),
+        false,
+        true,
+        true,
+        &launch_transport,
+    )
+    .expect("direct Cursor launch fixture should spawn");
+    assert_cursor_proxy_spawn(&launch_transport.single_spawn(), true);
+
+    let restart_direct = compiled_cursor_profile_team("cursor-direct-restart", "direct");
+    seed_restart_state_with_profile(&restart_direct, "worker_a", "cursor_proxy");
+    let restart_transport = RecordingTransport::new().with_session_present(false);
+    restart_with_transport(&restart_direct, true, None, &restart_transport)
+        .expect("direct Cursor restart fixture should spawn");
+    assert_cursor_proxy_spawn(&restart_transport.single_spawn(), true);
+
+    let launch_inherit = compiled_cursor_profile_team("cursor-inherit-launch", "inherit");
+    let inherit_transport = RecordingTransport::new().with_session_present(false);
+    launch_with_transport(
+        &launch_inherit.join("team.spec.yaml"),
+        false,
+        true,
+        true,
+        &inherit_transport,
+    )
+    .expect("inherit Cursor launch fixture should spawn");
+    assert_cursor_proxy_spawn(&inherit_transport.single_spawn(), false);
+
+    let restart_inherit = compiled_cursor_profile_team("cursor-inherit-restart", "inherit");
+    seed_restart_state_with_profile(&restart_inherit, "worker_a", "cursor_proxy");
+    let restart_inherit_transport = RecordingTransport::new().with_session_present(false);
+    restart_with_transport(
+        &restart_inherit,
+        true,
+        None,
+        &restart_inherit_transport,
+    )
+    .expect("inherit Cursor restart fixture should spawn");
+    assert_cursor_proxy_spawn(&restart_inherit_transport.single_spawn(), false);
+}
+
+fn assert_cursor_proxy_spawn(spawn: &RecordedSpawn, direct: bool) {
+    let keys = [
+        "HTTPS_PROXY",
+        "HTTP_PROXY",
+        "ALL_PROXY",
+        "https_proxy",
+        "http_proxy",
+        "all_proxy",
+        "GLOBAL_AGENT_HTTPS_PROXY",
+        "GLOBAL_AGENT_HTTP_PROXY",
+    ];
+    for key in keys {
+        if direct {
+            assert!(!spawn.env.contains_key(key), "direct env must omit {key}");
+            assert!(
+                spawn.env_unset.iter().any(|candidate| candidate == key),
+                "direct env_unset must contain {key}; got {:?}",
+                spawn.env_unset
+            );
+        } else {
+            assert!(spawn.env.contains_key(key), "inherit env must preserve {key}");
+            assert!(
+                spawn.env_unset.iter().all(|candidate| candidate != key),
+                "inherit env_unset must not contain {key}; got {:?}",
+                spawn.env_unset
+            );
+        }
+    }
+    for key in ["NO_PROXY", "no_proxy"] {
+        assert!(spawn.env.contains_key(key), "NO_PROXY bypass key must remain: {key}");
+        assert!(
+            spawn.env_unset.iter().all(|candidate| candidate != key),
+            "NO_PROXY bypass key must not be unset: {key}"
+        );
+    }
+}
+
 #[test]
 fn tmux_control_filter_uses_env_keys_not_substring_in_inherited_values() {
     let mut env = BTreeMap::from([
@@ -410,6 +507,39 @@ fn compiled_team_dir(label: &str, agents: &[(&str, &str)]) -> PathBuf {
     compiled_team_dir_for_provider(label, agents, "codex")
 }
 
+fn compiled_cursor_profile_team(label: &str, proxy_mode: &str) -> PathBuf {
+    let team = tmp_dir(label).join("teamdir");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(
+        team.join("TEAM.md"),
+        "---\nname: envteam\nobjective: Cursor proxy environment contract.\nprovider: cursor_agent\n---\n\nTeam.\n",
+    )
+    .unwrap();
+    std::fs::write(
+        team.join("agents").join("worker_a.md"),
+        "---\nname: worker_a\nrole: Cursor Worker\nprovider: cursor_agent\nmodel: sonnet-4-thinking\nauth_mode: subscription\nprofile: cursor_proxy\ndangerously_skip_permissions: false\ntools:\n  - mcp_team\n---\n\nCursor worker.\n",
+    )
+    .unwrap();
+    for directory in [
+        team.join("profiles"),
+        team.join(".team/current/profiles"),
+    ] {
+        std::fs::create_dir_all(&directory).unwrap();
+        std::fs::write(
+            directory.join("cursor_proxy.env"),
+            format!("AUTH_MODE=subscription\nPROFILE_NAME=cursor_proxy\nPROXY_MODE={proxy_mode}\n"),
+        )
+        .unwrap();
+    }
+    let spec = team_agent::compiler::compile_team(&team).unwrap();
+    std::fs::write(
+        team.join("team.spec.yaml"),
+        team_agent::model::yaml::dumps(&spec),
+    )
+    .unwrap();
+    team
+}
+
 fn compiled_team_dir_for_provider(label: &str, agents: &[(&str, &str)], provider: &str) -> PathBuf {
     let team = tmp_dir(label).join("teamdir");
     std::fs::create_dir_all(team.join("agents")).unwrap();
@@ -450,6 +580,13 @@ fn seed_restart_state(team: &Path, agent_id: &str) {
     seed_restart_state_as(team, agent_id, "codex");
 }
 
+fn seed_restart_state_with_profile(team: &Path, agent_id: &str, profile: &str) {
+    seed_restart_state_as(team, agent_id, "cursor_agent");
+    let mut state = team_agent::state::persist::load_runtime_state(team).unwrap();
+    state["agents"][agent_id]["profile"] = json!(profile);
+    team_agent::state::persist::save_runtime_state(team, &state).unwrap();
+}
+
 fn seed_restart_state_as(team: &Path, agent_id: &str, provider: &str) {
     team_agent::state::persist::save_runtime_state(
         team,

package/crates/team-agent/src/lifecycle/types.rs

@@ -544,6 +544,8 @@ pub struct LaunchReport {
     pub permissions: Vec<PermissionSummary>,
     /// leader receiver(attach 成功时;经 step10 leader::attach_leader_to_state)。
     pub leader_receiver_attached: bool,
+    pub leader_bind_stage: Option<String>,
+    pub leader_bind_reason: Option<String>,
     pub session_capture_incomplete_agents: Vec<String>,
 }
 
@@ -619,6 +621,7 @@ pub enum QuickStartReport {
         /// [`QuickStartReadiness::PendingToolLoad`] (or `Degraded` if any agent
         /// failed to spawn) so the CLI surface cannot lie about availability.
         worker_readiness: QuickStartReadiness,
+        team: String,
     },
     /// 已有 runtime state → quick-start 拒绝并引导用 restart。
     ExistingRuntime {
@@ -627,6 +630,7 @@ pub enum QuickStartReport {
         state_path: Option<PathBuf>,
         next_actions: Vec<String>,
         attach_commands: Vec<String>,
+        agent_ids: Vec<String>,
     },
     /// preflight 阻塞(`quick_start.py:59`)。
     PreflightBlocked {
@@ -799,6 +803,8 @@ pub enum RestartReport {
         attach_commands: Vec<String>,
         /// Debt returned by this restart's best-effort auto-attach, if any.
         attach_window_failures: Option<serde_json::Value>,
+        leader_bind_ok: bool,
+        leader_bind_reason: Option<String>,
     },
     /// At least one worker failed during live spawn, but other workers were isolated
     /// and restarted. The CLI reports `status=partial` and exits non-zero.
@@ -815,6 +821,8 @@ pub enum RestartReport {
         attach_commands: Vec<String>,
         /// Debt returned by this restart's best-effort auto-attach, if any.
         attach_window_failures: Option<serde_json::Value>,
+        leader_bind_ok: bool,
+        leader_bind_reason: Option<String>,
     },
     /// All workers failed during live spawn. No worker is reported as restarted.
     Failed {