@team-agent/installer 0.5.72 → 0.5.73

package/Cargo.lock

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

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

@@ -162,6 +162,7 @@ pub(crate) fn prepare_leader_start_with_nested_attach(
         std::env::var_os("TMUX").is_some(),
         managed_client_attach_mode,
         managed_exec_provider,
+        allow_nested_attach,
     )?;
     Ok(PreparedLeaderStart {
         plan,
@@ -196,6 +197,7 @@ pub(crate) fn leader_start_plan_after_ambient_authority_check(
         in_tmux,
         managed_client_attach_mode,
         false,
+        false,
     )
 }
 
@@ -210,6 +212,7 @@ fn leader_start_plan_with_ambient_authority(
     in_tmux: bool,
     managed_client_attach_mode: Option<ManagedClientAttachMode>,
     managed_exec_provider: bool,
+    allow_nested_attach: bool,
 ) -> Result<LeaderStartPlan, LeaderError> {
     if attach_session.is_some() && !confirm_attach {
         return Err(LeaderError::Start(
@@ -327,6 +330,11 @@ fn leader_start_plan_with_ambient_authority(
                 tool_categories: &tools,
                 team_mcp_tools: &team_mcp_tools,
                 mcp_config: &mcp_config,
+                session_scope: crate::lifecycle::launch::pi_mcp::pi_leader_session_scope(
+                    provider_args,
+                    external_path,
+                    allow_nested_attach,
+                ),
             },
         )
         .map_err(|error| LeaderError::Start(error.to_string()))?

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

@@ -816,6 +816,27 @@ pub(crate) fn resolve_pi_executable_chain(
     Ok((chain, models))
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum PiSessionScope {
+    Isolated,
+    NativeDefault,
+}
+
+/// Zero-argument managed Pi is the interactive leader entry. Only that route
+/// may use Pi's cwd-keyed native session root; every explicit or worker route
+/// remains Team Agent session-isolated.
+pub(crate) fn pi_leader_session_scope(
+    provider_args: &[String],
+    external_path: bool,
+    allow_nested_attach: bool,
+) -> PiSessionScope {
+    if provider_args.is_empty() && !external_path && !allow_nested_attach {
+        PiSessionScope::NativeDefault
+    } else {
+        PiSessionScope::Isolated
+    }
+}
+
 pub(crate) struct PiMaterializeRequest<'a> {
     pub workspace: &'a Path,
     pub team_id: &'a str,
@@ -826,11 +847,13 @@ pub(crate) struct PiMaterializeRequest<'a> {
     pub tool_categories: &'a [&'a str],
     pub team_mcp_tools: &'a [&'a str],
     pub mcp_config: &'a McpConfig,
+    pub session_scope: PiSessionScope,
 }
 
 /// ---
 /// purpose: 共享物化 Pi leader 与 TeamMate 的 wrapper、UUID 和 CommandPlan
-/// returns: fresh Pi CommandPlan，含 expected UUID 与 seat session root
+/// returns: fresh Pi CommandPlan；isolated seats carry their session root, while the
+///          interactive leader preserves Pi's native default root
 /// errors: resolver、exact model、wrapper 或 argv 构造失败时返回 ProviderError
 /// ---
 pub(crate) fn materialize_pi_plan(
@@ -863,8 +886,18 @@ fn materialize_pi_plan_with_session(
         .map(|model| select_exact_pi_model(&catalog, model))
         .transpose()?;
     let paths = pi_seat_paths(request.workspace, request.team_id, request.agent_id);
+    let session_dir = match request.session_scope {
+        PiSessionScope::Isolated => Some(paths.sessions.as_path()),
+        PiSessionScope::NativeDefault => None,
+    };
     let resume = if let Some((session_id, session_path, spawn_cwd)) = resume {
-        let session_root = std::fs::canonicalize(&paths.sessions).map_err(|error| {
+        let session_dir = session_dir.ok_or_else(|| {
+            ProviderError::ResumeUnavailable(format!(
+                "Pi session root is unavailable {}",
+                paths.sessions.display()
+            ))
+        })?;
+        let session_root = std::fs::canonicalize(session_dir).map_err(|error| {
             ProviderError::ResumeUnavailable(format!(
                 "Pi session root is unavailable {}: {error}",
                 paths.sessions.display()
@@ -885,8 +918,11 @@ fn materialize_pi_plan_with_session(
         let _ = spawn_cwd;
         Some((session_id, exact_path))
     } else {
-        std::fs::create_dir_all(&paths.sessions)
-            .map_err(|error| ProviderError::Io(format!("{}: {error}", paths.sessions.display())))?;
+        if let Some(session_dir) = session_dir {
+            std::fs::create_dir_all(session_dir).map_err(|error| {
+                ProviderError::Io(format!("{}: {error}", session_dir.display()))
+            })?;
+        }
         None
     };
     let candidate = candidate_from_mcp_config(request.mcp_config)?;
@@ -908,7 +944,7 @@ fn materialize_pi_plan_with_session(
             effort: request.effort,
             system_prompt: request.system_prompt,
             tool_categories: request.tool_categories,
-            session_dir: &paths.sessions,
+            session_dir,
             session: PiSessionSelector::Resume { path: &exact_path },
             agent_id: request.agent_id,
         })?;
@@ -922,7 +958,7 @@ fn materialize_pi_plan_with_session(
             effort: request.effort,
             system_prompt: request.system_prompt,
             tool_categories: request.tool_categories,
-            session_dir: &paths.sessions,
+            session_dir,
             session: PiSessionSelector::Fresh {
                 session_id: session_id.as_str(),
             },
@@ -933,7 +969,7 @@ fn materialize_pi_plan_with_session(
     Ok(CommandPlan {
         argv,
         expected_session_id,
-        provider_projects_root: Some(paths.sessions),
+        provider_projects_root: session_dir.map(Path::to_path_buf),
         managed_mcp_config: false,
     })
 }

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

@@ -189,6 +189,7 @@ pub(super) fn spawn_agents(
                     tool_categories: &resolved_tool_refs,
                     team_mcp_tools: &["send_message", "report_result"],
                     mcp_config: &mcp_config,
+                    session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
                 },
             )
             .map_err(|e| LifecycleError::Provider(e.to_string()))?

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

@@ -402,6 +402,7 @@ pub(super) fn spawn_agent_window(
             tool_categories: &resolved_tool_refs,
             team_mcp_tools: &["send_message", "report_result"],
             mcp_config: &mcp_config,
+            session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
         };
         match resume_session_id {
             Some(session_id) => {

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

@@ -22,7 +22,7 @@ fn command_for_model(model: &str) -> Vec<String> {
         effort: Some(ProviderEffort::Medium),
         system_prompt: "worker contract",
         tool_categories: &["mcp_team"],
-        session_dir: Path::new("/workspace/.team/runtime/pi/t1/w1/sessions"),
+        session_dir: Some(Path::new("/workspace/.team/runtime/pi/t1/w1/sessions")),
         session: PiSessionSelector::Fresh {
             session_id: "716ba0cb-c491-4471-b41a-43c8d5e1f05a",
         },

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

@@ -1,5 +1,6 @@
 use std::path::Path;
 
+use crate::lifecycle::launch::pi_mcp::{pi_leader_session_scope, PiSessionScope};
 use crate::model::enums::ProviderEffort;
 use crate::provider::adapters::pi::{build_pi_command_argv, PiCommandRequest, PiSessionSelector};
 
@@ -11,7 +12,9 @@ fn request(session: PiSessionSelector<'static>) -> PiCommandRequest<'static> {
         effort: Some(ProviderEffort::High),
         system_prompt: "frozen worker prompt",
         tool_categories: &["mcp_team", "fs_read", "fs_write", "execute_bash"],
-        session_dir: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/sessions"),
+        session_dir: Some(Path::new(
+            "/workspace/.team/runtime/pi/team-a/worker-a/sessions",
+        )),
         session,
         agent_id: "worker-a",
     }
@@ -30,6 +33,73 @@ fn pi_command_omits_unset_model_and_thinking_flags() {
     assert!(!argv.iter().any(|arg| arg == "--thinking"), "argv={argv:?}");
 }
 
+fn leader_request() -> PiCommandRequest<'static> {
+    PiCommandRequest {
+        executable: Path::new("/verified/pi"),
+        extension: Path::new("/workspace/.team/runtime/pi/current/leader/team-mcp.ts"),
+        model: None,
+        effort: None,
+        system_prompt: "frozen leader prompt",
+        tool_categories: &["mcp_team", "fs_read", "fs_write", "execute_bash"],
+        session_dir: None,
+        session: PiSessionSelector::Fresh {
+            session_id: "da8c3622-2378-4d05-a26c-e826a6ef6d63",
+        },
+        agent_id: "leader",
+    }
+}
+
+#[test]
+fn pi_interactive_leader_argv_preserves_native_session_discovery() {
+    let argv = build_pi_command_argv(leader_request()).expect("native Pi leader command");
+
+    assert_eq!(
+        argv,
+        [
+            "/verified/pi",
+            "-e",
+            "/workspace/.team/runtime/pi/current/leader/team-mcp.ts",
+            "--append-system-prompt",
+            "frozen leader prompt",
+            "--session-id",
+            "da8c3622-2378-4d05-a26c-e826a6ef6d63",
+            "--name",
+            "leader",
+        ]
+        .map(str::to_string)
+    );
+    assert!(!argv.iter().any(|arg| arg == "--session-dir"));
+    for forbidden in ["--cwd", "--workspace", "--session"] {
+        assert!(!argv.iter().any(|arg| arg == forbidden), "argv={argv:?}");
+    }
+}
+
+#[test]
+fn pi_leader_session_scope_keeps_explicit_and_external_routes_isolated() {
+    assert_eq!(
+        pi_leader_session_scope(&[], false, false),
+        PiSessionScope::NativeDefault
+    );
+    for (args, external_path, allow_nested_attach) in [
+        (
+            vec![
+                "--model".to_string(),
+                "openai-codex/gpt-5.6-sol".to_string(),
+            ],
+            false,
+            false,
+        ),
+        (Vec::new(), true, false),
+        (Vec::new(), false, true),
+    ] {
+        assert_eq!(
+            pi_leader_session_scope(&args, external_path, allow_nested_attach),
+            PiSessionScope::Isolated,
+            "only the zero-argument managed route may use Pi's native root"
+        );
+    }
+}
+
 #[test]
 fn pi_command_preserves_direct_pi_defaults_with_only_team_runtime_additions() {
     let fresh = build_pi_command_argv(request(PiSessionSelector::Fresh {

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

@@ -59,7 +59,9 @@ fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<St
         effort: Some(effort),
         system_prompt: "Pi worker contract.",
         tool_categories: tools,
-        session_dir: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/sessions"),
+        session_dir: Some(Path::new(
+            "/workspace/.team/runtime/pi/t1/pi-worker/sessions",
+        )),
         session: PiSessionSelector::Fresh {
             session_id: "c5ddf218-24a5-4e74-960c-ab6606ea7e8c",
         },

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

@@ -2,13 +2,19 @@ use std::os::unix::fs::PermissionsExt;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU32, Ordering};
 
+use crate::lifecycle::launch::launch_with_transport_in_workspace;
 use crate::lifecycle::launch::pi_mcp::{
+    PiAdapterIdentity, PiExecutableChain, PiExecutableFileType, PiMaterializeRequest,
+    PiSessionScope, PiWrapperRequest, materialize_pi_plan, materialize_pi_resume_plan,
     parse_pi_list_models_table, pi_seat_paths, resolve_pi_executable_chain,
     validate_pi_adapter_identity, validate_pi_executable_chain, validate_pi_wrapper_source,
-    write_pi_wrapper, write_pi_wrapper_with_publish, PiAdapterIdentity, PiExecutableChain,
-    PiExecutableFileType, PiWrapperRequest,
+    write_pi_wrapper, write_pi_wrapper_with_publish,
 };
-use crate::provider::McpConfig;
+use crate::lifecycle::start_agent_with_transport;
+use crate::model::enums::ProviderEffort;
+use crate::provider::session_scan::{CaptureSessionContext, scan_session_candidates_once};
+use crate::provider::{McpConfig, Provider, SessionId};
+use crate::transport::test_support::OfflineTransport;
 
 #[path = "../../../tests/support/hermetic.rs"]
 mod hermetic_guard;
@@ -34,6 +40,11 @@ const PI_SYMLINK_TEST: &str = concat!(
     "lifecycle::tests::pi_executable_mcp_red::",
     "pi_standard_npm_symlink_is_a_verified_launch_entry"
 );
+const PI_MATERIALIZER_CHILD: &str = "TEAM_AGENT_TEST_PI_MATERIALIZER_CHILD";
+const PI_MATERIALIZER_TEST: &str = concat!(
+    "lifecycle::tests::pi_executable_mcp_red::",
+    "pi_materializer_and_worker_routes_use_the_recorded_scope"
+);
 
 fn run_process_isolated(marker: &str, test_name: &str, body: impl FnOnce()) {
     if std::env::var_os(marker).is_some() {
@@ -504,3 +515,385 @@ fn pi_wrapper_import_failure_body(hermetic: &HermeticTestEnv) {
 
     std::fs::remove_dir_all(root).expect("remove wrapper fixture");
 }
+
+#[test]
+fn pi_materializer_and_worker_routes_use_the_recorded_scope() {
+    run_process_isolated(PI_MATERIALIZER_CHILD, PI_MATERIALIZER_TEST, || {
+        let hermetic = HermeticTestEnv::enter("pi-materializer-scope");
+        assert_isolated_child();
+        pi_materializer_and_worker_routes_body(&hermetic);
+    });
+}
+
+fn pi_materializer_and_worker_routes_body(hermetic: &HermeticTestEnv) {
+    let fixture_root = hermetic.root().join("materializer-fixture");
+    let bin = fixture_root.join("bin");
+    let adapter_root = fixture_root.join("pi-mcp-adapter");
+    let candidate = fixture_root.join("candidate/team-agent");
+    let real = fixture_root.join("pi-real");
+    std::fs::create_dir_all(&bin).expect("create Pi fixture bin");
+    std::fs::create_dir_all(&adapter_root).expect("create Pi adapter fixture");
+    std::fs::create_dir_all(candidate.parent().expect("candidate parent"))
+        .expect("create candidate parent");
+    std::fs::write(&candidate, b"candidate").expect("write candidate fixture");
+    std::fs::write(
+        adapter_root.join("package.json"),
+        br#"{"name":"pi-mcp-adapter","version":"2.30.0","pi":{"extensions":["./index.ts"]}}"#,
+    )
+    .expect("write adapter package");
+    std::fs::write(
+        adapter_root.join("index.ts"),
+        b"export const createMcpAdapter = () => {};\n",
+    )
+    .expect("write adapter entry");
+    let pi_script = format!(
+        "#!/bin/sh\ncase \"${{1-}}\" in\n  --version) printf '0.84.4\\n' ;;\n  --list-models) printf 'provider model\\nteam-agent qwen3.8-27b\\n' ;;\n  list) printf 'npm:pi-mcp-adapter\\n{}\\n' ;;\n  *) exit 0 ;;\nesac\n",
+        adapter_root.display()
+    );
+    std::fs::write(&real, &pi_script).expect("write Pi real fixture");
+    std::fs::set_permissions(&real, std::fs::Permissions::from_mode(0o755))
+        .expect("make Pi real fixture executable");
+    std::os::unix::fs::symlink(&real, bin.join("pi")).expect("create Pi PATH symlink");
+    let _path = hermetic.with_env(
+        "PATH",
+        std::env::join_paths([&bin])
+            .expect("join Pi fixture PATH")
+            .to_str()
+            .expect("Pi fixture PATH is UTF-8"),
+    );
+
+    let native_workspace = hermetic.workspace("native");
+    let native_paths = pi_seat_paths(&native_workspace, "team-a", "leader");
+    let native_config = mcp_config(&candidate, &native_workspace, "leader");
+    let native = materialize_pi_plan(PiMaterializeRequest {
+        workspace: &native_workspace,
+        team_id: "team-a",
+        agent_id: "leader",
+        model: None,
+        effort: None,
+        system_prompt: "native leader fixture",
+        tool_categories: &["mcp_team"],
+        team_mcp_tools: &["send_message"],
+        mcp_config: &native_config,
+        session_scope: PiSessionScope::NativeDefault,
+    })
+    .expect("NativeDefault materializer");
+    assert!(
+        native.provider_projects_root.is_none(),
+        "NativeDefault must not expose a provider capture root: {native:?}"
+    );
+    assert!(
+        !native_paths.sessions.exists(),
+        "NativeDefault must not create the Team Agent seat session root"
+    );
+    for forbidden in ["--session-dir", "--cwd", "--workspace", "--session"] {
+        assert!(
+            !native.argv.iter().any(|arg| arg == forbidden),
+            "NativeDefault fresh argv must omit {forbidden}: {:?}",
+            native.argv
+        );
+    }
+
+    let isolated_workspace = hermetic.workspace("isolated");
+    let isolated_paths = pi_seat_paths(&isolated_workspace, "team-a", "worker-a");
+    let isolated_config = mcp_config(&candidate, &isolated_workspace, "worker-a");
+    let isolated = materialize_pi_plan(PiMaterializeRequest {
+        workspace: &isolated_workspace,
+        team_id: "team-a",
+        agent_id: "worker-a",
+        model: Some("team-agent/qwen3.8-27b"),
+        effort: Some(ProviderEffort::Medium),
+        system_prompt: "isolated worker fixture",
+        tool_categories: &["mcp_team"],
+        team_mcp_tools: &["send_message"],
+        mcp_config: &isolated_config,
+        session_scope: PiSessionScope::Isolated,
+    })
+    .expect("Isolated materializer");
+    assert_eq!(
+        isolated.provider_projects_root.as_deref(),
+        Some(isolated_paths.sessions.as_path())
+    );
+    assert_session_pair(&isolated.argv, &isolated_paths.sessions);
+    assert!(!isolated.argv.iter().any(|arg| arg == "--cwd"));
+    assert!(!isolated.argv.iter().any(|arg| arg == "--workspace"));
+
+    let session_id = SessionId::new("pi-materializer-resume");
+    let exact = isolated_paths.sessions.join("2026/09/exact.jsonl");
+    std::fs::create_dir_all(exact.parent().expect("exact session parent"))
+        .expect("create exact session parent");
+    std::fs::write(&exact, b"{}\n").expect("write exact session fixture");
+    let resumed = materialize_pi_resume_plan(
+        PiMaterializeRequest {
+            workspace: &isolated_workspace,
+            team_id: "team-a",
+            agent_id: "worker-a",
+            model: None,
+            effort: None,
+            system_prompt: "isolated resume fixture",
+            tool_categories: &["mcp_team"],
+            team_mcp_tools: &["send_message"],
+            mcp_config: &isolated_config,
+            session_scope: PiSessionScope::Isolated,
+        },
+        &session_id,
+        &exact,
+        &isolated_workspace,
+    )
+    .expect("Isolated exact-path resume materializer");
+    assert_eq!(
+        resumed.provider_projects_root.as_deref(),
+        Some(isolated_paths.sessions.as_path())
+    );
+    assert_session_pair(&resumed.argv, &isolated_paths.sessions);
+    assert!(
+        resumed
+            .argv
+            .windows(2)
+            .any(|pair| { pair == ["--session", exact.to_string_lossy().as_ref()] })
+    );
+
+    let native_resume = materialize_pi_resume_plan(
+        PiMaterializeRequest {
+            workspace: &native_workspace,
+            team_id: "team-a",
+            agent_id: "leader",
+            model: None,
+            effort: None,
+            system_prompt: "native resume fixture",
+            tool_categories: &["mcp_team"],
+            team_mcp_tools: &["send_message"],
+            mcp_config: &native_config,
+            session_scope: PiSessionScope::NativeDefault,
+        },
+        &session_id,
+        &exact,
+        &native_workspace,
+    );
+    assert!(
+        matches!(
+            native_resume,
+            Err(crate::provider::ProviderError::ResumeUnavailable(_))
+        ),
+        "NativeDefault resume must fail closed before emitting a native HOME path: {native_resume:?}"
+    );
+
+    let home_candidate = hermetic.home().join(".pi/agent/sessions/home.jsonl");
+    std::fs::create_dir_all(home_candidate.parent().expect("home session parent"))
+        .expect("create home session parent");
+    std::fs::write(&home_candidate, b"{}\n").expect("write home candidate");
+    let other_paths = pi_seat_paths(&isolated_workspace, "team-a", "worker-b");
+    let other_candidate = other_paths.sessions.join("other.jsonl");
+    std::fs::create_dir_all(other_candidate.parent().expect("other session parent"))
+        .expect("create other session parent");
+    std::fs::write(&other_candidate, b"{}\n").expect("write other seat candidate");
+    for (label, outside) in [("HOME", &home_candidate), ("other seat", &other_candidate)] {
+        let refused = materialize_pi_resume_plan(
+            PiMaterializeRequest {
+                workspace: &isolated_workspace,
+                team_id: "team-a",
+                agent_id: "worker-a",
+                model: None,
+                effort: None,
+                system_prompt: "isolated negative resume fixture",
+                tool_categories: &["mcp_team"],
+                team_mcp_tools: &["send_message"],
+                mcp_config: &isolated_config,
+                session_scope: PiSessionScope::Isolated,
+            },
+            &session_id,
+            &outside,
+            &isolated_workspace,
+        );
+        assert!(
+            matches!(
+                refused,
+                Err(crate::provider::ProviderError::ResumeUnavailable(_))
+            ),
+            "{label} candidate must be refused by the exact seat-root check: {refused:?}"
+        );
+    }
+
+    let worker_workspace = hermetic.workspace("worker-spawn");
+    let spec_path = worker_workspace
+        .join(".team")
+        .join("team-a")
+        .join("team.spec.yaml");
+    std::fs::create_dir_all(spec_path.parent().expect("worker Pi spec parent"))
+        .expect("create worker Pi spec parent");
+    let spec = crate::model::yaml::loads(
+        "team:\n  name: team-a\nruntime:\n  session_name: team-workers\n  display_backend: tmux_attach\nagents:\n  - id: worker-a\n    role: Worker A\n    provider: pi\n    model: team-agent/qwen3.8-27b\n    auth_mode: subscription\n    dangerously_skip_permissions: false\n    tools:\n      - mcp_team\n  - id: worker-b\n    role: Worker B\n    provider: pi\n    model: team-agent/qwen3.8-27b\n    auth_mode: subscription\n    dangerously_skip_permissions: false\n    tools:\n      - mcp_team\n",
+    )
+    .expect("parse worker Pi spec");
+    std::fs::write(&spec_path, crate::model::yaml::dumps(&spec)).expect("write worker Pi spec");
+    let transport = OfflineTransport::new();
+    let started = launch_with_transport_in_workspace(
+        &worker_workspace,
+        &spec_path,
+        false,
+        true,
+        true,
+        &transport,
+    )
+    .expect("worker fresh spawn construction")
+    .started;
+    assert_eq!(started.len(), 2, "both Pi worker seats must be spawned");
+    for worker in ["worker-a", "worker-b"] {
+        let paths = pi_seat_paths(&worker_workspace, "team-a", worker);
+        let started_agent = started
+            .iter()
+            .find(|entry| entry.agent_id.as_str() == worker)
+            .expect("started worker entry");
+        assert_eq!(
+            started_agent.provider_projects_root.as_deref(),
+            Some(paths.sessions.as_path()),
+            "fresh worker must expose its exact seat capture root"
+        );
+        let record = transport
+            .spawn_records()
+            .into_iter()
+            .find(|(_, argv)| {
+                argv.iter()
+                    .any(|arg| arg.as_str() == paths.wrapper.to_string_lossy().as_ref())
+            })
+            .expect("transport spawn record for worker seat");
+        assert_session_pair(&record.1, &paths.sessions);
+        assert!(
+            !record
+                .1
+                .iter()
+                .any(|arg| arg.as_str() == home_candidate.to_string_lossy().as_ref())
+        );
+        assert!(
+            !record
+                .1
+                .iter()
+                .any(|arg| arg.as_str() == other_candidate.to_string_lossy().as_ref())
+        );
+
+        let pending_session_id = started_agent
+            .pending_session_id
+            .clone()
+            .expect("fresh worker carries a pending Pi session id");
+        write_pi_session_header(
+            &home_candidate,
+            pending_session_id.as_str(),
+            &worker_workspace,
+            "2099-01-01T00:00:00Z",
+        );
+        let other_worker = if worker == "worker-a" {
+            "worker-b"
+        } else {
+            "worker-a"
+        };
+        let cross_seat = pi_seat_paths(&worker_workspace, "team-a", other_worker)
+            .sessions
+            .join("foreign.jsonl");
+        write_pi_session_header(
+            &cross_seat,
+            pending_session_id.as_str(),
+            &worker_workspace,
+            "2099-01-01T00:00:00Z",
+        );
+        let candidates = scan_session_candidates_once(
+            Provider::Pi,
+            &CaptureSessionContext {
+                agent_id: worker.to_string(),
+                spawn_cwd: worker_workspace.clone(),
+                pane_id: None,
+                pane_pid: None,
+                spawned_at: Some(started_agent.spawned_at.clone()),
+                expected_session_id: Some(pending_session_id),
+                provider_projects_root: Some(paths.sessions.clone()),
+            },
+        )
+        .expect("scan the recorded worker seat only");
+        assert!(
+            candidates.is_empty(),
+            "HOME and another worker seat must not become capture candidates: {candidates:?}"
+        );
+    }
+
+    let restart_workspace = hermetic.workspace("worker-restart");
+    let restart_paths = pi_seat_paths(&restart_workspace, "team-a", "worker-a");
+    let restart_exact = restart_paths.sessions.join("2026/09/restart.jsonl");
+    write_pi_session_header(
+        &restart_exact,
+        "pi-restart-session",
+        &restart_workspace,
+        "2026-09-01T00:00:01Z",
+    );
+    crate::state::persist::save_runtime_state(
+        &restart_workspace,
+        &serde_json::json!({
+            "session_name": "team-workers",
+            "active_team_key": "team-a",
+            "agents": {
+                "worker-a": {
+                    "id": "worker-a",
+                    "status": "running",
+                    "provider": "pi",
+                    "role": "Worker A",
+                    "model": "team-agent/qwen3.8-27b",
+                    "auth_mode": "subscription",
+                    "tools": ["mcp_team"],
+                    "session_id": "pi-restart-session",
+                    "rollout_path": restart_exact.to_string_lossy(),
+                    "spawn_cwd": restart_workspace.to_string_lossy(),
+                    "first_send_at": "2026-09-01T00:00:00Z"
+                }
+            }
+        }),
+    )
+    .expect("write restart state");
+    let restart_transport = OfflineTransport::new();
+    let _ = start_agent_with_transport(
+        &restart_workspace,
+        &crate::model::ids::AgentId::new("worker-a"),
+        false,
+        false,
+        false,
+        None,
+        &restart_transport,
+    );
+    let restart_record = restart_transport
+        .spawn_records()
+        .into_iter()
+        .next()
+        .expect("restart must reach the worker spawn construction");
+    assert_session_pair(&restart_record.1, &restart_paths.sessions);
+    assert!(
+        restart_record
+            .1
+            .windows(2)
+            .any(|pair| { pair == ["--session", restart_exact.to_string_lossy().as_ref()] })
+    );
+    assert!(
+        !restart_record
+            .1
+            .iter()
+            .any(|arg| arg.as_str() == home_candidate.to_string_lossy().as_ref())
+    );
+}
+
+fn assert_session_pair(argv: &[String], session_root: &Path) {
+    let expected = session_root.to_string_lossy();
+    assert!(
+        argv.windows(2)
+            .any(|pair| pair[0] == "--session-dir" && pair[1].as_str() == expected.as_ref()),
+        "argv must contain exact --session-dir pair for {}: {argv:?}",
+        session_root.display()
+    );
+}
+
+fn write_pi_session_header(path: &Path, id: &str, cwd: &Path, timestamp: &str) {
+    std::fs::create_dir_all(path.parent().expect("session parent")).expect("create session parent");
+    let header = serde_json::json!({
+        "type": "session",
+        "version": 3,
+        "id": id,
+        "cwd": cwd,
+        "timestamp": timestamp,
+    });
+    std::fs::write(path, format!("{header}\n")).expect("write Pi session header");
+}

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

@@ -60,7 +60,9 @@ fn resume_argv(path: &Path) -> Result<Vec<String>, ProviderError> {
         effort: Some(ProviderEffort::Medium),
         system_prompt: "worker contract",
         tool_categories: &["mcp_team"],
-        session_dir: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/sessions"),
+        session_dir: Some(Path::new(
+            "/workspace/.team/runtime/pi/team-a/worker-a/sessions",
+        )),
         session: PiSessionSelector::Resume { path },
         agent_id: "worker-a",
     })

package/crates/team-agent/src/provider/adapters/pi.rs

@@ -50,7 +50,8 @@ pub(crate) struct PiCommandRequest<'a> {
     pub effort: Option<ProviderEffort>,
     pub system_prompt: &'a str,
     pub tool_categories: &'a [&'a str],
-    pub session_dir: &'a Path,
+    /// Team-owned session root for isolated seats; `None` preserves Pi's native default.
+    pub session_dir: Option<&'a Path>,
     pub session: PiSessionSelector<'a>,
     pub agent_id: &'a str,
 }
@@ -65,14 +66,15 @@ pub(crate) fn build_pi_command_argv(
 ) -> Result<Vec<String>, ProviderError> {
     if request.executable.as_os_str().is_empty()
         || request.extension.as_os_str().is_empty()
-        || request.session_dir.as_os_str().is_empty()
+        || request
+            .session_dir
+            .is_some_and(|session_dir| session_dir.as_os_str().is_empty())
         || request.model.is_some_and(|model| model.trim().is_empty())
         || request.system_prompt.trim().is_empty()
         || request.agent_id.trim().is_empty()
     {
         return Err(ProviderError::Command(
-            "Pi command requires executable, extension, prompt, session directory, and agent id"
-                .to_string(),
+            "Pi command requires executable, extension, prompt, and agent id".to_string(),
         ));
     }
 
@@ -110,9 +112,13 @@ pub(crate) fn build_pi_command_argv(
     argv.extend([
         "--append-system-prompt".to_string(),
         request.system_prompt.to_string(),
-        "--session-dir".to_string(),
-        request.session_dir.to_string_lossy().into_owned(),
     ]);
+    if let Some(session_dir) = request.session_dir {
+        argv.extend([
+            "--session-dir".to_string(),
+            session_dir.to_string_lossy().into_owned(),
+        ]);
+    }
     // The shared lifecycle materializer always revalidates resume root/path/header.
     // Keep the pure argv builder usable before a fixture root is materialized, while
     // refusing a missing exact file once the recorded path's parent exists.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.72",
+  "version": "0.5.73",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.72",
-    "@team-agent/cli-darwin-x64": "0.5.72",
-    "@team-agent/cli-linux-x64": "0.5.72"
+    "@team-agent/cli-darwin-arm64": "0.5.73",
+    "@team-agent/cli-darwin-x64": "0.5.73",
+    "@team-agent/cli-linux-x64": "0.5.73"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/skills/team-agent/SKILL.md

@@ -2,7 +2,7 @@
 name: team-agent
 description: Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.
 requires_team_agent: ">=0.5.0"
-last_verified_against: "0.5.72"
+last_verified_against: "0.5.73"
 ---
 
 # Team Agent