@team-agent/installer 0.5.99 → 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

@@ -336,7 +336,7 @@ fn restart_with_selected_team_and_transport(
                 .first()
                 .cloned()
                 .unwrap_or_else(|| "dirty_topology".to_string()),
-            error: "restart refused: tmux endpoint/socket topology is inconsistent; run diagnose from the intended leader socket before restarting".to_string(),
+            error: "restart refused: tmux endpoint/socket topology is inconsistent; run doctor from the intended leader socket before restarting".to_string(),
             issue_ids: topology_issue_ids,
         });
     }
@@ -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(),
             );
@@ -1804,7 +1810,7 @@ fn restart_readiness_timeout_message(
          - tmux session created: {session}\n\
          - worker pane addressable: {pane}\n\
          - coordinator alive: {coordinator}\n\
-         Action: check coordinator log {log}, then inspect this workspace with `team-agent diagnose --workspace '{workspace}'`\n\
+         Action: check coordinator log {log}, then inspect this workspace with `team-agent doctor --workspace '{workspace}'`\n\
          Log: coordinator_log={log} state={state} pid_file={pid}",
         missing = restart_readiness_missing_summary(readiness),
         session = yes_no(readiness.session_created),
@@ -2703,7 +2709,7 @@ fn restart_failure_phase(
     // 0.5.39 Slice 1 (tmux-server-death-locate §11.1 B): promote
     // spawn/readiness errors whose stderr contains "server exited
     // unexpectedly" to `tmux_server_crashed`, so downstream event
-    // classification and diagnose next_actions ("team-agent diagnose")
+    // classification and doctor next_actions ("team-agent doctor")
     // don't misattribute a whole-server death to a per-agent provider
     // failure. Restart itself does not recover from server crashes in
     // 0.5.39 (§11.1 C is Slice 3, later car); it just classifies clearly.
@@ -2776,7 +2782,7 @@ fn write_restart_agent_failed_event(
                 "phase": phase,
                 "error": error,
                 "action": format!(
-                    "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                    "inspect worker {} output, then reset that worker with `team-agent reset-agent {} --discard-session` or rerun `team-agent restart --allow-fresh`",
                     decision.agent_id,
                     decision.agent_id
                 ),
@@ -3262,7 +3268,7 @@ fn restart_failure_next_actions(failed_agents: &[RestartFailedAgent]) -> Vec<Str
         .iter()
         .map(|failure| {
             format!(
-                "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                "inspect worker {} output, then reset that worker with `team-agent reset-agent {} --discard-session` or rerun `team-agent restart --allow-fresh`",
                 failure.agent_id, failure.agent_id
             )
         })
@@ -4911,7 +4917,7 @@ tasks:
             },
             std::time::Duration::from_secs(30),
         );
-        assert!(message.contains("team-agent diagnose --workspace"));
+        assert!(message.contains("team-agent doctor --workspace"));
         assert!(message.contains(workspace.to_string_lossy().as_ref()));
         assert!(!message.contains("--allow-fresh"));
         assert!(!message.contains("restart <agent>"));

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

package/crates/team-agent/src/lifecycle/tests/b0_reader_hideone_audit_contract.rs

@@ -122,7 +122,7 @@ fn stale_snapshot_cannot_flip_status_or_diagnose_ok_readiness() {
         "--json",
     ]);
     let diagnose_before = case.run_json(&[
-        "diagnose",
+        "doctor",
         "--workspace",
         case.workspace_str(),
         "--team",
@@ -142,7 +142,7 @@ fn stale_snapshot_cannot_flip_status_or_diagnose_ok_readiness() {
         "--json",
     ]);
     let diagnose_after = case.run_json(&[
-        "diagnose",
+        "doctor",
         "--workspace",
         case.workspace_str(),
         "--team",

package/crates/team-agent/src/lifecycle/tests/claude_profile_launch_red.rs

@@ -182,7 +182,7 @@ fn diagnose_missing_profile_is_rc1_ok_false_and_zero_token() {
     .unwrap();
 
     let output = Command::new(crate::lifecycle::tests::test_binary_path())
-        .args(["diagnose", team.to_str().unwrap(), "--workspace", ws.to_str().unwrap(), "--json"])
+        .args(["doctor", team.to_str().unwrap(), "--workspace", ws.to_str().unwrap(), "--json"])
         .current_dir(&team)
         .output()
         .expect("diagnose subprocess should run");

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -1,7 +1,7 @@
 use super::launch_spawn::seed_healthy_coordinator;
 use super::*;
 use crate::cli::{
-    cmd_diagnose, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult, DiagnoseArgs,
+    cmd_doctor, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult, DoctorArgs,
     SendArgs, StatusArgs,
 };
 use crate::transport::test_support::OfflineTransport;
@@ -582,10 +582,17 @@ fn run_diagnose_after_quick_start() -> Value {
             .is_some(),
         "index-missing diagnose requires a persisted seeded owner"
     );
-    let diagnose = cmd_diagnose(&DiagnoseArgs {
+    let diagnose = cmd_doctor(&DoctorArgs {
         workspace,
         json: true,
         team: Some("teamdir".to_string()),
+        spec: None,
+        gate: None,
+        comms: false,
+        fix: false,
+        fix_schema: false,
+        cleanup_orphans: false,
+        confirm: false,
     });
     match cmd_value(diagnose) {
         Value::Object(map) => map