@team-agent/installer 0.5.68 → 0.5.70

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.68"
+version = "0.5.70"
 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.68"
+version = "0.5.70"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -9,6 +9,74 @@ use crate::model::pane_authority_refusal::{
 use crate::provider::wire::{command_name, parse_provider, provider_wire};
 use crate::transport::Transport;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "snake_case")]
+pub(crate) enum PiBackingStatus {
+    Pending,
+    Captured,
+    Missing,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "snake_case")]
+pub(crate) enum PiMcpStatus {
+    Unavailable,
+    ConfiguredLazy,
+    RoundtripVerified,
+}
+
+pub(crate) struct PiDoctorInput {
+    pub executable_chain_verified: bool,
+    pub pi_version: Option<String>,
+    pub adapter_version: Option<String>,
+    pub catalog_sha256: Option<String>,
+    pub selected_model: Option<String>,
+    pub candidate_executable: Option<std::path::PathBuf>,
+    pub wrapper: Option<std::path::PathBuf>,
+    pub mcp_roundtrip_at: Option<String>,
+    pub backing: PiBackingStatus,
+    pub activity: crate::provider::TurnState,
+    pub activity_source: crate::provider::ClassifySource,
+    pub env_key_names: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+pub(crate) struct PiDoctorFacts {
+    pub mcp: PiMcpStatus,
+    pub mcp_connected: bool,
+    pub backing: PiBackingStatus,
+    pub activity: crate::provider::TurnState,
+    pub activity_source: crate::provider::ClassifySource,
+    pub auth_hint: crate::provider::AuthHintStatus,
+}
+
+pub(crate) fn pi_doctor_facts(input: PiDoctorInput) -> PiDoctorFacts {
+    let mcp = if input.mcp_roundtrip_at.is_some() {
+        PiMcpStatus::RoundtripVerified
+    } else if input.wrapper.is_some() {
+        PiMcpStatus::ConfiguredLazy
+    } else {
+        PiMcpStatus::Unavailable
+    };
+    let _ = (
+        input.executable_chain_verified,
+        input.pi_version,
+        input.adapter_version,
+        input.catalog_sha256,
+        input.selected_model,
+        input.candidate_executable,
+        input.env_key_names,
+    );
+    PiDoctorFacts {
+        mcp,
+        mcp_connected: mcp == PiMcpStatus::RoundtripVerified,
+        backing: input.backing,
+        activity: input.activity,
+        activity_source: input.activity_source,
+        auth_hint: crate::provider::AuthHintStatus::Unknown,
+    }
+}
+
 /// 0.5.39 Slice 1 (tmux-server-death-locate §11.1 B): classify a tmux
 /// transport error string into a diagnose issue id. When the underlying
 /// tmux subprocess stderr contains `server exited unexpectedly`, the
@@ -1424,6 +1492,11 @@ fn fake_agent_started(agent: &Value) -> bool {
 }
 
 fn agent_mcp_ready(agent: &Value) -> bool {
+    if agent.get("provider").and_then(Value::as_str) == Some("pi") {
+        // The generated wrapper proves configured-lazy only. No persisted
+        // objective Pi MCP roundtrip receipt exists on the readiness path yet.
+        return false;
+    }
     agent
         .get("mcp_config")
         .and_then(Value::as_str)
@@ -1567,6 +1640,7 @@ pub(crate) fn provider_doctor_checks() -> Value {
         crate::provider::Provider::GeminiCli,
         crate::provider::Provider::Grok,
         crate::provider::Provider::CursorAgent,
+        crate::provider::Provider::Pi,
         crate::provider::Provider::Fake,
     ] {
         let adapter = crate::provider::get_adapter(provider);

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

@@ -262,9 +262,10 @@ const DISPATCH_COMMANDS: &[&str] = &[
 const SPEC_ONLY_HELP_COMMANDS: &[&str] = &["start"];
 // Command grammar, not provider identity parsing: these are top-level CLI
 // passthrough verbs for starting a leader under a provider executable.
-const LEADER_PASSTHROUGH_COMMANDS: &[&str] = &["codex", "claude", "copilot", "grok", "cursor"];
+const LEADER_PASSTHROUGH_COMMANDS: &[&str] =
+    &["codex", "claude", "copilot", "grok", "cursor", "pi"];
 
-fn is_leader_passthrough_command(command: &str) -> bool {
+pub(crate) fn is_leader_passthrough_command(command: &str) -> bool {
     LEADER_PASSTHROUGH_COMMANDS.contains(&command)
         && matches!(
             command_spec(command).map(|spec| spec.kind),
@@ -285,7 +286,7 @@ fn is_known_subcommand(command: &str) -> bool {
     command_spec(command).is_some_and(|spec| spec.command_help)
 }
 
-fn default_help() -> String {
+pub(crate) fn default_help() -> String {
     let mut out = String::from("usage: team-agent <command> [options]\n");
     append_help_section(
         &mut out,
@@ -310,7 +311,7 @@ fn default_help() -> String {
         "Guided recovery",
         &["claim-leader", "takeover", "attach-leader"],
     );
-    out.push_str("\nProvider launchers:\n  team-agent codex|claude|copilot|grok|cursor ...\n");
+    out.push_str("\nProvider launchers:\n  team-agent codex|claude|copilot|grok|cursor|pi ...\n");
     out.push_str("\nRun `team-agent <command> --help` for command flags.");
     out
 }

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

@@ -130,6 +130,7 @@ pub(crate) fn leader_passthrough_provider(
         "copilot" => Some(Provider::Copilot),
         "grok" => Some(Provider::Grok),
         "cursor" => Some(Provider::CursorAgent),
+        "pi" => Some(Provider::Pi),
         _ => None,
     }
 }

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

@@ -181,6 +181,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "copilot", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "copilot" }, summary: "launch a Copilot leader", usage: "usage: team-agent copilot [provider args...]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "grok", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "grok" }, summary: "launch a Grok leader", usage: "usage: team-agent grok [provider args...]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "cursor", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "cursor" }, summary: "launch a Cursor leader", usage: "usage: team-agent cursor [provider args...]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "pi", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "pi" }, summary: "launch a Pi leader", usage: "usage: team-agent pi -- --model <exact> --thinking <effort>", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
 
     CommandSpec { name: "init", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::Init), summary: "legacy bootstrap command", usage: "usage: team-agent init [--workspace WORKSPACE] [--force] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: Some("quick-start"), sunset: Some("C2"), action: Some("use `team-agent quick-start`"), governance: None },
     CommandSpec { name: "start", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::SpecOnlyAlias { alias_of: "quick-start" }, summary: "legacy start alias", usage: "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::Conditional, alias_of: Some("quick-start"), sunset: Some("C2"), action: Some("use `team-agent quick-start` or `team-agent restart`"), governance: None },

package/crates/team-agent/src/compiler.rs

@@ -392,10 +392,25 @@ fn compile_role_agent_with_mode(
     let provider = required_string(&meta, role_path, "provider")?;
     require_explicit_grok_role_model(&meta, role_path, &provider)?;
     require_explicit_cursor_role_model(&meta, role_path, &provider)?;
-    let model = resolve_model(&meta, team_meta, &provider);
+    validate_pi_role_fields(&meta, role_path, &provider)?;
+    let is_pi = parse_canonical_provider(&provider) == Some(Provider::Pi);
+    let model = if is_pi {
+        string_field(&meta, "model")
+            .filter(|value| !value.trim().is_empty())
+            .map(Value::Str)
+            .unwrap_or(Value::Null)
+    } else {
+        resolve_model(&meta, team_meta, &provider)
+    };
     let auth_mode = string_field(&meta, "auth_mode")
         .or_else(|| string_field(team_meta, "default_auth_mode"))
         .unwrap_or_else(|| "subscription".to_string());
+    if is_pi && auth_mode != "subscription" {
+        return Err(ModelError::Validation(format!(
+            "{}: Pi roles support subscription auth_mode only",
+            role_path.display()
+        )));
+    }
     if auth_mode != "subscription" && meta.get("profile").is_none() {
         return Err(ModelError::Validation(format!(
             "{}: profile is required when auth_mode is '{auth_mode}'",
@@ -466,7 +481,11 @@ fn compile_role_agent_with_mode(
         Some(raw) if !raw.trim().is_empty() => ProviderEffort::parse(raw.trim()),
         _ => None,
     };
-    let resolved_effort = role_effort.or(team_effort);
+    let resolved_effort = if is_pi {
+        role_effort
+    } else {
+        role_effort.or(team_effort)
+    };
     if let Some(effort) = resolved_effort {
         // Reject max + non-Claude at compile time.
         let provider_str = agent_items
@@ -478,7 +497,10 @@ fn compile_role_agent_with_mode(
             })
             .unwrap_or("");
         let provider_enum = parse_canonical_provider(provider_str).unwrap_or(Provider::Codex);
-        if effort.is_claude_only() && !is_claude_family(provider_enum) {
+        if effort.is_claude_only()
+            && !is_claude_family(provider_enum)
+            && provider_enum != Provider::Pi
+        {
             return Err(ModelError::Validation(format!(
                 "{}: effort '{}' is only supported by claude/claude_code (provider: {provider_str})",
                 role_path.display(),
@@ -609,12 +631,37 @@ model: sonnet-4-thinking",
     )))
 }
 
+fn validate_pi_role_fields(meta: &Value, path: &Path, provider: &str) -> Result<(), ModelError> {
+    if parse_canonical_provider(provider) != Some(Provider::Pi) {
+        return Ok(());
+    }
+    if let Some(model) = string_field(meta, "model").filter(|value| !value.trim().is_empty()) {
+        let (catalog, name) = model.trim().split_once('/').ok_or_else(|| {
+            ModelError::Validation(format!(
+                "{}: Pi roles require a qualified exact model such as provider/model",
+                path.display()
+            ))
+        })?;
+        if catalog.is_empty() || name.is_empty() || model.contains('*') {
+            return Err(ModelError::Validation(format!(
+                "{}: Pi roles require a qualified exact model",
+                path.display()
+            )));
+        }
+    }
+    let tools = required_tools(meta, path)?;
+    if !tools.iter().any(|tool| tool == "mcp_team") {
+        return Err(ModelError::Validation(format!(
+            "{}: Pi roles require mcp_team",
+            path.display()
+        )));
+    }
+    Ok(())
+}
+
 /// 0.5.66 bypass 单源:角色 md 的 `dangerously_skip_permissions` 必填 bool。
 /// 缺 = 编译失败(消息含硬串);非 bool = 同 fail-loud。
-fn required_dangerously_skip_permissions(
-    meta: &Value,
-    path: &Path,
-) -> Result<bool, ModelError> {
+fn required_dangerously_skip_permissions(meta: &Value, path: &Path) -> Result<bool, ModelError> {
     match meta.get("dangerously_skip_permissions") {
         Some(Value::Bool(value)) => Ok(*value),
         Some(_) => Err(ModelError::Validation(format!(

package/crates/team-agent/src/coordinator/runtime_detectors.rs

@@ -584,6 +584,7 @@ fn runtime_event_provider_name(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/layout/worker_window_helpers.rs

@@ -19,6 +19,7 @@ pub fn provider_window_name(provider: Provider) -> &'static str {
         Provider::GeminiCli => "gemini",
         Provider::Grok => "grok",
         Provider::CursorAgent => "agent",
+        Provider::Pi => "pi",
         Provider::Fake => "fake",
     }
 }

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

@@ -285,10 +285,58 @@ fn leader_start_plan_with_ambient_authority(
         ),
         _ => None,
     };
+    let provider_argv = if provider == Provider::Pi && mode != LeaderStartMode::AttachExisting {
+        let parsed = crate::lifecycle::launch::pi_mcp::parse_pi_leader_args(provider_args)
+            .map_err(|error| LeaderError::Start(error.to_string()))?;
+        let mcp_config = adapter
+            .mcp_config(crate::model::enums::AuthMode::Subscription)
+            .map_err(|error| LeaderError::Start(error.to_string()))?;
+        let mcp_config = crate::lifecycle::launch::resolve_mcp_config(
+            mcp_config,
+            workspace,
+            "leader",
+            identity.team_id.as_str(),
+        );
+        let prompt = crate::lifecycle::worker_command_context::compile_pi_leader_system_prompt();
+        let tools = ["mcp_team", "fs_read", "fs_list", "fs_write", "execute_bash"];
+        let team_mcp_tools = [
+            "assign_task",
+            "send_message",
+            "update_state",
+            "get_team_status",
+            "stop_agent",
+            "reset_agent",
+            "add_agent",
+            "clone_agent",
+            "fork_agent",
+            "request_human",
+            "stuck_list",
+            "stuck_cancel",
+        ];
+        crate::lifecycle::launch::pi_mcp::materialize_pi_plan(
+            crate::lifecycle::launch::pi_mcp::PiMaterializeRequest {
+                workspace,
+                team_id: identity.team_id.as_str(),
+                agent_id: "leader",
+                model: parsed.model.as_deref(),
+                effort: parsed.effort,
+                system_prompt: &prompt,
+                tool_categories: &tools,
+                team_mcp_tools: &team_mcp_tools,
+                mcp_config: &mcp_config,
+            },
+        )
+        .map_err(|error| LeaderError::Start(error.to_string()))?
+        .argv
+    } else if provider == Provider::Pi {
+        Vec::new()
+    } else {
+        provider_command_argv(provider, provider_args)
+    };
     let argv = start_argv(
         mode,
         provider,
-        provider_args,
+        &provider_argv,
         workspace,
         session_name.as_ref(),
         managed_window.as_ref(),
@@ -305,7 +353,6 @@ fn leader_start_plan_with_ambient_authority(
     } else {
         leader_env.clone()
     };
-    let provider_argv = provider_command_argv(provider, provider_args);
     Ok(LeaderStartPlan {
         mode,
         provider,
@@ -970,20 +1017,15 @@ fn managed_leader_window_for_launch(
 fn start_argv(
     mode: LeaderStartMode,
     provider: Provider,
-    provider_args: &[String],
+    provider_argv: &[String],
     workspace: &Path,
     session_name: Option<&SessionName>,
     leader_window: Option<&WindowName>,
     leader_env: &BTreeMap<String, String>,
     managed_client_attach_mode: Option<ManagedClientAttachMode>,
 ) -> Result<Vec<String>, LeaderError> {
-    let provider_cmd = provider_command_name(provider).to_string();
     match mode {
-        LeaderStartMode::ExecProvider => {
-            let mut argv = vec![provider_cmd];
-            argv.extend(normalized_provider_args(provider_args));
-            Ok(argv)
-        }
+        LeaderStartMode::ExecProvider => Ok(provider_argv.to_vec()),
         LeaderStartMode::ManagedTmuxClient => {
             let Some(session) = session_name else {
                 return Err(LeaderError::Start(
@@ -1021,13 +1063,11 @@ fn start_argv(
             if let Some(path) = std::env::var_os("PATH").and_then(|p| p.into_string().ok()) {
                 exports.push(shlex_quote(&format!("PATH={path}")));
             }
-            let mut provider_argv = vec![provider_cmd];
-            provider_argv.extend(normalized_provider_args(provider_args));
             let shell = format!(
                 "cd {} && export {} && exec {}",
                 shlex_quote(&resolved_workspace.to_string_lossy()),
                 exports.join(" "),
-                shell_join(&provider_argv)
+                shell_join(provider_argv)
             );
             let argv = vec![
                 "tmux".to_string(),
@@ -2777,6 +2817,7 @@ fn provider_command_name(provider: Provider) -> &'static str {
         Provider::GeminiCli => "gemini",
         Provider::Grok => "grok",
         Provider::CursorAgent => "agent",
+        Provider::Pi => "pi",
         Provider::Fake => "fake",
     }
 }

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

@@ -20,7 +20,7 @@
 //! boundary:
 //!   - 不拷贝外部角色文件进 team 目录，就地读取编译
 //!   - 起席一律走 restart 的 start_agent_at_paths，本文件不直接 spawn
-//!   - 回滚只恢复 spec 字节与 runtime state，不回收已 spawn 的 pane
+//!   - start path 按 exact pane receipt 回收已 spawn pane；本文件恢复 spec/state，并删除新 Pi 席位的 exact wrapper
 //! maturity: wired
 //! ---
 use std::collections::{BTreeMap, BTreeSet};
@@ -217,18 +217,14 @@ pub fn add_agent(
     ) {
         Ok(selected) => selected,
         Err(_) if workspace.join("TEAM.md").exists() => {
-            // **0.3.24 add-agent socket drift fix**: even on the TEAM.md fallback
-            // path (no spec yet), prefer the state-aware resolver. It reads the
-            // team's persisted `tmux_endpoint` (set at `team-agent launch` time)
-            // and routes the new agent's spawn to the SAME tmux socket the live
-            // team uses. Cold workspaces / first-agent paths safely fall back to
-            // `TmuxBackend::for_workspace(team_workspace)` inside the resolver.
-            let team_ws = team_workspace(workspace);
+            // The MCP server already passes the canonical run workspace here.
+            // Reapplying team_workspace() would strip the scratch root and bind
+            // the first dynamic worker to the parent workspace's tmux server.
             let transport =
                 crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
-                    &team_ws, team,
+                    workspace, team,
                 )
-                .unwrap_or_else(|_| crate::tmux_backend::TmuxBackend::for_workspace(&team_ws));
+                .unwrap_or_else(|_| crate::tmux_backend::TmuxBackend::for_workspace(workspace));
             return add_agent_with_transport(
                 workspace,
                 agent_id,
@@ -516,6 +512,28 @@ pub(super) fn maybe_fail_force_recreate_after_spawn() -> Result<(), LifecycleErr
     )))
 }
 
+fn rollback_added_pi_wrapper(
+    run_workspace: &Path,
+    team_key: &str,
+    agent_id: &AgentId,
+    role_meta: &Value,
+) -> Result<(), LifecycleError> {
+    if role_meta.get("provider").and_then(Value::as_str) != Some("pi") {
+        return Ok(());
+    }
+    let wrapper =
+        crate::lifecycle::launch::pi_mcp::pi_seat_paths(run_workspace, team_key, agent_id.as_str())
+            .wrapper;
+    match std::fs::remove_file(&wrapper) {
+        Ok(()) => Ok(()),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
+        Err(error) => Err(LifecycleError::StatePersist(format!(
+            "failed to roll back added Pi wrapper {}: {error}",
+            wrapper.display()
+        ))),
+    }
+}
+
 /// ---
 /// purpose: 加席的实体实现，含 owner 门、重名拒绝、重编译 spec 原子写、席位 state upsert 与起席
 /// params:
@@ -701,6 +719,8 @@ fn add_agent_with_transport_at_paths_reserved(
     ) {
         Ok(started) => started,
         Err(error) => {
+            let wrapper_rollback =
+                rollback_added_pi_wrapper(run_workspace, &canonical_team_key, agent_id, &meta);
             rollback_add_agent_atomic(
                 run_workspace,
                 &spec_path,
@@ -709,15 +729,42 @@ fn add_agent_with_transport_at_paths_reserved(
                 agent_id,
                 "start_agent_failed",
             );
-            return Err(error);
+            return match wrapper_rollback {
+                Ok(()) => Err(error),
+                Err(rollback_error) => Err(LifecycleError::StatePersist(format!(
+                    "{error}; {rollback_error}"
+                ))),
+            };
         }
     };
     let (env, start_mode) = match started {
         StartAgentOutcome::Running {
             env, start_mode, ..
         } => (env, start_mode),
-        StartAgentOutcome::Noop { env, .. } => (env, StartMode::Noop),
+        StartAgentOutcome::Noop { .. } => {
+            let wrapper_rollback =
+                rollback_added_pi_wrapper(run_workspace, &canonical_team_key, agent_id, &meta);
+            rollback_add_agent_atomic(
+                run_workspace,
+                &spec_path,
+                pre_spec_text.as_deref(),
+                None,
+                agent_id,
+                "added_agent_noop",
+            );
+            let error = LifecycleError::RequirementUnmet(format!(
+                "newly added agent {agent_id} returned start_agent.noop"
+            ));
+            return match wrapper_rollback {
+                Ok(()) => Err(error),
+                Err(rollback_error) => Err(LifecycleError::StatePersist(format!(
+                    "{error}; {rollback_error}"
+                ))),
+            };
+        }
         StartAgentOutcome::Paused { .. } => {
+            let wrapper_rollback =
+                rollback_added_pi_wrapper(run_workspace, &canonical_team_key, agent_id, &meta);
             rollback_add_agent_atomic(
                 run_workspace,
                 &spec_path,
@@ -726,9 +773,14 @@ fn add_agent_with_transport_at_paths_reserved(
                 agent_id,
                 "added_agent_paused",
             );
-            return Err(LifecycleError::RequirementUnmet(format!(
-                "added agent {agent_id} is paused"
-            )));
+            let error =
+                LifecycleError::RequirementUnmet(format!("added agent {agent_id} is paused"));
+            return match wrapper_rollback {
+                Ok(()) => Err(error),
+                Err(rollback_error) => Err(LifecycleError::StatePersist(format!(
+                    "{error}; {rollback_error}"
+                ))),
+            };
         }
     };
     if let Some(reservation) = reservation {

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

@@ -167,6 +167,24 @@ pub(super) fn upsert_agent_state_from_role(
             "runtime state root is not an object".to_string(),
         ));
     };
+    if !root
+        .get("session_name")
+        .and_then(serde_json::Value::as_str)
+        .is_some_and(|session| !session.is_empty())
+    {
+        if let Some(owner_session) = root
+            .get("leader_receiver")
+            .and_then(|receiver| receiver.get("session_name"))
+            .and_then(serde_json::Value::as_str)
+            .filter(|session| !session.is_empty())
+            .map(str::to_string)
+        {
+            root.insert(
+                "session_name".to_string(),
+                serde_json::Value::String(owner_session),
+            );
+        }
+    }
     let agents = root
         .entry("agents".to_string())
         .or_insert_with(|| serde_json::json!({}));

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

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