@team-agent/installer 0.3.35 → 0.3.37

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.35"
+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.35"
+version = "0.3.37"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -152,7 +152,7 @@ fn quickstart_human(value: &Value) -> String {
         .map(|items| items.iter().filter_map(Value::as_str).collect())
         .unwrap_or_default();
     if attach.is_empty() {
-        return summary.to_string();
+        return append_reminder(summary.to_string(), crate::cli::QUICK_START_REMINDER);
     }
     let mut out = String::from(summary);
     out.push_str("\n\nattach:");
@@ -160,7 +160,15 @@ fn quickstart_human(value: &Value) -> String {
         out.push_str("\n  ");
         out.push_str(cmd);
     }
-    out
+    append_reminder(out, crate::cli::QUICK_START_REMINDER)
+}
+
+fn append_reminder(text: String, reminder: &str) -> String {
+    if text.is_empty() {
+        reminder.to_string()
+    } else {
+        format!("{text}\n{reminder}")
+    }
 }
 
 /// `cmd_compile`(`commands.py:42`)。
@@ -240,7 +248,10 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
             true,
             false,
         )?;
-        return Ok(CmdResult::human(format_status_summary(&value)));
+        return Ok(CmdResult::human(append_reminder(
+            format_status_summary(&value),
+            crate::cli::STATUS_REMINDER,
+        )));
     }
     if args.json {
         let value = status_port::status_scoped(
@@ -252,12 +263,15 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
         )?;
         return Ok(CmdResult::from_json(value, true));
     }
-    Ok(CmdResult::human(status_port::format_status_scoped(
-        &selected.run_workspace,
-        &selected.state,
-        Some(&selected.team_key),
-        args.agent.as_deref(),
-    )?))
+    Ok(CmdResult::human(append_reminder(
+        status_port::format_status_scoped(
+            &selected.run_workspace,
+            &selected.state,
+            Some(&selected.team_key),
+            args.agent.as_deref(),
+        )?,
+        crate::cli::STATUS_REMINDER,
+    )))
 }
 
 fn status_selector_error_payload(error: &str, workspace: &Path) -> Value {
@@ -276,6 +290,7 @@ fn status_selector_error_payload(error: &str, workspace: &Path) -> Value {
         "action": "run `team-agent doctor` or inspect the log path shown here",
         "log": log_path.to_string_lossy().to_string(),
         "workspace": workspace.to_string_lossy().to_string(),
+        "reminder": crate::cli::STATUS_REMINDER,
     })
 }
 
@@ -1583,15 +1598,22 @@ mod tests {
         assert!(out.contains("team started"), "must keep summary; got {out}");
         assert!(out.contains("attach:"), "must render attach block; got {out}");
         assert!(out.contains("team-y:w1") && out.contains("team-y:w2"), "must list each attach cmd; got {out}");
+        assert!(out.ends_with(crate::cli::QUICK_START_REMINDER), "must append harness reminder; got {out}");
     }
 
     #[test]
     fn e13_quickstart_human_summary_only_when_no_attach() {
         let value = json!({"summary": "quick-start complete"});
-        assert_eq!(quickstart_human(&value), "quick-start complete");
+        assert_eq!(
+            quickstart_human(&value),
+            format!("quick-start complete\n{}", crate::cli::QUICK_START_REMINDER)
+        );
         // 空数组也只 summary。
         let value2 = json!({"summary": "s", "attach_commands": []});
-        assert_eq!(quickstart_human(&value2), "s");
+        assert_eq!(
+            quickstart_human(&value2),
+            format!("s\n{}", crate::cli::QUICK_START_REMINDER)
+        );
     }
 
     #[test]

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

@@ -48,6 +48,9 @@ use crate::messaging::{self, AlertType, MessageTarget, SendOptions};
 use crate::model::ids::{TaskId, TeamKey};
 
 pub(crate) const COMMS_BOUNDARY_TEXT: &str = "validates live pane binding consistency and zero-token comms contracts. Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
+pub(crate) const QUICK_START_REMINDER: &str = "Reminder: Do not inspect raw worker terminal output during normal operation. Use team-agent status / inbox / collect instead. Wait for report_result.";
+pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker to report_result. Do not poll the worker terminal with capture-pane.";
+pub(crate) const STATUS_REMINDER: &str = "To wait for results use --watch-result or team-agent collect. Do not capture-pane worker terminals.";
 
 pub mod adapters;
 pub mod diagnose;
@@ -2528,6 +2531,7 @@ pub mod lifecycle_port {
                     "display_backend": display_backend,
                     "next_actions": next_actions,
                     "attach_commands": attach_commands,
+                    "reminder": crate::cli::QUICK_START_REMINDER,
                     "readiness": readiness_json.clone(),
                     "worker_readiness": readiness_json,
                 })
@@ -2546,6 +2550,7 @@ pub mod lifecycle_port {
                 "state_path": state_path.map(|p| p.to_string_lossy().to_string()),
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::QuickStartReport::PreflightBlocked {
                 summary,
@@ -2558,6 +2563,7 @@ pub mod lifecycle_port {
                 "blockers": blockers,
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
         }
     }
@@ -2582,6 +2588,10 @@ pub mod lifecycle_port {
                 Some("tmux -S /tmp/tmux-501/ta-test attach -t team-teamA:worker"),
                 "B-2: ExistingRuntime JSON must preserve attach_commands instead of only next_actions; value={value}"
             );
+            assert_eq!(
+                value.get("reminder").and_then(Value::as_str),
+                Some(crate::cli::QUICK_START_REMINDER)
+            );
         }
 
         #[test]
@@ -2598,6 +2608,20 @@ pub mod lifecycle_port {
                 "B-2: PreflightBlocked JSON must include attach_commands: [] for schema parity with Ready/Restart; value={value}"
             );
         }
+
+        #[test]
+        fn restart_json_includes_harness_reminder() {
+            let value = restart_value(crate::lifecycle::RestartReport::RefusedResumeAtomicity {
+                unresumable: Vec::new(),
+                allow_fresh: false,
+                error: "resume refused".to_string(),
+            });
+
+            assert_eq!(
+                value.get("reminder").and_then(Value::as_str),
+                Some(crate::cli::QUICK_START_REMINDER)
+            );
+        }
     }
 
     fn restart_value(report: crate::lifecycle::RestartReport) -> Value {
@@ -2616,6 +2640,7 @@ pub mod lifecycle_port {
                 "coordinator_started": coordinator_started,
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::Partial {
                 session_name,
@@ -2650,6 +2675,7 @@ pub mod lifecycle_port {
                 "coordinator_started": coordinator_started,
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::Failed {
                 session_name,
@@ -2681,6 +2707,7 @@ pub mod lifecycle_port {
                 })).collect::<Vec<_>>(),
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::RefusedResumeAtomicity {
                 unresumable,
@@ -2692,6 +2719,7 @@ pub mod lifecycle_port {
                 "allow_fresh": allow_fresh,
                 "error": error,
                 "unresumable": unresumable.iter().map(|w| w.agent_id.as_str()).collect::<Vec<_>>(),
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::RefusedResumeNotReady {
                 missing,
@@ -2716,6 +2744,7 @@ pub mod lifecycle_port {
                     "pending_agent_ids": missing.iter().map(|w| w.as_str()).collect::<Vec<_>>(),
                 },
                 "next_action": "rerun restart after session capture completes, or pass --allow-fresh to deliberately discard missing context",
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::RefusedInvalidFirstSendAt {
                 invalid,
@@ -2727,6 +2756,7 @@ pub mod lifecycle_port {
                 "allow_fresh": allow_fresh,
                 "error": error,
                 "invalid": invalid.iter().map(|w| w.worker_id.as_str()).collect::<Vec<_>>(),
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
         }
     }

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

@@ -22,7 +22,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
         if content.is_empty() {
             return Err(CliError::Usage("--pane requires a non-empty message".to_string()));
         }
-        let value = send_to_pane_direct(
+        let mut value = send_to_pane_direct(
             &args.workspace,
             pane_id,
             &content,
@@ -31,6 +31,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
             args.team.as_deref(),
             args.json,
         )?;
+        add_send_reminder_if_ok(&mut value);
         return Ok(CmdResult::from_json(value, args.json));
     }
     let selected = crate::state::selector::resolve_active_team(
@@ -60,6 +61,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
             obj.insert("watch".to_string(), watch_notice_json(&target, &opts));
         }
     }
+    add_send_reminder_if_ok(&mut value);
     Ok(CmdResult::from_json(value, args.json))
 }
 
@@ -471,6 +473,15 @@ fn delivery_outcome_json(
     })
 }
 
+fn add_send_reminder_if_ok(value: &mut Value) {
+    if value.get("ok").and_then(Value::as_bool) != Some(true) {
+        return;
+    }
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("reminder".to_string(), json!(crate::cli::SEND_REMINDER));
+    }
+}
+
 fn target_json(target: &MessageTarget) -> Value {
     match target {
         MessageTarget::Single(agent) => json!(agent),

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

@@ -99,6 +99,7 @@ use rusqlite::params;
             "readiness": readiness,
             "coordinator": coordinator_health_value(health),
             "runtime": runtime_block,
+            "reminder": crate::cli::STATUS_REMINDER,
             "last_events": Value::Array(
                 crate::event_log::EventLog::new(workspace)
                     .tail(10)
@@ -598,6 +599,7 @@ use rusqlite::params;
             "latest_results": take_array(full.get("latest_results"), 5),
             "readiness": full.get("readiness").cloned().unwrap_or_else(|| json!({})),
             "coordinator": compact_object(full.get("coordinator"), &["status", "pid", "metadata_ok", "schema_ok"]),
+            "reminder": full.get("reminder").cloned().unwrap_or_else(|| json!(crate::cli::STATUS_REMINDER)),
             "last_events": take_array_tail(full.get("last_events"), 10),
         })
     }

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

@@ -50,10 +50,15 @@ use super::*;
             "results",
             "latest_results",
             "coordinator",
+            "reminder",
             "last_events",
         ] {
             assert!(obj.contains_key(key), "compact status missing key `{key}`");
         }
+        assert_eq!(
+            obj.get("reminder").and_then(|v| v.as_str()),
+            Some(crate::cli::STATUS_REMINDER)
+        );
         // seeded agent surfaces through the projection.
         assert!(
             obj["agents"].as_object().unwrap().contains_key("a1"),
@@ -65,6 +70,27 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn cmd_status_human_appends_harness_reminder() {
+        let ws = seed_status_workspace();
+        let args = StatusArgs {
+            agent: None,
+            workspace: ws.clone(),
+            detail: false,
+            summary: false,
+            json: false,
+        };
+
+        let r = cmd_status_for_team(&args, None).expect("status");
+        let text = match r.output {
+            CmdOutput::Human(text) => text,
+            other => panic!("expected human status output, got {other:?}"),
+        };
+
+        assert!(text.ends_with(crate::cli::STATUS_REMINDER), "{text}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn status_port_status_reports_managed_leader_topology_and_attach_command() {
         let ws = seed_status_workspace();
@@ -255,6 +281,12 @@ use super::*;
         match r.output {
             CmdOutput::Json(ref v) => {
                 assert!(v.get("ok").is_some(), "send result Json must carry `ok`");
+                if v.get("ok").and_then(|ok| ok.as_bool()) == Some(true) {
+                    assert_eq!(
+                        v.get("reminder").and_then(|reminder| reminder.as_str()),
+                        Some(crate::cli::SEND_REMINDER)
+                    );
+                }
             }
             other => panic!("cmd_send must emit Json DeliveryOutcome, got {other:?}"),
         }

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.35",
+  "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.35",
-    "@team-agent/cli-darwin-x64": "0.3.35",
-    "@team-agent/cli-linux-x64": "0.3.35"
+    "@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",