@team-agent/installer 0.5.72 → 0.5.74

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

@@ -243,12 +243,6 @@ pub fn register_binding_from_state_best_effort(
     );
     let event_log = crate::event_log::EventLog::new(workspace);
     let write_result = write_entry_best_effort(&entry);
-    // Fresh quick-start is acquisition-only: it must never displace another
-    // same-pane row. Its caller performs a validated-LIVE check before this
-    // write; manual/restart ownership paths keep existing behavior.
-    if write_result.is_some() && source != "quick-start" {
-        let _ = mark_displaced_same_pane_entries_unbound(&entry);
-    }
     let status = if let Some(path) = &write_result {
         let _ = event_log.write(
             EVENT_REGISTERED,
@@ -281,68 +275,6 @@ pub fn register_binding_from_state_best_effort(
     })
 }
 
-/// Stored registry status after another workspace claimed the same pane.
-pub const REGISTRY_STATUS_UNBOUND: &str = "unbound";
-
-/// When workspace B claims a pane, every other attached registry row that
-/// still names that pane is no longer deliverable. Mark those rows unbound.
-/// Does not change pane-side authorization storage.
-pub fn mark_displaced_same_pane_entries_unbound(winner: &LeaderRegistryEntry) -> Vec<PathBuf> {
-    let Some(winner_pane) = winner
-        .channel
-        .get("pane_id")
-        .and_then(Value::as_str)
-        .filter(|pane| !pane.is_empty())
-    else {
-        return Vec::new();
-    };
-    let winner_socket = winner
-        .channel
-        .get("tmux_socket")
-        .and_then(Value::as_str)
-        .filter(|socket| !socket.is_empty());
-    let mut displaced = Vec::new();
-    for (path, mut entry) in read_all_entries() {
-        if entry.workspace_hash == winner.workspace_hash && entry.team_key == winner.team_key {
-            continue;
-        }
-        if entry.status != "attached" {
-            continue;
-        }
-        let Some(pane) = entry
-            .channel
-            .get("pane_id")
-            .and_then(Value::as_str)
-            .filter(|pane| !pane.is_empty())
-        else {
-            continue;
-        };
-        if pane != winner_pane {
-            continue;
-        }
-        let Some(socket) = entry
-            .channel
-            .get("tmux_socket")
-            .and_then(Value::as_str)
-            .filter(|socket| !socket.is_empty())
-        else {
-            continue;
-        };
-        let Some(winner_socket) = winner_socket else {
-            continue;
-        };
-        if socket != winner_socket {
-            continue;
-        }
-        entry.status = REGISTRY_STATUS_UNBOUND.to_string();
-        entry.updated_at = chrono::Utc::now().to_rfc3339();
-        if write_entry_best_effort(&entry).is_some() {
-            displaced.push(path);
-        }
-    }
-    displaced
-}
-
 fn entry_filename(entry: &LeaderRegistryEntry) -> String {
     format!("{}__{}.json", entry.workspace_hash, entry.team_key)
 }
@@ -546,27 +478,6 @@ pub fn list_validated_with_gc() -> Vec<(LeaderRegistryEntry, &'static str, Optio
     out
 }
 
-/// Refuse a fresh quick-start binding when the caller pane already backs a
-/// canonically LIVE receiver for another workspace/team. This is read-only:
-/// quick-start never displaces or takes over an existing binding.
-#[must_use]
-pub(crate) fn live_same_pane_binding_elsewhere(
-    pane_id: &str,
-    workspace: &Path,
-    team_key: &str,
-) -> bool {
-    let workspace = std::fs::canonicalize(workspace).unwrap_or_else(|_| workspace.to_path_buf());
-    list_validated_no_gc().into_iter().any(|(entry, status, _)| {
-        status == "LIVE"
-            && entry
-                .channel
-                .get("pane_id")
-                .and_then(Value::as_str)
-                == Some(pane_id)
-            && (entry.workspace != workspace || entry.team_key != team_key)
-    })
-}
-
 /// Same as `list_validated_with_gc` but preserves all entries. `send
 /// --to-leader` needs to see stale entries so it can refuse with
 /// `registry_stale` (and never silently fall through to

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,
     })
 }