@team-agent/installer 0.5.100 → 0.5.101

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

@@ -954,7 +954,7 @@ pub(crate) fn lifecycle_worker_transport_for_selected_state(
 /// returns: 后端与 endpoint 来源
 /// errors: state 声明后端是 conpty 时返回 TeamSelect
 /// ---
-pub(super) fn lifecycle_worker_tmux_backend_selection_for_state(
+pub(crate) fn lifecycle_worker_tmux_backend_selection_for_state(
     run_workspace: &Path,
     state: &serde_json::Value,
 ) -> Result<crate::tmux_backend::RuntimeTmuxBackendSelection, LifecycleError> {
@@ -1344,6 +1344,119 @@ pub(crate) fn session_identity_probe_for_agent(
     }
 }
 
+/// ---
+/// purpose: 将合法 Pi fork 血统纳入共享会话身份判定
+/// params:
+///   workspace/state/agent: 当前被验证席位及同队来源记录
+///   rollout_path: 当前席位的精确 backing
+/// returns: 字面身份一致，或经独立 Pi backing 与 fork 血统验证后合法继承时为 true
+/// ---
+pub(crate) fn session_identity_probe_for_agent_with_fork_ancestry(
+    workspace: &Path,
+    state: &serde_json::Value,
+    agent_id: &AgentId,
+    agent: &serde_json::Value,
+    provider: Provider,
+    rollout_path: Option<&RolloutPath>,
+) -> SessionIdentityProbeResult {
+    let mut probe = session_identity_probe_for_agent(agent_id, provider, rollout_path);
+    if probe.identity_ok != Some(false)
+        || !pi_fork_ancestor_identity_is_valid(
+            workspace,
+            state,
+            agent_id,
+            agent,
+            provider,
+            rollout_path,
+            probe.embedded_agent_id.as_deref(),
+        )
+    {
+        return probe;
+    }
+    probe.identity_ok = Some(true);
+    probe
+}
+
+fn pi_fork_ancestor_identity_is_valid(
+    workspace: &Path,
+    state: &serde_json::Value,
+    agent_id: &AgentId,
+    agent: &serde_json::Value,
+    provider: Provider,
+    rollout_path: Option<&RolloutPath>,
+    embedded_agent_id: Option<&str>,
+) -> bool {
+    if provider != Provider::Pi
+        || agent.get("attribution_ambiguous").and_then(serde_json::Value::as_bool) == Some(true)
+        || agent.get("capture_state").and_then(serde_json::Value::as_str)
+            == Some("attribution_ambiguous")
+        || !matches!(
+            agent
+                .get("attribution_confidence")
+                .and_then(serde_json::Value::as_str),
+            Some("high" | "medium")
+        )
+    {
+        return false;
+    }
+    let (Some(embedded_agent_id), Some(forked_from), Some(target_path)) = (
+        embedded_agent_id,
+        agent
+            .get("forked_from")
+            .and_then(serde_json::Value::as_str)
+            .filter(|value| !value.is_empty()),
+        rollout_path.map(RolloutPath::as_path),
+    ) else {
+        return false;
+    };
+    if forked_from != embedded_agent_id || forked_from == agent_id.as_str() {
+        return false;
+    }
+    let Some(source_agent) = state
+        .get("agents")
+        .and_then(|agents| agents.get(forked_from))
+        .filter(|source| agent_provider(source) == Provider::Pi)
+    else {
+        return false;
+    };
+    let Some(source_path) = agent_rollout_path(source_agent) else {
+        return false;
+    };
+    if source_path.as_path() == target_path {
+        return false;
+    }
+    let (Some(session_id), Ok(target_path), Some(target_root)) = (
+        agent_session_id(agent),
+        std::fs::canonicalize(target_path),
+        agent
+            .get("claude_projects_root")
+            .and_then(serde_json::Value::as_str)
+            .filter(|path| !path.is_empty())
+            .map(std::path::PathBuf::from),
+    ) else {
+        return false;
+    };
+    let Ok(target_root) = std::fs::canonicalize(target_root) else {
+        return false;
+    };
+    if !target_path.starts_with(target_root)
+        || std::fs::canonicalize(source_path.as_path())
+            .is_ok_and(|source_path| source_path == target_path)
+        || !resume_backing_probe_for_agent(
+            workspace,
+            agent_id,
+            agent,
+            provider,
+            &session_id,
+            rollout_path,
+        )
+        .exists
+    {
+        return false;
+    }
+    true
+}
+
 /// ---
 /// purpose: 按 provider 分支探测 resume 依据，并记录所有查过的路径
 /// returns: 存在位与查过的路径列表；持久化的 rollout 路径即使不存在也记进列表

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

@@ -1133,8 +1133,11 @@ fn restart_with_selected_team_and_transport(
                 &session_id,
                 agent_rollout_path(&agent).as_ref(),
             );
-            let identity_probe = session_identity_probe_for_agent(
+            let identity_probe = session_identity_probe_for_agent_with_fork_ancestry(
+                &selected.run_workspace,
+                &state,
                 &decision.agent_id,
+                &agent,
                 provider,
                 agent_rollout_path(&agent).as_ref(),
             );
@@ -1221,8 +1224,11 @@ fn restart_with_selected_team_and_transport(
                 &session_id,
                 agent_rollout_path(&agent_after).as_ref(),
             );
-            let identity_probe_after = session_identity_probe_for_agent(
+            let identity_probe_after = session_identity_probe_for_agent_with_fork_ancestry(
+                &selected.run_workspace,
+                &state,
                 &decision.agent_id,
+                &agent_after,
                 provider,
                 agent_rollout_path(&agent_after).as_ref(),
             );

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

@@ -349,8 +349,20 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
                 }
                 _ => (true, Vec::new()),
             };
-        let identity_probe =
-            session_identity_probe_for_agent(&agent_id, provider, rollout_path.as_ref());
+        let identity_probe = workspace
+            .map(|workspace| {
+                session_identity_probe_for_agent_with_fork_ancestry(
+                    workspace,
+                    state,
+                    &agent_id,
+                    agent,
+                    provider,
+                    rollout_path.as_ref(),
+                )
+            })
+            .unwrap_or_else(|| {
+                session_identity_probe_for_agent(&agent_id, provider, rollout_path.as_ref())
+            });
         let session_identity_mismatch = session_id.is_some()
             && provider_can_resume
             && resume_backing_exists

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

@@ -66,6 +66,8 @@ struct LifecyclePathRefs<'a> {
 }
 
 mod agent;
+mod avatar;
+pub(crate) use avatar::fork_pi_new_seat_locked;
 mod common;
 mod orchestrator;
 pub mod preflight;
@@ -82,11 +84,16 @@ pub(crate) use agent::{
 };
 pub(crate) use common::refresh_missing_provider_sessions;
 pub(crate) use common::restart_required_missing_session_agent_ids;
-pub(crate) use common::session_identity_probe_for_agent;
+pub(crate) use common::{
+    session_identity_probe_for_agent, session_identity_probe_for_agent_with_fork_ancestry,
+};
 // 0.3.24 add-agent socket drift fix: state-aware tmux resolver shared with
 // `lifecycle::launch::add_agent` / `fork_agent` so all three (restart / add / fork)
 // route to the SAME tmux socket the live team uses.
-pub(crate) use common::lifecycle_worker_tmux_backend_for_selected_state;
+pub(crate) use common::{
+    lifecycle_worker_tmux_backend_for_selected_state,
+    lifecycle_worker_tmux_backend_selection_for_state,
+};
 pub(crate) use orchestrator::{halt_plan, plan_status};
 pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline;
 // 0.5.38 (`.team/artifacts/startup-latency-locate.md` §5): expose the phase
@@ -100,10 +107,10 @@ pub(crate) use rebuild::{
     restart_candidates, restart_with_transport, restart_with_transport_with_readiness_deadline,
     select_restart_state,
 };
-pub use remove::{remove_agent, remove_agent_flag_requirements};
 pub(crate) use remove::remove_agent_with_transport;
-pub(crate) use selection::{classify_first_send_at, classify_restart_plan, python_type_name};
+pub use remove::{remove_agent, remove_agent_flag_requirements};
 pub use selection::decide_start_mode;
+pub(crate) use selection::{classify_first_send_at, classify_restart_plan, python_type_name};
 // Layer 2 (leader follow-up 2026-06-22): test-visible workspace-aware
 // classification so lifecycle/tests/restart.rs can exercise the
 // SessionBackingStoreMissing + checked_paths + RecoveryHint path