@team-agent/installer 0.3.1 → 0.3.3

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]