@team-agent/installer 0.5.12 → 0.5.13

package/Cargo.lock

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

package/Cargo.toml

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

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

@@ -3321,8 +3321,9 @@ pub mod lifecycle_port {
                     .map(|id| json!({"id": id}))
                     .collect::<Vec<_>>(),
                 "next_actions": [
-                    "run team-agent diagnose --json from the intended leader socket",
-                    "repair the tmux endpoint/socket split before retrying restart"
+                    "team-agent diagnose --json",
+                    "team-agent claim-leader --confirm --json",
+                    "team-agent takeover --confirm --json"
                 ],
                 "reminder": crate::cli::QUICK_START_REMINDER,
             }),

package/crates/team-agent/src/layout/sessions.rs

@@ -160,7 +160,9 @@ pub fn assert_topology_invariants(state: &JsonValue, spec: &YamlValue) -> Vec<To
                         kind: TopologyViolationKind::LeaderPaneIdCollidesWithAgent,
                         detail: format!(
                             "leader_receiver.pane_id `{leader_pane}` is also bound to \
-                             agent `{agent_id}` — leader pane and agent pane must be disjoint"
+                             agent `{agent_id}` — legacy bare-pane advisory only; validate \
+                             endpoint/session/window/pane_pid tuple before using this as an \
+                             identity blocker"
                         ),
                     });
                 }

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

@@ -447,10 +447,11 @@ pub fn claim_leader(
             .list_targets()
             .unwrap_or_default(),
     );
-    let caller_target = targets
+    let caller_pane_info = targets
         .iter()
-        .find(|target| target.pane_id.as_str() == caller)
-        .and_then(|target| claim_target_from_pane_info(workspace, target));
+        .find(|target| target.pane_id.as_str() == caller);
+    let caller_target =
+        caller_pane_info.and_then(|target| claim_target_from_pane_info(workspace, target));
     let env_team = std::env::var("TEAM_AGENT_TEAM_ID")
         .ok()
         .filter(|team| !team.is_empty());
@@ -496,6 +497,7 @@ pub fn claim_leader(
         &event_log,
         &liveness,
         caller_target.as_ref(),
+        caller_pane_info,
         scoped_team.map(|_| team_id.as_str()),
     )?;
     if result.ok {
@@ -556,6 +558,7 @@ pub fn claim_lease_no_incident(
         event_log,
         liveness,
         None,
+        None,
         scoped_team,
     )
 }
@@ -586,6 +589,7 @@ fn claim_lease_no_incident_with_target(
     event_log: &crate::event_log::EventLog,
     liveness: &dyn crate::state::owner_gate::PaneLivenessProbe,
     caller_target: Option<&LeaderClaimTarget>,
+    caller_pane_info: Option<&PaneInfo>,
     scoped_team: Option<&str>,
 ) -> Result<LeaseResult, LeaderError> {
     let _ = team;
@@ -705,25 +709,53 @@ fn claim_lease_no_incident_with_target(
     // worker's tmux pane overwrites leader_receiver.pane_id with the worker's
     // pane → delivery routes worker messages to itself (loop) and the leader
     // loses its handle (the macmini "hand-handle mapping 灾难" truth source).
-    if let Some(worker_id) = registered_worker_for_pane(state, caller_pane) {
-        emit_lease_refusal(
-            event_log,
-            LeaseReason::CallerNotLeaderShaped,
+    if let Some(caller_pane_info) = caller_pane_info {
+        match crate::topology::classify_registered_worker_for_observed_pane(
             state,
-            bound_pane_id.as_deref(),
-            Some(caller_pane.as_str()),
-            team_id,
-        )?;
-        return Ok(refused(
-            LeaseReason::CallerNotLeaderShaped,
-            &format!(
-                "pane {} is registered as worker {worker_id}; \
-                 run claim-leader from the leader's own pane, not a worker pane",
-                caller_pane.as_str()
-            ),
-            None,
-            bound_pane_id.clone().map(PaneId::new),
-        ));
+            caller_pane_info,
+        ) {
+            crate::topology::WorkerPaneBindingMatch::LiveSameWorker { agent_id } => {
+                emit_lease_refusal(
+                    event_log,
+                    LeaseReason::CallerNotLeaderShaped,
+                    state,
+                    bound_pane_id.as_deref(),
+                    Some(caller_pane.as_str()),
+                    team_id,
+                )?;
+                return Ok(refused(
+                    LeaseReason::CallerNotLeaderShaped,
+                    &format!(
+                        "pane {} is registered as worker {agent_id}; \
+                         run claim-leader from the leader's own pane, not a worker pane",
+                        caller_pane.as_str()
+                    ),
+                    None,
+                    bound_pane_id.clone().map(PaneId::new),
+                ));
+            }
+            crate::topology::WorkerPaneBindingMatch::Stale { agent_id, reason } => {
+                event_log.write(
+                    "leader_receiver.worker_pane_binding_ignored",
+                    json!({
+                        "agent_id": agent_id,
+                        "pane_id": caller_pane.as_str(),
+                        "reason": reason,
+                    }),
+                )?;
+            }
+            crate::topology::WorkerPaneBindingMatch::IncompleteLegacy { agent_id } => {
+                event_log.write(
+                    "leader_receiver.worker_pane_binding_ignored",
+                    json!({
+                        "agent_id": agent_id,
+                        "pane_id": caller_pane.as_str(),
+                        "reason": "incomplete_legacy_tuple",
+                    }),
+                )?;
+            }
+            crate::topology::WorkerPaneBindingMatch::NoMatch => {}
+        }
     }
     let reason = if bound_pane_id.is_some() {
         LeaseReason::PreviousOwnerPaneDead
@@ -1135,38 +1167,6 @@ fn make_owner(
     }
 }
 
-/// E51 (0.3.26 P0, lease guard): scan state.agents + teams[*].agents for a worker
-/// whose pane_id matches the caller. Returns the first matching agent_id, or None
-/// if no registered worker owns this pane. The check is O(N agents) — negligible
-/// on a team-agent team which rarely exceeds ~20 workers.
-fn registered_worker_for_pane(state: &Value, caller_pane: &PaneId) -> Option<String> {
-    if let Some(agent_id) = scan_agents_for_pane(state.get("agents"), caller_pane) {
-        return Some(agent_id);
-    }
-    if let Some(teams) = state.get("teams").and_then(Value::as_object) {
-        for (_, team_state) in teams {
-            if let Some(agent_id) = scan_agents_for_pane(team_state.get("agents"), caller_pane) {
-                return Some(agent_id);
-            }
-        }
-    }
-    None
-}
-
-fn scan_agents_for_pane(agents: Option<&Value>, caller_pane: &PaneId) -> Option<String> {
-    let map = agents?.as_object()?;
-    for (agent_id, agent) in map {
-        if agent
-            .get("pane_id")
-            .and_then(Value::as_str)
-            .is_some_and(|pane| pane == caller_pane.as_str())
-        {
-            return Some(agent_id.clone());
-        }
-    }
-    None
-}
-
 /// Stage 3a (identity-boundary unified plan, architect direction 2026-06-23)
 /// + Stage 3 owner persist fix (architect direction 2026-06-24): route the
 /// in-memory binding write through the `state::ownership` API. The

package/crates/team-agent/src/topology.rs

@@ -1,6 +1,6 @@
 use serde_json::{json, Value};
 
-use crate::transport::{SessionName, Transport};
+use crate::transport::{PaneInfo, SessionName, Transport};
 
 pub const WORKER_PANE_BINDING_STALE: &str = "worker_pane_binding_stale";
 pub const TMUX_ENDPOINT_SOCKET_CONFLICT: &str = "tmux_endpoint_socket_conflict";
@@ -30,6 +30,103 @@ pub fn issue_id(issue: &Value) -> Option<&str> {
     issue.get("id").and_then(Value::as_str)
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum WorkerPaneBindingMatch {
+    LiveSameWorker { agent_id: String },
+    Stale { agent_id: String, reason: &'static str },
+    IncompleteLegacy { agent_id: String },
+    NoMatch,
+}
+
+pub fn classify_worker_pane_binding(
+    agent_id: &str,
+    agent: &Value,
+    expected_session: &str,
+    observed: &PaneInfo,
+) -> WorkerPaneBindingMatch {
+    let Some(cached_pane_id) = non_empty_str(agent, "pane_id") else {
+        return WorkerPaneBindingMatch::NoMatch;
+    };
+    if cached_pane_id != observed.pane_id.as_str() {
+        return WorkerPaneBindingMatch::NoMatch;
+    }
+
+    let Some(observed_window) = observed.window_name.as_ref().map(|window| window.as_str()) else {
+        return WorkerPaneBindingMatch::IncompleteLegacy {
+            agent_id: agent_id.to_string(),
+        };
+    };
+    let expected_window = non_empty_str(agent, "window").unwrap_or(agent_id);
+    if expected_session.is_empty() || expected_window.is_empty() {
+        return WorkerPaneBindingMatch::IncompleteLegacy {
+            agent_id: agent_id.to_string(),
+        };
+    }
+
+    if let (Some(expected_pid), Some(observed_pid)) = (agent_pane_pid(agent), observed.pane_pid) {
+        if expected_pid != observed_pid {
+            return WorkerPaneBindingMatch::Stale {
+                agent_id: agent_id.to_string(),
+                reason: "pane_pid_mismatch",
+            };
+        }
+    }
+
+    if observed.session.as_str() == expected_session && observed_window == expected_window {
+        WorkerPaneBindingMatch::LiveSameWorker {
+            agent_id: agent_id.to_string(),
+        }
+    } else {
+        WorkerPaneBindingMatch::Stale {
+            agent_id: agent_id.to_string(),
+            reason: "session_window_mismatch",
+        }
+    }
+}
+
+pub fn classify_registered_worker_for_observed_pane(
+    state: &Value,
+    observed: &PaneInfo,
+) -> WorkerPaneBindingMatch {
+    let mut fallback = WorkerPaneBindingMatch::NoMatch;
+    classify_agents_for_observed_pane(state, observed, &mut fallback);
+    if matches!(fallback, WorkerPaneBindingMatch::LiveSameWorker { .. }) {
+        return fallback;
+    }
+    if let Some(teams) = state.get("teams").and_then(Value::as_object) {
+        for team_state in teams.values() {
+            classify_agents_for_observed_pane(team_state, observed, &mut fallback);
+            if matches!(fallback, WorkerPaneBindingMatch::LiveSameWorker { .. }) {
+                return fallback;
+            }
+        }
+    }
+    fallback
+}
+
+fn classify_agents_for_observed_pane(
+    state: &Value,
+    observed: &PaneInfo,
+    fallback: &mut WorkerPaneBindingMatch,
+) {
+    let expected_session = non_empty_str(state, "session_name").unwrap_or_default();
+    let Some(agents) = state.get("agents").and_then(Value::as_object) else {
+        return;
+    };
+    for (agent_id, agent) in agents {
+        let candidate = classify_worker_pane_binding(agent_id, agent, expected_session, observed);
+        if matches!(candidate, WorkerPaneBindingMatch::LiveSameWorker { .. }) {
+            *fallback = candidate;
+            return;
+        }
+        if matches!(fallback, WorkerPaneBindingMatch::NoMatch)
+            && !matches!(candidate, WorkerPaneBindingMatch::NoMatch)
+        {
+            *fallback = candidate;
+        }
+    }
+}
+
 fn append_socket_split_issues(state: &Value, issues: &mut Vec<Value>, include_readiness: bool) {
     let endpoint = non_empty_str(state, "tmux_endpoint");
     let socket = non_empty_str(state, "tmux_socket");
@@ -111,9 +208,20 @@ fn append_worker_pane_binding_issues(
             .as_ref()
             .map(|window| window.as_str())
             .unwrap_or_default();
-        if observed.session.as_str() == session && observed_window == window {
+        let classification = classify_worker_pane_binding(agent_id, agent, &session, observed);
+        if matches!(
+            classification,
+            WorkerPaneBindingMatch::LiveSameWorker { .. } | WorkerPaneBindingMatch::NoMatch
+        ) {
             continue;
         }
+        let reason = match classification {
+            WorkerPaneBindingMatch::Stale { reason, .. } => reason,
+            WorkerPaneBindingMatch::IncompleteLegacy { .. } => "incomplete_legacy_tuple",
+            WorkerPaneBindingMatch::LiveSameWorker { .. } | WorkerPaneBindingMatch::NoMatch => {
+                "unknown"
+            }
+        };
         issues.push(json!({
             "id": WORKER_PANE_BINDING_STALE,
             "agent_id": agent_id,
@@ -123,10 +231,18 @@ fn append_worker_pane_binding_issues(
             "observed_session": observed.session.as_str(),
             "observed_window": observed_window,
             "observed_pane_pid": observed.pane_pid,
+            "reason": reason,
         }));
     }
 }
 
+fn agent_pane_pid(agent: &Value) -> Option<u32> {
+    agent
+        .get("pane_pid")
+        .and_then(Value::as_u64)
+        .and_then(|value| u32::try_from(value).ok())
+}
+
 fn session_exists_on_endpoint(endpoint: &str, session: &str) -> bool {
     crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
         .has_session(&SessionName::new(session.to_string()))

package/package.json

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