@team-agent/installer 0.5.16 → 0.5.17

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.16"
+version = "0.5.17"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.16"
+version = "0.5.17"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -4060,79 +4060,15 @@ pub mod leader_port {
         source: &str,
         response: &mut Value,
     ) {
-        let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
-            return;
-        };
-        let team_key = match team.filter(|t| !t.is_empty()) {
-            Some(t) => t.to_string(),
-            None => crate::state::projection::team_state_key(&state),
-        };
-        let receiver = state
-            .get("teams")
-            .and_then(|v| v.as_object())
-            .and_then(|teams| teams.get(&team_key))
-            .and_then(|t| t.get("leader_receiver"))
-            .or_else(|| state.get("leader_receiver"))
-            .cloned();
-        let Some(receiver) = receiver else {
-            return;
-        };
-        let transport_kind = receiver
-            .get("transport_kind")
-            .and_then(Value::as_str)
-            .unwrap_or("direct_tmux")
-            .to_string();
-        let owner_epoch = receiver
-            .get("owner_epoch")
-            .and_then(Value::as_u64)
-            .or_else(|| {
-                state
-                    .get("teams")
-                    .and_then(|v| v.as_object())
-                    .and_then(|teams| teams.get(&team_key))
-                    .and_then(|t| t.get("owner_epoch"))
-                    .and_then(Value::as_u64)
-            })
-            .unwrap_or(0);
-        let entry = crate::leader::registry::build_entry(
+        let Some(outcome) = crate::leader::registry::register_binding_from_state_best_effort(
             workspace,
-            &team_key,
-            &transport_kind,
-            receiver,
-            owner_epoch,
+            team,
             source,
-            chrono::Utc::now().to_rfc3339(),
-        );
-        let event_log = crate::event_log::EventLog::new(workspace);
-        let write_result = crate::leader::registry::write_entry_best_effort(&entry);
-        let registry_status = match &write_result {
-            Some(path) => {
-                let _ = event_log.write(
-                    crate::leader::registry::EVENT_REGISTERED,
-                    json!({
-                        "path": path.display().to_string(),
-                        "team_key": team_key,
-                        "workspace_hash": entry.workspace_hash,
-                        "source": source,
-                        "owner_epoch": entry.owner_epoch,
-                    }),
-                );
-                json!({"status": "registered", "path": path.display().to_string()})
-            }
-            None => {
-                let _ = event_log.write(
-                    crate::leader::registry::EVENT_WRITE_FAILED,
-                    json!({
-                        "team_key": team_key,
-                        "workspace_hash": entry.workspace_hash,
-                        "source": source,
-                    }),
-                );
-                json!({"status": "write_failed"})
-            }
+        ) else {
+            return;
         };
         if let Some(obj) = response.as_object_mut() {
-            obj.insert("leader_registry".to_string(), registry_status);
+            obj.insert("leader_registry".to_string(), outcome.response_json());
         }
     }
 

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

@@ -22,6 +22,7 @@
 use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
 use sha2::{Digest, Sha256};
 
 use crate::transport::Transport;
@@ -98,6 +99,26 @@ pub const AMBIGUOUS_NAMES_FIELD: &str = "ambiguous_names";
 /// a fully-qualified form.
 pub const REASON_AMBIGUOUS: &str = "name_ambiguous";
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RegistryWriteOutcome {
+    pub status: &'static str,
+    pub path: Option<PathBuf>,
+    pub team_key: String,
+    pub workspace_hash: String,
+    pub source: String,
+    pub owner_epoch: u64,
+}
+
+impl RegistryWriteOutcome {
+    #[must_use]
+    pub fn response_json(&self) -> Value {
+        match &self.path {
+            Some(path) => json!({"status": self.status, "path": path.display().to_string()}),
+            None => json!({"status": self.status}),
+        }
+    }
+}
+
 /// Absolute path to `~/.team-agent/leaders`. Returns `None` when the
 /// caller has no HOME (e.g. some CI shells) — callers should treat this as
 /// "no registry" rather than an error, since registry is derived.
@@ -170,6 +191,89 @@ pub fn build_entry(
     }
 }
 
+/// After a canonical leader binding succeeds, write the derived host
+/// discovery entry from the just-persisted state. Registry failure is
+/// non-fatal: callers get a write_failed outcome and the binding remains
+/// successful.
+pub fn register_binding_from_state_best_effort(
+    workspace: &Path,
+    team: Option<&str>,
+    source: &str,
+) -> Option<RegistryWriteOutcome> {
+    let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
+        return None;
+    };
+    let team_key = match team.filter(|team| !team.is_empty()) {
+        Some(team) => team.to_string(),
+        None => crate::state::projection::team_state_key(&state),
+    };
+    let receiver = state
+        .get("teams")
+        .and_then(|value| value.as_object())
+        .and_then(|teams| teams.get(&team_key))
+        .and_then(|team| team.get("leader_receiver"))
+        .or_else(|| state.get("leader_receiver"))
+        .cloned()?;
+    let transport_kind = receiver
+        .get("transport_kind")
+        .and_then(Value::as_str)
+        .unwrap_or("direct_tmux")
+        .to_string();
+    let owner_epoch = receiver
+        .get("owner_epoch")
+        .and_then(Value::as_u64)
+        .or_else(|| {
+            state
+                .get("teams")
+                .and_then(|value| value.as_object())
+                .and_then(|teams| teams.get(&team_key))
+                .and_then(|team| team.get("owner_epoch"))
+                .and_then(Value::as_u64)
+        })
+        .unwrap_or(0);
+    let entry = build_entry(
+        workspace,
+        &team_key,
+        &transport_kind,
+        receiver,
+        owner_epoch,
+        source,
+        chrono::Utc::now().to_rfc3339(),
+    );
+    let event_log = crate::event_log::EventLog::new(workspace);
+    let write_result = write_entry_best_effort(&entry);
+    let status = if let Some(path) = &write_result {
+        let _ = event_log.write(
+            EVENT_REGISTERED,
+            json!({
+                "path": path.display().to_string(),
+                "team_key": team_key,
+                "workspace_hash": entry.workspace_hash,
+                "source": source,
+            }),
+        );
+        "registered"
+    } else {
+        let _ = event_log.write(
+            EVENT_WRITE_FAILED,
+            json!({
+                "team_key": team_key,
+                "workspace_hash": entry.workspace_hash,
+                "source": source,
+            }),
+        );
+        "write_failed"
+    };
+    Some(RegistryWriteOutcome {
+        status,
+        path: write_result,
+        team_key,
+        workspace_hash: entry.workspace_hash,
+        source: source.to_string(),
+        owner_epoch: entry.owner_epoch,
+    })
+}
+
 fn entry_filename(entry: &LeaderRegistryEntry) -> String {
     format!("{}__{}.json", entry.workspace_hash, entry.team_key)
 }

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

@@ -1404,6 +1404,11 @@ fn try_autobind_leader_after_restart(
     let team_str = team;
     match crate::leader::attach_leader(workspace, team_str, None, provider) {
         Ok(result) if result.ok => {
+            let _ = crate::leader::registry::register_binding_from_state_best_effort(
+                workspace,
+                team_str,
+                "restart-auto-attach",
+            );
             eprintln!(
                 "team_agent::restart auto_attach_leader ok pane={:?} team={:?}",
                 result.bound_pane_id.as_ref().map(|p| p.as_str()),

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

@@ -3,6 +3,9 @@ use crate::transport::test_support::OfflineTransport;
 use serde_json::json;
 use serial_test::serial;
 
+#[allow(dead_code)]
+struct HermeticTestEnv;
+
 const QS_TEAM_MD: &str =
     "---\nname: quickteam\nobjective: Quick start.\nprovider: codex\n---\n\nQuick-start team.\n";
 pub(super) const QS_VALID_ROLE: &str = "---\nname: implementer\nrole: Implementation Engineer\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nImplement bounded tasks.\n";

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"),
@@ -415,13 +479,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 {

package/package.json

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