@team-agent/installer 0.5.16 → 0.5.18

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

@@ -242,7 +242,7 @@ fn r2_lifecycle_lock_exists_precondition() {
     assert_public_operation(&rebuild, "restart");
     let drop_idx = rebuild.find("drop(lifecycle_lock);").unwrap();
     let coordinator_idx = rebuild
-        .find("start_coordinator_for_workspace(&selected.run_workspace)")
+        .find("start_coordinator_for_workspace(&selected.run_workspace, Some(&selected.team_key))")
         .unwrap();
     let readiness_idx = rebuild.find("wait_restart_readiness_or_timeout(").unwrap();
     assert!(

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

@@ -19,6 +19,9 @@ use serde_json::json;
 use std::collections::BTreeSet;
 use std::time::Duration;
 
+#[allow(dead_code)]
+struct HermeticTestEnv;
+
 #[test]
 fn concurrent_reset_discard_session_serializes() {
     let ids = (1..=6).map(|n| format!("w{n}")).collect::<Vec<_>>();

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

@@ -9,22 +9,89 @@ use crate::transport::WindowName;
 use serde_json::{json, Map, Value};
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
 
 const ANCESTRY_ENV: &str = "TEAM_AGENT_TEST_PROCESS_ANCESTRY_ARGV_JSON";
-const CALLER_IDENTITY_ENVS: &[&str] = &[
-    "TMUX",
-    "TMUX_PANE",
-    "TEAM_AGENT_LEADER_PANE_ID",
-    "TEAM_AGENT_LEADER_SESSION_UUID",
-    "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
-    "TEAM_AGENT_LEADER_PROVIDER",
-    "TEAM_AGENT_MACHINE_FINGERPRINT",
-    "TEAM_AGENT_WORKSPACE",
-    "TEAM_AGENT_TEAM_ID",
-    "TEAM_AGENT_OWNER_TEAM_ID",
-    "TEAM_AGENT_ACTIVE_TEAM",
-    "TEAM_AGENT_ID",
-];
+
+static HERMETIC_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+struct HermeticTestEnv {
+    root: PathBuf,
+    previous: Vec<(&'static str, Option<String>)>,
+}
+
+impl HermeticTestEnv {
+    fn enter(tag: &str) -> Self {
+        let base = std::env::var_os("TEAM_AGENT_TEST_TMP")
+            .map(PathBuf::from)
+            .unwrap_or_else(std::env::temp_dir);
+        std::fs::create_dir_all(&base).expect("create hermetic test tmp root");
+        let root = base.join(format!(
+            "ta-phase-golden-{tag}-{}-{}",
+            std::process::id(),
+            HERMETIC_COUNTER.fetch_add(1, Ordering::Relaxed)
+        ));
+        let _ = std::fs::remove_dir_all(&root);
+        std::fs::create_dir_all(root.join("home/.team-agent/leaders"))
+            .expect("create phase golden hermetic root");
+        let root = std::fs::canonicalize(root).expect("canonicalize phase golden hermetic root");
+        let home = root.join("home");
+        let mut previous = Vec::new();
+        for key in std::iter::once("HOME").chain(hermetic_caller_envs().iter().copied()) {
+            previous.push((key, std::env::var(key).ok()));
+        }
+        unsafe {
+            std::env::set_var("HOME", &home);
+            for key in hermetic_caller_envs() {
+                std::env::remove_var(key);
+            }
+        }
+        Self { root, previous }
+    }
+
+    fn workspace(&self, tag: &str) -> PathBuf {
+        let path = self.root.join(format!(
+            "workspace-{tag}-{}",
+            HERMETIC_COUNTER.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&path).expect("create phase golden workspace");
+        std::fs::canonicalize(path).expect("canonicalize phase golden workspace")
+    }
+}
+
+impl Drop for HermeticTestEnv {
+    fn drop(&mut self) {
+        for (key, value) in self.previous.drain(..).rev() {
+            unsafe {
+                if let Some(value) = value {
+                    std::env::set_var(key, value);
+                } else {
+                    std::env::remove_var(key);
+                }
+            }
+        }
+        if std::env::var("TEAM_AGENT_KEEP_TEST_TMP").as_deref() != Ok("1") {
+            let _ = std::fs::remove_dir_all(&self.root);
+        }
+    }
+}
+
+fn hermetic_caller_envs() -> &'static [&'static str] {
+    &[
+        "TMUX",
+        "TMUX_PANE",
+        "TEAM_AGENT_LEADER_PANE_ID",
+        "TEAM_AGENT_LEADER_SESSION_UUID",
+        "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+        "TEAM_AGENT_LEADER_PROVIDER",
+        "TEAM_AGENT_MACHINE_FINGERPRINT",
+        "TEAM_AGENT_WORKSPACE",
+        "TEAM_AGENT_TEAM_ID",
+        "TEAM_AGENT_OWNER_TEAM_ID",
+        "TEAM_AGENT_ACTIVE_TEAM",
+        "TEAM_AGENT_ID",
+    ]
+}
 
 #[test]
 #[serial_test::serial(env)]
@@ -154,12 +221,9 @@ struct PhaseGolden {
 }
 
 fn run_phase_golden(spec: PhaseGolden) -> Value {
+    let hermetic = HermeticTestEnv::enter(spec.phase);
     let _permission_mode = EnvVarGuard::set(ANCESTRY_ENV, "[]");
-    let _caller_identity = CALLER_IDENTITY_ENVS
-        .iter()
-        .map(|key| EnvVarGuard::unset(key))
-        .collect::<Vec<_>>();
-    let team = two_worker_team_dir();
+    let team = two_worker_team_dir(&hermetic);
     let workspace = team.parent().expect("workspace").to_path_buf();
     seed_healthy_coordinator(&workspace);
     let launch_transport = codex_ready_transport();
@@ -298,8 +362,8 @@ fn phase_b_reset_discard_session(
     }
 }
 
-fn two_worker_team_dir() -> PathBuf {
-    let team = temp_ws().join("teamdir");
+fn two_worker_team_dir(hermetic: &HermeticTestEnv) -> PathBuf {
+    let team = hermetic.workspace("team").join("teamdir");
     std::fs::create_dir_all(team.join("agents")).unwrap();
     std::fs::write(
         team.join("TEAM.md"),
@@ -414,14 +478,6 @@ impl EnvVarGuard {
         }
         Self { key, previous }
     }
-
-    fn unset(key: &'static str) -> Self {
-        let previous = std::env::var(key).ok();
-        unsafe {
-            std::env::remove_var(key);
-        }
-        Self { key, previous }
-    }
 }
 
 impl Drop for EnvVarGuard {
@@ -524,6 +580,9 @@ fn normalize_string(text: String, ctx: &mut NormalizeCtx, key: Option<&str>) ->
     if key_is_timestamp(key) {
         return json!("<TS>");
     }
+    if text == crate::packaging::Version::current().as_str() {
+        return json!("<VERSION>");
+    }
     if key.contains("endpoint") && value_looks_like_endpoint_path(&text) {
         return json!("<SOCKET>");
     }
@@ -545,6 +604,7 @@ fn normalize_string(text: String, ctx: &mut NormalizeCtx, key: Option<&str>) ->
 
 fn normalize_path_string(text: &str, ctx: &NormalizeCtx) -> String {
     let mut out = text.to_string();
+    out = normalize_team_agent_binary_path(&out);
     for alias in &ctx.workspace_aliases {
         out = out.replace(alias, "<WORKSPACE>");
     }
@@ -552,7 +612,6 @@ fn normalize_path_string(text: &str, ctx: &NormalizeCtx) -> String {
     for alias in &ctx.temp_aliases {
         out = out.replace(alias, "<TMP>");
     }
-    out = normalize_team_agent_binary_path(&out);
     out = normalize_tmux_socket_dir(&out);
     normalize_socket_token(&out)
 }
@@ -565,7 +624,7 @@ fn value_looks_like_endpoint_path(text: &str) -> bool {
 }
 
 fn normalize_team_agent_binary_path(text: &str) -> String {
-    let mut out = text.to_string();
+    let mut out = replace_known_team_agent_binary_paths(text);
     // 0.5.0 hermetic 教训「环境路径类 token 化」的直接延伸
     // (leader msg_6ee04cf5aee8):归一化改为结构判据,不绑路径前缀。
     // 用户 CARGO_TARGET_DIR 可以指到任意目录(默认 `<repo>/target`,
@@ -585,6 +644,30 @@ fn normalize_team_agent_binary_path(text: &str) -> String {
     out
 }
 
+fn replace_known_team_agent_binary_paths(text: &str) -> String {
+    let mut out = text.to_string();
+    for alias in known_team_agent_binary_path_aliases() {
+        out = out.replace(&alias, "<TEAM_AGENT_BIN>");
+    }
+    out
+}
+
+fn known_team_agent_binary_path_aliases() -> Vec<String> {
+    let mut aliases = Vec::new();
+    if let Some(path) = option_env!("CARGO_BIN_EXE_team-agent") {
+        push_path_alias(&mut aliases, PathBuf::from(path));
+    }
+    if let Some(path) = std::env::var_os("CARGO_BIN_EXE_team-agent") {
+        push_path_alias(&mut aliases, PathBuf::from(path));
+    }
+    if let Ok(path) = std::env::current_exe() {
+        push_path_alias(&mut aliases, path);
+    }
+    aliases.sort_by(|a, b| b.len().cmp(&a.len()).then_with(|| a.cmp(b)));
+    aliases.dedup();
+    aliases
+}
+
 /// Structural (path-prefix-independent) normalization for
 /// `/…/deps/team_agent-<hex>(.exe)?` occurrences. Scans the input for
 /// every `/deps/team_agent-` marker and rewrites the containing
@@ -693,17 +776,31 @@ fn normalize_tmux_uid_with_prefix(mut text: String, prefix: &str) -> String {
 }
 
 fn normalize_socket_token(text: &str) -> String {
-    let mut out = text.to_string();
-    while let Some(idx) = out.find("ta-") {
-        let end = out[idx..]
+    const CONTEXT: &str = "/tmux-<UID>/";
+    let mut out = String::with_capacity(text.len());
+    let mut search_from = 0;
+    while let Some(offset) = text[search_from..].find(CONTEXT) {
+        let context_start = search_from + offset;
+        let token_start = context_start + CONTEXT.len();
+        if !text[token_start..].starts_with("ta-") {
+            out.push_str(&text[search_from..token_start]);
+            search_from = token_start;
+            continue;
+        }
+        let end = text[token_start..]
             .find(|c: char| !(c.is_ascii_alphanumeric() || c == '-'))
-            .map(|offset| idx + offset)
-            .unwrap_or_else(|| out.len());
-        if end == idx + 3 {
-            break;
+            .map(|offset| token_start + offset)
+            .unwrap_or_else(|| text.len());
+        if end == token_start + 3 {
+            out.push_str(&text[search_from..end]);
+            search_from = end;
+            continue;
         }
-        out.replace_range(idx..end, "ta-<SOCKET>");
+        out.push_str(&text[search_from..token_start]);
+        out.push_str("ta-<SOCKET>");
+        search_from = end;
     }
+    out.push_str(&text[search_from..]);
     out
 }
 
@@ -744,3 +841,85 @@ fn pretty(value: &Value) -> String {
     text.push('\n');
     text
 }
+
+#[test]
+fn phase_golden_normalizer_maps_custom_cargo_target_deps_binary_before_tmp_aliasing() {
+    let ctx = NormalizeCtx {
+        workspace_aliases: Vec::new(),
+        temp_aliases: vec!["/Volumes/nvme/tmp".to_string()],
+        pane_ids: BTreeMap::new(),
+    };
+    let input = concat!(
+        "mcp_servers.team_orchestrator.command=\"",
+        "/Volumes/nvme/tmp/ta-0517-target/debug/deps/team_agent-c924abc123",
+        "\""
+    );
+
+    assert_eq!(
+        normalize_path_string(input, &ctx),
+        "mcp_servers.team_orchestrator.command=\"<TEAM_AGENT_BIN>\"",
+        "custom CARGO_TARGET_DIR binary paths must normalize to <TEAM_AGENT_BIN> before tmp/socket tokenization"
+    );
+}
+
+#[test]
+fn phase_golden_normalizer_maps_current_test_binary_to_team_agent_marker() {
+    let ctx = NormalizeCtx {
+        workspace_aliases: Vec::new(),
+        temp_aliases: vec!["/Volumes/nvme/tmp".to_string()],
+        pane_ids: BTreeMap::new(),
+    };
+    let input = format!(
+        "mcp_servers.team_orchestrator.command=\"{}\"",
+        std::env::current_exe()
+            .expect("current test binary path")
+            .display()
+    );
+
+    assert_eq!(
+        normalize_path_string(&input, &ctx),
+        "mcp_servers.team_orchestrator.command=\"<TEAM_AGENT_BIN>\"",
+        "actual test argv0/current_exe path must normalize to <TEAM_AGENT_BIN>"
+    );
+}
+
+#[test]
+fn phase_golden_normalizer_does_not_treat_cargo_target_dir_as_socket_token() {
+    let ctx = NormalizeCtx {
+        workspace_aliases: Vec::new(),
+        temp_aliases: vec!["/Volumes/nvme/tmp".to_string()],
+        pane_ids: BTreeMap::new(),
+    };
+
+    assert_eq!(
+        normalize_path_string("/Volumes/nvme/tmp/ta-0517-target/build.log", &ctx),
+        "<TMP>/ta-0517-target/build.log",
+        "ta-* directory names outside tmux socket context must not be rewritten as ta-<SOCKET>"
+    );
+    assert_eq!(
+        normalize_path_string("tmux -S /tmp/tmux-501/ta-a60d10b25edd attach", &ctx),
+        "tmux -S <TMP>/tmux-<UID>/ta-<SOCKET> attach",
+        "real tmux socket paths still need stable socket tokenization"
+    );
+}
+
+#[test]
+fn phase_golden_normalizer_maps_current_version_by_value_only() {
+    let mut ctx = NormalizeCtx {
+        workspace_aliases: Vec::new(),
+        temp_aliases: Vec::new(),
+        pane_ids: BTreeMap::new(),
+    };
+    let current = crate::packaging::Version::current().as_str().to_string();
+
+    assert_eq!(
+        normalize_string(current.clone(), &mut ctx, Some("arbitrary_field")),
+        json!("<VERSION>"),
+        "current binary version values must normalize without depending on field names"
+    );
+    assert_eq!(
+        normalize_string(format!("version={current}"), &mut ctx, Some("binary_version")),
+        json!(format!("version={current}")),
+        "version normalization must be exact-value based, not a broad substring or field-name rewrite"
+    );
+}

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

@@ -83,6 +83,52 @@ impl PlanId {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CoordinatorStartSummary {
+    pub ok: bool,
+    pub status: String,
+    pub pid: Option<u32>,
+    pub binary_path: Option<String>,
+    pub binary_version: Option<String>,
+    pub rotation_reason: Option<String>,
+}
+
+impl CoordinatorStartSummary {
+    pub fn from_start_report(report: &crate::coordinator::StartReport) -> Self {
+        Self {
+            ok: report.ok,
+            status: coordinator_start_status_wire(report.status).to_string(),
+            pid: report.pid.map(|pid| pid.get()),
+            binary_path: report.binary_path.clone(),
+            binary_version: report.binary_version.clone(),
+            rotation_reason: report.rotation_reason.clone(),
+        }
+    }
+}
+
+fn coordinator_start_status_wire(status: crate::coordinator::StartOutcome) -> &'static str {
+    match status {
+        crate::coordinator::StartOutcome::AlreadyRunning => "already_running",
+        crate::coordinator::StartOutcome::RestartIncompatibleStopFailed => {
+            "restart_incompatible_stop_failed"
+        }
+        crate::coordinator::StartOutcome::SchemaIncompatible => "schema_incompatible",
+        crate::coordinator::StartOutcome::Started => "started",
+        crate::coordinator::StartOutcome::StartedAfterRotation => "started_after_rotation",
+    }
+}
+
+pub fn coordinator_start_summary_value(summary: &CoordinatorStartSummary) -> serde_json::Value {
+    serde_json::json!({
+        "ok": summary.ok,
+        "status": summary.status,
+        "pid": summary.pid,
+        "binary_path": summary.binary_path,
+        "binary_version": summary.binary_version,
+        "rotation_reason": summary.rotation_reason,
+    })
+}
+
 impl std::fmt::Display for PlanId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(&self.0)
@@ -650,6 +696,7 @@ pub enum RestartReport {
         session_name: SessionName,
         agents: Vec<RestartedAgent>,
         coordinator_started: bool,
+        coordinator: CoordinatorStartSummary,
         next_actions: Vec<String>,
         attach_commands: Vec<String>,
     },
@@ -660,6 +707,7 @@ pub enum RestartReport {
         agents: Vec<RestartedAgent>,
         failed_agents: Vec<RestartFailedAgent>,
         coordinator_started: bool,
+        coordinator: CoordinatorStartSummary,
         next_actions: Vec<String>,
         attach_commands: Vec<String>,
     },

package/crates/team-agent/src/messaging/results.rs

@@ -301,12 +301,19 @@ fn start_report_value(report: &crate::coordinator::StartReport) -> serde_json::V
         }
         crate::coordinator::StartOutcome::SchemaIncompatible => "schema_incompatible",
         crate::coordinator::StartOutcome::Started => "started",
+        crate::coordinator::StartOutcome::StartedAfterRotation => "started_after_rotation",
     };
     let mut value = serde_json::json!({
         "ok": report.ok,
         "pid": report.pid.map(|p| p.get()),
         "status": status,
+        "binary_path": report.binary_path.clone(),
+        "binary_version": report.binary_version.clone(),
+        "rotation_reason": report.rotation_reason.clone(),
     });
+    if let Some(previous_pid) = report.previous_pid {
+        value["previous_pid"] = serde_json::json!(previous_pid.get());
+    }
     if let Some(log) = &report.log {
         value["log"] = serde_json::json!(log.to_string_lossy().to_string());
     }

package/package.json

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