@team-agent/installer 0.3.6 → 0.3.8

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

@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 
 use serde_json::Value;
 
-use crate::model::paths::{canonical_run_workspace, team_workspace};
+use crate::model::paths::{canonical_run_workspace, runtime_spec_path, team_workspace};
 use crate::state::persist::{load_runtime_state, runtime_state_path};
 use crate::state::projection::{select_runtime_state, team_state_key};
 use crate::state::StateError;
@@ -20,7 +20,13 @@ pub struct SelectedTeam {
     pub run_workspace: PathBuf,
     pub team_key: String,
     pub state: Value,
+    /// E5 §3 解耦:**角色定义目录**(用户目录,含 TEAM.md+agents/*.md+profiles)。
+    /// 给 compile_team / 找角色定义 / profiles。**永远是用户目录**,不是 spec 落点。
+    /// 来源 = state.team_dir;缺则回落 run_workspace(自含 team-dir 布局)。
+    pub team_dir: PathBuf,
+    /// spec yaml 所在目录(demote 后 = .team/runtime/<team_key>/)。读写 spec yaml 用。
     pub spec_workspace: Option<PathBuf>,
+    /// spec yaml 路径(= runtime_spec_path(run_ws, team_key))。读写 spec yaml 用。
     pub spec_path: Option<PathBuf>,
 }
 
@@ -30,7 +36,7 @@ pub fn resolve_active_team(
     mode: SelectorMode,
 ) -> Result<SelectedTeam, StateError> {
     let explicit_spec = input.join("team.spec.yaml");
-    let (run_workspace, state, spec_workspace) = if explicit_spec.exists() {
+    let (run_workspace, state) = if explicit_spec.exists() {
         let team_run = team_workspace(input).map_err(|e| StateError::TeamSelect(e.to_string()))?;
         let run = if runtime_state_path(input).exists() || !runtime_state_path(&team_run).exists() {
             input.to_path_buf()
@@ -38,7 +44,7 @@ pub fn resolve_active_team(
             team_run
         };
         let state = select_runtime_state(&run, team).or_else(|_| load_runtime_state(&run))?;
-        (run, state, Some(input.to_path_buf()))
+        (run, state)
     } else {
         let run = canonical_run_workspace(input)
             .map_err(|e| StateError::TeamSelect(e.to_string()))?;
@@ -53,30 +59,58 @@ pub fn resolve_active_team(
             )));
         }
         let state = select_runtime_state(&run, team).or_else(|_| load_runtime_state(&run))?;
-        let spec_workspace = spec_workspace_from_state(&state)
-            .or_else(|| run.join("team.spec.yaml").exists().then(|| run.clone()));
-        (run, state, spec_workspace)
+        (run, state)
     };
 
-    let spec_path = spec_workspace.as_ref().map(|workspace| workspace.join("team.spec.yaml"));
+    // E5 spec 迁移·读序 B(architect+leader 裁定):
+    //   1) runtime spec 优先严格:<run_ws>/.team/runtime/<team_key>/team.spec.yaml 存在即必用。
+    //   2) 缺失才**只读回落**用户目录旧 spec(过渡腿;绝不在此写/迁移——迁移+清理只属启动重建)。
+    // TODO(E5 后续版本):新 team 永不写用户目录(G1),回落腿可在 legacy 清零后移除。
+    let team_key = selected_team_key(&state, team);
+    let runtime_spec = runtime_spec_path(&run_workspace, &team_key);
+    let (spec_workspace, spec_path) = if runtime_spec.exists() {
+        (
+            runtime_spec.parent().map(Path::to_path_buf),
+            Some(runtime_spec.clone()),
+        )
+    } else {
+        // 回落(只读):优先 explicit input/team.spec.yaml,其次 state 推断的 spec_workspace。
+        let legacy_ws = if explicit_spec.exists() {
+            Some(input.to_path_buf())
+        } else {
+            spec_workspace_from_state(&state)
+                .or_else(|| run_workspace.join("team.spec.yaml").exists().then(|| run_workspace.clone()))
+        };
+        let legacy_spec = legacy_ws.as_ref().map(|ws| ws.join("team.spec.yaml"));
+        (legacy_ws, legacy_spec)
+    };
     if matches!(mode, SelectorMode::RequireSpec) && !spec_path.as_ref().is_some_and(|path| path.exists()) {
-        let expected = spec_path
-            .as_ref()
-            .cloned()
-            .unwrap_or_else(|| run_workspace.join("team.spec.yaml"));
+        // 期望路径报 canonical runtime spec(重建落点),非用户目录。
+        let expected = spec_path.as_ref().cloned().unwrap_or(runtime_spec);
+        // E5 Bug2 N38:spec=中间产物,运行期由 restart 以角色定义重建;首装走 quick-start;
+        // 加新角色用 add-agent。不再提 reconcile(已废)。
         return Err(StateError::TeamSelect(format!(
-            "active team spec not found: input_workspace={} run_workspace={} team_key={} expected_spec_path={} hint=run quick-start or pass --team/--workspace <teamdir>",
+            "active team spec not found: input_workspace={} run_workspace={} team_key={} expected_spec_path={} hint=run `team-agent restart` to rebuild it from the role docs, or `team-agent quick-start <teamdir>` for first launch (to add a role at runtime use `team-agent add-agent <id> --role-file <path>`)",
             input.display(),
             run_workspace.display(),
-            selected_team_key(&state, team),
+            team_key,
             expected.display()
         )));
     }
 
+    // E5 §3 解耦:team_dir = 角色定义目录(用户目录),恒取 state.team_dir;缺则回落 run_workspace。
+    let team_dir = state
+        .get("team_dir")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .map(PathBuf::from)
+        .unwrap_or_else(|| run_workspace.clone());
+
     Ok(SelectedTeam {
         run_workspace,
-        team_key: selected_team_key(&state, team),
+        team_key,
         state,
+        team_dir,
         spec_workspace,
         spec_path,
     })

package/crates/team-agent/src/tmux_backend/tests.rs

@@ -503,6 +503,50 @@
         );
     }
 
+    #[test]
+    fn has_pane_is_direct_existence_probe_not_liveness_guess() {
+        let (be, rec) = backend_with(MockResp::Out(ok("%7")), vec![]);
+        assert_eq!(be.has_pane(&PaneId::new("%7")).expect("has_pane"), Some(true));
+        let argv0 = rec.lock().unwrap()[0].clone();
+        assert!(
+            argv0.contains(&"display-message".to_string())
+                && argv0.iter().any(|x| x.contains("#{pane_id}"))
+                && argv0.contains(&"%7".to_string()),
+            "has_pane must use the cheap display-message #{{pane_id}} probe; got {argv0:?}"
+        );
+
+        let (be, _r) = backend_with(MockResp::Out(ok("")), vec![]);
+        assert_eq!(
+            be.has_pane(&PaneId::new("%9999")).expect("has_pane"),
+            Some(false),
+            "real tmux can report a missing pane as exit 0 with empty stdout"
+        );
+
+        let (be, _r) = backend_with(MockResp::Out(fail(1, "can't find pane: %9999")), vec![]);
+        assert_eq!(be.has_pane(&PaneId::new("%9999")).expect("has_pane"), Some(false));
+
+        let (be, _r) = backend_with(MockResp::Out(ok("%8")), vec![]);
+        assert_eq!(
+            be.has_pane(&PaneId::new("%7")).expect("has_pane"),
+            None,
+            "a successful but mismatched pane id is not proof that the requested pane exists"
+        );
+
+        let (be, _r) = backend_with(MockResp::Out(ok("not-a-pane")), vec![]);
+        assert_eq!(
+            be.has_pane(&PaneId::new("%7")).expect("has_pane"),
+            None,
+            "a successful but invalid pane id stays Unknown"
+        );
+
+        let (be, _r) = backend_with(MockResp::Out(fail(1, "error connecting to server: No such file or directory")), vec![]);
+        assert_eq!(
+            be.has_pane(&PaneId::new("%7")).expect("has_pane"),
+            None,
+            "server/probe errors remain Unknown, not absent"
+        );
+    }
+
     // ── CP-1: per-team socket — for_workspace injects `-L ta-<hash>` at the run chokepoint; new() does NOT ─
     #[test]
     fn for_workspace_backend_injects_per_team_socket_but_default_backend_does_not() {

package/crates/team-agent/src/tmux_backend.rs

@@ -18,6 +18,7 @@
 use std::collections::BTreeMap;
 use std::hash::{Hash, Hasher};
 use std::io::{Read, Write};
+use std::os::unix::fs::FileTypeExt;
 use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::time::{Duration, Instant};
@@ -331,6 +332,20 @@ pub(crate) fn socket_name_for_workspace(workspace: &Path) -> String {
 }
 
 pub(crate) fn socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
+    if let Some(existing) = existing_socket_path_for_workspace(workspace) {
+        return Some(existing);
+    }
+    let uid = unsafe { libc::geteuid() };
+    let default_root = PathBuf::from(format!("/tmp/tmux-{uid}"));
+    let default_root = default_root.canonicalize().unwrap_or(default_root);
+    Some(default_root.join(socket_name_for_workspace(workspace)))
+}
+
+pub(crate) fn socket_probe_missing_for_workspace(workspace: &Path) -> bool {
+    existing_socket_path_for_workspace(workspace).is_none()
+}
+
+fn existing_socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
     let socket_name = socket_name_for_workspace(workspace);
     let roots = tmux_socket_roots();
     for root in &roots {
@@ -340,12 +355,19 @@ pub(crate) fn socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
             return Some(candidate.canonicalize().unwrap_or(candidate));
         }
     }
-    let uid = unsafe { libc::geteuid() };
-    let default_root = PathBuf::from(format!("/tmp/tmux-{uid}"));
-    let default_root = default_root
-        .canonicalize()
-        .unwrap_or(default_root);
-    Some(default_root.join(socket_name))
+    None
+}
+
+pub(crate) fn socket_missing_hint_for_workspace(workspace: &Path) -> String {
+    let socket_name = socket_name_for_workspace(workspace);
+    let roots = tmux_socket_roots()
+        .into_iter()
+        .map(|root| root.display().to_string())
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!(
+        "tmux socket {socket_name} not found under [{roots}]; run `team-agent attach-leader` or restart the team before attaching"
+    )
 }
 
 pub(crate) fn attach_command_for_workspace(
@@ -373,7 +395,7 @@ pub(crate) fn attach_commands_for_windows<'a>(
         .collect()
 }
 
-fn tmux_socket_roots() -> Vec<PathBuf> {
+pub(crate) fn tmux_socket_roots() -> Vec<PathBuf> {
     let uid = unsafe { libc::geteuid() };
     let mut roots = vec![PathBuf::from(format!("/tmp/tmux-{uid}"))];
     if let Some(tmpdir) = std::env::var_os("TMPDIR") {
@@ -384,6 +406,29 @@ fn tmux_socket_roots() -> Vec<PathBuf> {
     roots
 }
 
+pub(crate) fn tmux_socket_endpoints() -> Vec<String> {
+    let mut endpoints = Vec::new();
+    for root in tmux_socket_roots() {
+        let Ok(entries) = std::fs::read_dir(root) else {
+            continue;
+        };
+        for entry in entries.flatten() {
+            let Ok(file_type) = entry.file_type() else {
+                continue;
+            };
+            if !file_type.is_socket() {
+                continue;
+            }
+            let path = entry.path();
+            let path = path.canonicalize().unwrap_or(path);
+            endpoints.push(path.to_string_lossy().to_string());
+        }
+    }
+    endpoints.sort();
+    endpoints.dedup();
+    endpoints
+}
+
 pub(crate) fn socket_name_from_tmux_env() -> Option<String> {
     let tmux = std::env::var("TMUX")
         .ok()
@@ -448,9 +493,21 @@ impl TmuxBackend {
         ];
         let output = self.run_spawn(&pane_argv)?;
         let pane = output.stdout.trim();
-        let pane_id = if pane.is_empty() { "%0" } else { pane };
+        // T3-5 (harvest §1): never fabricate a `%0` pane id on an empty reply — a fake
+        // pane id mis-addresses every later inject/capture/kill. Surface the miss.
+        if pane.is_empty() {
+            return Err(TransportError::Subprocess {
+                argv: pane_argv,
+                code: output.code,
+                stderr: format!(
+                    "tmux display-message returned no pane id for {}:{}",
+                    session.as_str(),
+                    window.as_str()
+                ),
+            });
+        }
         Ok(SpawnResult {
-            pane_id: PaneId::new(pane_id),
+            pane_id: PaneId::new(pane),
             session: session.clone(),
             window: window.clone(),
             child_pid: None,
@@ -661,6 +718,10 @@ impl Transport for TmuxBackend {
         BackendKind::Tmux
     }
 
+    fn probes_real_tmux_socket_roots(&self) -> bool {
+        true
+    }
+
     fn spawn_first(
         &self,
         session: &SessionName,
@@ -847,6 +908,40 @@ impl Transport for TmuxBackend {
         }
     }
 
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "display-message".to_string(),
+            "-p".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            "#{pane_id}".to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if output.success {
+            let pane_id = output.stdout.trim();
+            if pane_id.is_empty() {
+                return Ok(Some(false));
+            }
+            if pane_id == pane.as_str()
+                && pane_id.starts_with('%')
+                && pane_id[1..].chars().all(|ch| ch.is_ascii_digit())
+            {
+                return Ok(Some(true));
+            }
+            return Ok(None);
+        }
+        let stderr = output.stderr.to_ascii_lowercase();
+        if stderr.contains("can't find pane")
+            || stderr.contains("no such pane")
+            || (stderr.contains("can't find") && stderr.contains("pane"))
+        {
+            Ok(Some(false))
+        } else {
+            Ok(None)
+        }
+    }
+
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
         // P5 (C-P5-3): `#{pane_pid}` rides the single list-panes call (field index 11),
         // killing the per-pane display-message N+1 fallback.

package/crates/team-agent/src/transport/test_support.rs

@@ -18,18 +18,39 @@ pub struct SpawnRecord {
     pub argv: Vec<String>,
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 struct OfflineState {
     session_present: bool,
     session_absent_after_spawn_first: bool,
     targets: Vec<PaneInfo>,
     windows: Vec<WindowName>,
+    pane_presence: BTreeMap<String, bool>,
+    liveness: BTreeMap<String, PaneLiveness>,
+    default_liveness: PaneLiveness,
     calls: Vec<&'static str>,
     spawns: Vec<SpawnRecord>,
     inject_targets: Vec<Target>,
     inject_payloads: Vec<String>,
 }
 
+impl Default for OfflineState {
+    fn default() -> Self {
+        Self {
+            session_present: false,
+            session_absent_after_spawn_first: false,
+            targets: Vec::new(),
+            windows: Vec::new(),
+            pane_presence: BTreeMap::new(),
+            liveness: BTreeMap::new(),
+            default_liveness: PaneLiveness::Unknown,
+            calls: Vec::new(),
+            spawns: Vec::new(),
+            inject_targets: Vec::new(),
+            inject_payloads: Vec::new(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct OfflineTransport {
     inner: Arc<Mutex<OfflineState>>,
@@ -60,6 +81,25 @@ impl OfflineTransport {
         self
     }
 
+    pub fn with_default_liveness(self, liveness: PaneLiveness) -> Self {
+        self.with_state(|state| state.default_liveness = liveness);
+        self
+    }
+
+    pub fn with_liveness(self, pane: impl Into<String>, liveness: PaneLiveness) -> Self {
+        self.with_state(|state| {
+            state.liveness.insert(pane.into(), liveness);
+        });
+        self
+    }
+
+    pub fn with_pane_presence(self, pane: impl Into<String>, present: bool) -> Self {
+        self.with_state(|state| {
+            state.pane_presence.insert(pane.into(), present);
+        });
+        self
+    }
+
     pub fn calls(&self) -> Vec<&'static str> {
         self.with_state(|state| state.calls.clone())
     }
@@ -198,9 +238,22 @@ impl Transport for OfflineTransport {
         Ok(None)
     }
 
-    fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
-        self.record("liveness");
-        Ok(PaneLiveness::Unknown)
+    fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
+        Ok(self.with_state(|state| {
+            state.calls.push("liveness");
+            state
+                .liveness
+                .get(pane.as_str())
+                .copied()
+                .unwrap_or(state.default_liveness)
+        }))
+    }
+
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        Ok(self.with_state(|state| {
+            state.calls.push("has_pane");
+            state.pane_presence.get(pane.as_str()).copied()
+        }))
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {

package/crates/team-agent/src/transport.rs

@@ -399,6 +399,12 @@ pub trait Transport: Send + Sync {
     /// 后端种类(诊断/事件用)。
     fn kind(&self) -> BackendKind;
 
+    /// Only the concrete tmux backend should scan real tmux socket roots.
+    /// Test doubles stay hermetic and use their injected probe results.
+    fn probes_real_tmux_socket_roots(&self) -> bool {
+        false
+    }
+
     // —— SPAWN(ST):所有后端天然满足;cwd/env 是 spawn 参数,无独立动词(§gap-setenv)——
 
     /// tmux=`new-session -d` / wezterm=`spawn --new-window` / conpty=`openpty`+spawn。
@@ -481,6 +487,13 @@ pub trait Transport: Send + Sync {
     /// pane 存活三态(`PaneLiveness`,bug-085 穷尽 match;unknown ≠ dead ≠ live)。
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError>;
 
+    /// Cheap direct pane existence check when a backend can prove it. `Ok(None)`
+    /// preserves the existing Unknown boundary.
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        let _ = pane;
+        Ok(None)
+    }
+
     // —— ENUMERATE / IDENTITY(SL + 进程探测):身份/rebind 地基 ——
 
     /// 全局枚举所有 pane + 每 pane 的 leader_env。tmux=`list-panes -a` + 读进程 env;

package/npm/install.mjs

@@ -80,13 +80,13 @@ function install(argv) {
   writeExecWrapper(path.join(binDir, "team-agent"), runtimeBinary, []);
   writeExecWrapper(path.join(binDir, "team_orchestrator"), runtimeBinary, ["mcp-server"]);
   writeExecWrapper(path.join(binDir, "team-agent-coordinator"), runtimeBinary, ["coordinator"]);
-  installSkills();
+  installSkills(runtimeBinary);
 
   const teamAgent = path.join(binDir, "team-agent");
   console.log(`installed: ${teamAgent}`);
   console.log(`runtime: ${dest}`);
   console.log(`binary: ${platformBinary.packageName}`);
-  console.log("skill: installed for Codex and Claude");
+  console.log("skill: installed for Codex, Claude and Copilot");
   console.log(`PATH: ensure ${binDir} is on PATH`);
 
   // 0.3.6 hotfix · C-5 cr verdict — post-install binary smoke 门(走 `--help`
@@ -149,14 +149,24 @@ function runDoctor(argv) {
 function uninstall(argv) {
   const opts = parseOptions(argv);
   const prefix = path.resolve(expandHome(opts.prefix || path.join(os.homedir(), ".local")));
+  // 卸载 skill 走二进制单源(同一 SkillTarget 表 codex/claude/copilot),在删 wrapper 前调
+  // (删 wrapper 后 PATH 上的 team-agent 没了,但 runtime 二进制仍在;用 runtime 二进制直调)。
+  const teamAgentBin = path.join(prefix, "bin", "team-agent");
+  if (fs.existsSync(teamAgentBin)) {
+    const res = spawnSync(teamAgentBin, ["install-skill", "--target", "all", "--uninstall", "--json"], {
+      text: true,
+      encoding: "utf8",
+      timeout: VERSION_SMOKE_TIMEOUT_MS,
+    });
+    if (res.status !== 0) {
+      console.error(`WARN: skill uninstall via binary failed (status=${res.status ?? "signal"}); skill dirs may remain under ~/.codex|.claude|.copilot/skills/team-agent`);
+    }
+  }
   for (const name of ["team-agent", "team_orchestrator", "team-agent-coordinator"]) {
     fs.rmSync(path.join(prefix, "bin", name), { force: true });
   }
-  for (const skillDir of skillDestinations()) {
-    fs.rmSync(skillDir, { recursive: true, force: true });
-  }
   console.log(`removed wrappers from ${path.join(prefix, "bin")}`);
-  console.log("removed skills from ~/.codex/skills/team-agent and ~/.claude/skills/team-agent");
+  console.log("removed skills from ~/.codex, ~/.claude and ~/.copilot skills/team-agent");
   if (opts.purgeRuntime) {
     const runtimeRoot = path.resolve(expandHome(opts.runtimeDir || path.join(os.homedir(), ".team-agent", "runtime")));
     fs.rmSync(runtimeRoot, { recursive: true, force: true });
@@ -238,46 +248,32 @@ exec ${shellQuote(binary)} ${argPrefix}"$@"
   fs.chmodSync(file, 0o755);
 }
 
-function installSkills() {
+// RED-1 根治(单源):skill 安装唯一实现在二进制 `install-skill`(SkillTarget 表:
+// codex/claude/copilot)。install.mjs 不再有自己的 JS 拷贝逻辑/目标硬编码——改调二进制,
+// 失败显式报错(非零退出),绝不静默回退 JS。
+function installSkills(runtimeBinary) {
   const source = path.join(packageRoot, "skills", "team-agent");
   if (!fs.existsSync(source)) {
     throw new Error(`skill source not found: ${source}`);
   }
-  for (const dest of skillDestinations()) {
-    fs.rmSync(dest, { recursive: true, force: true });
-    copyTree(source, dest);
+  const res = spawnSync(runtimeBinary, ["install-skill", "--target", "all", "--source", source, "--json"], {
+    text: true,
+    encoding: "utf8",
+    timeout: VERSION_SMOKE_TIMEOUT_MS,
+  });
+  if (res.status !== 0) {
+    const log = (res.stderr || res.stdout || "").trim() || "no stderr/stdout";
+    console.error(`ERROR: skill install failed (status=${res.status ?? "signal"})`);
+    console.error(`ACTION: reinstall, or run \`team-agent install-skill --target all --source ${source}\` manually`);
+    console.error(`LOG: ${runtimeBinary} install-skill --target all => ${log}`);
+    process.exit(1);
   }
 }
 
-function skillDestinations() {
-  return [
-    path.join(os.homedir(), ".codex", "skills", "team-agent"),
-    path.join(os.homedir(), ".claude", "skills", "team-agent"),
-  ];
-}
-
 function makeDoctorWorkspace() {
   return fs.mkdtempSync(path.join(os.tmpdir(), "team-agent-doctor-"));
 }
 
-function copyTree(src, dest) {
-  const stat = fs.lstatSync(src);
-  if (stat.isDirectory()) {
-    fs.mkdirSync(dest, { recursive: true, mode: stat.mode });
-    for (const entry of fs.readdirSync(src)) {
-      if (entry === ".DS_Store") {
-        continue;
-      }
-      copyTree(path.join(src, entry), path.join(dest, entry));
-    }
-    return;
-  }
-  if (stat.isFile()) {
-    fs.copyFileSync(src, dest);
-    fs.chmodSync(dest, stat.mode);
-  }
-}
-
 function expandHome(value) {
   if (value === "~") {
     return os.homedir();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "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.6",
-    "@team-agent/cli-darwin-x64": "0.3.6",
-    "@team-agent/cli-linux-x64": "0.3.6"
+    "@team-agent/cli-darwin-arm64": "0.3.8",
+    "@team-agent/cli-darwin-x64": "0.3.8",
+    "@team-agent/cli-linux-x64": "0.3.8"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",