@team-agent/installer 0.3.2 → 0.3.4

package/crates/team-agent/src/mcp_server/lifecycle_tools/agent_ops.rs

@@ -0,0 +1,341 @@
+use std::path::{Path, PathBuf};
+
+use serde_json::Value;
+
+use crate::lifecycle::{ResetAgentOutcome, ResetRefusal};
+use crate::model::yaml::{self, Value as YamlValue};
+use crate::model::ids::{AgentId, TeamKey};
+
+use super::super::helpers::{enum_value, object_fields, tool_runtime_error};
+use super::super::{ToolOk, ToolResult};
+
+pub(crate) fn stop_agent(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+    agent_id: &str,
+) -> ToolResult {
+    let lifecycle_workspace = lifecycle_workspace(workspace, owner_team, true)?;
+    let report = crate::lifecycle::stop_agent(
+        &lifecycle_workspace,
+        &AgentId::new(agent_id),
+        owner_team.map(TeamKey::as_str),
+    )
+    .map_err(tool_runtime_error)?;
+    Ok(ToolOk {
+        fields: object_fields(serde_json::json!({
+            "ok": true,
+            "agent_id": report.agent_id.as_str(),
+            "status": "stopped",
+            "stopped": report.stopped,
+            "target": report.target,
+            "display_closed": report.display_closed,
+            "state_file": report.state_file.to_string_lossy().to_string(),
+        })),
+    })
+}
+
+pub(crate) fn reset_agent(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+    agent_id: &str,
+    discard_session: bool,
+) -> ToolResult {
+    if !discard_session {
+        return Ok(ToolOk {
+            fields: object_fields(serde_json::json!({
+                "ok": false,
+                "agent_id": agent_id,
+                "status": "refused",
+                "reason": "discard_session_required",
+            })),
+        });
+    }
+    let lifecycle_workspace = lifecycle_workspace(workspace, owner_team, true)?;
+    match crate::lifecycle::reset_agent(
+        &lifecycle_workspace,
+        &AgentId::new(agent_id),
+        discard_session,
+        false,
+        owner_team.map(TeamKey::as_str),
+    )
+    .map_err(tool_runtime_error)?
+    {
+        ResetAgentOutcome::Reset { env, start_mode } => Ok(ToolOk {
+            fields: object_fields(serde_json::json!({
+                "ok": true,
+                "agent_id": env.agent_id.as_str(),
+                "status": "reset",
+                "state_file": env.state_file.to_string_lossy().to_string(),
+                "coordinator_started": env.coordinator_started,
+                "start_mode": enum_value(start_mode),
+            })),
+        }),
+        ResetAgentOutcome::Refused { reason } => Ok(ToolOk {
+            fields: object_fields(serde_json::json!({
+                "ok": false,
+                "agent_id": agent_id,
+                "status": "refused",
+                "reason": reset_refusal_reason(reason),
+            })),
+        }),
+    }
+}
+
+pub(crate) fn fork_agent(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+    source_agent_id: &str,
+    as_agent_id: &str,
+    label: Option<&str>,
+) -> ToolResult {
+    let _ = label;
+    let lifecycle_workspace = lifecycle_workspace(workspace, owner_team, false)?;
+    let report = crate::lifecycle::launch::fork_agent(
+        &lifecycle_workspace,
+        &AgentId::new(source_agent_id),
+        &AgentId::new(as_agent_id),
+        false,
+        owner_team.map(TeamKey::as_str),
+    )
+    .map_err(tool_runtime_error)?;
+    Ok(ToolOk {
+        fields: object_fields(serde_json::json!({
+            "ok": true,
+            "status": "forked",
+            "source_agent_id": report.source_agent_id.as_str(),
+            "agent_id": report.new_agent_id.as_str(),
+            "new_agent_id": report.new_agent_id.as_str(),
+            "state_file": report.env.state_file.to_string_lossy().to_string(),
+            "coordinator_started": report.env.coordinator_started,
+            "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+        })),
+    })
+}
+
+fn reset_refusal_reason(reason: ResetRefusal) -> Value {
+    match reason {
+        ResetRefusal::DiscardSessionRequired => Value::String("discard_session_required".to_string()),
+    }
+}
+
+fn lifecycle_workspace(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+    prepare_state: bool,
+) -> Result<PathBuf, super::super::ToolError> {
+    let team = owner_team.map(TeamKey::as_str);
+    if let Ok(raw_state) = load_local_runtime_state(workspace) {
+        if let Some(path) = state_spec_workspace(&raw_state, team) {
+            return Ok(path);
+        }
+        if raw_state.get("agents").is_some() || raw_state.get("teams").is_some() {
+            return materialize_mcp_lifecycle_spec(workspace, raw_state, team, prepare_state);
+        }
+    }
+    if let Ok(selected) = crate::state::selector::resolve_active_team(
+        workspace,
+        team,
+        crate::state::selector::SelectorMode::RequireSpec,
+    ) {
+        if let Some(path) = selected.spec_workspace {
+            return Ok(path);
+        }
+    }
+    let state = crate::state::projection::select_runtime_state(workspace, team)
+        .map_err(tool_runtime_error)?;
+    if let Some(path) = state_spec_workspace(&state, team) {
+        return Ok(path);
+    }
+    Ok(workspace.to_path_buf())
+}
+
+fn state_spec_workspace(state: &Value, team: Option<&str>) -> Option<PathBuf> {
+    if let Some(team) = team {
+        if let Some(entry) = state
+            .get("teams")
+            .and_then(Value::as_object)
+            .and_then(|teams| teams.get(team))
+        {
+            if let Some(path) = state_spec_workspace_from_entry(entry) {
+                return Some(path);
+            }
+        }
+    }
+    state_spec_workspace_from_entry(state).or_else(|| {
+        let teams = state.get("teams").and_then(Value::as_object)?;
+        if teams.len() == 1 {
+            teams.values().next().and_then(state_spec_workspace_from_entry)
+        } else {
+            None
+        }
+    })
+}
+
+fn state_spec_workspace_from_entry(state: &Value) -> Option<PathBuf> {
+    state
+        .get("spec_path")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .and_then(|s| Path::new(s).parent().map(Path::to_path_buf))
+        .filter(|p| p.join("team.spec.yaml").exists())
+        .or_else(|| {
+            state
+                .get("team_dir")
+                .and_then(Value::as_str)
+                .filter(|s| !s.is_empty())
+                .map(PathBuf::from)
+                .filter(|p| p.join("team.spec.yaml").exists())
+        })
+}
+
+fn load_local_runtime_state(workspace: &Path) -> Result<Value, super::super::ToolError> {
+    let path = crate::state::persist::runtime_state_path(workspace);
+    let text = std::fs::read_to_string(&path).map_err(|e| {
+        tool_runtime_error(format!("read local runtime state {}: {e}", path.display()))
+    })?;
+    serde_json::from_str(&text).map_err(|e| {
+        tool_runtime_error(format!("parse local runtime state {}: {e}", path.display()))
+    })
+}
+
+fn materialize_mcp_lifecycle_spec(
+    workspace: &Path,
+    mut state: Value,
+    team: Option<&str>,
+    prepare_state: bool,
+) -> Result<PathBuf, super::super::ToolError> {
+    let team_name = team
+        .filter(|s| !s.is_empty())
+        .or_else(|| state.get("active_team_key").and_then(Value::as_str))
+        .unwrap_or("team");
+    let team_name = team_name.to_string();
+    let Some(agents) = selected_agents(&state, team) else {
+        return Ok(workspace.to_path_buf());
+    };
+    let mut agent_items = Vec::new();
+    let top_agents = state.get("agents").and_then(Value::as_object);
+    for (agent_id, agent_state) in agents {
+        let provider = agent_state
+            .get("provider")
+            .and_then(Value::as_str)
+            .or_else(|| {
+                top_agents
+                    .and_then(|all| all.get(agent_id))
+                    .and_then(|agent| agent.get("provider"))
+                    .and_then(Value::as_str)
+            })
+            .unwrap_or("fake");
+        agent_items.push(YamlValue::Map(vec![
+            ("id".to_string(), YamlValue::Str(agent_id.clone())),
+            ("provider".to_string(), YamlValue::Str(provider.to_string())),
+            ("role".to_string(), YamlValue::Str("Worker".to_string())),
+        ]));
+    }
+    if agent_items.is_empty() {
+        return Ok(workspace.to_path_buf());
+    }
+    let spec = YamlValue::Map(vec![
+        (
+            "team".to_string(),
+            YamlValue::Map(vec![
+                ("name".to_string(), YamlValue::Str(team_name.clone())),
+                (
+                    "objective".to_string(),
+                    YamlValue::Str("MCP lifecycle state-backed team".to_string()),
+                ),
+            ]),
+        ),
+        (
+            "leader".to_string(),
+            YamlValue::Map(vec![("provider".to_string(), YamlValue::Str("codex".to_string()))]),
+        ),
+        ("agents".to_string(), YamlValue::List(agent_items)),
+    ]);
+    let spec_workspace = workspace.join(".team").join(&team_name);
+    std::fs::create_dir_all(&spec_workspace).map_err(|e| {
+        tool_runtime_error(format!("create MCP lifecycle spec dir {}: {e}", spec_workspace.display()))
+    })?;
+    let spec_path = spec_workspace.join("team.spec.yaml");
+    std::fs::write(&spec_path, yaml::dumps(&spec)).map_err(|e| {
+        tool_runtime_error(format!("write MCP lifecycle spec {}: {e}", spec_path.display()))
+    })?;
+    if prepare_state {
+        prepare_selected_team_state(workspace, &mut state, &team_name, &spec_workspace, &spec_path)?;
+    }
+    Ok(spec_workspace)
+}
+
+fn selected_agents<'a>(
+    state: &'a Value,
+    team: Option<&str>,
+) -> Option<&'a serde_json::Map<String, Value>> {
+    team
+        .and_then(|team| {
+            state
+                .get("teams")
+                .and_then(Value::as_object)
+                .and_then(|teams| teams.get(team))
+                .and_then(|entry| entry.get("agents"))
+                .and_then(Value::as_object)
+        })
+        .or_else(|| state.get("agents").and_then(Value::as_object))
+}
+
+fn prepare_selected_team_state(
+    workspace: &Path,
+    state: &mut Value,
+    team: &str,
+    spec_workspace: &Path,
+    spec_path: &Path,
+) -> Result<(), super::super::ToolError> {
+    let Some(root) = state.as_object_mut() else {
+        return Ok(());
+    };
+    let top_session_name = root.get("session_name").cloned();
+    let top_leader_receiver = root.get("leader_receiver").cloned();
+    let top_agents = root.get("agents").and_then(Value::as_object).cloned();
+    let teams = root
+        .entry("teams".to_string())
+        .or_insert_with(|| Value::Object(serde_json::Map::new()));
+    let Some(teams) = teams.as_object_mut() else {
+        return Ok(());
+    };
+    let entry = teams
+        .entry(team.to_string())
+        .or_insert_with(|| Value::Object(serde_json::Map::new()));
+    let Some(entry) = entry.as_object_mut() else {
+        return Ok(());
+    };
+    if let Some(value) = top_session_name {
+        entry.entry("session_name".to_string()).or_insert(value);
+    }
+    if let Some(value) = top_leader_receiver {
+        entry.entry("leader_receiver".to_string()).or_insert(value);
+    }
+    entry.insert(
+        "team_dir".to_string(),
+        Value::String(spec_workspace.to_string_lossy().to_string()),
+    );
+    entry.insert(
+        "spec_path".to_string(),
+        Value::String(spec_path.to_string_lossy().to_string()),
+    );
+    if let Some(top_agents) = top_agents {
+        if let Some(team_agents) = entry.get_mut("agents").and_then(Value::as_object_mut) {
+            for (agent_id, top_agent) in top_agents {
+                let Some(team_agent) = team_agents.get_mut(&agent_id).and_then(Value::as_object_mut) else {
+                    continue;
+                };
+                let Some(top_agent) = top_agent.as_object() else {
+                    continue;
+                };
+                for (key, value) in top_agent {
+                    team_agent.entry(key.clone()).or_insert_with(|| value.clone());
+                }
+            }
+        }
+    }
+    crate::state::persist::save_runtime_state(workspace, state).map_err(|e| {
+        tool_runtime_error(format!("save MCP lifecycle scoped state {}: {e}", workspace.display()))
+    })
+}

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

@@ -0,0 +1,10 @@
+//! MCP lifecycle tool facades.
+//!
+//! S0 keeps the old placeholder behavior behind stable module boundaries so
+//! follow-up lanes can implement real lifecycle logic without touching tools.rs.
+
+mod agent_ops;
+mod state_status;
+
+pub(crate) use agent_ops::{fork_agent, reset_agent, stop_agent};
+pub(crate) use state_status::{get_team_status, update_state};

package/crates/team-agent/src/mcp_server/lifecycle_tools/state_status.rs

@@ -0,0 +1,158 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::model::ids::TeamKey;
+
+use super::super::helpers::{ensure_object, object_fields, tool_runtime_error};
+use super::super::{ToolOk, ToolResult};
+
+pub(crate) fn update_state(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+    note: &str,
+) -> ToolResult {
+    let selected = match crate::state::selector::resolve_active_team(
+        workspace,
+        owner_team.map(TeamKey::as_str),
+        crate::state::selector::SelectorMode::RequireSpec,
+    ) {
+        Ok(selected) => selected,
+        Err(err) if is_missing_active_spec(&err) => {
+            return update_state_without_spec(workspace, owner_team, note);
+        }
+        Err(err) => return Err(tool_runtime_error(err)),
+    };
+    let mut state = selected.state;
+    ensure_object(&mut state);
+    append_note(&mut state, note);
+    crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
+        .map_err(tool_runtime_error)?;
+    let spec_path = selected
+        .spec_path
+        .ok_or_else(|| tool_runtime_error("active team spec not found for update_state"))?;
+    let spec_workspace = spec_path.parent().ok_or_else(|| {
+        tool_runtime_error(format!("active team spec has no parent: {}", spec_path.display()))
+    })?;
+    let spec_text = std::fs::read_to_string(&spec_path).map_err(tool_runtime_error)?;
+    let spec = crate::model::yaml::loads(&spec_text).map_err(tool_runtime_error)?;
+    let path = crate::lifecycle::restart::write_team_state(spec_workspace, &spec, &state)
+        .map_err(tool_runtime_error)?;
+    Ok(update_state_ok(path))
+}
+
+fn update_state_without_spec(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+    note: &str,
+) -> ToolResult {
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        owner_team.map(TeamKey::as_str),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )
+    .map_err(tool_runtime_error)?;
+    let mut state = selected.state;
+    ensure_object(&mut state);
+    seed_legacy_team_key(&mut state, &selected.run_workspace, &selected.team_key);
+    append_note(&mut state, note);
+    crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
+        .map_err(tool_runtime_error)?;
+    let path = crate::lifecycle::restart::write_team_state(
+        &selected.run_workspace,
+        &crate::model::yaml::Value::Null,
+        &state,
+    )
+    .map_err(tool_runtime_error)?;
+    Ok(update_state_ok(path))
+}
+
+fn append_note(state: &mut Value, note: &str) {
+    if let Some(obj) = state.as_object_mut() {
+        let notes = obj
+            .entry("notes".to_string())
+            .or_insert_with(|| Value::Array(Vec::new()));
+        if !notes.is_array() {
+            *notes = Value::Array(Vec::new());
+        }
+        if let Some(items) = notes.as_array_mut() {
+            items.push(Value::String(note.to_string()));
+        }
+    }
+}
+
+fn seed_legacy_team_key(state: &mut Value, run_workspace: &Path, team_key: &str) {
+    if state.get("team_dir").and_then(Value::as_str).is_some()
+        || state.get("spec_path").and_then(Value::as_str).is_some()
+        || state.get("session_name").and_then(Value::as_str).is_some()
+    {
+        return;
+    }
+    if let Some(obj) = state.as_object_mut() {
+        obj.insert(
+            "team_dir".to_string(),
+            Value::String(
+                run_workspace
+                    .join(".team")
+                    .join(team_key)
+                    .to_string_lossy()
+                    .to_string(),
+            ),
+        );
+    }
+}
+
+fn update_state_ok(path: std::path::PathBuf) -> ToolOk {
+    let mut fields = serde_json::Map::new();
+    fields.insert("ok".to_string(), Value::Bool(true));
+    fields.insert(
+        "state_file".to_string(),
+        Value::String(path.to_string_lossy().to_string()),
+    );
+    ToolOk { fields }
+}
+
+fn is_missing_active_spec(err: &crate::state::StateError) -> bool {
+    matches!(
+        err,
+        crate::state::StateError::TeamSelect(message)
+            if message.starts_with("active team spec not found:")
+    )
+}
+
+pub(crate) fn get_team_status(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+) -> ToolResult {
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        owner_team.map(TeamKey::as_str),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )
+    .map_err(tool_runtime_error)?;
+    let status = crate::cli::status_port::status_scoped(
+        &selected.run_workspace,
+        &selected.state,
+        Some(selected.team_key.as_str()),
+        true,
+        false,
+    )
+    .map_err(tool_runtime_error)?;
+    let mut fields = object_fields(status);
+    fields
+        .entry("teams".to_string())
+        .or_insert_with(|| selected_team_only(&selected.state, &selected.team_key));
+    Ok(ToolOk { fields })
+}
+
+fn selected_team_only(state: &Value, team_key: &str) -> Value {
+    let mut teams = serde_json::Map::new();
+    if let Some(team) = state
+        .get("teams")
+        .and_then(Value::as_object)
+        .and_then(|all| all.get(team_key))
+    {
+        teams.insert(team_key.to_string(), team.clone());
+    }
+    Value::Object(teams)
+}

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

@@ -31,8 +31,8 @@
 //! 铁律 (card §11, Rust 绝不重蹈 Python 坑):
 //!   - **scope 锚 env, 禁候选扫描** (C13-C17/bug-064/082): sender identity =
 //!     spawn-time `TEAM_AGENT_ID`; scope = `TEAM_AGENT_OWNER_TEAM_ID`. `to="*"`
-//!     defaults to the sender team; `scope="workspace"` is the only cross-team
-//!     opt-in. A peer not in scope → typed [`ToolError`] with
+//!     defaults to the sender team; worker-origin RPC arguments cannot widen
+//!     that scope. A peer not in scope → typed [`ToolError`] with
 //!     [`ToolErrorReason::PeerNotInScope`] — never leak other-team peer names.
 //!   - **错误信封冗余键** (server.py:98-106): `reason == error_code` and
 //!     `message == error` are byte-stable downstream contracts — preserved verbatim
@@ -83,6 +83,7 @@ use crate::state::persist::{load_runtime_state, save_runtime_state};
 use crate::messaging::{self, DeliveryOutcome, MessageTarget, SendOptions};
 
 pub mod helpers;
+pub(crate) mod lifecycle_tools;
 pub mod normalize;
 pub mod tools;
 pub mod types;
@@ -107,77 +108,5 @@ pub(crate) use normalize::{
 };
 pub(crate) use wire::dispatch_tool;
 
-// ═══════════════════════════════════════════════════════════════════════════
-// CROSS-DEP PLACEHOLDERS — step 13 lifecycle / team_state surface not yet in tree.
-// The 13/15 sibling lanes are in flight; do NOT guess their authoritative names.
-// Leader reconciles these at integration.
-// ═══════════════════════════════════════════════════════════════════════════
-
-/// **PLACEHOLDER** — step 13 lifecycle `runtime.{stop,reset,add,fork}_agent`. The
-/// lifecycle lane is not yet in the tree; these tool handlers delegate to it. Minimal
-/// local stubs so the handler signatures compile and contracts can name the
-/// delegation. Leader swaps for the authoritative step-13 surface at integration.
-pub mod lifecycle_placeholder {
-    use super::*;
-
-    /// `runtime.stop_agent(workspace, agent_id)` (step 13).
-    pub fn stop_agent(workspace: &Path, agent_id: &str) -> Result<Value, McpError> {
-        let _ = workspace;
-        Ok(serde_json::json!({"ok": true, "status": "stopped", "agent_id": agent_id}))
-    }
-
-    /// `runtime.reset_agent(workspace, agent_id, discard_session)` (step 13).
-    pub fn reset_agent(workspace: &Path, agent_id: &str, discard_session: bool) -> Result<Value, McpError> {
-        let _ = workspace;
-        Ok(serde_json::json!({"ok": true, "status": "reset", "agent_id": agent_id, "discard_session": discard_session}))
-    }
-
-    /// `runtime.add_agent(workspace, new_agent_id, role_file_path)` (step 13).
-    pub fn add_agent(workspace: &Path, new_agent_id: &str, role_file_path: &str) -> Result<Value, McpError> {
-        let _ = workspace;
-        Ok(serde_json::json!({"ok": true, "status": "added", "agent_id": new_agent_id, "role_file_path": role_file_path}))
-    }
-
-    /// `runtime.fork_agent(workspace, source_agent_id, as_agent_id, label)` (step 13).
-    pub fn fork_agent(workspace: &Path, source_agent_id: &str, as_agent_id: &str, label: Option<&str>) -> Result<Value, McpError> {
-        let _ = workspace;
-        Ok(serde_json::json!({"ok": true, "status": "forked", "source_agent_id": source_agent_id, "agent_id": as_agent_id, "label": label}))
-    }
-
-    /// `runtime.status(workspace, as_json=true, compact=true)` (step 13 status
-    /// projection; `tools.py:328`).
-    pub fn runtime_status(workspace: &Path, compact: bool) -> Result<Value, McpError> {
-        let _ = (workspace, compact);
-        Ok(serde_json::json!({"ok": true, "status": "ok"}))
-    }
-
-    /// `state.write_team_state(workspace, spec, state)` (step 5/13 team_state.md
-    /// rewrite; `tools.py:324`). Step 5 persist exists, but this writer is not yet
-    /// exported; placeholder until the persist/lifecycle lane lands it.
-    pub fn write_team_state(workspace: &Path, spec: &Value, state: &Value) -> Result<PathBuf, McpError> {
-        let rel = spec
-            .get("context")
-            .and_then(|v| v.get("state_file"))
-            .and_then(Value::as_str)
-            .unwrap_or("team_state.md");
-        let path = workspace.join(rel);
-        if let Some(parent) = path.parent() {
-            std::fs::create_dir_all(parent)?;
-        }
-        let mut text = String::from("# Team State\n\n## Notes\n\n");
-        if let Some(notes) = state.get("notes").and_then(Value::as_array) {
-            for note in notes {
-                if let Some(note) = note.as_str() {
-                    text.push_str("- ");
-                    text.push_str(note);
-                    text.push('\n');
-                }
-            }
-        }
-        std::fs::write(&path, text)?;
-        Ok(path)
-    }
-}
-
 #[cfg(test)]
 mod tests;

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

@@ -185,5 +185,5 @@
         assert_eq!(refused["scope"], json!("team"));
         assert_eq!(refused["sender_team_id"], json!("teamA"));
         assert_eq!(refused["hint"],
-            json!("the requested peer is not part of your team. pass scope='workspace' to address peers in other teams."));
+            json!("the requested peer is not part of your team; worker-origin MCP cannot widen team scope."));
     }

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

@@ -154,22 +154,23 @@
         assert_eq!(env.get("reason"), Some(&json!("peer_not_in_scope")));
         assert_eq!(
             env.get("hint"),
-            Some(&json!("the requested peer is not part of your team. pass scope='workspace' to address peers in other teams."))
+            Some(&json!("the requested peer is not part of your team; worker-origin MCP cannot widen team scope."))
         );
     }
 
     #[test]
-    fn refuse_cross_team_peer_allows_workspace_scope_optin() {
+    fn refuse_cross_team_peer_rejects_workspace_scope_override_for_worker() {
         let tools = TeamOrchestratorTools::with_identity(
             Path::new("/tmp/ws"),
             Some(AgentId::new("worker-1")),
             Some(TeamKey::new("teamA")),
         );
-        // scope="workspace" → None (allowed to proceed)
-        assert!(tools.refuse_cross_team_peer(
+        // scope="workspace" is not worker consent to cross team boundaries.
+        let te = tools.refuse_cross_team_peer(
             &MessageTarget::Single("other-team-bob".to_string()),
             Some(Scope::Workspace),
-        ).is_none(), "workspace scope opts in to cross-team addressing");
+        ).expect("workspace scope override must still be refused for worker-origin MCP");
+        assert_eq!(te.reason, ToolErrorReason::McpScopeRefused);
     }
 
     #[test]