@team-agent/installer 0.3.33 → 0.3.35

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.33"
+version = "0.3.35"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.33"
+version = "0.3.35"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -158,13 +158,7 @@ pub mod lifecycle_port {
             crate::leader::LeaderLaunchStatus::Detached => true,
             crate::leader::LeaderLaunchStatus::NotStarted => false,
         };
-        let leader_attach_command = if plan.is_external_leader {
-            None
-        } else {
-            plan.session_name.as_ref().and_then(|session| {
-                crate::tmux_backend::attach_command_for_workspace(cwd, session, "leader")
-            })
-        };
+        let leader_attach_command = leader_attach_command_for_plan(cwd, &plan);
         Ok(json!({
             "ok": ok,
             "provider": provider,
@@ -182,6 +176,18 @@ pub mod lifecycle_port {
             "session_name": plan.session_name.as_ref().map(|session| session.as_str().to_string()),
         }))
     }
+
+    pub(crate) fn leader_attach_command_for_plan(
+        cwd: &Path,
+        plan: &crate::leader::LeaderStartPlan,
+    ) -> Option<String> {
+        if plan.is_external_leader {
+            return None;
+        }
+        let session = plan.session_name.as_ref()?;
+        let window = plan.leader_window.as_ref()?;
+        crate::tmux_backend::attach_command_for_workspace(cwd, session, window.as_str())
+    }
     /// `runtime.shutdown`(`cmd_shutdown`)。
     pub fn shutdown(workspace: &Path, keep_logs: bool, team: Option<&str>) -> Result<Value, CliError> {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)

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

@@ -53,11 +53,15 @@ use rusqlite::params;
         let leader_attach_command = if is_external_leader {
             None
         } else {
+            let window_name = state
+                .pointer("/leader_receiver/window_name")
+                .and_then(Value::as_str)
+                .unwrap_or("leader");
             session_name.as_str().and_then(|session| {
                 crate::tmux_backend::attach_command_for_workspace(
                     workspace,
                     &crate::transport::SessionName::new(session.to_string()),
-                    "leader",
+                    window_name,
                 )
             })
         };

package/crates/team-agent/src/cli/tests/status_send.rs

@@ -86,6 +86,59 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn status_port_managed_attach_command_uses_receiver_window_name() {
+        let ws = seed_status_workspace();
+        let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        if let Some(obj) = state.as_object_mut() {
+            obj.insert("is_external_leader".to_string(), json!(false));
+            obj.insert("session_name".to_string(), json!("team-current"));
+            obj.insert(
+                "leader_receiver".to_string(),
+                json!({"pane_id": "%3", "window_name": "claude_code", "status": "attached"}),
+            );
+        }
+        crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+
+        let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
+
+        let attach = v["leader_attach_command"]
+            .as_str()
+            .expect("managed status includes attach command");
+        assert!(attach.contains("attach -t team-current:claude_code"), "{attach}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn leader_attach_command_for_plan_uses_plan_leader_window() {
+        let ws = tmp_workspace();
+        let plan = crate::leader::LeaderStartPlan {
+            mode: crate::leader::LeaderStartMode::ManagedTmuxClient,
+            provider: crate::provider::Provider::ClaudeCode,
+            workspace: ws.clone(),
+            socket: crate::leader::LeaderLaunchSocket::Workspace,
+            session_name: Some(crate::transport::SessionName::new(
+                "team-agent-leader-claude_code-demo".to_string(),
+            )),
+            argv: Vec::new(),
+            provider_argv: Vec::new(),
+            leader_window: Some(crate::transport::WindowName::new("claude_code")),
+            is_external_leader: false,
+            leader_env: std::collections::BTreeMap::new(),
+            identity: None,
+            detached: false,
+        };
+
+        let attach = lifecycle_port::leader_attach_command_for_plan(&ws, &plan)
+            .expect("managed plan has attach command");
+
+        assert!(
+            attach.contains("attach -t team-agent-leader-claude_code-demo:claude_code"),
+            "{attach}"
+        );
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn status_port_missing_topology_marker_defaults_to_managed() {
         let ws = seed_status_workspace();

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

@@ -7,7 +7,9 @@ use std::process::{Command, Stdio};
 
 use crate::provider::{get_adapter, Provider};
 use crate::tmux_backend::TmuxBackend;
-use crate::transport::{PaneId, SessionName, SpawnResult, Target, Transport, WindowName};
+use crate::transport::{
+    PaneId, PaneLiveness, SessionName, SpawnResult, Target, Transport, WindowName,
+};
 
 use super::helpers::{
     provider_wire, resolve_workspace_for_hash, sanitize_session_folder, sha1_hex_prefix,
@@ -405,6 +407,7 @@ fn execute_managed_leader_plan(
                 .unwrap_or_else(|| "signal".to_string())
         )));
     }
+    ensure_managed_provider_live_after_attach(&transport, &spawned)?;
     Ok(LeaderLaunchOutcome {
         status: LeaderLaunchStatus::Exited,
         exit_code: code,
@@ -414,7 +417,7 @@ fn execute_managed_leader_plan(
 }
 
 fn ensure_managed_leader_pane(
-    transport: &TmuxBackend,
+    transport: &dyn Transport,
     session: &SessionName,
     window: &WindowName,
     plan: &LeaderStartPlan,
@@ -455,6 +458,39 @@ fn ensure_managed_leader_pane(
     }
 }
 
+fn ensure_managed_provider_live_after_attach(
+    transport: &dyn Transport,
+    spawned: &SpawnResult,
+) -> Result<(), LeaderError> {
+    let live = match transport.liveness(&spawned.pane_id) {
+        Ok(PaneLiveness::Live) => true,
+        Ok(PaneLiveness::Dead) => false,
+        Ok(PaneLiveness::Unknown) | Err(_) => managed_spawned_pane_in_targets(transport, spawned),
+    };
+    if live {
+        return Ok(());
+    }
+    Err(LeaderError::Start(format!(
+        "managed leader provider pane is not running after tmux client returned: {} {}:{}",
+        spawned.pane_id.as_str(),
+        spawned.session.as_str(),
+        spawned.window.as_str()
+    )))
+}
+
+fn managed_spawned_pane_in_targets(transport: &dyn Transport, spawned: &SpawnResult) -> bool {
+    transport
+        .list_targets()
+        .unwrap_or_default()
+        .iter()
+        .any(|pane| {
+            pane.pane_id.as_str() == spawned.pane_id.as_str()
+                && pane.session.as_str() == spawned.session.as_str()
+                && pane.window_name.as_ref().map(WindowName::as_str)
+                    == Some(spawned.window.as_str())
+        })
+}
+
 fn persist_managed_leader_binding(
     plan: &LeaderStartPlan,
     workspace: &Path,
@@ -911,11 +947,16 @@ mod tests {
         TurnVerification, WindowName,
     };
 
-    use super::{execute_leader_plan, handle_exec_provider_startup_prompts, shlex_quote};
+    use super::{
+        ensure_managed_provider_live_after_attach, execute_leader_plan,
+        handle_exec_provider_startup_prompts, shlex_quote,
+    };
 
     struct ScriptedTransport {
         screens: Mutex<Vec<String>>,
         sent: Mutex<Vec<(Target, Vec<Key>)>>,
+        liveness: PaneLiveness,
+        targets: Vec<PaneInfo>,
     }
 
     impl ScriptedTransport {
@@ -923,6 +964,26 @@ mod tests {
             Self {
                 screens: Mutex::new(screens),
                 sent: Mutex::new(Vec::new()),
+                liveness: PaneLiveness::Unknown,
+                targets: Vec::new(),
+            }
+        }
+
+        fn with_liveness(liveness: PaneLiveness) -> Self {
+            Self {
+                screens: Mutex::new(Vec::new()),
+                sent: Mutex::new(Vec::new()),
+                liveness,
+                targets: Vec::new(),
+            }
+        }
+
+        fn with_liveness_and_targets(liveness: PaneLiveness, targets: Vec<PaneInfo>) -> Self {
+            Self {
+                screens: Mutex::new(Vec::new()),
+                sent: Mutex::new(Vec::new()),
+                liveness,
+                targets,
             }
         }
 
@@ -1024,11 +1085,11 @@ mod tests {
         }
 
         fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
-            Ok(PaneLiveness::Unknown)
+            Ok(self.liveness)
         }
 
         fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-            Ok(Vec::new())
+            Ok(self.targets.clone())
         }
 
         fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
@@ -1063,6 +1124,69 @@ mod tests {
         }
     }
 
+    fn managed_spawn_result() -> SpawnResult {
+        SpawnResult {
+            pane_id: PaneId::new("%42"),
+            session: SessionName::new("team-agent-leader-claude_code-demo"),
+            window: WindowName::new("claude_code"),
+            child_pid: Some(1234),
+        }
+    }
+
+    fn managed_pane_info(spawned: &SpawnResult) -> PaneInfo {
+        PaneInfo {
+            pane_id: spawned.pane_id.clone(),
+            session: spawned.session.clone(),
+            window_index: Some(0),
+            window_name: Some(spawned.window.clone()),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("claude".to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: spawned.child_pid,
+            leader_env: BTreeMap::new(),
+        }
+    }
+
+    #[test]
+    fn managed_attach_success_requires_live_provider_pane() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness(PaneLiveness::Dead);
+
+        let err = ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect_err("dead provider pane must fail managed launch");
+
+        let text = err.to_string();
+        assert!(
+            text.contains("managed leader provider pane is not running"),
+            "{text}"
+        );
+        assert!(text.contains("%42"), "{text}");
+        assert!(text.contains("claude_code"), "{text}");
+    }
+
+    #[test]
+    fn managed_attach_success_accepts_live_provider_pane() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness(PaneLiveness::Live);
+
+        ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect("live provider pane keeps managed launch successful");
+    }
+
+    #[test]
+    fn managed_attach_success_uses_target_scan_when_liveness_unknown() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness_and_targets(
+            PaneLiveness::Unknown,
+            vec![managed_pane_info(&spawned)],
+        );
+
+        ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect("target scan can prove provider pane is still live");
+    }
+
     struct EnvGuard {
         saved: Vec<(&'static str, Option<String>)>,
     }

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -471,7 +471,10 @@ pub(super) fn resume_backing_exists_for_agent(
             let _ = (workspace, agent_id, agent, session_id, rollout_path);
             false
         }
-        Provider::Codex => rollout_path_exists(rollout_path),
+        Provider::Codex => {
+            rollout_path_exists(rollout_path)
+                || codex_session_transcript_exists(agent, session_id.as_str(), rollout_path)
+        }
         Provider::Claude | Provider::ClaudeCode => {
             rollout_path_exists(rollout_path)
                 || event_log_transcript_exists(workspace, agent_id.as_str(), session_id.as_str())
@@ -557,6 +560,68 @@ fn claude_project_transcript_exists(agent: &serde_json::Value, session_id: &str)
         .any(|entry| entry.path().join(&transcript_name).is_file())
 }
 
+fn codex_session_transcript_exists(
+    agent: &serde_json::Value,
+    session_id: &str,
+    rollout_path: Option<&RolloutPath>,
+) -> bool {
+    if session_id.is_empty() {
+        return false;
+    }
+    let mut roots = Vec::new();
+    if let Some(parent) = rollout_path
+        .map(RolloutPath::as_path)
+        .and_then(Path::parent)
+        .filter(|path| path.is_dir())
+    {
+        roots.push(parent.to_path_buf());
+    }
+    if let Some(root) = agent
+        .get("codex_sessions_root")
+        .and_then(serde_json::Value::as_str)
+        .filter(|path| !path.is_empty())
+        .map(PathBuf::from)
+        .filter(|path| path.is_dir())
+    {
+        roots.push(root);
+    }
+    if let Some(root) = std::env::var_os("HOME")
+        .map(PathBuf::from)
+        .map(|home| home.join(".codex").join("sessions"))
+        .filter(|path| path.is_dir())
+    {
+        roots.push(root);
+    }
+    roots.sort();
+    roots.dedup();
+    roots
+        .iter()
+        .any(|root| session_transcript_exists_under(root, session_id, 4))
+}
+
+fn session_transcript_exists_under(root: &Path, session_id: &str, max_depth: usize) -> bool {
+    let Ok(entries) = std::fs::read_dir(root) else {
+        return false;
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_file() {
+            let Some(name) = path.file_name().and_then(|name| name.to_str()) else {
+                continue;
+            };
+            if name.ends_with(".jsonl") && name.contains(session_id) {
+                return true;
+            }
+        } else if max_depth > 0
+            && path.is_dir()
+            && session_transcript_exists_under(&path, session_id, max_depth.saturating_sub(1))
+        {
+            return true;
+        }
+    }
+    false
+}
+
 fn copilot_session_store_has_session(session_id: &str) -> bool {
     let Some(home) = std::env::var_os("HOME").map(PathBuf::from) else {
         return false;
@@ -1082,4 +1147,41 @@ mod e36_transcript_backing_tests {
         let agent = serde_json::json!({});
         assert!(!claude_project_transcript_exists(&agent, ""));
     }
+
+    #[test]
+    fn codex_session_transcript_is_recognized_when_rollout_path_is_stale() {
+        let scratch = ScratchDir::new("codex-recognized");
+        let sessions_root = scratch.path().join("sessions");
+        let dated = sessions_root.join("2026").join("06").join("20");
+        std::fs::create_dir_all(&dated).expect("mkdir dated sessions");
+        let session_id = "019ee540-37ed-7a20-a141-1d654224d209";
+        std::fs::write(
+            dated.join(format!("rollout-2026-06-20T21-37-31-{session_id}.jsonl")),
+            b"{}\n",
+        )
+        .expect("codex transcript");
+
+        let stale = RolloutPath::new(scratch.path().join("old").join("missing.jsonl"));
+        let agent = serde_json::json!({
+            "codex_sessions_root": sessions_root.to_string_lossy(),
+        });
+        assert!(
+            codex_session_transcript_exists(&agent, session_id, Some(&stale)),
+            "matching codex transcript under codex_sessions_root must count as resume backing"
+        );
+    }
+
+    #[test]
+    fn missing_codex_session_transcript_is_not_backing() {
+        let scratch = ScratchDir::new("codex-missing");
+        let sessions_root = scratch.path().join("sessions");
+        std::fs::create_dir_all(&sessions_root).expect("mkdir sessions");
+        let agent = serde_json::json!({
+            "codex_sessions_root": sessions_root.to_string_lossy(),
+        });
+        assert!(
+            !codex_session_transcript_exists(&agent, "019ee540-ffff-7a20-a141-1d654224d209", None,),
+            "no matching codex transcript => no backing"
+        );
+    }
 }

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -172,7 +172,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     if !convergence.converged && convergence.changed {
         save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
     }
-    let mut forced_fresh_missing = if convergence.converged {
+    let forced_fresh_missing = if convergence.converged {
         std::collections::BTreeSet::new()
     } else {
         convergence.missing.iter().cloned().collect()
@@ -183,12 +183,6 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         &state,
         allow_fresh,
     )?;
-    for decision in &plan.decisions {
-        if matches!(decision.decision, ResumeDecision::FreshStart) && decision.session_id.is_some()
-        {
-            forced_fresh_missing.insert(decision.agent_id.as_str().to_string());
-        }
-    }
     write_restart_resume_decision_events(
         &selected.run_workspace,
         &state,

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

@@ -43,6 +43,7 @@ pub use rebuild::{
     restart, restart_candidates, restart_with_session_convergence_deadline, restart_with_transport,
     restart_with_transport_with_readiness_deadline, select_restart_state,
 };
+pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline;
 pub use remove::{remove_agent, remove_agent_with_transport};
 pub use selection::{classify_first_send_at, classify_restart_plan, decide_start_mode, python_type_name};
 pub(crate) use team_state::write_team_state;

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

@@ -1533,6 +1533,107 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
     );
 }
 
+#[test]
+fn restart_allow_fresh_does_not_force_fresh_other_agents_when_one_session_capture_times_out() {
+    let ws = temp_ws().join("restartatomic");
+    std::fs::create_dir_all(ws.join("agents")).unwrap();
+    std::fs::write(
+        ws.join("TEAM.md"),
+        "---\nname: restartatomic\nobjective: Restart atomicity probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(ws.join("agents").join("alpha.md"), DELEG_ROLE_ALPHA).unwrap();
+    std::fs::write(ws.join("agents").join("bravo.md"), DELEG_ROLE_BRAVO).unwrap();
+
+    let sessions_root = ws.join("codex-sessions");
+    let dated = sessions_root.join("2026").join("06").join("20");
+    std::fs::create_dir_all(&dated).unwrap();
+    let alpha_session = "019ee540-37ed-7a20-a141-1d654224d209";
+    std::fs::write(
+        dated.join(format!(
+            "rollout-2026-06-20T21-37-31-{alpha_session}.jsonl"
+        )),
+        "{}\n",
+    )
+    .unwrap();
+
+    let spec = crate::compiler::compile_team(&ws).expect("compile restart team");
+    std::fs::write(ws.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-restartatomic",
+            "agents": {
+                "alpha": {
+                    "status": "running",
+                    "provider": "codex",
+                    "session_id": alpha_session,
+                    "rollout_path": ws.join("stale").join("missing-alpha.jsonl").to_string_lossy(),
+                    "codex_sessions_root": sessions_root.to_string_lossy(),
+                    "first_send_at": "2026-05-27T10:00:00+00:00"
+                },
+                "bravo": {
+                    "status": "running",
+                    "provider": "codex",
+                    "session_id": null,
+                    "spawn_cwd": ws.to_string_lossy(),
+                    "first_send_at": "2026-05-27T10:00:00+00:00"
+                }
+            }
+        }),
+    )
+    .unwrap();
+    seed_healthy_coordinator(&ws);
+    let transport = OfflineTransport::new();
+
+    let result = restart_with_transport_with_session_convergence_deadline(
+        &ws,
+        true,
+        None,
+        &transport,
+        Some(0),
+        None,
+    );
+
+    assert!(
+        matches!(result, Ok(RestartReport::Restarted { .. })),
+        "allow-fresh restart should complete with alpha resumed and bravo fresh; got {result:?}"
+    );
+    let events = crate::event_log::EventLog::new(&ws).tail(80).unwrap();
+    let decisions = events
+        .iter()
+        .filter(|event| {
+            event.get("event").and_then(|v| v.as_str()) == Some("restart.resume_decision")
+        })
+        .collect::<Vec<_>>();
+    let alpha = decisions
+        .iter()
+        .find(|event| event.get("worker_id").and_then(|v| v.as_str()) == Some("alpha"))
+        .expect("alpha decision");
+    assert_eq!(
+        alpha.get("decision").and_then(|v| v.as_str()),
+        Some("resume"),
+        "alpha has session_id plus matching codex transcript and must not be forced fresh: {alpha}"
+    );
+    assert!(
+        alpha.get("forced_fresh").is_none(),
+        "alpha must not inherit bravo's convergence timeout: {alpha}"
+    );
+    let bravo = decisions
+        .iter()
+        .find(|event| event.get("worker_id").and_then(|v| v.as_str()) == Some("bravo"))
+        .expect("bravo decision");
+    assert_eq!(
+        bravo.get("decision").and_then(|v| v.as_str()),
+        Some("fresh_start")
+    );
+    assert_eq!(
+        bravo.get("forced_fresh").and_then(|v| v.as_bool()),
+        Some(true),
+        "only the missing-session agent should carry forced_fresh: {bravo}"
+    );
+}
+
 #[test]
 fn restart_spawn_failure_isolated_to_partial_report() {
     let ws = restart_ws_two_resumable_workers();

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

@@ -1476,7 +1476,6 @@ fn claude_base_command(
         };
         argv.push("--mcp-config".to_string());
         argv.push(raw.to_string());
-        argv.push("--strict-mcp-config".to_string());
     }
     for tool in claude_disallowed_tools(tools) {
         argv.push("--disallowedTools".to_string());

package/crates/team-agent/src/provider/tests/adapter.rs

@@ -215,6 +215,31 @@ fn build_command_includes_model_and_system_prompt() {
     );
 }
 
+#[test]
+fn claude_mcp_config_does_not_enable_strict_mode() {
+    let adapter = get_adapter(Provider::ClaudeCode);
+    let config = adapter
+        .mcp_config(AuthMode::Subscription)
+        .expect("mcp config");
+    let argv = adapter
+        .build_command(
+            AuthMode::Subscription,
+            Some(&config),
+            Some("worker"),
+            Some("opus"),
+        )
+        .expect("build command with mcp config");
+
+    assert!(
+        argv_contains_adjacent(&argv, &["--mcp-config"]),
+        "Claude worker argv must still pass Team Agent MCP config: {argv:?}"
+    );
+    assert!(
+        !argv.iter().any(|arg| arg == "--strict-mcp-config"),
+        "--mcp-config must merge with user-level Claude MCP; strict mode hides user MCP: {argv:?}"
+    );
+}
+
 #[test]
 fn unsupported_provider_capability_error_message_shape() {
     // unsupported.py:31 ProviderCapabilityError — placeholder providers reject
@@ -236,4 +261,3 @@ fn unsupported_provider_capability_error_message_shape() {
 // ═══════════════ P2 FIX-LOOP RED (复绿即对抗 cross-model findings) ═══════════════
 // Lock the CORRECT Python v0.2.11 behavior the strengthened contracts missed.
 // Golden re-probed via /tmp/probe_p2_provider.py vs team-agent-public @ 439bef8.
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.33",
+  "version": "0.3.35",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.3.33",
-    "@team-agent/cli-darwin-x64": "0.3.33",
-    "@team-agent/cli-linux-x64": "0.3.33"
+    "@team-agent/cli-darwin-arm64": "0.3.35",
+    "@team-agent/cli-darwin-x64": "0.3.35",
+    "@team-agent/cli-linux-x64": "0.3.35"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",