@team-agent/installer 0.5.121 → 0.5.122

package/Cargo.lock

@@ -727,7 +727,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.121"
+version = "0.5.122"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -11,7 +11,7 @@ exclude = ["crates/team-agent-contract"]
 
 [workspace.package]
 edition = "2021"
-version = "0.5.121"
+version = "0.5.122"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/coordinator/tests/health_sync.rs

@@ -15,6 +15,7 @@ use super::*;
 /// agent. `has_session`→true (gate passes); `inject`→Ok (delivery may run); the rest are Ok defaults.
 struct CapturingTransport {
     scrollback: String,
+    targets: Vec<PaneInfo>,
 }
 impl Transport for CapturingTransport {
     fn kind(&self) -> BackendKind {
@@ -73,7 +74,7 @@ impl Transport for CapturingTransport {
         Ok(PaneLiveness::Live)
     }
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        Ok(self.targets.clone())
     }
     fn has_session(&self, _s: &SessionName) -> Result<bool, TransportError> {
         Ok(true)
@@ -106,6 +107,14 @@ impl Transport for CapturingTransport {
 fn seeded_health_coord(
     agents: serde_json::Value,
     scrollback: &str,
+) -> (Coordinator, std::path::PathBuf) {
+    seeded_health_coord_with_readiness(agents, scrollback, false)
+}
+
+fn seeded_health_coord_with_readiness(
+    agents: serde_json::Value,
+    scrollback: &str,
+    ready: bool,
 ) -> (Coordinator, std::path::PathBuf) {
     use std::sync::atomic::{AtomicU64, Ordering};
     static N: AtomicU64 = AtomicU64::new(0);
@@ -115,11 +124,18 @@ fn seeded_health_coord(
         N.fetch_add(1, Ordering::Relaxed)
     ));
     std::fs::create_dir_all(&dir).unwrap();
-    crate::state::persist::save_runtime_state(
-        &dir,
-        &serde_json::json!({ "session_name": "team-health", "agents": agents }),
-    )
-    .unwrap();
+    let mut state = serde_json::json!({ "session_name": "team-health", "agents": agents });
+    #[cfg(unix)]
+    let targets = if ready {
+        vec![crate::mcp_server::readiness::test_ready_worker(
+            &dir, &mut state, "current", "w1", "%1",
+        )]
+    } else {
+        Vec::new()
+    };
+    #[cfg(not(unix))]
+    let targets = { let _ = ready; Vec::new() };
+    crate::state::persist::save_runtime_state(&dir, &state).unwrap();
     let ws = WorkspacePath::new(dir.clone());
     let reg: Box<dyn ProviderRegistry> = Box::new(MockRegistry::new(&[], &[]));
     let coord = Coordinator::for_test(
@@ -127,6 +143,7 @@ fn seeded_health_coord(
         reg,
         Box::new(CapturingTransport {
             scrollback: scrollback.to_string(),
+            targets,
         }),
         None,
         None,
@@ -260,10 +277,12 @@ fn spine2_capture_missing_captures_session_id_for_missing_agent() {
 // activity/agent_health WORKING remains diagnostic turn state.
 #[test]
 fn spine2_sync_health_working_status_delivers_same_tick() {
-    let (coord, dir) = seeded_health_coord(one_agent("codex"), "Working (5s · esc to interrupt)");
+    let (coord, dir) = seeded_health_coord_with_readiness(
+        one_agent("codex"), "Working (5s · esc to interrupt)", true,
+    );
     let store = MessageStore::open(&dir).unwrap();
     let mid = store
-        .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
+        .create_message(Some("t"), "leader", "w1", "hi", None, true, Some("current"))
         .unwrap();
     let conn = crate::db::schema::open_db(store.db_path()).unwrap();
     conn.execute(

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

@@ -1410,6 +1410,9 @@ pub(super) fn mark_agent_started(
         "spawn_cwd".to_string(),
         serde_json::json!(spawn.spawn_cwd.to_string_lossy().to_string()),
     );
+    if let Some(path) = &spawn.mcp_config_path {
+        agent.insert("mcp_config".to_string(), serde_json::json!(path));
+    }
     // 0.4.6 Stage 1+2: ensure spawn_epoch is present after every start.
     // reset_agent_at_paths bumps it before start; non-reset starts
     // initialise to 1 (or preserve existing) so capture/event paths can

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

@@ -45,6 +45,8 @@ pub(super) struct SpawnedAgentWindow {
     pub profile_launch: crate::provider::ProviderProfileLaunch,
     pub layout_placement: Option<crate::lifecycle::launch::LayoutPlacement>,
     pub spawn_cwd: std::path::PathBuf,
+    /// Actual configuration generated for this spawn, not inferred from old state.
+    pub mcp_config_path: Option<std::path::PathBuf>,
     /// Issue 2 (Round 3b gate review §6): the resolved `owner_team_id` used
     /// for this spawn's MCP env / command. Callers (`mark_agent_respawned`,
     /// `mark_agent_started`) must persist this back into the agent row so
@@ -701,6 +703,7 @@ pub(super) fn spawn_agent_window(
         profile_launch,
         layout_placement: layout_placement.cloned(),
         spawn_cwd: native_spawn_cwd,
+        mcp_config_path,
         owner_team_id: team_id,
     })
 }

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

@@ -2480,6 +2480,9 @@ fn mark_agent_respawned(
         "spawn_cwd".to_string(),
         serde_json::json!(spawn.spawn_cwd.to_string_lossy().to_string()),
     );
+    if let Some(path) = &spawn.mcp_config_path {
+        agent.insert("mcp_config".to_string(), serde_json::json!(path));
+    }
     // 0.5.38 (`.team/artifacts/startup-latency-locate.md` §7): every
     // multi-worker restart respawn is a fresh process cohort. The
     // pre-0.5.38 code only wrote `spawned_at` here and left `spawn_epoch`
@@ -2968,6 +2971,7 @@ impl Clone for ParallelSpawnResult {
                 profile_launch: self.spawn.profile_launch.clone(),
                 layout_placement: self.spawn.layout_placement.clone(),
                 spawn_cwd: self.spawn.spawn_cwd.clone(),
+                mcp_config_path: self.spawn.mcp_config_path.clone(),
                 owner_team_id: self.spawn.owner_team_id.clone(),
             },
             spawn_start: self.spawn_start,
@@ -4232,6 +4236,7 @@ tasks:
             profile_launch: crate::provider::ProviderProfileLaunch::default(),
             layout_placement: None,
             spawn_cwd: std::path::PathBuf::from("/tmp/team-epoch"),
+            mcp_config_path: None,
             owner_team_id: None,
         };
         mark_agent_respawned(

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

@@ -59,6 +59,14 @@ fn b4_monitor_step_failure_does_not_block_deliver_pending() {
     let _g = EnvGuard::set(&[(ANCESTRY_KEY, NEUTRAL_ANCESTRY)]);
     let ws = tmp_ws("b4-monitor");
     seed_copilot_team_state(&ws, "cp1", true);
+    let mut state = team_agent::state::persist::load_runtime_state(&ws).unwrap();
+    #[cfg(unix)]
+    let targets = vec![crate::mcp_server::readiness::test_ready_worker(
+        &ws, &mut state, "team-b4", "cp1", "%41",
+    )];
+    #[cfg(not(unix))]
+    let targets = Vec::new();
+    save_runtime_state(&ws, &state).unwrap();
     let store = MessageStore::open(&ws).unwrap();
     store
         .create_message(
@@ -68,14 +76,17 @@ fn b4_monitor_step_failure_does_not_block_deliver_pending() {
             "do the thing",
             None,
             false,
-            None,
+            Some("team-b4"),
         )
         .unwrap();
 
     let coord = Coordinator::new(
         WorkspacePath::new(ws.clone()),
         Box::new(RealRegistry),
-        Box::new(MonitorFailTransport::new()),
+        Box::new(MonitorFailTransport {
+            targets,
+            ..MonitorFailTransport::new()
+        }),
     );
     let report = coord.tick();
 
@@ -603,11 +614,13 @@ fn attach_socket_path(command: &str) -> Option<PathBuf> {
 /// (B-4). Sessions/windows present so the tick proceeds to the monitor steps.
 struct MonitorFailTransport {
     session: Mutex<bool>,
+    targets: Vec<PaneInfo>,
 }
 impl MonitorFailTransport {
     fn new() -> Self {
         Self {
             session: Mutex::new(true),
+            targets: Vec::new(),
         }
     }
 }
@@ -688,7 +701,7 @@ impl Transport for MonitorFailTransport {
         }
     }
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        Ok(self.targets.clone())
     }
     fn list_windows(&self, _s: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         Ok(vec![WindowName::new("cp1")])

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

@@ -36,6 +36,112 @@ use team_agent::lifecycle::{
 };
 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() {
@@ -109,7 +215,23 @@ fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
         primary.to_string_lossy().as_ref()
     );
     patch_cursor_writer(&mut state, sid, &dir, &primary);
-    save_runtime_state(&ws, &state).expect("save captured");
+    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);
 
@@ -135,6 +257,15 @@ fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
         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

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,

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

@@ -273,9 +273,6 @@ pub(crate) fn preflight(
     let Some(agent) = state.get("agents").and_then(|agents| agents.get(agent_id)) else {
         return Ok(None);
     };
-    let Some(config) = agent.get("mcp_config").and_then(Value::as_str) else {
-        return Ok(None);
-    };
     let provider = agent
         .get("provider")
         .and_then(Value::as_str)
@@ -284,6 +281,11 @@ pub(crate) fn preflight(
     if !crate::provider::get_adapter(provider).requires_worker_mcp_handshake() {
         return Ok(None);
     }
+    let config = agent
+        .get("mcp_config")
+        .and_then(Value::as_str)
+        .filter(|path| !path.trim().is_empty())
+        .ok_or("mcp_handshake_config_missing")?;
     let owner = owner
         .filter(|s| !s.is_empty())
         .ok_or("mcp_handshake_scope_missing")?;
@@ -427,6 +429,67 @@ pub(crate) fn test_carrier_pid() -> Option<u32> {
     crate::platform::process::current_parent_pid()
 }
 
+/// Bind a controlled live test helper through the real receipt publisher. This
+/// does not bypass preflight or fabricate a process/image/ancestry receipt.
+#[cfg(test)]
+pub(crate) fn test_ready_worker(
+    workspace: &Path,
+    state: &mut Value,
+    owner: &str,
+    agent: &str,
+    pane: &str,
+) -> PaneInfo {
+    let workspace = workspace.canonicalize().unwrap();
+    let carrier = test_carrier_pid().unwrap();
+    let config = workspace
+        .join(".team/runtime/mcp")
+        .join(format!("{agent}.json"));
+    std::fs::create_dir_all(config.parent().unwrap()).unwrap();
+    std::fs::write(&config, serde_json::to_vec(&serde_json::json!({
+        "mcpServers": {"team_orchestrator": {
+            "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
+            "env": {"TEAM_AGENT_WORKSPACE": workspace, "TEAM_AGENT_ID": agent, "TEAM_AGENT_OWNER_TEAM_ID": owner}
+        }}
+    })).unwrap()).unwrap();
+    state["team_key"] = serde_json::json!(owner);
+    state["active_team_key"] = serde_json::json!(owner);
+    let row = &mut state["agents"][agent];
+    row["mcp_config"] = serde_json::json!(config);
+    row["pane_id"] = serde_json::json!(pane);
+    row["pane_pid"] = serde_json::json!(carrier);
+    row["spawned_at"] =
+        serde_json::json!((Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
+    let window = row["window"].as_str().unwrap_or(agent).to_string();
+    let session = state["session_name"].as_str().unwrap().to_string();
+    if state["teams"][owner].is_object() {
+        state["teams"][owner]["agents"][agent] = state["agents"][agent].clone();
+    }
+    publish(&workspace, owner, agent, Utc::now()).unwrap();
+    let target = PaneInfo {
+        pane_id: crate::transport::PaneId::new(pane),
+        session: crate::transport::SessionName::new(session),
+        window_index: None,
+        window_name: Some(crate::transport::WindowName::new(window)),
+        pane_index: None,
+        tty: None,
+        current_command: None,
+        current_path: Some(workspace.clone()),
+        active: true,
+        pane_pid: Some(carrier),
+        leader_env: Default::default(),
+    };
+    let admission = preflight(&workspace, Some(owner), agent, state)
+        .unwrap()
+        .unwrap();
+    revalidate(
+        &admission,
+        &Target::Pane(target.pane_id.clone()),
+        std::slice::from_ref(&target),
+    )
+    .unwrap();
+    target
+}
+
 #[cfg(test)]
 #[path = "readiness_tests.rs"]
 mod tests;

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

@@ -94,6 +94,29 @@ impl Drop for Case {
     }
 }
 
+#[test]
+fn issue345_missing_mcp_config_does_not_disable_eager_admission() {
+    for provider in ["cursor_agent", "codex", "claude"] {
+        let mut case = Case::new();
+        case.state["agents"]["worker"]["provider"] = json!(provider);
+        case.state["agents"]["worker"]
+            .as_object_mut()
+            .unwrap()
+            .remove("mcp_config");
+        assert!(
+            case.admission().is_err(),
+            "missing config cannot disable {provider} admission"
+        );
+        for value in [Value::Null, json!(false), json!(""), json!(" ")] {
+            case.state["agents"]["worker"]["mcp_config"] = value;
+            assert!(
+                case.admission().is_err(),
+                "invalid config cannot disable {provider} admission"
+            );
+        }
+    }
+}
+
 #[test]
 fn missing_handshake_defers_then_a_live_scoped_receipt_admits() {
     let case = Case::new();
@@ -238,5 +261,12 @@ fn fake_and_pi_keep_their_existing_non_eager_or_runtime_registry_admission() {
         assert!(preflight(&case.ws, Some("owner"), "worker", &state)
             .unwrap()
             .is_none());
+        state["agents"]["worker"]
+            .as_object_mut()
+            .unwrap()
+            .remove("mcp_config");
+        assert!(preflight(&case.ws, Some("owner"), "worker", &state)
+            .unwrap()
+            .is_none());
     }
 }

package/crates/team-agent/src/messaging/delivery_consumption_tests.rs

@@ -122,9 +122,20 @@ fn successful_transport_report_does_not_override_unconsumed_composer() {
         "[Pasted text #1 +25 lines]",
         "foreign draft",
     ] {
-        let f = Fixture::new("cursor_agent");
+        let mut f = Fixture::new("cursor_agent");
+        #[cfg(unix)]
+        let panes = vec![crate::mcp_server::readiness::test_ready_worker(
+            &f.workspace,
+            &mut f.state,
+            "team",
+            "worker",
+            "%1",
+        )];
+        #[cfg(not(unix))]
+        let panes = f.transport().list_targets().unwrap();
         let t = f
             .transport()
+            .with_targets(panes)
             .with_native_input_observation(frame(composer, ""));
         let out = f.deliver(&t);
         assert!(!out.ok, "composer={composer}");

package/crates/team-agent/src/messaging/tests/dup_inject.rs

@@ -66,6 +66,30 @@ fn eager_mcp_waits_without_spending_input_attempts_then_delivers_the_same_messag
     assert_eq!(transport.inject_count(), 1, "same queued row proceeds after the real receipt");
 }
 
+#[test]
+#[cfg(unix)]
+fn issue345_missing_eager_config_defers_without_input_or_attempts() {
+    let mut case = WorkerCase::new("missing-mcp-config", "cursor_agent");
+    let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+    case.state["team_key"] = serde_json::json!("dup-team");
+    case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
+    case.state["agents"]["w1"]["spawned_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
+    case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
+    crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
+    let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
+    let message_id = case.store.create_message(None, "leader", "w1", "missing config canary", None, false, Some("dup-team")).unwrap();
+    for _ in 0..3 {
+        let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
+            &message_id, &case.event_log, &case.state).unwrap();
+        assert!(!outcome.ok);
+        assert!(outcome.verification.as_deref().unwrap().starts_with("mcp_handshake_"));
+        assert_eq!(transport.inject_count(), 0, "missing metadata must never reach input");
+    }
+    let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
+    let attempts: i64 = connection.query_row("select delivery_attempts from messages where message_id=?1", [&message_id], |row| row.get(0)).unwrap();
+    assert_eq!(attempts, 0, "metadata wait is not an input attempt");
+}
+
 #[test]
 fn error_retry_claim_is_single_winner_across_two_delivers() {
     let case = WorkerCase::new("claim-gate", "fake");
@@ -141,10 +165,30 @@ fn observer_state_save_failure_after_enter_does_not_return_err() {
 
 #[test]
 fn pane_token_refuses_second_inject_for_claude_grok_cursor() {
-    for provider in ["claude", "grok", "cursor"] {
-        let case = WorkerCase::new(&format!("token-{provider}"), provider);
-        let transport = RecordingTransport::new("");
-        let message_id = case.seed_leader_to_worker(&format!("{provider} canary"));
+    for provider in ["claude", "grok", "cursor_agent"] {
+        let mut case = WorkerCase::new(&format!("token-{provider}"), provider);
+        #[cfg(unix)]
+        let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+        #[cfg(not(unix))]
+        let carrier = std::process::id();
+        let config = case.workspace.join(".team/runtime/mcp/w1.json");
+        std::fs::create_dir_all(config.parent().unwrap()).unwrap();
+        std::fs::write(&config, serde_json::to_vec(&serde_json::json!({
+            "mcpServers": {"team_orchestrator": {
+                "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
+                "env": {"TEAM_AGENT_WORKSPACE": case.workspace, "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": "dup-team"}
+            }}
+        })).unwrap()).unwrap();
+        case.state["team_key"] = serde_json::json!("dup-team");
+        case.state["agents"]["w1"]["mcp_config"] = serde_json::json!(config);
+        case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
+        case.state["agents"]["w1"]["spawned_at"] = serde_json::json!((chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
+        case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
+        crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
+        #[cfg(unix)]
+        crate::mcp_server::readiness::publish(&case.workspace, "dup-team", "w1", chrono::Utc::now()).unwrap();
+        let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
+        let message_id = case.store.create_message(None, "leader", "w1", &format!("{provider} canary"), None, false, Some("dup-team")).unwrap();
         let first = deliver_pending_message(
             &case.workspace,
             &case.store,

package/crates/team-agent/src/messaging/tests/spine.rs

@@ -169,7 +169,10 @@ fn p2_scheduler_unknown_kind_surfaces_error() {
 
 /// A delivery transport whose `inject` RECORDS-and-succeeds (the real deliver loop legitimately
 /// injects; the §84-guard NoopTransport panics). Only `inject` is reached by deliver_pending_message.
-struct DeliverOkTransport;
+#[derive(Default)]
+struct DeliverOkTransport {
+    targets: Vec<PaneInfo>,
+}
 impl Transport for DeliverOkTransport {
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
@@ -232,7 +235,7 @@ impl Transport for DeliverOkTransport {
         Ok(PaneLiveness::Unknown)
     }
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        Ok(self.targets.clone())
     }
     fn has_session(&self, _s: &SessionName) -> Result<bool, TransportError> {
         Ok(true)
@@ -333,9 +336,9 @@ fn spine_delivery_skips_queued_statuses() {
         .unwrap();
     set_message_status(&store, &qidle, "queued_until_idle");
     set_message_status(&store, &qstart, "queued_until_start");
-    let state = serde_json::json!({"agents": {"w1": {}}});
+    let state = serde_json::json!({"agents": {"w1": {"provider": "fake"}}});
 
-    let _ = deliver_pending_messages(&ws, &state, &DeliverOkTransport, &log).unwrap();
+    let _ = deliver_pending_messages(&ws, &state, &DeliverOkTransport::default(), &log).unwrap();
 
     assert_eq!(
         message_status_of(&store, &qidle),
@@ -359,9 +362,9 @@ fn spine_delivery_busy_recipient_is_injected_without_idle_deferral() {
     let mid = store
         .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
         .unwrap();
-    let state = serde_json::json!({"agents": {"w1": {"status": "busy"}}});
+    let state = serde_json::json!({"agents": {"w1": {"provider": "fake", "status": "busy"}}});
 
-    let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport, &log).unwrap();
+    let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport::default(), &log).unwrap();
 
     assert!(delivered.contains(&mid));
     assert_eq!(message_status_of(&store, &mid), "delivered");
@@ -380,11 +383,39 @@ fn spine_delivery_pi_cursor_uses_v113_direct_input_without_idle_scope() {
         let store = store_for(&ws);
         let log = EventLog::new(&ws);
         let mid = store
-            .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
+            .create_message(Some("t"), "leader", "w1", "hi", None, true, Some("spine-team"))
             .unwrap();
-        let state = serde_json::json!({"agents": {"w1": {"provider": provider, "status": "running"}}});
-        let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport, &log).unwrap();
-        assert!(delivered.contains(&mid), "{provider}");
+        #[cfg(unix)]
+        let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+        #[cfg(not(unix))]
+        let carrier = std::process::id();
+        let config = ws.join(".team/runtime/mcp/w1.json");
+        std::fs::create_dir_all(config.parent().unwrap()).unwrap();
+        std::fs::write(&config, serde_json::to_vec(&serde_json::json!({
+            "mcpServers": {"team_orchestrator": {
+                "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
+                "env": {"TEAM_AGENT_WORKSPACE": ws, "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": "spine-team"}
+            }}
+        })).unwrap()).unwrap();
+        let mut state = serde_json::json!({"team_key": "spine-team", "active_team_key": "spine-team", "session_name": "spine", "agents": {"w1": {
+            "provider": provider, "status": "running", "window": "w1", "mcp_config": config,
+            "spawned_at": (chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339(),
+            "pane_id": "%spine", "pane_pid": carrier
+        }}});
+        state["teams"] = serde_json::json!({"spine-team": state.clone()});
+        crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+        #[cfg(unix)]
+        if provider == "cursor_agent" {
+            crate::mcp_server::readiness::publish(&ws, "spine-team", "w1", chrono::Utc::now()).unwrap();
+        }
+        let transport = DeliverOkTransport { targets: vec![PaneInfo {
+            pane_id: PaneId::new("%spine"), session: SessionName::new("spine"),
+            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(),
+        }] };
+        let delivered = deliver_pending_messages(&ws, &state, &transport, &log).unwrap();
+        assert!(delivered.contains(&mid), "{provider}: {:?}", read_event_log(&ws));
         assert_eq!(message_status_of(&store, &mid), "delivered");
     }
 }
@@ -405,9 +436,9 @@ fn contract_alive_worker_with_working_health_is_deliverable_not_deferred() {
         .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
         .unwrap();
     seed_agent_health(&store, "w1", "WORKING"); // turn-level state — must NOT gate delivery
-    let state = serde_json::json!({"agents": {"w1": {"status": "running"}}}); // lifecycle: alive
+    let state = serde_json::json!({"agents": {"w1": {"provider": "fake", "status": "running"}}}); // lifecycle: alive
 
-    let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport, &log).unwrap();
+    let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport::default(), &log).unwrap();
 
     let events = read_event_log(&ws);
     let deferred: Vec<_> = events
@@ -530,7 +561,7 @@ fn spine_delivery_injects_resolvable_target_not_bare_agent_pane() {
     // in-team, non-busy agent -> deliver proceeds; the session-qualified resolution uses session_name + window.
     let state = serde_json::json!({
         "session_name": "team-x",
-        "agents": {"w1": {"status": "idle", "window": "w1"}}
+        "agents": {"w1": {"provider": "fake", "status": "idle", "window": "w1"}}
     });
     let transport = OfflineTransport::new();
 
@@ -585,7 +616,7 @@ fn spine_delivery_injects_rendered_protocol_block_not_raw_content() {
         .unwrap();
     let state = serde_json::json!({
         "session_name": "team-x",
-        "agents": {"w1": {"status": "idle", "window": "w1"}}
+        "agents": {"w1": {"provider": "fake", "status": "idle", "window": "w1"}}
     });
     let transport = OfflineTransport::new();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.121",
+  "version": "0.5.122",
   "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.121",
-    "@team-agent/cli-darwin-x64": "0.5.121",
-    "@team-agent/cli-linux-x64": "0.5.121"
+    "@team-agent/cli-darwin-arm64": "0.5.122",
+    "@team-agent/cli-darwin-x64": "0.5.122",
+    "@team-agent/cli-linux-x64": "0.5.122"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",