@team-agent/installer 0.5.77 → 0.5.80

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

@@ -333,7 +333,7 @@ pub(crate) fn start_agent_at_paths(
         )));
     }
     let spawn_session_id = if matches!(start_mode, StartMode::Resumed) {
-        session_id.as_ref()
+        session_id.clone()
     } else {
         None
     };
@@ -375,7 +375,7 @@ pub(crate) fn start_agent_at_paths(
         &session_name,
         agent_id,
         &agent,
-        spawn_session_id,
+        spawn_session_id.as_ref(),
         into_existing_session,
         transport,
         Some(&safety),
@@ -390,106 +390,95 @@ pub(crate) fn start_agent_at_paths(
         &session_name,
         &spawn.spawn.window,
     ) {
-        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);
+        return Err(rollback_spawned_pane_keep_error(
+            transport,
+            &spawn.spawn.pane_id,
+            error,
+        ));
     }
     let actual_spawn_window = spawn.spawn.window.as_str().to_string();
-    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,
+    let spawned = (|| {
+    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 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);
-        }
+    }
+    // **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()
     };
+    persist_selected_receiver_session_name(&mut state, &session_name);
+    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,
+        &spawn.plan,
+        provider,
+        start_mode,
+        &session_name,
+        &actual_spawn_window,
+        spawn_session_id.as_ref(),
+        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(),
@@ -502,6 +491,29 @@ pub(crate) fn start_agent_at_paths(
         new_session_id: spawn.plan.expected_session_id.clone(),
         rollout_path,
     })
+    })();
+    match spawned {
+        Ok(outcome) => Ok(outcome),
+        Err(error) => Err(rollback_spawned_pane_keep_error(
+            transport,
+            &spawn.spawn.pane_id,
+            error,
+        )),
+    }
+}
+
+fn rollback_spawned_pane_keep_error(
+    transport: &dyn crate::transport::Transport,
+    pane: &crate::transport::PaneId,
+    error: LifecycleError,
+) -> LifecycleError {
+    match transport.kill_pane(pane) {
+        Ok(()) => error,
+        Err(rollback_error) => LifecycleError::Transport(format!(
+            "{error}; failed to roll back spawned pane {}: {rollback_error}",
+            pane.as_str()
+        )),
+    }
 }
 
 fn replay_worker_target_missing_messages(
@@ -1783,8 +1795,8 @@ fn write_start_agent_start_event(
     workspace: &Path,
     agent_id: &AgentId,
     agent: &serde_json::Value,
+    spawn_plan: &crate::provider::CommandPlan,
     provider: crate::provider::Provider,
-    plan: &crate::provider::CommandPlan,
     start_mode: StartMode,
     session_name: &SessionName,
     window: &str,
@@ -1802,7 +1814,7 @@ fn write_start_agent_start_event(
                 "session": session_name.as_str(),
                 "window": window,
                 "tmux_start_mode": tmux_start_mode,
-                "command": plan.argv,
+                "command": spawn_plan.argv,
                 "mcp_config": agent.get("mcp_config").cloned().unwrap_or(serde_json::Value::Null),
             }),
         )

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

@@ -37,7 +37,6 @@
 //! maturity: wired
 //! ---
 use super::*;
-use crate::transport::Transport;
 
 pub(super) struct SpawnedAgentWindow {
     pub spawn: crate::transport::SpawnResult,
@@ -341,7 +340,7 @@ pub(super) fn spawn_agent_window(
         agent_id.as_str(),
         team_id.as_deref().unwrap_or(""),
     );
-    let mcp_config_path = if provider == Provider::Pi {
+    let mcp_config_path = if provider == crate::provider::Provider::Pi {
         None
     } else {
         Some(crate::lifecycle::launch::write_worker_mcp_config(
@@ -379,19 +378,19 @@ pub(super) fn spawn_agent_window(
         agent_id_hint: Some(agent_id.as_str()),
         effort: restart_effort,
     };
-    let pi_spawn_cwd = (provider == Provider::Pi)
+    let pi_spawn_cwd = (provider == crate::provider::Provider::Pi)
         .then(|| {
             agent
                 .get("spawn_cwd")
                 .and_then(serde_json::Value::as_str)
                 .filter(|value| !value.is_empty())
-                .map(PathBuf::from)
+                .map(std::path::PathBuf::from)
         })
         .flatten();
     let spawn_cwd = spawn_cwd_override
         .or(pi_spawn_cwd.as_deref())
         .unwrap_or(workspace);
-    let mut plan = if provider == Provider::Pi {
+    let mut plan = if provider == crate::provider::Provider::Pi {
         let request = crate::lifecycle::launch::pi_mcp::PiMaterializeRequest {
             workspace,
             team_id: team_id.as_deref().unwrap_or(""),
@@ -477,41 +476,33 @@ pub(super) fn spawn_agent_window(
             agent_id.as_str(),
             &system_prompt,
         )?;
-        crate::lifecycle::launch::apply_cursor_mcp_overlay(workspace, &mcp_config)?;
-        let project = if crate::lifecycle::launch::cursor_mcp_isolation_enabled() {
-            Some(crate::lifecycle::launch::cursor_mcp_project_dir(
-                workspace,
-                agent_id.as_str(),
-            )?)
-        } else {
-            None
-        };
-        crate::lifecycle::launch::enable_cursor_workspace_mcp(workspace, project.as_deref())?;
+        let project = crate::lifecycle::launch::prepare_cursor_seat_mcp(
+            workspace,
+            agent_id.as_str(),
+            &mcp_config,
+        )?;
+        crate::lifecycle::launch::enable_cursor_workspace_mcp_with_profile(
+            workspace,
+            project.as_deref(),
+            Some(&profile_launch),
+        )?;
         crate::lifecycle::launch::apply_cursor_spawn_workspace_pointers(
             &mut plan.argv,
             workspace,
             agent_id.as_str(),
         )?;
-        crate::lifecycle::launch::apply_cursor_subscription_proxy_env(&mut env);
+        crate::lifecycle::launch::apply_cursor_subscription_proxy_env_with_profile(
+            &mut env,
+            &profile_launch,
+        );
     }
     if provider == crate::provider::Provider::Grok {
         crate::lifecycle::launch::ensure_grok_login_and_folder_trust(workspace)?;
         crate::lifecycle::launch::apply_grok_mcp_overlay(workspace, &mcp_config)?;
     }
-    // 0.3.28 Step 3: per Python parity, worker spawn cwd is ALWAYS `workspace`.
-    // The persisted-state `agent.spawn_cwd` override is ignored (it was a
-    // Rust-only extension that drifted to `.team/runtime/<team_key>/` after
-    // rebuild.rs:138 — root cause of E56). The `spawn_cwd_override` parameter
-    // is still honoured for callers that need an explicit cwd (e.g. spec
-    // YAML-resolved cwd at first launch in `lifecycle/launch.rs`), but
-    // restart never passes it (see commit 71864c0 which fixed rebuild.rs:297
-    // to stop pinning `.team/runtime/<team_key>/`).
-    //
-    // NOTE: Step 4 will thread the YAML spec down to here so we can honour
-    // a per-agent YAML `spawn_cwd` field if one is set. Until then, override
-    // > workspace; state-based override is silently dropped for existing
-    // providers. Pi is the narrow exception because exact header/path resume
-    // must preserve the captured cwd or refuse.
+    // Non-Pi spawn cwd is override-or-workspace (E56: ignore drifted state
+    // `.team/runtime/<team_key>/`). Pi resume uses captured agent.spawn_cwd
+    // already resolved above so exact-path header checks match capture.
     // 0.4.x provider effort MVP step 9: scrub CLAUDE_EFFORT for Claude
     // worker spawn so a parent shell env cannot silently override the
     // framework's effort decision.
@@ -1158,34 +1149,19 @@ fn json_team_identity_matches(existing: &serde_json::Value, compact: &serde_json
 /// returns: 非空的 session_name，缺失时退到默认名
 /// ---
 pub(super) fn state_session_name(state: &serde_json::Value) -> SessionName {
-    worker_session_name_from_state(state)
-        .map(SessionName::new)
-        .unwrap_or_else(|| SessionName::new("team-agent"))
-}
-
-fn worker_session_name_from_state(state: &serde_json::Value) -> Option<&str> {
     state
         .get("session_name")
         .and_then(|v| v.as_str())
         .filter(|s| !s.is_empty())
         .or_else(|| {
-            let team_key = state
-                .get("active_team_key")
-                .and_then(serde_json::Value::as_str)
-                .filter(|team_key| !team_key.is_empty())?;
             state
-                .get("teams")?
-                .get(team_key)?
-                .pointer("/leader_receiver/session_name")?
-                .as_str()
-                .filter(|session| !session.is_empty())
-        })
-        .or_else(|| {
-            state
-                .pointer("/leader_receiver/session_name")
-                .and_then(serde_json::Value::as_str)
-                .filter(|session| !session.is_empty())
+                .get("leader_receiver")
+                .and_then(|receiver| receiver.get("session_name"))
+                .and_then(|v| v.as_str())
+                .filter(|s| !s.is_empty())
         })
+        .map(SessionName::new)
+        .unwrap_or_else(|| SessionName::new("team-agent"))
 }
 
 /// ---
@@ -1193,7 +1169,40 @@ fn worker_session_name_from_state(state: &serde_json::Value) -> Option<&str> {
 /// returns: 记了则 true
 /// ---
 pub(super) fn session_name_present(state: &serde_json::Value) -> bool {
-    worker_session_name_from_state(state).is_some()
+    state
+        .get("session_name")
+        .and_then(|v| v.as_str())
+        .map(|s| !s.is_empty())
+        .unwrap_or(false)
+}
+
+/// Persist the session actually used for spawn when the selected team only
+/// had it on `leader_receiver`. Send/status route on `session_name`; an
+/// explicit null must stay a miss and must not rewrite a sibling team.
+pub(super) fn persist_selected_receiver_session_name(
+    state: &mut serde_json::Value,
+    session: &SessionName,
+) {
+    if session_name_present(state) {
+        return;
+    }
+    let Some(from_receiver) = state
+        .get("leader_receiver")
+        .and_then(|receiver| receiver.get("session_name"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|name| !name.is_empty())
+    else {
+        return;
+    };
+    if from_receiver != session.as_str() {
+        return;
+    }
+    if let Some(object) = state.as_object_mut() {
+        object.insert(
+            "session_name".to_string(),
+            serde_json::json!(session.as_str()),
+        );
+    }
 }
 
 /// ---
@@ -2291,6 +2300,27 @@ mod e36_transcript_backing_tests {
         }
     }
 
+    #[test]
+    fn agent_rollout_path_keeps_captured_exact_session_file() {
+        // Live T1 public session.captured (events-before.jsonl / events-after-t1.jsonl):
+        // rollout_path was already assigned before shutdown; resume must not
+        // invent a different file or drop the captured path.
+        let captured = "/Volumes/nvme/tmp/team-agent-live-0578-r2-3087abc5/.team/runtime/pi/claim-live-0578-r2/echo/sessions/2026-09-09T15-53-03-460Z_0dac7250-aa88-45be-aa3e-03a6833f9552.jsonl";
+        let agent = serde_json::json!({
+            "session_id": "0dac7250-aa88-45be-aa3e-03a6833f9552",
+            "rollout_path": captured,
+        });
+        let path = agent_rollout_path(&agent).expect("captured exact path");
+        assert_eq!(path.as_path().to_string_lossy(), captured);
+        assert!(
+            agent_rollout_path(&serde_json::json!({
+                "session_id": "0dac7250-aa88-45be-aa3e-03a6833f9552",
+            }))
+            .is_none(),
+            "session_id alone is not an exact session path"
+        );
+    }
+
     #[test]
     fn convergence_event_uses_central_scrub_and_preserves_required_failure() {
         let scratch = ScratchDir::new("event-log-central");