@team-agent/installer 0.5.17 → 0.5.19

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

@@ -449,10 +449,13 @@ fn window_present_in_live(
     false
 }
 
-pub(super) fn start_coordinator_for_workspace(workspace: &Path) -> Result<bool, LifecycleError> {
+pub(super) fn start_coordinator_for_workspace(
+    workspace: &Path,
+    team_key: Option<&str>,
+) -> Result<crate::lifecycle::CoordinatorStartSummary, LifecycleError> {
     let workspace = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
-    crate::coordinator::start_coordinator(&workspace)
-        .map(|report| report.ok)
+    crate::coordinator::health::start_coordinator_with_team(&workspace, team_key)
+        .map(|report| crate::lifecycle::CoordinatorStartSummary::from_start_report(&report))
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 

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

@@ -590,6 +590,7 @@ fn restart_with_selected_team_and_transport(
             &successful_agents,
             &failed_agents,
             "fail",
+            None,
         )?;
         return Ok(RestartReport::Failed {
             session_name,
@@ -606,6 +607,7 @@ fn restart_with_selected_team_and_transport(
             &successful_agents,
             &failed_agents,
             "fail",
+            None,
         )?;
         return Ok(RestartReport::Failed {
             session_name,
@@ -824,6 +826,7 @@ fn restart_with_selected_team_and_transport(
             &successful_agents,
             &failed_agents,
             "fail",
+            None,
         )?;
         return Ok(RestartReport::Failed {
             session_name,
@@ -833,7 +836,9 @@ fn restart_with_selected_team_and_transport(
         });
     }
     drop(lifecycle_lock);
-    let coordinator_started = start_coordinator_for_workspace(&selected.run_workspace)?;
+    let coordinator =
+        start_coordinator_for_workspace(&selected.run_workspace, Some(&selected.team_key))?;
+    let coordinator_started = coordinator.ok;
     wait_restart_readiness_or_timeout(
         &selected.run_workspace,
         &state,
@@ -862,6 +867,7 @@ fn restart_with_selected_team_and_transport(
             &successful_agents,
             &failed_agents,
             "partial",
+            Some(&coordinator),
         )?;
         // 0.3.30 Bug 1: auto-attach on partial restart too — workers that did
         // come up still need a leader_receiver pane to deliver report_result.
@@ -875,6 +881,7 @@ fn restart_with_selected_team_and_transport(
             agents: successful_agents,
             failed_agents,
             coordinator_started,
+            coordinator,
             next_actions,
             attach_commands,
         });
@@ -884,6 +891,7 @@ fn restart_with_selected_team_and_transport(
         &successful_agents,
         &failed_agents,
         "ok",
+        Some(&coordinator),
     )?;
     // 0.3.30 Bug 1: auto-attach leader from caller's TMUX_PANE if available.
     // Mirrors quick-start's seed_launched_owner_from_env behaviour: a restart
@@ -900,6 +908,7 @@ fn restart_with_selected_team_and_transport(
         session_name,
         agents: successful_agents,
         coordinator_started,
+        coordinator,
         next_actions,
         attach_commands,
     })
@@ -1953,27 +1962,32 @@ fn write_restart_completed_event(
     successful_agents: &[RestartedAgent],
     failed_agents: &[RestartFailedAgent],
     rc: &str,
+    coordinator: Option<&crate::lifecycle::CoordinatorStartSummary>,
 ) -> Result<(), LifecycleError> {
+    let mut payload = serde_json::json!({
+        "rc": rc,
+        "status": rc,
+        "successful_agents": successful_agents
+            .iter()
+            .map(|agent| agent.agent_id.as_str())
+            .collect::<Vec<_>>(),
+        "failed_agents": failed_agents
+            .iter()
+            .map(|failure| serde_json::json!({
+                "agent_id": failure.agent_id.as_str(),
+                "phase": failure.phase,
+                "error": failure.error,
+            }))
+            .collect::<Vec<_>>(),
+    });
+    if let (Some(object), Some(coordinator)) = (payload.as_object_mut(), coordinator) {
+        object.insert(
+            "coordinator".to_string(),
+            crate::lifecycle::coordinator_start_summary_value(coordinator),
+        );
+    }
     crate::event_log::EventLog::new(workspace)
-        .write(
-            "restart.completed",
-            serde_json::json!({
-                "rc": rc,
-                "status": rc,
-                "successful_agents": successful_agents
-                    .iter()
-                    .map(|agent| agent.agent_id.as_str())
-                    .collect::<Vec<_>>(),
-                "failed_agents": failed_agents
-                    .iter()
-                    .map(|failure| serde_json::json!({
-                        "agent_id": failure.agent_id.as_str(),
-                        "phase": failure.phase,
-                        "error": failure.error,
-                    }))
-                    .collect::<Vec<_>>(),
-            }),
-        )
+        .write("restart.completed", payload)
         .map(|_| ())
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }

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_golden.rs

@@ -478,7 +478,6 @@ impl EnvVarGuard {
         }
         Self { key, previous }
     }
-
 }
 
 impl Drop for EnvVarGuard {
@@ -581,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>");
     }
@@ -602,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>");
     }
@@ -609,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)
 }
@@ -622,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`,
@@ -642,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
@@ -750,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
 }
 
@@ -801,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)
@@ -649,7 +695,11 @@ pub enum RestartReport {
     Restarted {
         session_name: SessionName,
         agents: Vec<RestartedAgent>,
+        /// Compatibility field: true means the coordinator requirement is
+        /// satisfied. The structured `coordinator` summary carries started vs
+        /// already-running vs rotated detail.
         coordinator_started: bool,
+        coordinator: CoordinatorStartSummary,
         next_actions: Vec<String>,
         attach_commands: Vec<String>,
     },
@@ -659,7 +709,11 @@ pub enum RestartReport {
         session_name: SessionName,
         agents: Vec<RestartedAgent>,
         failed_agents: Vec<RestartFailedAgent>,
+        /// Compatibility field: true means the coordinator requirement is
+        /// satisfied. The structured `coordinator` summary carries started vs
+        /// already-running vs rotated detail.
         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.17",
+  "version": "0.5.19",
   "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.17",
-    "@team-agent/cli-darwin-x64": "0.5.17",
-    "@team-agent/cli-linux-x64": "0.5.17"
+    "@team-agent/cli-darwin-arm64": "0.5.19",
+    "@team-agent/cli-darwin-x64": "0.5.19",
+    "@team-agent/cli-linux-x64": "0.5.19"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",