@team-agent/installer 0.3.36 → 0.3.37

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.36"
+version = "0.3.37"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.36"
+version = "0.3.37"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -308,14 +308,13 @@ fn pane_conflicts_with_leader_or_other(
     else {
         return false;
     };
+    let state_socket = runtime_tmux_socket(state);
+    let agent_socket = tmux_socket_field(agent).or(state_socket);
     // Check leader anchor.
     for key in ["leader_receiver", "team_owner"] {
-        if state
-            .get(key)
-            .and_then(|v| v.get("pane_id"))
-            .and_then(serde_json::Value::as_str)
-            .is_some_and(|lp| lp == pane_id)
-        {
+        if state.get(key).and_then(pane_socket_binding).is_some_and(|leader| {
+            pane_conflicts_on_same_socket(pane_id, agent_socket, leader)
+        }) {
             return true;
         }
     }
@@ -325,10 +324,13 @@ fn pane_conflicts_with_leader_or_other(
             if id == agent_id.as_str() {
                 continue;
             }
+            let other_socket = tmux_socket_field(other).or(state_socket);
             if other
                 .get("pane_id")
                 .and_then(serde_json::Value::as_str)
-                .is_some_and(|op| op == pane_id)
+                .is_some_and(|op| {
+                    op == pane_id && !tmux_sockets_known_different(agent_socket, other_socket)
+                })
             {
                 return true;
             }
@@ -337,6 +339,53 @@ fn pane_conflicts_with_leader_or_other(
     false
 }
 
+#[derive(Clone, Copy)]
+struct PaneSocketBinding<'a> {
+    pane_id: &'a str,
+    tmux_socket: Option<&'a str>,
+}
+
+fn pane_conflicts_on_same_socket(
+    pane_id: &str,
+    agent_socket: Option<&str>,
+    other: PaneSocketBinding<'_>,
+) -> bool {
+    other.pane_id == pane_id && !tmux_sockets_known_different(agent_socket, other.tmux_socket)
+}
+
+fn tmux_sockets_known_different(left: Option<&str>, right: Option<&str>) -> bool {
+    let (Some(left), Some(right)) = (left, right) else {
+        return false;
+    };
+    if left == right {
+        return false;
+    }
+    std::path::Path::new(left).is_absolute() && std::path::Path::new(right).is_absolute()
+}
+
+fn runtime_tmux_socket(state: &serde_json::Value) -> Option<&str> {
+    tmux_socket_field(state)
+}
+
+fn tmux_socket_field(value: &serde_json::Value) -> Option<&str> {
+    value
+        .get("tmux_endpoint")
+        .or_else(|| value.get("tmux_socket"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+}
+
+fn pane_socket_binding(value: &serde_json::Value) -> Option<PaneSocketBinding<'_>> {
+    let pane_id = value
+        .get("pane_id")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty() && *s != "__team_agent_unbound__")?;
+    Some(PaneSocketBinding {
+        pane_id,
+        tmux_socket: tmux_socket_field(value),
+    })
+}
+
 fn agent_pane_live(
     transport: &dyn crate::transport::Transport,
     agent: &serde_json::Value,
@@ -950,3 +999,81 @@ fn write_reset_complete_event(
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn e51_restart_allows_leader_same_pane_id_on_different_tmux_sockets() {
+        let state = serde_json::json!({
+            "tmux_endpoint": "/private/tmp/tmux-501/ta-worker",
+            "leader_receiver": {
+                "pane_id": "%0",
+                "tmux_socket": "/private/tmp/tmux-501/default"
+            },
+            "agents": {
+                "architect": {
+                    "pane_id": "%0",
+                    "tmux_socket": "/private/tmp/tmux-501/ta-worker"
+                }
+            }
+        });
+        let agent_id = AgentId::new("architect");
+        let agent = state["agents"]["architect"].clone();
+
+        assert!(
+            !pane_conflicts_with_leader_or_other(&state, &agent_id, &agent),
+            "same pane id on different tmux sockets must not force a fresh restart"
+        );
+    }
+
+    #[test]
+    fn e51_restart_keeps_leader_conflict_on_same_tmux_socket() {
+        let socket = "/private/tmp/tmux-501/default";
+        let state = serde_json::json!({
+            "tmux_endpoint": socket,
+            "leader_receiver": {
+                "pane_id": "%0",
+                "tmux_socket": socket
+            },
+            "agents": {
+                "architect": {
+                    "pane_id": "%0",
+                    "tmux_socket": socket
+                }
+            }
+        });
+        let agent_id = AgentId::new("architect");
+        let agent = state["agents"]["architect"].clone();
+
+        assert!(
+            pane_conflicts_with_leader_or_other(&state, &agent_id, &agent),
+            "same pane id on the same tmux socket must keep the E51 guard"
+        );
+    }
+
+    #[test]
+    fn e51_restart_allows_other_agent_same_pane_id_on_different_tmux_sockets() {
+        let state = serde_json::json!({
+            "tmux_endpoint": "/private/tmp/tmux-501/ta-worker",
+            "agents": {
+                "architect": {
+                    "pane_id": "%0",
+                    "tmux_socket": "/private/tmp/tmux-501/ta-worker"
+                },
+                "reviewer": {
+                    "pane_id": "%0",
+                    "tmux_socket": "/private/tmp/tmux-501/default"
+                }
+            }
+        });
+        let agent_id = AgentId::new("architect");
+        let agent = state["agents"]["architect"].clone();
+
+        assert!(
+            !pane_conflicts_with_leader_or_other(&state, &agent_id, &agent),
+            "other-agent collision checks must also include tmux_socket"
+        );
+    }
+}

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

@@ -587,8 +587,10 @@ fn resolve_inject_target(
     // is in lease.rs (E51 guard #1) which prevents the conflation; this is the
     // defence-in-depth in the delivery layer.
     if let Some(pane) = cached_pane.as_ref() {
-        let leader_pane = leader_receiver_pane_id(state);
-        if leader_pane.is_some_and(|lp| lp == pane.as_str()) {
+        let worker_socket = worker_tmux_socket(state, agent, transport);
+        if leader_receiver_pane_binding(state).is_some_and(|leader| {
+            pane_conflicts_on_same_socket(pane.as_str(), worker_socket.as_deref(), leader)
+        }) {
             return Target::SessionWindow {
                 session: SessionName::new(session),
                 window: WindowName::new(format!("{recipient}_pane_conflicts_with_leader")),
@@ -639,6 +641,57 @@ fn cached_pane_known_dead(transport: &dyn Transport, pane: &PaneId) -> bool {
     matches!(transport.liveness(pane), Ok(PaneLiveness::Dead))
 }
 
+#[derive(Clone, Copy)]
+struct PaneSocketBinding<'a> {
+    pane_id: &'a str,
+    tmux_socket: Option<&'a str>,
+}
+
+fn pane_conflicts_on_same_socket(
+    pane_id: &str,
+    worker_socket: Option<&str>,
+    leader: PaneSocketBinding<'_>,
+) -> bool {
+    leader.pane_id == pane_id
+        && !tmux_sockets_known_different(worker_socket, leader.tmux_socket)
+}
+
+fn tmux_sockets_known_different(left: Option<&str>, right: Option<&str>) -> bool {
+    let (Some(left), Some(right)) = (left, right) else {
+        return false;
+    };
+    if left == right {
+        return false;
+    }
+    std::path::Path::new(left).is_absolute() && std::path::Path::new(right).is_absolute()
+}
+
+fn worker_tmux_socket(
+    state: &serde_json::Value,
+    agent: Option<&serde_json::Value>,
+    transport: &dyn Transport,
+) -> Option<String> {
+    agent
+        .and_then(tmux_socket_field)
+        .or_else(|| runtime_tmux_socket(state))
+        .map(str::to_string)
+        .or_else(|| transport.tmux_endpoint())
+}
+
+fn runtime_tmux_socket(state: &serde_json::Value) -> Option<&str> {
+    tmux_socket_field(state)
+        .or_else(|| active_team_entry(state).and_then(tmux_socket_field))
+        .or_else(|| only_team_entry(state).and_then(tmux_socket_field))
+}
+
+fn tmux_socket_field(value: &serde_json::Value) -> Option<&str> {
+    value
+        .get("tmux_endpoint")
+        .or_else(|| value.get("tmux_socket"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+}
+
 /// Read the bound leader pane id off the projected or team-scoped runtime state.
 fn leader_receiver_pane_id(state: &serde_json::Value) -> Option<&str> {
     leader_receiver_pane_id_in_state(state)
@@ -646,6 +699,12 @@ fn leader_receiver_pane_id(state: &serde_json::Value) -> Option<&str> {
         .or_else(|| only_team_entry(state).and_then(leader_receiver_pane_id_in_state))
 }
 
+fn leader_receiver_pane_binding(state: &serde_json::Value) -> Option<PaneSocketBinding<'_>> {
+    leader_receiver_pane_binding_in_state(state)
+        .or_else(|| active_team_entry(state).and_then(leader_receiver_pane_binding_in_state))
+        .or_else(|| only_team_entry(state).and_then(leader_receiver_pane_binding_in_state))
+}
+
 /// `state` is "usable" for leader delivery when the bound `leader_receiver.pane_id`
 /// is present and alive (in `live_targets` or `liveness` probe returns not-Dead).
 ///
@@ -761,6 +820,25 @@ fn leader_receiver_pane_id_in_state(state: &serde_json::Value) -> Option<&str> {
         })
 }
 
+fn leader_receiver_pane_binding_in_state(
+    state: &serde_json::Value,
+) -> Option<PaneSocketBinding<'_>> {
+    ["leader_receiver", "team_owner"]
+        .into_iter()
+        .find_map(|key| state.get(key).and_then(pane_socket_binding))
+}
+
+fn pane_socket_binding(value: &serde_json::Value) -> Option<PaneSocketBinding<'_>> {
+    let pane_id = value
+        .get("pane_id")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty() && *s != "__team_agent_unbound__")?;
+    Some(PaneSocketBinding {
+        pane_id,
+        tmux_socket: tmux_socket_field(value),
+    })
+}
+
 fn leader_receiver_tmux_socket(state: &serde_json::Value) -> Option<&str> {
     leader_receiver_field(state, "tmux_socket")
 }

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1812,6 +1812,88 @@ fn u1_resolve_inject_target_uses_live_pane_when_cached_pane_drifted() {
     );
 }
 
+#[test]
+fn e51_delivery_allows_same_pane_id_on_different_tmux_sockets() {
+    let ws = tmp_ws("e51diffsocket");
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let state = serde_json::json!({
+        "session_name": "team-e51",
+        "tmux_endpoint": "/private/tmp/tmux-501/ta-worker",
+        "leader_receiver": {
+            "pane_id": "%0",
+            "tmux_socket": "/private/tmp/tmux-501/default"
+        },
+        "agents": {
+            "architect": {
+                "provider": "fake",
+                "pane_id": "%0",
+                "window": "architect"
+            }
+        }
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let _ = store
+        .create_message(None, "peer", "architect", "socket-aware", None, false, None)
+        .unwrap();
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint("/private/tmp/tmux-501/ta-worker")
+        .with_targets(vec![pane_info("%0", "team-e51", "architect")]);
+
+    let delivered = deliver_pending_messages(&ws, &state, &transport, &log)
+        .expect("same pane id on different sockets must not poison delivery");
+
+    assert_eq!(delivered.len(), 1);
+    assert_eq!(
+        transport.inject_targets(),
+        vec![Target::Pane(PaneId::new("%0"))],
+        "E51 must compare pane_id with tmux_socket; different sockets are not a leader conflict"
+    );
+}
+
+#[test]
+fn e51_delivery_keeps_same_socket_pane_conflict_guard() {
+    let ws = tmp_ws("e51samesocket");
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let socket = "/private/tmp/tmux-501/default";
+    let state = serde_json::json!({
+        "session_name": "team-e51",
+        "tmux_endpoint": socket,
+        "leader_receiver": {
+            "pane_id": "%0",
+            "tmux_socket": socket
+        },
+        "agents": {
+            "architect": {
+                "provider": "fake",
+                "pane_id": "%0",
+                "window": "architect"
+            }
+        }
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let _ = store
+        .create_message(None, "peer", "architect", "same-socket", None, false, None)
+        .unwrap();
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint(socket)
+        .with_targets(vec![pane_info("%0", "team-e51", "architect")]);
+
+    let delivered = deliver_pending_messages(&ws, &state, &transport, &log)
+        .expect("same-socket E51 guard should still resolve to a structured target");
+
+    assert_eq!(delivered.len(), 1);
+    assert_eq!(
+        transport.inject_targets(),
+        vec![Target::SessionWindow {
+            session: SessionName::new("team-e51"),
+            window: WindowName::new("architect_pane_conflicts_with_leader"),
+        }],
+        "same pane id on the same socket must keep the E51 loop guard"
+    );
+}
+
 #[test]
 fn u1_multi_team_send_does_not_backfill_top_level_leader_binding() {
     let ws = tmp_ws("u1backfill");

package/package.json

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