@team-agent/installer 0.5.68 → 0.5.70

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

@@ -183,7 +183,11 @@ pub(crate) fn annotate_runtime_tmux_endpoint(
     transport: &dyn Transport,
     workspace: &Path,
 ) {
-    let Some(endpoint) = transport.tmux_endpoint() else {
+    let transport_endpoint = transport.tmux_endpoint();
+    let endpoint = crate::tmux_backend::owning_tmux_endpoint_from_state(state)
+        .map(|(endpoint, _source)| endpoint.to_string())
+        .or_else(|| transport_endpoint.clone());
+    let Some(endpoint) = endpoint else {
         return;
     };
     let endpoint_for_state = if Path::new(&endpoint).is_absolute() || endpoint == "default" {
@@ -208,8 +212,10 @@ pub(crate) fn annotate_runtime_tmux_endpoint(
                 .cloned()
                 .unwrap_or(serde_json::Value::Null),
         );
-        if let Some(source) = selected_tmux_socket_source(transport, workspace) {
-            obj.insert("tmux_socket_source".to_string(), serde_json::json!(source));
+        if transport_endpoint.as_deref() == Some(endpoint.as_str()) {
+            if let Some(source) = selected_tmux_socket_source(transport, workspace) {
+                obj.insert("tmux_socket_source".to_string(), serde_json::json!(source));
+            }
         }
     }
 }

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

@@ -135,12 +135,16 @@ pub(super) fn spawn_agents(
             .mcp_config(auth_mode)
             .map_err(|e| LifecycleError::Provider(e.to_string()))?;
         let mcp_config = resolve_mcp_config(mcp_config, workspace, agent_id_raw, &mcp_team_id);
-        let mcp_config_path = write_worker_mcp_config_for_provider(
-            workspace,
-            agent_id_raw,
-            &mcp_config,
-            Some(provider),
-        )?;
+        let mcp_config_path = if provider == Provider::Pi {
+            None
+        } else {
+            Some(write_worker_mcp_config_for_provider(
+                workspace,
+                agent_id_raw,
+                &mcp_config,
+                Some(provider),
+            )?)
+        };
         let profile_dir = team_dir.join("profiles");
         let profile_launch =
             crate::lifecycle::profile_launch::prepare_provider_profile_launch_with_profile_dir(
@@ -159,24 +163,44 @@ pub(super) fn spawn_agents(
             let _ = crate::event_log::EventLog::new(workspace)
                 .write("provider.effort_unsupported", event_value);
         }
-        let mut plan = adapter
-            .build_command_plan(crate::provider::ProviderCommandContext {
-                auth_mode,
-                mcp_config: Some(&mcp_config),
-                system_prompt: Some(system_prompt.as_str()),
-                model: command_model,
-                tools: &resolved_tool_refs,
-                profile_launch: Some(&profile_launch),
-                // Layer 1 self-healing (architect probe 2026-06-22): expose
-                // agent_id as a display-name hint so Claude / Copilot
-                // adapters can pass `--name <agent_id>`. Codex has no
-                // equivalent flag and ignores the hint.
-                agent_id_hint: Some(agent_id_raw),
-                effort: agent_effort,
-            })
-            .map_err(|e| LifecycleError::Provider(e.to_string()))?;
+        let command_context = crate::provider::ProviderCommandContext {
+            auth_mode,
+            mcp_config: Some(&mcp_config),
+            system_prompt: Some(system_prompt.as_str()),
+            model: command_model,
+            tools: &resolved_tool_refs,
+            profile_launch: Some(&profile_launch),
+            // Layer 1 self-healing (architect probe 2026-06-22): expose
+            // agent_id as a display-name hint so Claude / Copilot
+            // adapters can pass `--name <agent_id>`. Codex has no
+            // equivalent flag and ignores the hint.
+            agent_id_hint: Some(agent_id_raw),
+            effort: agent_effort,
+        };
+        let mut plan = if provider == Provider::Pi {
+            crate::lifecycle::launch::pi_mcp::materialize_pi_plan(
+                crate::lifecycle::launch::pi_mcp::PiMaterializeRequest {
+                    workspace,
+                    team_id: &mcp_team_id,
+                    agent_id: agent_id_raw,
+                    model: command_model,
+                    effort: agent_effort,
+                    system_prompt: &system_prompt,
+                    tool_categories: &resolved_tool_refs,
+                    team_mcp_tools: &["send_message", "report_result"],
+                    mcp_config: &mcp_config,
+                },
+            )
+            .map_err(|e| LifecycleError::Provider(e.to_string()))?
+        } else {
+            adapter
+                .build_command_plan(command_context)
+                .map_err(|e| LifecycleError::Provider(e.to_string()))?
+        };
         if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
-            point_native_mcp_config_at_file(&mut plan.argv, provider, &mcp_config_path);
+            if let Some(mcp_config_path) = mcp_config_path.as_ref() {
+                point_native_mcp_config_at_file(&mut plan.argv, provider, mcp_config_path);
+            }
         }
         // C-A-4 cr verdict v2 — Copilot BYOK(compatible_api)硬性校验:
         // "A model is required for BYOK"(help-providers 原文)。检查 agent
@@ -287,15 +311,23 @@ pub(super) fn spawn_agents(
                 );
             }
         }
-        // Cursor: role 经 .cursor/rules；MCP 身份必须写进 mcp.json env
-        // （不继承父进程 TEAM_AGENT_*）。--workspace 钉物理路径。
-        // mcp.json last-writer：同 workspace 第二 CursorAgent 拒绝。
+        // Cursor: role 经 .cursor/rules。MCP 身份默认写 provider-config/<id>/cursor
+        // （不继承父进程 TEAM_AGENT_*）。--workspace 指该工程根，--add-dir 真 workspace。
+        // 隔离关闭时仍拒绝第二席（共用 mcp.json last-writer）。不改 HOME。
         if matches!(provider, Provider::CursorAgent) {
             refuse_second_cursor_occupant(workspace, agent_id_raw, Some(spec))?;
             apply_cursor_agent_rules_overlay(workspace, agent_id_raw, system_prompt.as_str())?;
             apply_cursor_mcp_overlay(workspace, &mcp_config)?;
-            enable_cursor_workspace_mcp(workspace)?;
-            apply_cursor_workspace_physical_path(&mut plan.argv, workspace);
+            let project = if crate::lifecycle::launch::cursor_mcp_isolation_enabled() {
+                Some(crate::lifecycle::launch::cursor_mcp_project_dir(
+                    workspace,
+                    agent_id_raw,
+                )?)
+            } else {
+                None
+            };
+            enable_cursor_workspace_mcp(workspace, project.as_deref())?;
+            apply_cursor_spawn_workspace_pointers(&mut plan.argv, workspace, agent_id_raw)?;
             let proxy = apply_cursor_subscription_proxy_env(&mut env);
             let event_log = crate::event_log::EventLog::new(workspace);
             let _ = event_log.write(

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

@@ -599,6 +599,7 @@ pub(crate) fn provider_display_str(provider: Provider) -> &'static str {
         Provider::GeminiCli => "gemini_cli",
         Provider::Grok => "grok",
         Provider::CursorAgent => "cursor_agent",
+        Provider::Pi => "pi",
         Provider::Fake => "fake",
     }
 }

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

@@ -307,10 +307,18 @@ pub(crate) use mcp_config::{
     write_worker_mcp_config_for_provider,
 };
 
+pub(crate) mod pi_mcp;
+
+mod cursor_mcp_iso;
+pub use cursor_mcp_iso::{
+    cursor_mcp_isolation_enabled, cursor_mcp_json_path, cursor_mcp_project_dir,
+    materialize_cursor_mcp_project,
+};
 mod cursor_mcp;
 pub use cursor_mcp::{
-    apply_cursor_mcp_overlay, apply_cursor_workspace_physical_path, cursor_mcp_enable_argv,
-    enable_cursor_workspace_mcp, physical_workspace_path, refuse_second_cursor_occupant,
+    apply_cursor_mcp_overlay, apply_cursor_spawn_workspace_pointers,
+    apply_cursor_workspace_physical_path, cursor_mcp_enable_argv, enable_cursor_workspace_mcp,
+    physical_workspace_path, refuse_second_cursor_occupant,
 };
 
 mod cursor_create_chat;

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

@@ -484,7 +484,7 @@ fn provider_env_exports(
         // grok/cursor_agent 一期无 profile exports（subscription 已登录态）。
         // Cursor 订阅席的代理透传不在这里：profile 只服务 compatible-api。
         // 订阅路径见 apply_cursor_subscription_proxy_env（只记有无，不记值）。
-        Provider::Grok | Provider::CursorAgent => {}
+        Provider::Grok | Provider::CursorAgent | Provider::Pi => {}
         Provider::Fake => {}
     }
     exports
@@ -567,6 +567,7 @@ pub(crate) fn provider_env_unsets(provider: Provider, auth_mode: AuthMode) -> BT
         // 禁止在这里 unset 代理。
         Provider::Grok => {}
         Provider::CursorAgent => {}
+        Provider::Pi => {}
         Provider::Fake => {}
     }
     unsets
@@ -992,7 +993,7 @@ fn required_profile_keys(provider: Provider, auth_mode: AuthMode) -> &'static [&
         // 二期 BYOK 立项时填(向后兼容字段保留)。
         Provider::Copilot => &[],
         // 0.5.67: grok/cursor_agent 一期无 BYOK required key 集合 (同 copilot 精神)。
-        Provider::Grok | Provider::CursorAgent => &[],
+        Provider::Grok | Provider::CursorAgent | Provider::Pi => &[],
         Provider::Fake => &[],
     }
 }

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

@@ -236,6 +236,7 @@ impl SmokeTarget {
             Provider::Copilot
             | Provider::Grok
             | Provider::CursorAgent
+            | Provider::Pi
             | Provider::GeminiCli
             | Provider::Fake => {
                 Err("unsupported_provider_smoke_skipped")

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

@@ -399,85 +399,97 @@ pub(crate) fn start_agent_at_paths(
         return Err(error);
     }
     let actual_spawn_window = spawn.spawn.window.as_str().to_string();
-    mark_agent_started(
-        &mut state,
-        agent_id,
-        &actual_spawn_window,
-        &spawn,
-        transport,
-        &safety,
-        start_mode,
-    )?;
-    // 0.5.66 bypass 单源 §2.7:启动即带 bypass → 审计留痕。
-    if safety.enabled {
-        let state_agent = state
-            .get("agents")
-            .and_then(|v| v.get(agent_id.as_str()));
-        let _ = crate::event_log::EventLog::new(workspace).write(
-            "worker.spawn_dangerously_skip_permissions",
-            serde_json::json!({
-                "agent_id": agent_id.as_str(),
-                "role": state_agent
-                    .and_then(|a| a.get("role"))
-                    .and_then(serde_json::Value::as_str)
-                    .unwrap_or_default(),
-                "provider": state_agent
-                    .and_then(|a| a.get("provider"))
-                    .and_then(serde_json::Value::as_str)
-                    .unwrap_or_default(),
-                "trigger": "start-agent",
-                "spec_source_path": crate::lifecycle::launch::agent_id_spec_source_path(
-                    workspace, agent_id.as_str(),
-                ),
-            }),
+    let post_spawn = (|| -> Result<bool, LifecycleError> {
+        mark_agent_started(
+            &mut state,
+            agent_id,
+            &actual_spawn_window,
+            &spawn,
+            transport,
+            &safety,
+            start_mode,
+        )?;
+        // 0.5.66 bypass 单源 §2.7:启动即带 bypass → 审计留痕。
+        if safety.enabled {
+            let state_agent = state.get("agents").and_then(|v| v.get(agent_id.as_str()));
+            let _ = crate::event_log::EventLog::new(workspace).write(
+                "worker.spawn_dangerously_skip_permissions",
+                serde_json::json!({
+                    "agent_id": agent_id.as_str(),
+                    "role": state_agent
+                        .and_then(|a| a.get("role"))
+                        .and_then(serde_json::Value::as_str)
+                        .unwrap_or_default(),
+                    "provider": state_agent
+                        .and_then(|a| a.get("provider"))
+                        .and_then(serde_json::Value::as_str)
+                        .unwrap_or_default(),
+                    "trigger": "start-agent",
+                    "spec_source_path": crate::lifecycle::launch::agent_id_spec_source_path(
+                        workspace, agent_id.as_str(),
+                    ),
+                }),
+            );
+        }
+        // **0.3.24 add-agent socket drift fix**: keep `state.tmux_endpoint` /
+        // `state.tmux_socket` synchronized with the transport actually used for the
+        // spawn. Without this, add-agent / fork-agent could spawn to a socket that
+        // never gets persisted, and the next coordinator tick would re-resolve to
+        // the workspace-hash socket and lose the new pane. Annotation runs inside
+        // the same `save_restart_projected_state` window — no parallel "annotate
+        // after spawn" race with coordinator and no double source of truth.
+        crate::lifecycle::launch::annotate_runtime_tmux_endpoint(&mut state, transport, workspace);
+        let team_key = restart_projection_team_key(&state, team);
+        // 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
+        // clear the matching `agent_health` observation on the new spawn cohort
+        // so five-line status summary and status --json do not surface a stale
+        // WORKING row from the pre-shutdown process. Best-effort: DB failure
+        // must not fail the start-agent path.
+        let _ = crate::db::agent_health_capture::clear_agent_health_observation(
+            workspace, &team_key, agent_id,
         );
-    }
-    // **0.3.24 add-agent socket drift fix**: keep `state.tmux_endpoint` /
-    // `state.tmux_socket` synchronized with the transport actually used for the
-    // spawn. Without this, add-agent / fork-agent could spawn to a socket that
-    // never gets persisted, and the next coordinator tick would re-resolve to
-    // the workspace-hash socket and lose the new pane. Annotation runs inside
-    // the same `save_restart_projected_state` window — no parallel "annotate
-    // after spawn" race with coordinator and no double source of truth.
-    crate::lifecycle::launch::annotate_runtime_tmux_endpoint(&mut state, transport, workspace);
-    let team_key = restart_projection_team_key(&state, team);
-    // 0.5.32 (`.team/artifacts/restart-resumed-stale-activity-locate.md` §5):
-    // clear the matching `agent_health` observation on the new spawn cohort
-    // so five-line status summary and status --json do not surface a stale
-    // WORKING row from the pre-shutdown process. Best-effort: DB failure
-    // must not fail the start-agent path.
-    let _ = crate::db::agent_health_capture::clear_agent_health_observation(
-        workspace, &team_key, agent_id,
-    );
-    let skip_capture_backfill = if matches!(
-        start_mode,
-        StartMode::Fresh | StartMode::FreshAfterMissingRollout
-    ) {
-        vec![agent_id.as_str()]
-    } else {
-        Vec::new()
+        let skip_capture_backfill = if matches!(
+            start_mode,
+            StartMode::Fresh | StartMode::FreshAfterMissingRollout
+        ) {
+            vec![agent_id.as_str()]
+        } else {
+            Vec::new()
+        };
+        save_restart_projected_state_with_capture_backfill_skip(
+            workspace,
+            &mut state,
+            &team_key,
+            &skip_capture_backfill,
+            &[agent_id.as_str()],
+        )?;
+        write_start_agent_start_event(
+            workspace,
+            agent_id,
+            &agent,
+            provider,
+            &spawn.plan,
+            start_mode,
+            &session_name,
+            &actual_spawn_window,
+            spawn_session_id,
+            tmux_start_mode_for_spawn(&spawn, into_existing_session),
+        )?;
+        replay_worker_target_missing_messages(workspace, agent_id, &team_key, &state, transport)?;
+        Ok(start_coordinator_for_workspace(workspace, Some(&team_key))?.ok)
+    })();
+    let coordinator_started = match post_spawn {
+        Ok(started) => started,
+        Err(error) => {
+            if let Err(rollback_error) = transport.kill_pane(&spawn.spawn.pane_id) {
+                return Err(LifecycleError::RequirementUnmet(format!(
+                    "{error}; failed to roll back spawned pane {}: {rollback_error}",
+                    spawn.spawn.pane_id.as_str()
+                )));
+            }
+            return Err(error);
+        }
     };
-    save_restart_projected_state_with_capture_backfill_skip(
-        workspace,
-        &mut state,
-        &team_key,
-        &skip_capture_backfill,
-        &[agent_id.as_str()],
-    )?;
-    write_start_agent_start_event(
-        workspace,
-        agent_id,
-        &agent,
-        provider,
-        start_mode,
-        &session_name,
-        &actual_spawn_window,
-        spawn_session_id,
-        tmux_start_mode_for_spawn(&spawn, into_existing_session),
-    )?;
-    replay_worker_target_missing_messages(workspace, agent_id, &team_key, &state, transport)?;
-    let coordinator = start_coordinator_for_workspace(workspace, Some(&team_key))?;
-    let coordinator_started = coordinator.ok;
     Ok(StartAgentOutcome::Running {
         env: AgentActionEnvelope {
             agent_id: agent_id.clone(),
@@ -1772,95 +1784,13 @@ fn write_start_agent_start_event(
     agent_id: &AgentId,
     agent: &serde_json::Value,
     provider: crate::provider::Provider,
+    plan: &crate::provider::CommandPlan,
     start_mode: StartMode,
     session_name: &SessionName,
     window: &str,
     session_id: Option<&SessionId>,
     tmux_start_mode: &'static str,
 ) -> Result<(), LifecycleError> {
-    let auth_mode = agent_auth_mode(agent);
-    let model = agent.get("model").and_then(|v| v.as_str());
-    let adapter = crate::provider::get_adapter(provider);
-    // Contract C / F6.4: event log must record the same context-aware argv that the
-    // actual spawn used — so the role/tools/MCP context appears in `start_agent.agent_start`.
-    let command_agent = crate::lifecycle::worker_command_context::WorkerCommandAgent::from_json(
-        agent,
-        Some(agent_id.as_str()),
-        provider,
-    )?;
-    let system_prompt =
-        crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
-    let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(
-        &command_agent,
-        provider,
-    )?;
-    let resolved_tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
-    let mcp_config = adapter
-        .mcp_config(auth_mode)
-        .map_err(|e| LifecycleError::Provider(e.to_string()))?;
-    let team_id = agent.get("owner_team_id").and_then(|v| v.as_str());
-    let mcp_config = crate::lifecycle::launch::resolve_mcp_config(
-        mcp_config,
-        workspace,
-        agent_id.as_str(),
-        team_id.unwrap_or(""),
-    );
-    let mcp_config_path = crate::lifecycle::launch::write_worker_mcp_config(
-        workspace,
-        agent_id.as_str(),
-        &mcp_config,
-    )?;
-    let profile_launch =
-        crate::lifecycle::profile_launch::prepare_provider_profile_launch_from_json(
-            workspace,
-            agent_id.as_str(),
-            agent,
-            Some(&mcp_config),
-        )?;
-    let command_model = profile_launch.command_overrides.model.as_deref().or(model);
-    // 0.4.x provider effort MVP: start_agent path preserves effort from the
-    // persisted agent JSON.
-    let start_agent_effort =
-        crate::lifecycle::launch::provider_effort_for_spawn_json(&agent, provider);
-    if let Some(event_value) = crate::lifecycle::launch::provider_effort_event_if_dropped_json(
-        &agent,
-        provider,
-        agent_id.as_str(),
-    ) {
-        let _ = crate::event_log::EventLog::new(workspace)
-            .write("provider.effort_unsupported", event_value);
-    }
-    let context = crate::provider::ProviderCommandContext {
-        auth_mode,
-        mcp_config: Some(&mcp_config),
-        system_prompt: Some(system_prompt.as_str()),
-        model: command_model,
-        tools: &resolved_tool_refs,
-        profile_launch: Some(&profile_launch),
-        agent_id_hint: Some(agent_id.as_str()),
-        effort: start_agent_effort,
-    };
-    let mut plan = match session_id {
-        Some(session_id) => adapter
-            .build_resume_command_plan(Some(session_id), context)
-            .map_err(|e| LifecycleError::Provider(e.to_string()))?,
-        None => adapter
-            .build_command_plan(context)
-            .map_err(|e| LifecycleError::Provider(e.to_string()))?,
-    };
-    if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
-        crate::lifecycle::launch::point_native_mcp_config_at_file(
-            &mut plan.argv,
-            provider,
-            &mcp_config_path,
-        );
-    }
-    crate::lifecycle::launch::fill_spawn_placeholders_full(
-        &mut plan.argv,
-        workspace,
-        agent_id.as_str(),
-        team_id,
-    );
     crate::event_log::EventLog::new(workspace)
         .write(
             "start_agent.agent_start",