@team-agent/installer 0.5.60 → 0.5.61

package/crates/team-agent/src/leader/tests/identity.rs

@@ -130,7 +130,7 @@ fn leader_start_plan_external_leader_keeps_exec_provider_in_tmux() {
     std::fs::create_dir_all(&ws).unwrap();
 
     let provider_args = vec!["--".to_string(), "--model".to_string(), "opus".to_string()];
-    let plan = leader_start_plan(
+    let plan = crate::leader::start::leader_start_plan_after_ambient_authority_check(
         Provider::Fake,
         &provider_args,
         &ws,
@@ -202,7 +202,7 @@ fn managed_leader_uses_dedicated_leader_session_independent_of_state_session_nam
 
 #[test]
 #[serial_test::serial(env)]
-fn in_tmux_default_leader_runs_provider_in_current_pane() {
+fn in_tmux_default_leader_uses_managed_client_and_external_opt_out_keeps_exec_provider() {
     let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
     let ws = std::env::temp_dir().join(format!("ta_rs_lsp_switch_{}", std::process::id()));
     std::fs::create_dir_all(&ws).unwrap();
@@ -210,26 +210,65 @@ fn in_tmux_default_leader_runs_provider_in_current_pane() {
     let endpoint = format!("/private/tmp/tmux-501/{socket},88432,187");
     let _e = EnvGuard::apply(&[("TMUX", Some(&endpoint)), ("TMUX_PANE", Some("%7"))]);
 
-    let plan = leader_start_plan(Provider::Fake, &[], &ws, false, false, None, false).unwrap();
+    let managed = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        false,
+    )
+    .unwrap();
 
-    assert_eq!(plan.mode, LeaderStartMode::ExecProvider);
-    assert!(!plan.is_external_leader);
-    assert!(plan.session_name.is_none());
-    assert_eq!(plan.leader_window, None);
-    assert_eq!(plan.argv, vec!["fake".to_string()]);
+    assert_eq!(
+        managed.mode,
+        LeaderStartMode::ManagedTmuxClient,
+        "N41 managed default: an in-tmux caller on the workspace server must use the managed client path"
+    );
+    assert!(!managed.is_external_leader);
+    assert!(managed.session_name.is_some());
+    assert_eq!(
+        managed.leader_window.as_ref().map(WindowName::as_str),
+        Some("fake")
+    );
     assert!(
-        !plan
+        managed.argv.iter().any(|arg| arg == "switch-client")
+            && !managed.argv.iter().any(|arg| arg == "attach-session"),
+        "N41 managed default: same-server dispatch must switch the existing client, not nested-attach: {:?}",
+        managed.argv
+    );
+    assert_eq!(managed.provider_argv, vec!["fake".to_string()]);
+
+    let external = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        true,
+    )
+    .unwrap();
+
+    assert_eq!(external.mode, LeaderStartMode::ExecProvider);
+    assert!(external.is_external_leader);
+    assert_eq!(external.leader_window, None);
+    assert_eq!(external.argv, vec!["fake".to_string()]);
+    assert_eq!(external.provider_argv, vec!["fake".to_string()]);
+    assert!(
+        !external
             .argv
             .iter()
             .any(|arg| arg == "switch-client" || arg == "attach-session"),
-        "in-tmux default launch must not create or attach a background leader session: {:?}",
-        plan.argv
+        "N41 external opt-out: explicit external topology must remain a direct provider path: {:?}",
+        external.argv
     );
 }
 
 #[test]
 #[serial_test::serial(env)]
-fn in_tmux_default_leader_does_not_refuse_different_tmux_server() {
+fn in_tmux_external_opt_out_keeps_exec_provider_across_server_boundary() {
     let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
     let _e = EnvGuard::apply(&[
         ("TMUX", Some("/private/tmp/tmux-501/default,88432,187")),
@@ -238,12 +277,21 @@ fn in_tmux_default_leader_does_not_refuse_different_tmux_server() {
     let ws = std::env::temp_dir().join(format!("ta_rs_lsp_refuse_{}", std::process::id()));
     std::fs::create_dir_all(&ws).unwrap();
 
-    let plan = leader_start_plan(Provider::Fake, &[], &ws, false, false, None, false).unwrap();
+    let plan = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        true,
+    )
+    .unwrap();
 
     assert_eq!(plan.mode, LeaderStartMode::ExecProvider);
-    assert!(!plan.is_external_leader);
-    assert!(plan.session_name.is_none());
+    assert!(plan.is_external_leader);
     assert_eq!(plan.argv, vec!["fake".to_string()]);
+    assert_eq!(plan.provider_argv, vec!["fake".to_string()]);
 }
 
 #[test]
@@ -420,45 +468,4 @@ fn p2_leader_detect_divergence_catches_owner_uuid_split() {
 // refactor must also update these tests.
 // ═══════════════════════════════════════════════════════════════════════
 
-#[test]
-fn unit0_leader_session_prefix_constant_is_stable() {
-    // Pinned: the literal leader session prefix that gates "is this a
-    // leader session" decisions everywhere in the runtime.
-    assert_eq!(
-        crate::leader::start::LEADER_SESSION_PREFIX,
-        "team-agent-leader-"
-    );
-    // The layout module re-exports the same value (kept in sync via
-    // const re-export).
-    assert_eq!(
-        crate::layout::sessions::LEADER_SESSION_PREFIX,
-        crate::leader::start::LEADER_SESSION_PREFIX
-    );
-}
-
-#[test]
-fn unit0_leader_prefixed_name_must_never_be_taken_as_worker_session() {
-    // Pinned invariant fed into unit-1 typed identity: any session
-    // name starting with `LEADER_SESSION_PREFIX` is a leader launcher
-    // session, never a worker session. unit-1 will wrap this rule in
-    // typed constructors (`WorkerSession::new` rejects the prefix,
-    // `LeaderLauncherSession::new` requires it).
-    let leader = "team-agent-leader-claude-x-aaaaaaaaaaaa";
-    let worker = "team-real-worker";
-    let prefix = crate::leader::start::LEADER_SESSION_PREFIX;
-    assert!(leader.starts_with(prefix));
-    assert!(!worker.starts_with(prefix));
-    // Symmetry: the runtime today uses this exact check
-    // (cli/mod.rs:261 `starts_with(LEADER_SESSION_PREFIX)`) to spare
-    // leader sessions during shutdown.
-    let leader_name = crate::transport::SessionName::new(leader);
-    let worker_name = crate::transport::SessionName::new(worker);
-    assert!(
-        crate::layout::sessions::is_leader_session(&leader_name),
-        "is_leader_session must accept a leader-prefixed session",
-    );
-    assert!(
-        !crate::layout::sessions::is_leader_session(&worker_name),
-        "is_leader_session must reject a non-prefixed session",
-    );
-}
+include!("identity_session_names.rs");

package/crates/team-agent/src/leader/tests/identity_session_names.rs

@@ -0,0 +1,42 @@
+#[test]
+fn unit0_leader_session_prefix_constant_is_stable() {
+    // Pinned: the literal leader session prefix that gates "is this a
+    // leader session" decisions everywhere in the runtime.
+    assert_eq!(
+        crate::leader::start::LEADER_SESSION_PREFIX,
+        "team-agent-leader-"
+    );
+    // The layout module re-exports the same value (kept in sync via
+    // const re-export).
+    assert_eq!(
+        crate::layout::sessions::LEADER_SESSION_PREFIX,
+        crate::leader::start::LEADER_SESSION_PREFIX
+    );
+}
+
+#[test]
+fn unit0_leader_prefixed_name_must_never_be_taken_as_worker_session() {
+    // Pinned invariant fed into unit-1 typed identity: any session
+    // name starting with `LEADER_SESSION_PREFIX` is a leader launcher
+    // session, never a worker session. unit-1 will wrap this rule in
+    // typed constructors (`WorkerSession::new` rejects the prefix,
+    // `LeaderLauncherSession::new` requires it).
+    let leader = "team-agent-leader-claude-x-aaaaaaaaaaaa";
+    let worker = "team-real-worker";
+    let prefix = crate::leader::start::LEADER_SESSION_PREFIX;
+    assert!(leader.starts_with(prefix));
+    assert!(!worker.starts_with(prefix));
+    // Symmetry: the runtime today uses this exact check
+    // (cli/mod.rs:261 `starts_with(LEADER_SESSION_PREFIX)`) to spare
+    // leader sessions during shutdown.
+    let leader_name = crate::transport::SessionName::new(leader);
+    let worker_name = crate::transport::SessionName::new(worker);
+    assert!(
+        crate::layout::sessions::is_leader_session(&leader_name),
+        "is_leader_session must accept a leader-prefixed session",
+    );
+    assert!(
+        !crate::layout::sessions::is_leader_session(&worker_name),
+        "is_leader_session must reject a non-prefixed session",
+    );
+}

package/crates/team-agent/src/lib.rs

@@ -50,6 +50,10 @@ pub mod state;
 // step 6 (compiler) — TEAM.md + agents/*.md → 规范 team.spec dict(doc→spec 纯变换)。
 pub mod compiler;
 
+// Official communication-mode catalog. Configuration compilation and every
+// future projection consumer must use this typed single source of truth.
+pub mod communication_mode;
+
 // step 7 (message_store) — team.db 上的核心消息生命周期(create/claim/mark/通知去重)。
 // unit-10 (Stage 4) compat shim. Physical home is now `crate::db::message_store`.
 pub use crate::db::message_store;

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

@@ -126,7 +126,7 @@ pub fn fork_agent_with_transport(
         new_agent,
         Some(as_agent_id.as_str()),
         provider,
-    );
+    )?;
     let system_prompt =
         crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
     let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(

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

@@ -120,7 +120,7 @@ pub(super) fn spawn_agents(
             agent,
             Some(agent_id_raw),
             provider,
-        );
+        )?;
         let system_prompt =
             crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
         let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(

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

@@ -1635,7 +1635,7 @@ fn write_start_agent_start_event(
         agent,
         Some(agent_id.as_str()),
         provider,
-    );
+    )?;
     let system_prompt =
         crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
     let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(

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

@@ -220,7 +220,7 @@ pub(super) fn spawn_agent_window(
         agent,
         Some(agent_id.as_str()),
         provider,
-    );
+    )?;
     let system_prompt =
         crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
     let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(

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

@@ -1,5 +1,6 @@
 use std::path::Path;
 
+use crate::communication_mode::CommunicationMode;
 use crate::lifecycle::types::{DangerousApproval, LifecycleError};
 use crate::model::enums::{Enforcement, Provider};
 use crate::model::ids::AgentId;
@@ -12,15 +13,10 @@ output. All communication must go through Team Agent MCP tools.
 
 ## Communication (mandatory)
 
-- Progress, blockers, questions: team_orchestrator.send_message(to='leader', content='...')
 - Coordinate with teammate: team_orchestrator.send_message(to='<agent_id>', content='...')
 - Broadcast to all teammates: team_orchestrator.send_message(to='*', content='...')
 - Task complete: team_orchestrator.report_result(summary='...') — call exactly once
 
-When you receive a message from the leader or a teammate, you MUST respond
-through MCP tools. Writing a reply in your terminal does nothing — the sender
-will never see it.
-
 ## Rules
 
 - Do not pass sender, task_id, or schema_version — the MCP runtime fills them.
@@ -45,6 +41,7 @@ pub(crate) struct WorkerCommandAgent {
     system_prompt_inline: Option<String>,
     system_prompt_file: Option<String>,
     output_contract_format: Option<String>,
+    communication_mode: CommunicationMode,
 }
 
 impl WorkerCommandAgent {
@@ -52,9 +49,9 @@ impl WorkerCommandAgent {
         agent: &crate::model::yaml::Value,
         fallback_id: Option<&str>,
         provider: Provider,
-    ) -> Self {
+    ) -> Result<Self, LifecycleError> {
         let system_prompt = agent.get("system_prompt");
-        Self {
+        Ok(Self {
             id: agent
                 .get("id")
                 .and_then(crate::model::yaml::Value::as_str)
@@ -90,16 +87,21 @@ impl WorkerCommandAgent {
                 .and_then(|contract| contract.get("format"))
                 .and_then(crate::model::yaml::Value::as_str)
                 .map(str::to_string),
-        }
+            communication_mode: communication_mode(
+                agent
+                    .get("communication_mode")
+                    .and_then(crate::model::yaml::Value::as_str),
+            )?,
+        })
     }
 
     pub(crate) fn from_json(
         agent: &serde_json::Value,
         fallback_id: Option<&str>,
         provider: Provider,
-    ) -> Self {
+    ) -> Result<Self, LifecycleError> {
         let system_prompt = agent.get("system_prompt");
-        Self {
+        Ok(Self {
             id: agent
                 .get("id")
                 .and_then(serde_json::Value::as_str)
@@ -135,7 +137,12 @@ impl WorkerCommandAgent {
                 .and_then(|contract| contract.get("format"))
                 .and_then(serde_json::Value::as_str)
                 .map(str::to_string),
-        }
+            communication_mode: communication_mode(
+                agent
+                    .get("communication_mode")
+                    .and_then(serde_json::Value::as_str),
+            )?,
+        })
     }
 }
 
@@ -149,6 +156,7 @@ pub(crate) fn compile_worker_system_prompt(
     let mut chunks = vec![
         identity_section(agent),
         runtime_contract_section(),
+        agent.communication_mode.runtime_contract().to_string(),
         role_body(agent)?,
     ];
     if let Some(contract) = output_contract(agent) {
@@ -197,6 +205,14 @@ fn runtime_contract_section() -> String {
     RUNTIME_CONTRACT_SECTION.to_string()
 }
 
+fn communication_mode(value: Option<&str>) -> Result<CommunicationMode, LifecycleError> {
+    let Some(value) = value else {
+        return Ok(CommunicationMode::default());
+    };
+    CommunicationMode::parse(value)
+        .ok_or_else(|| LifecycleError::Compile(format!("unknown communication_mode {value:?}")))
+}
+
 fn identity_section(agent: &WorkerCommandAgent) -> String {
     format!(
         "You are Team Agent worker `{}` with role `{}`. When asked about your role or identity, answer with this Team Agent worker identity first, not only the generic provider product identity.",
@@ -291,6 +307,7 @@ mod tests {
             system_prompt_inline: None,
             system_prompt_file: None,
             output_contract_format: None,
+            communication_mode: CommunicationMode::default(),
         };
         let tools =
             resolved_tool_strings_for_command(&agent, Provider::ClaudeCode, &disabled_safety())
@@ -335,6 +352,7 @@ mod tests {
             system_prompt_inline: Some("Implement the assigned slice.".to_string()),
             system_prompt_file: None,
             output_contract_format: Some("result_envelope_v1".to_string()),
+            communication_mode: CommunicationMode::default(),
         };
         let prompt = compile_worker_system_prompt(&agent).unwrap();
         assert!(

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

@@ -260,6 +260,7 @@ pub fn compact_tool_result(result: &Value) -> ToolResult {
             "notification_channel",
             "notification_event_id",
             "warnings",
+            "warning",
         ]
     };
     for key in keys {

package/crates/team-agent/src/mcp_server/tests/send.rs

@@ -78,6 +78,7 @@ fn send_outcome_worker_accepted_envelope_byte_stable() {
     let outcome = SendOutcome::WorkerAccepted {
         message_id: "42".to_string(),
         poll_via: "team-agent inbox 42".to_string(),
+        warning: None,
     };
     let v = outcome.to_value();
     assert_eq!(
@@ -160,6 +161,7 @@ fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
         Ok(SendOutcome::WorkerAccepted {
             message_id,
             poll_via,
+            ..
         }) => {
             assert!(!message_id.is_empty());
             assert_eq!(poll_via, format!("team-agent inbox {message_id}"));
@@ -353,6 +355,30 @@ fn send_message_leader_recipient_is_direct_not_accepted() {
     );
 }
 
+#[test]
+fn send_message_mailbox_is_durable_without_live_injection() {
+    let tools = TeamOrchestratorTools::with_identity(
+        &unique_ws("send-leader-mailbox"),
+        Some(AgentId::new("worker-1")),
+        Some(TeamKey::new("teamA")),
+    );
+    let mailbox = json!(true);
+    let outcome = tools
+        .send_message_with_presentation(
+            &MessageTarget::Single("leader".to_string()),
+            "stored update",
+            None,
+            None,
+            None,
+            Some(&mailbox),
+            None,
+        )
+        .expect("mailbox send persists");
+    let value = outcome.to_value();
+    assert_eq!(value.get("status"), Some(&json!("stored_only")));
+    assert!(value.get("message_id").and_then(Value::as_str).is_some());
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // CROSS-TEAM PRE-REFUSAL (C23) — refuse_cross_team_peer (tools.py:185-213)
 // ════════════════════════════════════════════════════════════════════════

package/crates/team-agent/src/mcp_server/tests/wire.rs

@@ -79,7 +79,7 @@ fn tools_contract_has_thirteen_tools_in_order() {
         .unwrap();
     assert_eq!(
             send["description"],
-            json!("Send a message to a teammate, the leader, or '*' for all other team members. Team Agent fills identity and delivery metadata; optional presentation routing is durable and never drops the message.")
+            json!("Send a message to a teammate, the leader, or '*' for all other team members. mailbox=true stores durably without live injection; the default is live delivery.")
         );
     assert_eq!(send["inputSchema"]["additionalProperties"], json!(false));
     assert_eq!(send["inputSchema"]["required"], json!(["to", "content"]));