@team-agent/installer 0.3.0 → 0.3.2

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

@@ -1,11 +1,25 @@
 //! status_port extracted from cli::mod inline placeholder.
 use super::*;
+use crate::state::projection::OwnerTeamResolution;
 use crate::transport::Transport;
+use rusqlite::params;
 
     /// `status.status(workspace, as_json, compact)`(`queries.py:33`,**有副作用**:capture→refresh→save)。
     pub fn status(workspace: &Path, compact: bool, detail: bool) -> Result<Value, CliError> {
-        let _ = detail;
         let state = read_runtime_state(workspace);
+        status_scoped(workspace, &state, None, compact, detail)
+    }
+
+    pub fn status_scoped(
+        workspace: &Path,
+        state: &Value,
+        owner_team_id: Option<&str>,
+        compact: bool,
+        detail: bool,
+    ) -> Result<Value, CliError> {
+        let _ = detail;
+        let resolved_owner_team_id = resolve_status_owner_team(workspace, owner_team_id)?;
+        let owner_team_id = resolved_owner_team_id.as_deref().or(owner_team_id);
         let health = crate::coordinator::coordinator_health(
             &crate::coordinator::WorkspacePath::new(workspace.to_path_buf()),
         );
@@ -30,11 +44,11 @@ use crate::transport::Transport;
             "leader_receiver": leader_receiver,
             "teams": state.get("teams").cloned().unwrap_or_else(|| json!({})),
             "agents": agents,
-            "agent_health": agent_health(&conn)?,
+            "agent_health": agent_health(&conn, owner_team_id)?,
             "tasks": tasks,
-            "messages": message_counts(&conn)?,
-            "queued_messages": queued_messages(&conn, 8)?,
-            "results": result_counts(&conn)?,
+            "messages": message_counts(&conn, owner_team_id)?,
+            "queued_messages": queued_messages(&conn, owner_team_id, 8)?,
+            "results": result_counts(&conn, owner_team_id)?,
             "latest_results": json!([]),
             "coordinator": coordinator_health_value(health),
             "last_events": Value::Array(
@@ -51,7 +65,17 @@ use crate::transport::Transport;
     }
     /// `status.format_status(workspace, agent)`(人读)。
     pub fn format_status(workspace: &Path, agent: Option<&str>) -> Result<String, CliError> {
-        let status = status(workspace, true, false)?;
+        let state = read_runtime_state(workspace);
+        format_status_scoped(workspace, &state, None, agent)
+    }
+
+    pub fn format_status_scoped(
+        workspace: &Path,
+        state: &Value,
+        owner_team_id: Option<&str>,
+        agent: Option<&str>,
+    ) -> Result<String, CliError> {
+        let status = status_scoped(workspace, state, owner_team_id, true, false)?;
         Ok(match agent {
             Some(agent) => format!("agent {agent}: {}", status.pointer("/agents").is_some()),
             None => crate::cli::format_status_summary(&status),
@@ -165,6 +189,32 @@ use crate::transport::Transport;
             .unwrap_or_else(|| json!({}))
     }
 
+    fn resolve_status_owner_team(
+        workspace: &Path,
+        owner_team_id: Option<&str>,
+    ) -> Result<Option<String>, CliError> {
+        let Some(requested) = owner_team_id.filter(|team| !team.is_empty()) else {
+            return Ok(None);
+        };
+        let state = read_runtime_state(workspace);
+        match crate::state::projection::resolve_owner_team_id(&state, requested) {
+            OwnerTeamResolution::Canonical(canonical) => Ok(Some(canonical)),
+            OwnerTeamResolution::LegacyAlias { requested, canonical } => {
+                let log = crate::event_log::EventLog::new(workspace);
+                crate::messaging::delivery::normalize_owner_team_id_rows(
+                    workspace,
+                    &requested,
+                    &canonical,
+                    None,
+                    Some(&log),
+                )
+                .map_err(CliError::from)?;
+                Ok(Some(canonical))
+            }
+            OwnerTeamResolution::Unresolved { .. } | OwnerTeamResolution::Ambiguous { .. } => Ok(None),
+        }
+    }
+
     fn agent_window(agent_id: &str, agent_state: &Value) -> String {
         ["window", "window_name"]
             .iter()
@@ -224,15 +274,15 @@ use crate::transport::Transport;
             .unwrap_or(false)
     }
 
-    fn message_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
-        status_counts(conn, "messages")
+    fn message_counts(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {
+        status_counts(conn, "messages", owner_team_id)
     }
 
-    fn result_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
-        let by_status = result_status_counts(conn)?;
-        let total = count_rows(conn, "results")?;
-        let invalid = count_where_status(conn, "results", "invalid")?;
-        let collected = count_where_status(conn, "results", "collected")?;
+    fn result_counts(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {
+        let by_status = result_status_counts(conn, owner_team_id)?;
+        let total = count_rows(conn, "results", owner_team_id)?;
+        let invalid = count_where_status(conn, "results", owner_team_id, "invalid")?;
+        let collected = count_where_status(conn, "results", owner_team_id, "collected")?;
         let uncollected = total.saturating_sub(collected).saturating_sub(invalid);
         Ok(json!({
             "total": total,
@@ -243,10 +293,24 @@ use crate::transport::Transport;
         }))
     }
 
-    fn status_counts(conn: &rusqlite::Connection, table: &str) -> Result<Value, CliError> {
-        let sql = format!("select status, count(*) from {table} group by status order by status");
+    fn status_counts(
+        conn: &rusqlite::Connection,
+        table: &str,
+        owner_team_id: Option<&str>,
+    ) -> Result<Value, CliError> {
+        let sql = match owner_team_id {
+            Some(_) => format!(
+                "select status, count(*) from {table}
+                 where owner_team_id = ?1
+                 group by status order by status"
+            ),
+            None => format!("select status, count(*) from {table} group by status order by status"),
+        };
         let mut stmt = conn.prepare(&sql).map_err(|e| CliError::Runtime(e.to_string()))?;
-        let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut rows = match owner_team_id {
+            Some(team) => stmt.query(params![team]).map_err(|e| CliError::Runtime(e.to_string()))?,
+            None => stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?,
+        };
         let mut out = Map::new();
         while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
             let status: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -256,16 +320,28 @@ use crate::transport::Transport;
         Ok(Value::Object(out))
     }
 
-    fn result_status_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
-        let mut stmt = conn
-            .prepare(
+    fn result_status_counts(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select status, count(*) from results
+                 where status not in ('collected', 'invalid') and owner_team_id = ?1
+                 group by status
+                 order by status"
+            }
+            None => {
                 "select status, count(*) from results
                  where status not in ('collected', 'invalid')
                  group by status
-                 order by status",
-            )
+                 order by status"
+            }
+        };
+        let mut stmt = conn
+            .prepare(sql)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut rows = match owner_team_id {
+            Some(team) => stmt.query(params![team]).map_err(|e| CliError::Runtime(e.to_string()))?,
+            None => stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?,
+        };
         let mut out = Map::new();
         while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
             let status: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -275,19 +351,32 @@ use crate::transport::Transport;
         Ok(Value::Object(out))
     }
 
-    fn queued_messages(conn: &rusqlite::Connection, limit: usize) -> Result<Value, CliError> {
+    fn queued_messages(
+        conn: &rusqlite::Connection,
+        owner_team_id: Option<&str>,
+        limit: usize,
+    ) -> Result<Value, CliError> {
         let limit = i64::try_from(limit).unwrap_or(i64::MAX);
-        let mut stmt = conn
-            .prepare(
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select message_id, recipient, status, created_at, delivery_attempts
+                 from messages
+                 where status like 'queued%' and owner_team_id = ?1
+                 order by created_at desc
+                 limit ?2"
+            }
+            None => {
                 "select message_id, recipient, status, created_at, delivery_attempts
                  from messages
                  where status like 'queued%'
                  order by created_at desc
-                 limit ?1",
-            )
+                 limit ?1"
+            }
+        };
+        let mut stmt = conn
+            .prepare(sql)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let rows = stmt
-            .query_map([limit], |row| {
+        let map_row = |row: &rusqlite::Row<'_>| {
                 Ok(json!({
                     "message_id": row.get::<_, String>(0)?,
                     "recipient": row.get::<_, Option<String>>(1)?,
@@ -295,8 +384,12 @@ use crate::transport::Transport;
                     "created_at": row.get::<_, Option<String>>(3)?,
                     "delivery_attempts": row.get::<_, i64>(4)?,
                 }))
-            })
-            .map_err(|e| CliError::Runtime(e.to_string()))?;
+            };
+        let rows = match owner_team_id {
+            Some(team) => stmt.query_map(params![team, limit], map_row),
+            None => stmt.query_map(params![limit], map_row),
+        }
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
         let values = rows
             .collect::<Result<Vec<_>, _>>()
             .map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -410,30 +503,63 @@ use crate::transport::Transport;
         Value::Array(items.iter().skip(start).cloned().collect())
     }
 
-    fn count_rows(conn: &rusqlite::Connection, table: &str) -> Result<i64, CliError> {
-        let sql = format!("select count(*) from {table}");
-        conn.query_row(&sql, [], |row| row.get::<_, i64>(0))
-            .map_err(|e| CliError::Runtime(e.to_string()))
+    fn count_rows(
+        conn: &rusqlite::Connection,
+        table: &str,
+        owner_team_id: Option<&str>,
+    ) -> Result<i64, CliError> {
+        match owner_team_id {
+            Some(team) => {
+                let sql = format!("select count(*) from {table} where owner_team_id = ?1");
+                conn.query_row(&sql, [team], |row| row.get::<_, i64>(0))
+                    .map_err(|e| CliError::Runtime(e.to_string()))
+            }
+            None => {
+                let sql = format!("select count(*) from {table}");
+                conn.query_row(&sql, [], |row| row.get::<_, i64>(0))
+                    .map_err(|e| CliError::Runtime(e.to_string()))
+            }
+        }
     }
 
     fn count_where_status(
         conn: &rusqlite::Connection,
         table: &str,
+        owner_team_id: Option<&str>,
         status: &str,
     ) -> Result<i64, CliError> {
-        let sql = format!("select count(*) from {table} where status = ?1");
-        conn.query_row(&sql, [status], |row| row.get::<_, i64>(0))
-            .map_err(|e| CliError::Runtime(e.to_string()))
+        match owner_team_id {
+            Some(team) => {
+                let sql = format!("select count(*) from {table} where status = ?1 and owner_team_id = ?2");
+                conn.query_row(&sql, params![status, team], |row| row.get::<_, i64>(0))
+                    .map_err(|e| CliError::Runtime(e.to_string()))
+            }
+            None => {
+                let sql = format!("select count(*) from {table} where status = ?1");
+                conn.query_row(&sql, [status], |row| row.get::<_, i64>(0))
+                    .map_err(|e| CliError::Runtime(e.to_string()))
+            }
+        }
     }
 
-    fn agent_health(conn: &rusqlite::Connection) -> Result<Value, CliError> {
-        let mut stmt = conn
-            .prepare(
+    fn agent_health(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at, owner_team_id
+                 from agent_health where owner_team_id = ?1 order by agent_id"
+            }
+            None => {
                 "select agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at, owner_team_id
-                 from agent_health order by agent_id",
-            )
+                 from agent_health order by agent_id"
+            }
+        };
+        let mut stmt = conn
+            .prepare(sql)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut rows = match owner_team_id {
+            Some(team) => stmt.query(params![team]).map_err(|e| CliError::Runtime(e.to_string()))?,
+            None => stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?,
+        };
         let mut out = Map::new();
         while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
             let agent_id: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;

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

@@ -152,6 +152,7 @@ fn current_uid() -> Option<String> {
         let ws = crate::model::paths::team_workspace(&team).unwrap();
         let _guard = TeamSocketGuard { ws };
         let args = QuickStartArgs {
+            workspace: crate::model::paths::team_workspace(&team).unwrap(),
             agents_dir: team.clone(),
             name: None,
             team_id: None,
@@ -177,6 +178,7 @@ fn current_uid() -> Option<String> {
         std::fs::write(team.join("TEAM.md"), DELEG_TEAM_MD).unwrap();
         std::fs::write(team.join("agents").join("broken.md"), DELEG_INVALID_ROLE).unwrap();
         let args = QuickStartArgs {
+            workspace: crate::model::paths::team_workspace(&team).unwrap(),
             agents_dir: team,
             name: None,
             team_id: None,

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

@@ -253,6 +253,7 @@ pub struct InteractionCounts {
 /// `quick-start`(`parser.py:105`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct QuickStartArgs {
+    pub workspace: PathBuf,
     pub agents_dir: PathBuf,
     pub name: Option<String>,
     pub team_id: Option<String>,

package/crates/team-agent/src/coordinator/health.rs

@@ -3,6 +3,7 @@
 use std::io::{Read, Seek, SeekFrom};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
+use std::time::Duration;
 
 use serde_json::Value;
 use thiserror::Error;
@@ -119,6 +120,9 @@ pub fn start_coordinator(workspace: &WorkspacePath) -> Result<StartReport, Start
 pub fn stop_coordinator(workspace: &WorkspacePath) -> Result<StopReport, StopError> {
     let pid_path = coordinator_pid_path(workspace);
     if !pid_path.exists() {
+        if let Some(report) = stop_discovered_coordinators(workspace)? {
+            return Ok(report);
+        }
         return Ok(StopReport {
             ok: true,
             status: StopOutcome::Missing,
@@ -134,6 +138,15 @@ pub fn stop_coordinator(workspace: &WorkspacePath) -> Result<StopReport, StopErr
             pid: None,
         });
     };
+    if pid_is_running(pid).ok() == Some(false) {
+        remove_file_if_exists(&pid_path)?;
+        remove_file_if_exists(&coordinator_meta_path(workspace))?;
+        return Ok(StopReport {
+            ok: true,
+            status: StopOutcome::Missing,
+            pid: Some(pid),
+        });
+    }
     let Ok(pid_t) = libc::pid_t::try_from(pid.get()) else {
         return Ok(StopReport {
             ok: false,
@@ -158,6 +171,123 @@ pub fn stop_coordinator(workspace: &WorkspacePath) -> Result<StopReport, StopErr
     })
 }
 
+fn stop_discovered_coordinators(
+    workspace: &WorkspacePath,
+) -> Result<Option<StopReport>, StopError> {
+    let pids = discover_coordinator_pids(workspace);
+    if pids.is_empty() {
+        return Ok(None);
+    }
+
+    let mut stopped = None;
+    let mut failed = None;
+    for pid in pids {
+        if terminate_pid(pid) {
+            stopped.get_or_insert(pid);
+        } else {
+            failed.get_or_insert(pid);
+        }
+    }
+    remove_file_if_exists(&coordinator_meta_path(workspace))?;
+
+    if let Some(pid) = stopped {
+        Ok(Some(StopReport {
+            ok: true,
+            status: StopOutcome::Stopped,
+            pid: Some(pid),
+        }))
+    } else {
+        Ok(Some(StopReport {
+            ok: false,
+            status: StopOutcome::KillFailed,
+            pid: failed,
+        }))
+    }
+}
+
+fn discover_coordinator_pids(workspace: &WorkspacePath) -> Vec<Pid> {
+    let output = match Command::new("ps")
+        .args(["-axo", "pid=,command="])
+        .output()
+    {
+        Ok(output) if output.status.success() => output,
+        _ => return Vec::new(),
+    };
+    let text = String::from_utf8_lossy(&output.stdout);
+    let candidates = workspace_match_candidates(workspace.as_path());
+    text.lines()
+        .filter_map(|line| parse_ps_command_line(line))
+        .filter(|(pid, command)| {
+            *pid != std::process::id()
+                && coordinator_command_matches_workspace(command, &candidates)
+        })
+        .map(|(pid, _)| Pid::new(pid))
+        .collect()
+}
+
+fn parse_ps_command_line(line: &str) -> Option<(u32, &str)> {
+    let line = line.trim_start();
+    let split = line
+        .find(char::is_whitespace)
+        .unwrap_or(line.len());
+    let pid = line.get(..split)?.trim().parse::<u32>().ok()?;
+    let command = line.get(split..)?.trim();
+    Some((pid, command))
+}
+
+fn workspace_match_candidates(workspace: &Path) -> Vec<String> {
+    let mut candidates = vec![workspace.to_string_lossy().to_string()];
+    if let Ok(canonical) = workspace.canonicalize() {
+        let text = canonical.to_string_lossy().to_string();
+        if !candidates.iter().any(|candidate| candidate == &text) {
+            candidates.push(text);
+        }
+    }
+    candidates
+}
+
+fn coordinator_command_matches_workspace(command: &str, workspaces: &[String]) -> bool {
+    command
+        .split_whitespace()
+        .any(|token| token == "team-agent" || token.ends_with("/team-agent"))
+        && command.split_whitespace().any(|token| token == "coordinator")
+        && command.contains("--workspace")
+        && workspaces.iter().any(|workspace| command.contains(workspace))
+}
+
+fn terminate_pid(pid: Pid) -> bool {
+    if pid_is_running(pid).ok() == Some(false) {
+        return true;
+    }
+    if !send_signal(pid, libc::SIGTERM) {
+        return false;
+    }
+    if wait_until_not_running(pid, Duration::from_millis(750)) {
+        return true;
+    }
+    send_signal(pid, libc::SIGKILL) && wait_until_not_running(pid, Duration::from_millis(750))
+}
+
+fn send_signal(pid: Pid, signal: libc::c_int) -> bool {
+    let Ok(pid_t) = libc::pid_t::try_from(pid.get()) else {
+        return false;
+    };
+    unsafe { libc::kill(pid_t, signal) == 0 }
+}
+
+fn wait_until_not_running(pid: Pid, timeout: Duration) -> bool {
+    let start = std::time::Instant::now();
+    loop {
+        if pid_is_running(pid).ok() != Some(true) {
+            return true;
+        }
+        if start.elapsed() >= timeout {
+            return false;
+        }
+        std::thread::sleep(Duration::from_millis(25));
+    }
+}
+
 // ===========================================================================
 // metadata 身份原语(metadata.py)—— 自由函数面
 // ===========================================================================

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

@@ -424,7 +424,8 @@ fn claim_lease_no_incident_with_target(
         ));
     }
     let non_empty_caller_pane = NonEmptyPaneId::try_from_pane(caller_pane)?;
-    if bound_pane_id.as_deref() == Some(caller_pane.as_str()) {
+    let bound_endpoint_matches_caller = bound_endpoint_matches_current_process(state);
+    if bound_pane_id.as_deref() == Some(caller_pane.as_str()) && bound_endpoint_matches_caller {
         return Ok(LeaseResult {
             ok: true,
             status: LeaseStatus::AlreadyBound,
@@ -438,7 +439,12 @@ fn claim_lease_no_incident_with_target(
     }
     let owner_live = bound_pane_id
         .as_deref()
-        .is_some_and(|pane| liveness.liveness(pane) == PaneLiveness::Live);
+        .is_some_and(|pane| {
+            if pane == caller_pane.as_str() && !bound_endpoint_matches_caller {
+                return false;
+            }
+            liveness.liveness(pane) == PaneLiveness::Live
+        });
     if owner_live && !confirm {
         emit_lease_refusal(
             event_log,
@@ -596,6 +602,20 @@ fn bound_pane(state: &Value) -> Option<String> {
         .or_else(|| get_path_str(state, &["team_owner", "pane_id"]).filter(|v| !v.is_empty()))
 }
 
+fn bound_endpoint_matches_current_process(state: &Value) -> bool {
+    let Some(bound) = get_path_str(state, &["leader_receiver", "tmux_socket"]).filter(|v| !v.is_empty()) else {
+        return true;
+    };
+    let Some(current) = crate::tmux_backend::socket_name_from_tmux_env() else {
+        return false;
+    };
+    tmux_endpoints_match(&bound, &current)
+}
+
+fn tmux_endpoints_match(bound: &str, current: &str) -> bool {
+    bound == current
+}
+
 fn prior_provider(state: &Value) -> Provider {
     get_path_str(state, &["leader_receiver", "provider"])
         .or_else(|| get_path_str(state, &["team_owner", "provider"]))
@@ -844,6 +864,7 @@ fn make_receiver(
         pane_index: target.as_ref().and_then(|t| t.pane_index.map(|v| v.to_string())),
         pane_tty: target.as_ref().and_then(|t| t.tty.clone()),
         pane_current_command: target.as_ref().and_then(|t| t.current_command.clone()),
+        tmux_socket: crate::tmux_backend::socket_name_from_tmux_env(),
         fingerprint: target.as_ref().map(receiver_fingerprint),
         leader_session_uuid: Some(uuid.clone()),
         owner_epoch: Some(epoch),

package/crates/team-agent/src/leader/rediscover/tests.rs

@@ -31,6 +31,7 @@ fn receiver(pane: &str, uuid: &str, epoch: u64) -> LeaderReceiver {
         pane_index: None,
         pane_tty: None,
         pane_current_command: None,
+        tmux_socket: None,
         fingerprint: None,
         leader_session_uuid: serde_json::from_value(Value::String(uuid.to_string())).ok(),
         owner_epoch: Some(OwnerEpoch(epoch)),

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

@@ -1013,6 +1013,7 @@ fn receiver_from_candidate(
         pane_index: target.pane_index.clone(),
         pane_tty: target.tty.clone(),
         pane_current_command: target.current_command.clone(),
+        tmux_socket: prior.tmux_socket.clone(),
         fingerprint: target.fingerprint.clone(),
         leader_session_uuid: uuid,
         owner_epoch: Some(epoch),
@@ -1035,6 +1036,7 @@ fn empty_prior(provider: Provider, epoch: OwnerEpoch) -> LeaderReceiver {
         pane_index: None,
         pane_tty: None,
         pane_current_command: None,
+        tmux_socket: None,
         fingerprint: None,
         leader_session_uuid: None,
         owner_epoch: Some(epoch),

package/crates/team-agent/src/leader/tests/byte_findings.rs

@@ -18,7 +18,7 @@ use super::*;
             "golden new_owner includes os_user");
     }
 
-    // D2 [BLOCK] — claim-path leader_receiver is golden's 14 keys in golden order; NO
+    // D2 [BLOCK] — claim-path leader_receiver is golden's 15 keys in golden order; NO
     // fingerprint/requested_provider/warning. Golden _receiver_from_claim_target (__init__.py:861-877).
     // Rust LeaderReceiver serializes all 17 (no skip_serializing_if) -> 3 always-null extras leak. RED.
     // (The POPULATED tmux values session_name/window_*/pane_* come from the caller-target scan — a
@@ -26,9 +26,12 @@ use super::*;
     // locked here are unchanged by that scan.)
     #[test]
     #[serial_test::serial(env)]
-    fn d2_claim_leader_receiver_is_fourteen_golden_keys_in_order_no_extras() {
+    fn d2_claim_leader_receiver_is_fifteen_golden_keys_in_order_no_extras() {
         let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
-        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let _e = EnvGuard::apply(&[
+            ("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None),
+            ("TMUX", Some("/tmp/tmux-501/default,123,0")),
+        ]);
         let ws = p2_temp_ws("d2_recv_keys");
         let mut state = serde_json::json!({"session_name": "team-agent-x"});
         let r = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
@@ -42,9 +45,9 @@ use super::*;
         let keys: Vec<&str> = recv.keys().map(String::as_str).collect();
         assert_eq!(keys, vec![
             "mode","status","provider","pane_id","session_name","window_index","window_name",
-            "pane_index","pane_tty","pane_current_command","leader_session_uuid","owner_epoch",
-            "attached_at","discovery",
-        ], "golden _receiver_from_claim_target 14-key set + ORDER (__init__.py:861-877)");
+            "pane_index","pane_tty","pane_current_command","tmux_socket","leader_session_uuid",
+            "owner_epoch","attached_at","discovery",
+        ], "golden _receiver_from_claim_target 15-key set + ORDER (__init__.py:861-877 + BUG-4 socket-qualified receiver)");
     }
 
     // D2 seam — the caller-target SCAN that fills session_name/window_index/window_name/pane_index/

package/crates/team-agent/src/leader/tests/idle.rs

@@ -197,6 +197,7 @@ use super::*;
             pane_index: Some("2".into()),
             pane_tty: Some("/dev/ttys001".into()),
             pane_current_command: Some("claude".into()),
+            tmux_socket: None,
             fingerprint: Some("fp".into()),
             leader_session_uuid: Some(uuid("fp", "/ws", "u", "default")),
             owner_epoch: Some(OwnerEpoch(3)),