@team-agent/installer 0.5.0 → 0.5.1

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

@@ -7,6 +7,38 @@ use crate::messaging::{DeliveryOutcome, DeliveryRefusal, DeliveryStage, Delivery
 /// `cmd_send`(`commands.py:164`)。解析 target(`--to` fanout / 单 target / `*`)→ [`MessageTarget`],
 /// 拼 [`SendOptions`](no_ack→requires_ack 取反、no_wait→wait_visible 取反等)→ `messaging::send_message`。
 pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
+    if let Some(ref to_name) = args.to_name {
+        if args.pane.is_some() || args.target.is_some() || args.targets.is_some() {
+            return Err(CliError::Usage(
+                "--to-name and --pane/TARGET/--to are mutually exclusive: \
+                 --to-name resolves a stable workspace/team/name to a live pane"
+                    .to_string(),
+            ));
+        }
+        let content = args.message.join(" ");
+        if content.is_empty() {
+            return Err(CliError::Usage("--to-name requires a non-empty message".to_string()));
+        }
+        let (resolved, transport) =
+            match crate::cli::named_address::resolve_name_for_cli(&args.workspace, to_name) {
+                Ok(resolved) => resolved,
+                Err(error) if args.json => {
+                    return Ok(CmdResult::from_json(error.to_json(), args.json));
+                }
+                Err(error) => return Err(CliError::Usage(error.n38_message())),
+            };
+        let mut value = send_to_named_pane_direct(
+            &args.workspace,
+            transport.as_ref(),
+            &resolved,
+            &content,
+            &args.sender,
+            args.task.as_deref(),
+            args.json,
+        )?;
+        add_send_reminder_if_ok(&mut value);
+        return Ok(CmdResult::from_json(value, args.json));
+    }
     // F1 (0.3.26, cross-team send): --pane <pane_id> direct targeting.
     // Mutually exclusive with target / --to (agent-name routing).
     if let Some(ref pane_id) = args.pane {
@@ -145,6 +177,78 @@ fn send_to_pane_direct(
     }))
 }
 
+fn send_to_named_pane_direct(
+    sender_workspace: &Path,
+    transport: &dyn crate::transport::Transport,
+    resolved: &crate::cli::named_address::ResolvedNamedAddress,
+    content: &str,
+    sender: &str,
+    task_id: Option<&str>,
+    _json: bool,
+) -> Result<serde_json::Value, CliError> {
+    use crate::messaging::delivery::render_message;
+    use crate::transport::{InjectPayload, Key, PaneId, Target};
+
+    let message_id = format!("named_send_{}", chrono::Utc::now().timestamp_millis());
+    let rendered = render_message(sender, task_id, content, &message_id);
+    let target = Target::Pane(PaneId::new(&resolved.pane_id));
+    let sender_run_workspace = crate::model::paths::canonical_run_workspace(sender_workspace)
+        .unwrap_or_else(|_| sender_workspace.to_path_buf());
+    let event_log = crate::event_log::EventLog::new(&sender_run_workspace);
+    if let Some(warning) = &resolved.warning {
+        eprintln!("warning: {warning}");
+    }
+    let report = transport
+        .inject(&target, &InjectPayload::Text(rendered), Key::Enter, true)
+        .map_err(|e| {
+            CliError::Runtime(format!(
+                "inject to named target {} pane {} failed: {e}",
+                resolved.raw_name, resolved.pane_id
+            ))
+        })?;
+    let target_kind = named_target_kind_wire(resolved.target_kind);
+    let event = serde_json::json!({
+        "to_name": resolved.raw_name,
+        "target_kind": target_kind,
+        "sender": sender,
+        "sender_workspace": sender_run_workspace.display().to_string(),
+        "target_workspace": resolved.target_workspace.display().to_string(),
+        "team_key": resolved.team_key,
+        "agent_id": resolved.agent_id,
+        "pane_id": resolved.pane_id,
+        "session_name": resolved.session_name,
+        "window_name": resolved.window_name,
+        "tmux_endpoint": resolved.tmux_endpoint,
+        "state_pane_id": resolved.state_pane_id,
+        "state_pane_stale": resolved.state_pane_stale,
+        "agent_status": resolved.agent_status,
+        "warning": resolved.warning,
+        "message_id": message_id,
+        "submit_verification": crate::transport::submit_verification_wire(report.submit_verification),
+        "inject_verification": format!("{:?}", report.inject_verification),
+    });
+    let _ = event_log.write("send.name_direct", event.clone());
+    let ok = matches!(
+        report.submit_verification,
+        crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck
+            | crate::transport::SubmitVerification::PastedContentPromptAbsentAfterSubmit
+            | crate::transport::SubmitVerification::KeySentAfterVisibleToken { .. }
+    );
+    let mut value = event;
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("ok".to_string(), serde_json::json!(ok));
+    }
+    Ok(value)
+}
+
+fn named_target_kind_wire(kind: crate::cli::named_address::NamedTargetKind) -> &'static str {
+    match kind {
+        crate::cli::named_address::NamedTargetKind::Worker => "worker",
+        crate::cli::named_address::NamedTargetKind::Leader => "leader",
+        crate::cli::named_address::NamedTargetKind::SessionWindow => "session_window",
+    }
+}
+
 pub fn cmd_fallback_send_leader(args: &FallbackSendLeaderArgs) -> Result<CmdResult, CliError> {
     if let Some(value) = fallback_business_refusal(&args.primary_error, args.json) {
         return Ok(value);

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

@@ -50,6 +50,7 @@ use super::*;
             json: true,
             message_id: None,
             pane: None,
+            to_name: None,
         };
         let _ = cmd_send(&args);
 

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

@@ -87,6 +87,7 @@ mod divergence;
 mod lane_c;
 mod leader_watch;
 mod missing_subcommands;
+mod named_address;
 mod repair_state_byte_lock;
 mod peer_allow;
 mod run_delegation;

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

@@ -0,0 +1,455 @@
+use super::*;
+use crate::transport::test_support::OfflineTransport;
+use crate::transport::{PaneId, PaneInfo, SessionName, WindowName};
+use serde_json::json;
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+fn named_ws(tag: &str) -> PathBuf {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static N: AtomicU64 = AtomicU64::new(0);
+    let dir = std::env::temp_dir().join(format!(
+        "ta-named-{tag}-{}-{}",
+        std::process::id(),
+        N.fetch_add(1, Ordering::Relaxed)
+    ));
+    std::fs::create_dir_all(dir.join(".team").join("runtime")).unwrap();
+    dir
+}
+
+fn seed_state(ws: &Path, state: serde_json::Value) {
+    std::fs::create_dir_all(ws.join(".team").join("runtime")).unwrap();
+    std::fs::write(
+        ws.join(".team").join("runtime").join("state.json"),
+        serde_json::to_vec_pretty(&state).unwrap(),
+    )
+    .unwrap();
+}
+
+fn state_with_teams(teams: serde_json::Value) -> serde_json::Value {
+    json!({
+        "session_name": "projected",
+        "tmux_endpoint": "workspace-socket",
+        "teams": teams,
+    })
+}
+
+fn worker_team(session: &str, agent: &str, pane: &str, window: &str) -> serde_json::Value {
+    json!({
+        "session_name": session,
+        "tmux_endpoint": format!("{session}-socket"),
+        "agents": {
+            agent: {
+                "status": "running",
+                "pane_id": pane,
+                "window": window,
+            }
+        }
+    })
+}
+
+fn worker_team_with_status(
+    session: &str,
+    agent: &str,
+    pane: &str,
+    window: &str,
+    status: &str,
+) -> serde_json::Value {
+    let mut team = worker_team(session, agent, pane, window);
+    team["agents"][agent]["status"] = json!(status);
+    team
+}
+
+fn leader_team(session: &str, pane: &str, socket: &str) -> serde_json::Value {
+    json!({
+        "session_name": session,
+        "tmux_endpoint": format!("{session}-worker-socket"),
+        "agents": {},
+        "leader_receiver": {
+            "pane_id": pane,
+            "session_name": format!("{session}-leader"),
+            "window_name": "codex",
+            "tmux_socket": socket,
+            "status": "attached"
+        }
+    })
+}
+
+fn pane(session: &str, window: &str, pane_id: &str) -> PaneInfo {
+    PaneInfo {
+        pane_id: PaneId::new(pane_id),
+        session: SessionName::new(session),
+        window_index: None,
+        window_name: Some(WindowName::new(window)),
+        pane_index: None,
+        tty: None,
+        current_command: None,
+        current_path: None,
+        active: false,
+        pane_pid: None,
+        leader_env: BTreeMap::new(),
+    }
+}
+
+fn assert_kind(
+    result: Result<ResolvedNamedAddress, NamedAddressError>,
+    kind: NamedAddressErrorKind,
+) {
+    let err = result.unwrap_err();
+    assert_eq!(err.kind, kind, "{err}");
+    let n38 = err.n38_message();
+    assert!(n38.contains("Error: "), "{n38}");
+    assert!(n38.contains("Action: "), "{n38}");
+    assert!(n38.contains("Log: "), "{n38}");
+}
+
+fn named_send_args(
+    ws: &Path,
+    to_name: Option<&str>,
+    pane: Option<&str>,
+    targets: Option<&str>,
+    message: &[&str],
+) -> SendArgs {
+    SendArgs {
+        target: None,
+        message: message.iter().map(|part| (*part).to_string()).collect(),
+        targets: targets.map(str::to_string),
+        workspace: ws.to_path_buf(),
+        team: None,
+        task: None,
+        sender: "leader".to_string(),
+        no_ack: false,
+        no_wait: false,
+        watch_result: false,
+        timeout: 0.0,
+        confirm_human: false,
+        json: true,
+        message_id: None,
+        pane: pane.map(str::to_string),
+        to_name: to_name.map(str::to_string),
+    }
+}
+
+#[test]
+fn resolve_name_current_team_unique() {
+    let ws = named_ws("unique");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "team-a": worker_team("team-a", "qa", "%old", "qa")
+        })),
+    );
+    let transport = OfflineTransport::new().with_targets(vec![pane("team-a", "qa", "%1")]);
+
+    let resolved = resolve_name_with_transport(&ws, "qa", &transport).unwrap();
+    assert_eq!(resolved.pane_id, "%1");
+    assert_eq!(resolved.team_key.as_deref(), Some("team-a"));
+    assert_eq!(resolved.agent_id.as_deref(), Some("qa"));
+    assert_eq!(resolved.target_kind, NamedTargetKind::Worker);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_name_ambiguous_same_role() {
+    let ws = named_ws("ambiguous-role");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "team-a": worker_team("team-a", "qa", "%1", "qa"),
+            "team-b": worker_team("team-b", "qa", "%2", "qa")
+        })),
+    );
+    let transport = OfflineTransport::new()
+        .with_targets(vec![pane("team-a", "qa", "%1"), pane("team-b", "qa", "%2")]);
+
+    let err = resolve_name_with_transport(&ws, "qa", &transport).unwrap_err();
+    assert_eq!(err.kind, NamedAddressErrorKind::NameAmbiguous);
+    let candidates = serde_json::to_string(&err.candidates).unwrap();
+    assert!(candidates.contains("team-a/qa"), "{candidates}");
+    assert!(candidates.contains("team-b/qa"), "{candidates}");
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_name_team_disambiguated() {
+    let ws = named_ws("team-disambiguated");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "team-a": worker_team("team-a", "qa", "%1", "qa"),
+            "team-b": worker_team("team-b", "qa", "%2", "qa")
+        })),
+    );
+    let transport = OfflineTransport::new()
+        .with_targets(vec![pane("team-a", "qa", "%1"), pane("team-b", "qa", "%2")]);
+
+    let resolved = resolve_name_with_transport(&ws, "team-b/qa", &transport).unwrap();
+    assert_eq!(resolved.pane_id, "%2");
+    assert_eq!(resolved.team_key.as_deref(), Some("team-b"));
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_name_stale_pane() {
+    let ws = named_ws("stale-pane");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "team-a": worker_team("team-a", "qa", "%old", "qa")
+        })),
+    );
+    let transport = OfflineTransport::new().with_targets(vec![pane("team-a", "qa", "%new")]);
+
+    let resolved = resolve_name_with_transport(&ws, "team-a/qa", &transport).unwrap();
+    assert_eq!(resolved.pane_id, "%new");
+    assert_eq!(resolved.state_pane_id.as_deref(), Some("%old"));
+    assert!(resolved.state_pane_stale);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_name_cross_workspace_socket() {
+    let sender = named_ws("sender");
+    let target = named_ws("target");
+    seed_state(&sender, state_with_teams(json!({})));
+    seed_state(
+        &target,
+        state_with_teams(json!({
+            "alpha": worker_team("alpha-session", "qa", "%target-old", "qa")
+        })),
+    );
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint("target-socket")
+        .with_targets(vec![pane("alpha-session", "qa", "%target-live")]);
+
+    let resolved = resolve_name_with_transport(
+        &sender,
+        &format!("{}::alpha/qa", target.display()),
+        &transport,
+    )
+    .unwrap();
+    assert_eq!(resolved.sender_workspace, sender);
+    assert_eq!(resolved.target_workspace, target);
+    assert_eq!(resolved.tmux_endpoint.as_deref(), Some("target-socket"));
+    assert_eq!(resolved.pane_id, "%target-live");
+    let _ = std::fs::remove_dir_all(&sender);
+    let _ = std::fs::remove_dir_all(&target);
+}
+
+#[test]
+fn send_to_name_mutual_exclusion() {
+    let cwd = named_ws("mutual");
+    let args = named_send_args(&cwd, Some("team-a/qa"), Some("%1"), None, &["hello"]);
+    let err = cmd_send(&args).unwrap_err();
+    assert!(
+        matches!(err, CliError::Usage(ref message) if message.contains("--to-name and --pane/TARGET/--to are mutually exclusive")),
+        "expected --to-name mutual exclusion, got {err:?}"
+    );
+
+    let args = named_send_args(&cwd, Some("team-a/qa"), None, Some("worker"), &["hello"]);
+    let err = cmd_send(&args).unwrap_err();
+    assert!(
+        matches!(err, CliError::Usage(ref message) if message.contains("--to-name and --pane/TARGET/--to are mutually exclusive")),
+        "expected --to-name/--to mutual exclusion, got {err:?}"
+    );
+
+    let args = named_send_args(&cwd, Some("team-a/qa"), None, None, &[]);
+    let err = cmd_send(&args).unwrap_err();
+    assert!(
+        matches!(err, CliError::Usage(ref message) if message == "--to-name requires a non-empty message"),
+        "expected empty-message usage error, got {err:?}"
+    );
+    let _ = std::fs::remove_dir_all(&cwd);
+}
+
+#[test]
+fn resolve_leader_name_uses_receiver_socket() {
+    let ws = named_ws("leader-socket");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": leader_team("alpha-session", "%leader", "/tmp/leader.sock")
+        })),
+    );
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint("/tmp/leader.sock")
+        .with_targets(vec![pane("alpha-session-leader", "codex", "%leader")]);
+
+    let resolved = resolve_name_with_transport(&ws, "alpha/leader", &transport).unwrap();
+    assert_eq!(resolved.target_kind, NamedTargetKind::Leader);
+    assert_eq!(resolved.pane_id, "%leader");
+    assert_eq!(resolved.tmux_endpoint.as_deref(), Some("/tmp/leader.sock"));
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_leader_name_not_live() {
+    let ws = named_ws("leader-not-live");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": leader_team("alpha-session", "%missing", "/tmp/leader.sock")
+        })),
+    );
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint("/tmp/leader.sock")
+        .with_targets(vec![pane("other", "codex", "%other")]);
+
+    let err = resolve_name_with_transport(&ws, "alpha/leader", &transport).unwrap_err();
+    assert_eq!(err.kind, NamedAddressErrorKind::NameNotLive);
+    let n38 = err.n38_message();
+    assert!(n38.contains("claim-leader"), "{n38}");
+    assert!(n38.contains("attach-leader"), "{n38}");
+    assert!(n38.contains("takeover"), "{n38}");
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_leader_name_after_rebind() {
+    let ws = named_ws("leader-rebind");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": leader_team("alpha-session", "%new", "/tmp/leader.sock")
+        })),
+    );
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint("/tmp/leader.sock")
+        .with_targets(vec![pane("alpha-session-leader", "codex", "%new")]);
+
+    let resolved = resolve_name_with_transport(&ws, "alpha/leader", &transport).unwrap();
+    assert_eq!(resolved.pane_id, "%new");
+    assert_eq!(resolved.target_kind, NamedTargetKind::Leader);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_name_invalid_syntax() {
+    let ws = named_ws("invalid");
+    let transport = OfflineTransport::new();
+    assert_kind(
+        resolve_name_with_transport(&ws, "", &transport),
+        NamedAddressErrorKind::NameInvalid,
+    );
+    assert_kind(
+        resolve_name_with_transport(&ws, "team//qa", &transport),
+        NamedAddressErrorKind::NameInvalid,
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_name_workspace_not_found() {
+    let ws = named_ws("sender-missing-target");
+    let missing = std::env::temp_dir().join(format!(
+        "ta-named-missing-{}-{}",
+        std::process::id(),
+        chrono::Utc::now().timestamp_nanos_opt().unwrap_or_default()
+    ));
+    let transport = OfflineTransport::new();
+    assert_kind(
+        resolve_name_with_transport(&ws, &format!("{}::alpha/qa", missing.display()), &transport),
+        NamedAddressErrorKind::WorkspaceNotFound,
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_name_state_missing() {
+    let ws = named_ws("state-missing");
+    let state_path = ws.join(".team").join("runtime").join("state.json");
+    let _ = std::fs::remove_file(state_path);
+    let transport = OfflineTransport::new();
+    assert_kind(
+        resolve_name_with_transport(&ws, "alpha/qa", &transport),
+        NamedAddressErrorKind::StateNotFound,
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_name_same_team_key_across_workspaces() {
+    let sender = named_ws("same-team-sender");
+    let other = named_ws("same-team-other");
+    seed_state(
+        &sender,
+        state_with_teams(json!({
+            "alpha": worker_team("alpha-a", "qa", "%a", "qa")
+        })),
+    );
+    seed_state(
+        &other,
+        state_with_teams(json!({
+            "alpha": worker_team("alpha-b", "qa", "%b", "qa")
+        })),
+    );
+    let sender_transport = OfflineTransport::new().with_targets(vec![pane("alpha-a", "qa", "%a")]);
+    let other_transport = OfflineTransport::new().with_targets(vec![pane("alpha-b", "qa", "%b")]);
+
+    let err = resolve_name_with_workspace_transports(
+        &sender,
+        "alpha/qa",
+        &[
+            NamedWorkspaceTransport {
+                workspace: &sender,
+                transport: &sender_transport,
+            },
+            NamedWorkspaceTransport {
+                workspace: &other,
+                transport: &other_transport,
+            },
+        ],
+    )
+    .unwrap_err();
+    assert_eq!(err.kind, NamedAddressErrorKind::NameAmbiguous);
+    assert!(err.n38_message().contains("<workspace>::alpha/qa"));
+    let _ = std::fs::remove_dir_all(&sender);
+    let _ = std::fs::remove_dir_all(&other);
+}
+
+#[test]
+fn resolve_paused_agent_with_live_pane_succeeds_with_warning() {
+    let ws = named_ws("paused-live");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": worker_team_with_status("alpha-session", "qa", "%paused", "qa", "paused")
+        })),
+    );
+    let transport =
+        OfflineTransport::new().with_targets(vec![pane("alpha-session", "qa", "%paused")]);
+
+    let resolved = resolve_name_with_transport(&ws, "alpha/qa", &transport).unwrap();
+    assert_eq!(resolved.pane_id, "%paused");
+    assert_eq!(resolved.agent_status.as_deref(), Some("paused"));
+    assert!(resolved.warning.as_deref().unwrap_or("").contains("paused"));
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn named_address_resolver_does_not_write_leader_receiver_or_owner_fields() {
+    let src = std::fs::read_to_string(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/src/cli/named_address.rs"
+    ))
+    .unwrap();
+    for forbidden in ["leader_receiver.*=", "team_owner.*=", "owner_epoch.*="] {
+        assert!(
+            !src.contains(forbidden),
+            "resolver must not contain binding write pattern {forbidden}"
+        );
+    }
+    for line in src.lines() {
+        let trimmed = line.trim();
+        for field in ["leader_receiver", "team_owner", "owner_epoch"] {
+            assert!(
+                !(trimmed.starts_with(field) && trimmed.contains('=')),
+                "resolver must not assign binding field `{field}`: {trimmed}"
+            );
+            assert!(
+                !(trimmed.starts_with(&format!(".{field}")) && trimmed.contains('=')),
+                "resolver must not assign binding field `{field}`: {trimmed}"
+            );
+        }
+    }
+}

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

@@ -447,6 +447,7 @@ use super::*;
             json: false,
             message_id: None,
             pane: None,
+            to_name: None,
         }
     }
 

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

@@ -323,6 +323,10 @@ pub struct SendArgs {
     /// the **cross-team communication** primitive: the target pane does not
     /// need to be in the sender's team.
     pub pane: Option<String>,
+    /// `--to-name <name>` — stable named addressing. Mutually exclusive with
+    /// `target` / `targets` / `--pane`; resolves workspace/team/agent or leader
+    /// name to the current live pane before using direct pane injection.
+    pub to_name: Option<String>,
 }
 
 /// E23 worker-side emergency fallback for `team_orchestrator.send_message`

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

@@ -11,6 +11,20 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
 
 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",
+];
 
 #[test]
 #[serial_test::serial(env)]
@@ -141,6 +155,10 @@ struct PhaseGolden {
 
 fn run_phase_golden(spec: PhaseGolden) -> Value {
     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 workspace = team.parent().expect("workspace").to_path_buf();
     seed_healthy_coordinator(&workspace);
@@ -186,6 +204,7 @@ fn run_phase_golden(spec: PhaseGolden) -> Value {
         json: true,
         message_id: Some("phase-golden-message".to_string()),
         pane: None,
+        to_name: None,
     });
     let collect = cmd_collect(&CollectArgs {
         workspace: workspace.clone(),
@@ -394,6 +413,14 @@ 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.0",
+  "version": "0.5.1",
   "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.0",
-    "@team-agent/cli-darwin-x64": "0.5.0",
-    "@team-agent/cli-linux-x64": "0.5.0"
+    "@team-agent/cli-darwin-arm64": "0.5.1",
+    "@team-agent/cli-darwin-x64": "0.5.1",
+    "@team-agent/cli-linux-x64": "0.5.1"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",