@team-agent/installer 0.5.51 → 0.5.52

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.51"
+version = "0.5.52"
 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.51"
+version = "0.5.52"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -939,103 +939,71 @@ fn resolve_leader(
         );
         return Err(err);
     }
-    if crate::codex_app_server::receiver_is_app_server(receiver) {
-        return resolve_app_server_leader(
-            sender_workspace,
-            target_workspace,
-            team,
-            parsed,
-            receiver,
-        );
-    }
-    let pane_id = string_field(receiver, "pane_id")
-        .filter(|pane| !pane.is_empty())
-        .ok_or_else(|| {
-            let mut err = leader_not_attached_third_party(
-                target_workspace,
-                team,
-                None,
-                None,
-                None,
-                transport.tmux_endpoint(),
-            );
-            err.candidates =
-                leader_advisory_candidates(state, team, transport, "state_recorded_socket");
-            err
-        })?;
     let session = string_field(receiver, "session_name");
     let window = string_field(receiver, "window_name");
     let socket = string_field(receiver, "tmux_socket")
         .map(str::to_string)
         .or_else(|| transport.tmux_endpoint());
-    let targets = list_targets(transport)?;
-    let matches = targets
-        .iter()
-        .filter(|target| {
-            target.pane_id.as_str() == pane_id
-                && session.is_none_or(|expected| target.session.as_str() == expected)
-                && window.is_none_or(|expected| {
-                    target
-                        .window_name
-                        .as_ref()
-                        .is_some_and(|name| name.as_str() == expected)
-                })
-        })
-        .collect::<Vec<_>>();
-    let stale_pane_seen = targets
-        .iter()
-        .any(|target| target.pane_id.as_str() == pane_id);
-    match matches.len() {
-        1 => Ok(ResolvedNamedAddress {
+    match crate::messaging::resolve_live_leader_channel(
+        target_workspace,
+        receiver,
+        transport,
+    ) {
+        crate::messaging::LeaderChannelResolution::Live(
+            crate::messaging::LiveLeaderChannel::DirectTmux(channel),
+        ) => Ok(ResolvedNamedAddress {
             raw_name: parsed.display_name(),
             target_kind: NamedTargetKind::Leader,
             sender_workspace: sender_workspace.to_path_buf(),
             target_workspace: target_workspace.to_path_buf(),
             team_key: Some(team.to_string()),
             agent_id: None,
-            pane_id: pane_id.to_string(),
+            pane_id: channel.pane_id.clone(),
             session_name: session.map(str::to_string),
             window_name: window.map(str::to_string),
             tmux_endpoint: socket,
             transport_kind: Some("direct_tmux".to_string()),
             app_server: None,
-            state_pane_id: Some(pane_id.to_string()),
+            state_pane_id: Some(channel.pane_id),
             state_pane_stale: false,
             agent_status: None,
-            warning: None,
+            warning: (!channel.metadata_drift.is_empty()).then(|| {
+                format!(
+                    "leader_channel_metadata_drift:{}",
+                    channel.metadata_drift.join(",")
+                )
+            }),
         }),
-        0 => {
+        crate::messaging::LeaderChannelResolution::Live(
+            crate::messaging::LiveLeaderChannel::CodexAppServer(_),
+        ) => resolve_app_server_leader(sender_workspace, target_workspace, team, parsed, receiver),
+        crate::messaging::LeaderChannelResolution::Unbound(reason) => {
+            let pane_id = string_field(receiver, "pane_id");
             let mut err = leader_not_attached_third_party(
                 target_workspace,
                 team,
-                Some(pane_id),
+                pane_id,
                 session,
                 window,
                 socket,
             );
-            if stale_pane_seen {
-                err.log = format!("{} stale_tuple_mismatch=true", err.log);
-            }
+            err.log = format!("{} channel_unbound={reason:?}", err.log);
             err.candidates =
                 leader_advisory_candidates(state, team, transport, "state_recorded_socket");
             Err(err)
         }
-        _ => Err(name_ambiguous(
-            "multiple live panes matched leader_receiver pane id",
-            matches
-                .into_iter()
-                .map(|pane| {
-                    json!({
-                        "name": format!("{team}/leader"),
-                        "workspace": target_workspace.display().to_string(),
-                        "team_key": team,
-                        "pane_id": pane.pane_id.as_str(),
-                        "session": pane.session.as_str(),
-                        "window": pane.window_name.as_ref().map(|w| w.as_str()),
-                    })
-                })
-                .collect(),
-        )),
+        crate::messaging::LeaderChannelResolution::ProbeFailed(error) => {
+            let mut err = leader_not_attached_third_party(
+                target_workspace,
+                team,
+                string_field(receiver, "pane_id"),
+                session,
+                window,
+                socket,
+            );
+            err.log = format!("{} channel_probe_failed={error}", err.log);
+            Err(err)
+        }
     }
 }
 

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

@@ -400,6 +400,7 @@ fn ux_wait_ready_does_not_report_ready_true_without_ready_runtime_state() {
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
+            "active_team_key": "wait-ready",
             "agents": {"w1": {"status": "starting"}},
             "tasks": [{"id": "t1", "assignee": "w1", "status": "pending"}],
             "leader_receiver": {"status": "attached"},

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

@@ -712,25 +712,46 @@ fn claim_lease_no_incident_with_target(
             candidate_source,
             pre_epoch,
         );
-        if converged {
+        let observation_refreshed = caller_pane_info.is_some_and(|pane_info| {
+            refresh_already_bound_receiver_observation(
+                state,
+                pane_info,
+                observed_endpoint.or(current_endpoint.as_deref()),
+                scoped_team.or(team),
+            )
+        });
+        if converged || observation_refreshed {
             write_claim_state(workspace, state, scoped_team, team)?;
-            topology_convergence = verify_persisted_topology_convergence(
-                workspace,
-                team_id.as_str(),
-                topology_convergence,
-                pre_epoch,
-            )?;
-            if topology_convergence
-                .as_ref()
-                .and_then(|metadata| metadata.get("status"))
-                .and_then(Value::as_str)
-                != Some("converged")
-            {
-                return Ok(convergence_persistence_refusal(
+            if observation_refreshed {
+                event_log.write(
+                    "leader_receiver.observation_refreshed",
+                    json!({
+                        "pane_id": caller_pane.as_str(),
+                        "owner_epoch": pre_epoch.0,
+                        "owner_changed": false,
+                        "source": "claim_leader_already_bound",
+                    }),
+                )?;
+            }
+            if converged {
+                topology_convergence = verify_persisted_topology_convergence(
+                    workspace,
+                    team_id.as_str(),
                     topology_convergence,
                     pre_epoch,
-                    Some(caller_pane.clone()),
-                ));
+                )?;
+                if topology_convergence
+                    .as_ref()
+                    .and_then(|metadata| metadata.get("status"))
+                    .and_then(Value::as_str)
+                    != Some("converged")
+                {
+                    return Ok(convergence_persistence_refusal(
+                        topology_convergence,
+                        pre_epoch,
+                        Some(caller_pane.clone()),
+                    ));
+                }
             }
         }
         return Ok(LeaseResult {
@@ -1659,6 +1680,108 @@ fn receiver_fingerprint(target: &PaneInfo) -> String {
     )
 }
 
+fn refresh_already_bound_receiver_observation(
+    state: &mut Value,
+    observed: &PaneInfo,
+    observed_endpoint: Option<&str>,
+    team_key: Option<&str>,
+) -> bool {
+    let attached_at = now_ts();
+    let mut refreshed = state
+        .get_mut("leader_receiver")
+        .and_then(Value::as_object_mut)
+        .is_some_and(|receiver| {
+            refresh_receiver_observation(
+                receiver,
+                observed,
+                observed_endpoint,
+                attached_at.as_str(),
+            )
+        });
+    if let Some(team_key) = team_key {
+        refreshed |= state
+            .get_mut("teams")
+            .and_then(|teams| teams.get_mut(team_key))
+            .and_then(|entry| entry.get_mut("leader_receiver"))
+            .and_then(Value::as_object_mut)
+            .is_some_and(|receiver| {
+                refresh_receiver_observation(
+                    receiver,
+                    observed,
+                    observed_endpoint,
+                    attached_at.as_str(),
+                )
+            });
+    }
+    refreshed
+}
+
+fn refresh_receiver_observation(
+    receiver: &mut serde_json::Map<String, Value>,
+    observed: &PaneInfo,
+    observed_endpoint: Option<&str>,
+    attached_at: &str,
+) -> bool {
+    let before = Value::Object(receiver.clone());
+    receiver.insert(
+        "session_name".to_string(),
+        Value::String(observed.session.as_str().to_string()),
+    );
+    receiver.insert(
+        "window_index".to_string(),
+        observed
+            .window_index
+            .map(|value| Value::String(value.to_string()))
+            .unwrap_or(Value::Null),
+    );
+    receiver.insert(
+        "window_name".to_string(),
+        observed
+            .window_name
+            .as_ref()
+            .map(|value| Value::String(value.as_str().to_string()))
+            .unwrap_or(Value::Null),
+    );
+    receiver.insert(
+        "pane_index".to_string(),
+        observed
+            .pane_index
+            .map(|value| Value::String(value.to_string()))
+            .unwrap_or(Value::Null),
+    );
+    receiver.insert(
+        "pane_tty".to_string(),
+        observed
+            .tty
+            .as_ref()
+            .map(|value| Value::String(value.clone()))
+            .unwrap_or(Value::Null),
+    );
+    receiver.insert(
+        "pane_current_command".to_string(),
+        observed
+            .current_command
+            .as_ref()
+            .map(|value| Value::String(value.clone()))
+            .unwrap_or(Value::Null),
+    );
+    receiver.insert(
+        "fingerprint".to_string(),
+        Value::String(receiver_fingerprint(observed)),
+    );
+    if let Some(endpoint) = observed_endpoint.filter(|value| !value.is_empty()) {
+        receiver.insert(
+            "tmux_socket".to_string(),
+            Value::String(endpoint.to_string()),
+        );
+    }
+    receiver.insert(
+        "attached_at".to_string(),
+        Value::String(attached_at.to_string()),
+    );
+    Value::Object(receiver.clone()) != before
+}
+
 fn make_owner(
     provider: Provider,
     pane: &NonEmptyPaneId,
@@ -2124,6 +2247,22 @@ fn readable_team_snapshot_path(w: &BP, n: &str) -> BF /* B0_DIAGNOSTIC_LEGACY_SN
 mod tests {
     use super::*;
 
+    fn observed_pane() -> PaneInfo {
+        PaneInfo {
+            pane_id: PaneId::new("%7"),
+            session: crate::transport::SessionName::new("new-session"),
+            window_index: Some(3),
+            window_name: Some(crate::transport::WindowName::new("new-window")),
+            pane_index: Some(1),
+            tty: Some("/dev/ttys007".to_string()),
+            current_command: Some("codex".to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: Some(700),
+            leader_env: std::collections::BTreeMap::new(),
+        }
+    }
+
     #[test]
     fn attribute_command_provider_recognizes_copilot() {
         assert_eq!(
@@ -2135,4 +2274,51 @@ mod tests {
             Some(Provider::Copilot)
         );
     }
+
+    #[test]
+    fn already_bound_refresh_updates_observations_without_reclaiming() {
+        let mut state = json!({
+            "leader_receiver": {
+                "status": "attached",
+                "pane_id": "%7",
+                "owner_epoch": 10,
+                "owner_agent_id": "leader",
+                "session_name": "old-session",
+                "pane_tty": "/dev/old",
+                "attached_at": "2026-01-01T00:00:00Z"
+            },
+            "teams": {"team-a": {"leader_receiver": {
+                "status": "attached",
+                "pane_id": "%7",
+                "owner_epoch": 10,
+                "owner_agent_id": "leader",
+                "session_name": "old-session",
+                "pane_tty": "/dev/old",
+                "attached_at": "2026-01-01T00:00:00Z"
+            }}}
+        });
+
+        assert!(refresh_already_bound_receiver_observation(
+            &mut state,
+            &observed_pane(),
+            Some("/tmp/team-agent-live.sock"),
+            Some("team-a"),
+        ));
+        let receiver = &state["leader_receiver"];
+        assert_eq!(receiver["owner_epoch"], json!(10));
+        assert_eq!(receiver["owner_agent_id"], json!("leader"));
+        assert_eq!(receiver["session_name"], json!("new-session"));
+        assert_eq!(receiver["window_name"], json!("new-window"));
+        assert_eq!(receiver["pane_tty"], json!("/dev/ttys007"));
+        assert_eq!(receiver["tmux_socket"], json!("/tmp/team-agent-live.sock"));
+        assert_ne!(receiver["attached_at"], json!("2026-01-01T00:00:00Z"));
+        assert_eq!(
+            state["teams"]["team-a"]["leader_receiver"]["session_name"],
+            json!("new-session")
+        );
+        assert_eq!(
+            state["teams"]["team-a"]["leader_receiver"]["owner_epoch"],
+            json!(10)
+        );
+    }
 }

package/crates/team-agent/src/lifecycle/launch/add_agent_state.rs

@@ -193,7 +193,13 @@ pub(super) fn upsert_agent_state_from_role(
         persist_effective_approval_policy(obj, safety);
     }
     agent_map.insert(agent_id.as_str().to_string(), entry);
-    save_launched_team_state_for_key(workspace, &state, Some(canonical_team_key))
+    crate::lifecycle::restart::remove::clear_agent_retirement_in_state(&mut state, agent_id);
+    save_launched_team_state_for_key(
+        workspace,
+        &state,
+        Some(canonical_team_key),
+        Some(agent_id.as_str()),
+    )
 }
 
 pub(super) fn role_source_ownership(workspace: &Path, role_file: &Path) -> &'static str {

package/crates/team-agent/src/lifecycle/launch/quick_start.rs

@@ -379,7 +379,7 @@ pub fn quick_start_with_transport_in_workspace_with_display(
     // to "unknown" in the payload) — Phase 2 refactor will thread
     // ResolvedTransport.source through the launch signature.
     annotate_runtime_transport(&mut state, transport, &workspace, None);
-    save_launched_team_state_for_key(&workspace, &state, Some(&state_team_key))?;
+    save_launched_team_state_for_key(&workspace, &state, Some(&state_team_key), None)?;
     annotate_persisted_team_depth(
         &workspace,
         &state_team_key,

package/crates/team-agent/src/lifecycle/launch/state_projection.rs

@@ -146,7 +146,7 @@ pub(super) fn persist_spawn_agent_state(
         obj.insert("agents".to_string(), serde_json::Value::Object(agents));
         state = serde_json::Value::Object(obj);
     }
-    save_launched_team_state_for_key(workspace, &state, Some(&team_id))
+    save_launched_team_state_for_key(workspace, &state, Some(&team_id), None)
 }
 
 pub(super) fn pane_pids_by_started_agent(
@@ -178,13 +178,14 @@ pub(super) fn save_launched_team_state(
     workspace: &Path,
     launched: &serde_json::Value,
 ) -> Result<(), LifecycleError> {
-    save_launched_team_state_for_key(workspace, launched, None)
+    save_launched_team_state_for_key(workspace, launched, None, None)
 }
 
 pub(super) fn save_launched_team_state_for_key(
     workspace: &Path,
     launched: &serde_json::Value,
     team_key: Option<&str>,
+    added_agent_id: Option<&str>,
 ) -> Result<(), LifecycleError> {
     let existing = load_runtime_state(workspace).unwrap_or_else(|_| serde_json::json!({}));
     let launched_key = team_key
@@ -231,13 +232,12 @@ pub(super) fn save_launched_team_state_for_key(
     };
     let mut projected = crate::state::projection::project_top_level_view(&merged, &launched_key);
     drop_unbound_top_level_owner(&mut projected);
+    let intent = crate::state::repository::StateWriteIntent::launch_team_or_add_agent(
+        &launched_key,
+        added_agent_id,
+    );
     crate::state::repository::StateRepository::new(workspace)
-        .save(
-            crate::state::repository::StateWriteIntent::LaunchTeam {
-                team_key: &launched_key,
-            },
-            &projected,
-        )
+        .save(intent, &projected)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 

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

@@ -18,13 +18,15 @@ pub fn start_agent(
     team: Option<&str>,
 ) -> Result<StartAgentOutcome, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "start-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     start_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -54,9 +56,12 @@ pub fn start_agent_with_transport(
         Err(_) if team.is_none() => LifecyclePaths {
             run_workspace: workspace.to_path_buf(),
             spec_workspace: workspace.to_path_buf(),
+            selected: None,
         },
         Err(error) => return Err(error),
     };
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "start-agent",
@@ -778,13 +783,15 @@ pub fn stop_agent(
     team: Option<&str>,
 ) -> Result<StopAgentReport, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "stop-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     stop_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -801,6 +808,8 @@ pub fn stop_agent_with_transport(
     transport: &dyn crate::transport::Transport,
 ) -> Result<StopAgentReport, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "stop-agent",
@@ -840,9 +849,12 @@ pub(crate) fn start_agent_at_paths_for_recovery(
         Err(_) if team.is_none() => LifecyclePaths {
             run_workspace: workspace.to_path_buf(),
             spec_workspace: workspace.to_path_buf(),
+            selected: None,
         },
         Err(error) => return Err(RecoveryError::Lifecycle(error.to_string())),
     };
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     // Best-effort stop: if the live pane still exists we tear it down so the
     // subsequent start creates a fresh provider process instead of a Noop.
     // Stop errors are absorbed into the start attempt result — the important
@@ -1217,13 +1229,15 @@ pub fn reset_agent(
         });
     }
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "reset-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     reset_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -1249,6 +1263,8 @@ pub fn reset_agent_with_transport(
         });
     }
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "reset-agent",