@team-agent/installer 0.5.100 → 0.5.102

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

@@ -397,7 +397,7 @@ pub(super) fn spawn_agent_window(
             model: command_model,
             effort: restart_effort,
             system_prompt: &system_prompt,
-            team_mcp_tools: &["send_message", "report_result"],
+            team_mcp_tools: &["send_message", "report_result", "get_team_status"],
             mcp_config: &mcp_config,
             session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
         };
@@ -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

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

@@ -532,22 +532,6 @@ fn reset_stopped_true_still_rechecks_same_role_residue_before_start() {
     );
 }
 
-#[test]
-fn mcp_reset_output_exposes_capture_outcome_and_weak_reset_proof() {
-    let src = include_str!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/src/mcp_server/lifecycle_tools/agent_ops.rs"
-    ));
-    let reset = source_section(src, "pub(crate) fn reset_agent", "pub(crate) fn fork_agent");
-    let json_object = reset_success_json_object(reset);
-    let missing = ["\"capture_state\":", "\"reset_proof\":", "\"transcript_missing\"", "\"attribution_ambiguous\"", "\"weak\""]
-        .into_iter().filter(|needle| !json_object.contains(needle)).collect::<Vec<_>>();
-    assert!(
-        missing.is_empty(),
-        "P0 MCP reset: ok=true/status=reset must expose additive capture_state and reset_proof=weak inside the ResetAgentOutcome::Reset serde_json::json! object; missing={missing:?}; reset_json={json_object}"
-    );
-}
-
 #[test]
 #[serial(env)]
 fn abnormal_shell_pane_with_live_delivery_is_not_dead_and_dedupe_ignores_size() {
@@ -972,15 +956,3 @@ impl ProviderRegistry for RealAdapterRegistry {
         get_adapter(provider)
     }
 }
-
-fn source_section<'a>(src: &'a str, start: &str, end: &str) -> &'a str { let start = src.find(start).unwrap_or(0); let rest = &src[start..]; &rest[..rest.find(end).unwrap_or(rest.len())] }
-
-fn reset_success_json_object(reset_src: &str) -> &str {
-    let success = source_section(reset_src, "ResetAgentOutcome::Reset", "ResetAgentOutcome::Refused");
-    let macro_start = success.find("serde_json::json!({").expect("reset success json object"); let object_start = macro_start + success[macro_start..].find('{').unwrap(); let mut depth = 0_i32;
-    for (offset, ch) in success[object_start..].char_indices() {
-        if ch == '{' { depth += 1; } if ch == '}' { depth -= 1; }
-        if depth == 0 { return &success[object_start..object_start + offset + 1]; }
-    }
-    panic!("unterminated reset success json object")
-}

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

@@ -108,12 +108,13 @@ fn pi_role_ignores_tools_and_preserves_provider_defaults() {
         .expect("Pi model and effort may use provider defaults");
     assert_eq!(
         compiled.agent.get("model"),
-        Some(&Value::Null),
-        "omitted Pi model must not inherit a synthesized framework default"
+        Some(&Value::Str("openai-codex/gpt-6-luna".to_string())),
+        "omitted Pi model uses the Luna default rather than team metadata"
     );
-    assert!(
-        compiled.agent.get("effort").is_none(),
-        "omitted Pi effort must not inherit a synthesized framework default"
+    assert_eq!(
+        compiled.agent.get("effort"),
+        Some(&Value::Str("max".to_string())),
+        "omitted Pi effort uses the global max default rather than team metadata"
     );
 
     let models = parse_pi_list_models_table(CATALOG).expect("catalog fixture");
@@ -160,10 +161,11 @@ fn pi_role_uses_standard_bypass_field_without_fabricating_argv() {
     );
 
     let missing_ack = valid_role_with("").replace("dangerously_skip_permissions: true\n", "");
-    let text = compile_error(compile_pi_role(&missing_ack)).to_string();
-    assert!(
-        text.contains("missing front matter field dangerously_skip_permissions"),
-        "got {text}"
+    let compiled = compile_pi_role(&missing_ack)
+        .expect("omitted bypass metadata defaults to true");
+    assert_eq!(
+        compiled.agent.get("dangerously_skip_permissions"),
+        Some(&Value::Bool(true))
     );
 }