@team-agent/installer 0.5.120 → 0.5.122

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

@@ -26,17 +26,122 @@ use std::sync::atomic::{AtomicU64, Ordering};
 
 use crate::lifecycle::restart::classify_restart_plan_with_resume_validation;
 use crate::lifecycle::types::ResumeDecision;
-use crate::provider::session_scan::cursor::{
-    cursor_session_archive_present, cursor_session_dir,
-};
+use crate::model::ids::AgentId;
+use crate::provider::session_scan::cursor::{cursor_session_archive_present, cursor_session_dir};
 use crate::state::persist::{load_runtime_state, save_runtime_state};
 use serial_test::serial;
-use crate::model::ids::AgentId;
 use team_agent::lifecycle::{
-    fork_agent_with_transport, quick_start_with_transport_in_workspace, restart_with_transport,
+    cursor_mcp_project_dir, fork_agent_with_transport, quick_start_with_transport_in_workspace,
+    restart_with_transport,
 };
 use team_agent::transport::test_support::OfflineTransport;
 
+#[test]
+#[serial(env)]
+fn issue345_dynamic_cursor_start_persists_its_generated_mcp_path() {
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-dynamic-mcp");
+    let (ws, _home, _guard, team) = seed_cursor("dynamic-mcp");
+    std::fs::write(
+        team.join("agents/cursor_writer.md"),
+        "---\nprovider: fake\ndangerously_skip_permissions: true\n---\nControl seat.\n",
+    )
+    .unwrap();
+    let transport = OfflineTransport::new();
+    quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &transport)
+        .unwrap();
+    let role = team.join("cursor_dynamic.md");
+    std::fs::write(&role, "---\nprovider: cursor_agent\nmodel: grok-4.7-high\nauth_mode: subscription\ndangerously_skip_permissions: true\n---\nDynamic Cursor seat.\n").unwrap();
+    crate::lifecycle::add_agent_with_transport(
+        &team,
+        &AgentId::new("cursor_dynamic"),
+        &role,
+        false,
+        Some("cursortm"),
+        &transport,
+    )
+    .unwrap();
+    let state = load_runtime_state(&ws).unwrap();
+    let expected = ws.join(".team/runtime/mcp/cursor_dynamic.json");
+    assert!(
+        expected.is_file(),
+        "positive control: spawn generated the real config"
+    );
+    assert_eq!(
+        state["agents"]["cursor_dynamic"]["mcp_config"].as_str(),
+        expected.to_str()
+    );
+    assert_eq!(
+        state["teams"]["cursortm"]["agents"]["cursor_dynamic"]["mcp_config"].as_str(),
+        expected.to_str()
+    );
+    let config: serde_json::Value =
+        serde_json::from_slice(&std::fs::read(&expected).unwrap()).unwrap();
+    assert_eq!(
+        config["mcpServers"]["team_orchestrator"]["env"]["TEAM_AGENT_ID"],
+        "cursor_dynamic"
+    );
+    assert_eq!(
+        config["mcpServers"]["team_orchestrator"]["env"]["TEAM_AGENT_OWNER_TEAM_ID"],
+        "cursortm"
+    );
+}
+
+#[test]
+#[serial(env)]
+fn issue345_cursor_wakeup_restores_missing_derived_mcp_path() {
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-wakeup-mcp");
+    let (ws, _home, _guard, team) = seed_cursor("wakeup-mcp");
+    let transport = OfflineTransport::new();
+    quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &transport)
+        .unwrap();
+    crate::lifecycle::restart::stop_agent_with_transport(
+        &ws,
+        &AgentId::new("cursor_writer"),
+        Some("cursortm"),
+        &transport,
+    )
+    .unwrap();
+    let mut state = load_runtime_state(&ws).unwrap();
+    state["agents"]["cursor_writer"]
+        .as_object_mut()
+        .unwrap()
+        .remove("mcp_config");
+    state["teams"]["cursortm"]["agents"]["cursor_writer"]
+        .as_object_mut()
+        .unwrap()
+        .remove("mcp_config");
+    // Plant an actual legacy row; ordinary state saves intentionally backfill fields.
+    std::fs::write(
+        crate::state::persist::runtime_state_path(&ws),
+        serde_json::to_vec(&state).unwrap(),
+    )
+    .unwrap();
+    assert!(load_runtime_state(&ws).unwrap()["agents"]["cursor_writer"]
+        .get("mcp_config")
+        .is_none());
+    crate::lifecycle::restart::start_agent_with_transport(
+        &ws,
+        &AgentId::new("cursor_writer"),
+        false,
+        false,
+        true,
+        Some("cursortm"),
+        &transport,
+    )
+    .unwrap();
+    let after = load_runtime_state(&ws).unwrap();
+    let expected = ws.join(".team/runtime/mcp/cursor_writer.json");
+    assert!(expected.is_file());
+    assert_eq!(
+        after["agents"]["cursor_writer"]["mcp_config"].as_str(),
+        expected.to_str()
+    );
+    assert_eq!(
+        after["teams"]["cursortm"]["agents"]["cursor_writer"]["mcp_config"].as_str(),
+        expected.to_str()
+    );
+}
+
 #[test]
 #[serial(env)]
 fn cursor_fresh_spawn_does_not_invent_session_id() {
@@ -86,11 +191,16 @@ fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &first)
         .expect("initial cursor start");
     let sid = "502896a1-72ba-4c53-9a86-b2da28780806";
+    let primary = cursor_mcp_project_dir(&ws, "cursor_writer").unwrap();
+    let primary_before = std::fs::canonicalize(&primary).unwrap();
     let dir = {
         let path = home
             .join(".cursor")
             .join("chats")
-            .join("00a437742b92089861da7821a62f232a")
+            .join(format!(
+                "{:x}",
+                md5::compute(primary.to_string_lossy().as_bytes())
+            ))
             .join(sid);
         std::fs::create_dir_all(&path).unwrap();
         std::fs::write(path.join("store.db"), b"").unwrap();
@@ -100,8 +210,28 @@ fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
     assert_eq!(cursor_session_dir(sid).as_deref(), Some(dir.as_path()));
 
     let mut state = load_runtime_state(&ws).expect("load");
-    patch_cursor_writer(&mut state, sid, &dir, &ws);
-    save_runtime_state(&ws, &state).expect("save captured");
+    assert_eq!(
+        state["agents"]["cursor_writer"]["spawn_cwd"],
+        primary.to_string_lossy().as_ref()
+    );
+    patch_cursor_writer(&mut state, sid, &dir, &primary);
+    state["agents"]["cursor_writer"]
+        .as_object_mut()
+        .unwrap()
+        .remove("mcp_config");
+    state["teams"]["cursortm"]["agents"]["cursor_writer"]
+        .as_object_mut()
+        .unwrap()
+        .remove("mcp_config");
+    // Preserve the real captured SID while removing only the derived config path.
+    std::fs::write(
+        crate::state::persist::runtime_state_path(&ws),
+        serde_json::to_vec(&state).unwrap(),
+    )
+    .unwrap();
+    assert!(load_runtime_state(&ws).unwrap()["agents"]["cursor_writer"]
+        .get("mcp_config")
+        .is_none());
 
     seed_healthy_coordinator(&ws);
 
@@ -121,6 +251,30 @@ fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
         !argv.iter().any(|a| a == "--continue"),
         "resume argv must not use --continue; argv={argv:?}"
     );
+    let after = load_runtime_state(&ws).unwrap();
+    assert_eq!(
+        after["agents"]["cursor_writer"]["spawn_cwd"],
+        primary.to_string_lossy().as_ref()
+    );
+    assert_eq!(after["agents"]["cursor_writer"]["session_id"], sid);
+    let expected_config = ws.join(".team/runtime/mcp/cursor_writer.json");
+    assert_eq!(
+        after["agents"]["cursor_writer"]["mcp_config"].as_str(),
+        expected_config.to_str()
+    );
+    assert_eq!(
+        after["teams"]["cursortm"]["agents"]["cursor_writer"]["mcp_config"].as_str(),
+        expected_config.to_str()
+    );
+    assert_eq!(
+        cursor_mcp_project_dir(&ws, "cursor_writer").unwrap(),
+        primary_before
+    );
+    assert_eq!(argv_flag(&argv, "--workspace").as_deref(), primary.to_str());
+    assert!(argv_contains_adjacent(
+        &argv,
+        &["--add-dir", ws.to_str().unwrap()]
+    ));
 }
 
 #[test]

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

@@ -651,10 +651,10 @@ fn contract_b_delivery_gate_trusts_startup_handled_state_over_pane_scrollback()
             "SUB step2 probe: handled startup trust must deliver despite scrollback residue.",
             None,
             true,
-            None,
+            Some("subprep-scrollback"),
         )
         .unwrap();
-    let handled_state = json!({
+    let mut handled_state = json!({
         "session_name": "team-ta-subroot-SUB-PROBE-2-send-turn-idle",
         "agents": {
             "w1": {
@@ -670,9 +670,15 @@ fn contract_b_delivery_gate_trusts_startup_handled_state_over_pane_scrollback()
             }
         }
     });
+    #[cfg(unix)]
+    let pane = crate::mcp_server::readiness::test_ready_worker(
+        &handled_ws, &mut handled_state, "subprep-scrollback", "w1", "%7",
+    );
     team_agent::state::persist::save_runtime_state(&handled_ws, &handled_state).unwrap();
     let handled_transport =
         RecordingTransport::new(vec![SUBROOT_FULL_TRUST_PANE_AFTER_QUICKSTART.to_string()]);
+    #[cfg(unix)]
+    { handled_transport.state.lock().unwrap().carrier = pane.pane_pid; }
     let handled_log = EventLog::new(&handled_ws);
     let handled = deliver_pending_message(
         &handled_ws,
@@ -720,8 +726,12 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
     let ws = tmp_dir("b-step2-trust-retry");
     let mcp_config = ws.join(".team").join("runtime").join("mcp").join("w1.json");
     std::fs::create_dir_all(mcp_config.parent().unwrap()).unwrap();
-    std::fs::write(&mcp_config, "{}").unwrap();
-    let state = json!({
+    // This worker genuinely depends on MCP. Bind the controlled receipt to the
+    // live test carrier rather than bypassing readiness with an empty config.
+    let owner = "subprep-trust-retry";
+    let mut state = json!({
+        "team_key": owner,
+        "active_team_key": owner,
         "session_name": "team-ta-subroot-SUB-PROBE-2-send-turn-idle",
         "team_dir": ws.join("teamdir").to_string_lossy().to_string(),
         "agents": {
@@ -736,6 +746,21 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
             }
         }
     });
+    #[cfg(unix)]
+    let carrier = {
+        let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+        state["agents"]["w1"]["pane_pid"] = json!(carrier);
+        state["agents"]["w1"]["spawned_at"] =
+            json!((chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
+        carrier
+    };
+    state["teams"] = json!({owner: state.clone()});
+    std::fs::write(&mcp_config, serde_json::to_vec(&json!({
+        "mcpServers": {"team_orchestrator": {
+            "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
+            "env": {"TEAM_AGENT_WORKSPACE": ws.to_path_buf(), "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": owner}
+        }}
+    })).unwrap()).unwrap();
     team_agent::state::persist::save_runtime_state(&ws, &state).unwrap();
 
     let store = MessageStore::open(&ws).unwrap();
@@ -748,7 +773,7 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
             "SUB step2 probe: reply with one sentence and call report_result exactly once.",
             None,
             true,
-            None,
+            Some(owner),
         )
         .unwrap();
     let transport = RecordingTransport::new(vec![
@@ -759,6 +784,10 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
     ])
     .with_session_present(true)
     .with_windows(vec![WindowName::new("w1")]);
+    #[cfg(unix)]
+    {
+        transport.state.lock().unwrap().carrier = Some(carrier);
+    }
     let event_log = EventLog::new(&ws);
 
     let deferred =
@@ -787,6 +816,13 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
         "fixture sanity: delivery defer must be observable as delivery.deferred_startup_prompt"
     );
 
+    // No receipt existed during the actionable trust prompt. Once startup
+    // control can progress, model the successful live helper handshake before
+    // the coordinator retries this SAME queued row.
+    #[cfg(unix)]
+    {
+        crate::mcp_server::readiness::publish(&ws, owner, "w1", chrono::Utc::now()).unwrap();
+    }
     let coord = Coordinator::new(
         WorkspacePath::new(ws.to_path_buf()),
         Box::new(RealAdapterRegistry),
@@ -1045,6 +1081,7 @@ struct TransportState {
     session_present: bool,
     windows: Vec<WindowName>,
     spawn_argv: Vec<Vec<String>>,
+    carrier: Option<u32>,
 }
 
 #[derive(Debug, Clone)]
@@ -1189,7 +1226,19 @@ impl Transport for RecordingTransport {
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        Ok(self.state.lock().unwrap().carrier.map(|carrier| PaneInfo {
+            pane_id: PaneId::new("%7"),
+            session: SessionName::new("team-ta-subroot-SUB-PROBE-2-send-turn-idle"),
+            window_index: None,
+            window_name: Some(WindowName::new("w1")),
+            pane_index: None,
+            tty: None,
+            current_command: None,
+            current_path: None,
+            active: true,
+            pane_pid: Some(carrier),
+            leader_env: BTreeMap::new(),
+        }).into_iter().collect())
     }
 
     fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {

package/crates/team-agent/src/mcp_server/mod.rs

@@ -89,6 +89,8 @@ use crate::messaging::{self, DeliveryOutcome, MessageTarget, SendOptions, Truste
 pub mod helpers;
 pub(crate) mod lifecycle_tools;
 pub mod normalize;
+#[cfg(unix)]
+pub(crate) mod readiness;
 pub mod tools;
 pub mod types;
 pub mod wire;