@team-agent/installer 0.5.100 → 0.5.102

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

@@ -290,67 +290,6 @@
         );
     }
 
-    // ════════════════════════════════════════════════════════════════════════
-    // CONTROL-PLANE: request_human creates a requires_ack leader message → needs_human
-    // (tools.py:342-346). sender = explicit > env > "unknown" (never leader).
-    //
-    // Post-#230 N31/N32 funnel (cr-approved I-3): request_human routes through the
-    // shared leader-delivery primitive (`send_to_leader_receiver`) instead of doing a
-    // raw `store.create_message` bypass. Return shape from the caller's perspective is
-    // unchanged: `status="needs_human"` + a populated `message_id`. With no leader
-    // pane bound in this fixture, the primitive's I-4 rebind_required path STILL
-    // persists the message row and returns its `message_id` — audit + rebind replay
-    // both depend on it.
-    // ════════════════════════════════════════════════════════════════════════
-    #[test]
-    fn request_human_returns_needs_human_with_message_id() {
-        let tools = TeamOrchestratorTools::with_identity(
-            &unique_ws("request-human"),
-            Some(AgentId::new("worker-3")),
-            Some(TeamKey::new("teamA")),
-        );
-        let ok = tools.request_human("need approval", Some("task-1"), None)
-            .expect("request_human ok");
-        let v = serde_json::to_value(&ok).unwrap();
-        assert_eq!(v.get("status"), Some(&json!("needs_human")));
-        assert!(v.get("message_id").and_then(Value::as_str).is_some(),
-            "request_human must return the created leader message_id (persisted for rebind audit even on I-4 rebind_required)");
-    }
-
-    // ════════════════════════════════════════════════════════════════════════
-    // CONTROL-PLANE: update_state appends a note + returns state_file (tools.py:316-325)
-    // ════════════════════════════════════════════════════════════════════════
-    #[test]
-    fn update_state_returns_ok_and_state_file_path() {
-        let ws = seed_state_ws(
-            "update-state",
-            &json!({
-                "active_team_key": "teamA",
-                "team_key": "teamA",
-                "session_name": "teamA",
-                "status": "alive",
-                "teams": {
-                    "teamA": {
-                        "team_key": "teamA",
-                        "session_name": "teamA",
-                        "status": "alive",
-                        "agents": {}
-                    }
-                }
-            }),
-        );
-        let tools = TeamOrchestratorTools::with_identity(
-            &ws,
-            Some(AgentId::new("leader")),
-            Some(TeamKey::new("teamA")),
-        );
-        let ok = tools.update_state("checkpoint note").expect("update_state ok");
-        let v = serde_json::to_value(&ok).unwrap();
-        assert_eq!(v.get("ok"), Some(&json!(true)));
-        assert!(v.get("state_file").and_then(Value::as_str).is_some(),
-            "update_state returns the rewritten team_state.md path");
-    }
-
     // ════════════════════════════════════════════════════════════════════════
     // RpcId / RpcResponse byte-stability — null id echoed, error frame shape.
     // ════════════════════════════════════════════════════════════════════════

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

@@ -1,19 +1,9 @@
 #[test]
 fn mcp_tool_wire_names_and_parse_roundtrip() {
     let names = [
-        (McpTool::AssignTask, "assign_task"),
         (McpTool::SendMessage, "send_message"),
         (McpTool::ReportResult, "report_result"),
-        (McpTool::UpdateState, "update_state"),
         (McpTool::GetTeamStatus, "get_team_status"),
-        (McpTool::StopAgent, "stop_agent"),
-        (McpTool::ResetAgent, "reset_agent"),
-        (McpTool::AddAgent, "add_agent"),
-        (McpTool::CloneAgent, "clone_agent"),
-        (McpTool::ForkAgent, "fork_agent"),
-        (McpTool::RequestHuman, "request_human"),
-        (McpTool::StuckList, "stuck_list"),
-        (McpTool::StuckCancel, "stuck_cancel"),
     ];
     for (tool, name) in names {
         assert_eq!(tool.wire_name(), name);
@@ -45,27 +35,13 @@ fn rpc_method_classify() {
 // tools_contract — TOOLS wire list, exact names+order
 // ════════════════════════════════════════════════════════════════════════
 #[test]
-fn tools_contract_has_thirteen_tools_in_order() {
+fn tools_contract_has_three_tools_in_order() {
     let tools = tools_contract();
-    assert_eq!(tools.len(), 13);
+    assert_eq!(tools.len(), 3);
     let got: Vec<&str> = tools.iter().map(|t| t["name"].as_str().unwrap()).collect();
     assert_eq!(
         got,
-        vec![
-            "assign_task",
-            "send_message",
-            "report_result",
-            "update_state",
-            "get_team_status",
-            "stop_agent",
-            "reset_agent",
-            "add_agent",
-            "clone_agent",
-            "fork_agent",
-            "request_human",
-            "stuck_list",
-            "stuck_cancel",
-        ]
+        vec!["send_message", "report_result", "get_team_status"]
     );
     // each carries description + inputSchema
     for t in &tools {
@@ -89,32 +65,11 @@ fn tools_contract_has_thirteen_tools_in_order() {
             "{internal} is framework-owned, not caller-supplied"
         );
     }
-    let clone = tools
+    let status = tools
         .iter()
-        .find(|tool| tool["name"] == json!("clone_agent"))
+        .find(|tool| tool["name"] == json!("get_team_status"))
         .unwrap();
-    assert_eq!(
-        clone["description"],
-        json!("Clone a worker role into a fresh provider session.")
-    );
-    assert_eq!(clone["inputSchema"]["additionalProperties"], json!(false));
-    assert_eq!(
-        clone["inputSchema"]["required"],
-        json!(["source_agent_id", "as_agent_id"])
-    );
-    assert_eq!(
-        clone["inputSchema"]["properties"]
-            .as_object()
-            .unwrap()
-            .keys()
-            .cloned()
-            .collect::<BTreeSet<_>>(),
-        BTreeSet::from([
-            "as_agent_id".to_string(),
-            "label".to_string(),
-            "source_agent_id".to_string(),
-        ])
-    );
+    assert_eq!(status["description"], json!("Return machine-readable team status."));
 }
 
 #[test]

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

@@ -1,25 +1,8 @@
-//! ---
-//! purpose: MCP no-compaction contract test with fixture-owned workspace and path provenance
-//! contract:
-//!   provides:
-//!     - name: mcp_state_fixture
-//!       what: supplies explicit process-owned workspace and state-file paths without mutating process-global environment
-//!     - name: mcp_state_path_provenance
-//!       what: records raw/canonical workspace, resolved state path, and filesystem ownership facts
-//!   depends:
-//!     - crate::mcp_server::lifecycle_tools::state_status
-//!     - crate::state::selector
-//! boundary:
-//!   - the owned no-compaction test writes only within its fixture root
-//!   - this suite does not alter persistence semantics
-//! maturity: wired
-//! ---
-//! step 14a · mcp_server::tests — WAVE-2 RED contracts (Python v0.2.11 golden).
+//! MCP server unit-test fixtures and focused stdio/wire contract tests.
 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use super::*;
 use serde_json::json;
-use sha2::{Digest, Sha256};
 use std::path::{Path, PathBuf};
 
 // ── helpers ──────────────────────────────────────────────────────────────
@@ -35,11 +18,9 @@ fn keys(v: &Value) -> Vec<String> {
     v.as_object().unwrap().keys().cloned().collect()
 }
 
-/// A UNIQUE throwaway workspace dir per test (mirrors the state/coordinator idiom):
-/// tests that open the db (MessageStore) or write the filesystem MUST NOT share
-/// `/tmp/ws`, or they flake under parallel cargo (sqlite "database is locked" / NotFound).
-/// Pure-function / dispatch-shape tests that never touch fs/db keep a dummy fixed path.
-fn unique_ws(tag: &str) -> std::path::PathBuf {
+/// A UNIQUE throwaway workspace dir per test. Filesystem and database tests
+/// must not share `/tmp/ws` under parallel cargo.
+fn unique_ws(tag: &str) -> PathBuf {
     use std::io::ErrorKind;
     use std::sync::atomic::{AtomicU64, Ordering};
     static N: AtomicU64 = AtomicU64::new(0);
@@ -54,183 +35,6 @@ fn unique_ws(tag: &str) -> std::path::PathBuf {
     }
 }
 
-static MCP_FIXTURE_SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
-
-/// One process-owned root for update_state tests. All paths are passed explicitly
-/// to the code under test; the fixture never changes process-global environment.
-struct McpStateFixture {
-    root: PathBuf,
-    workspace: PathBuf,
-    receipt: PathBuf,
-}
-
-impl McpStateFixture {
-    fn new(_tag: &str) -> Self {
-        let seq = MCP_FIXTURE_SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-        let base = if cfg!(target_os = "macos") {
-            PathBuf::from("/private/tmp")
-        } else {
-            PathBuf::from("/tmp")
-        };
-        let raw_root = base.join(format!("ta-mcp-{}-{seq}", std::process::id()));
-        std::fs::create_dir(&raw_root).unwrap();
-        let root = std::fs::canonicalize(raw_root).unwrap();
-        let workspace = root.join("workspace");
-        let receipt = root
-            .parent()
-            .unwrap()
-            .join(format!("ta-mcp-receipt-{}-{seq}.json", std::process::id()));
-        std::fs::create_dir(&workspace).unwrap();
-
-        let fixture = Self {
-            root,
-            workspace,
-            receipt,
-        };
-        fixture.seed_spec("team_state.md");
-        crate::state::repository::StateRepository::new(&fixture.workspace)
-            .save(
-                crate::state::repository::StateWriteIntent::FakeE2eSeed,
-                &json!({
-                    "session_name": "mcp-fixture",
-                    "active_team_key": "current",
-                    "agents": {},
-                    "tasks": []
-                }),
-            )
-            .unwrap();
-        fixture
-    }
-
-    fn seed_spec(&self, state_file: &str) {
-        std::fs::write(
-            self.workspace.join("team.spec.yaml"),
-            format!(
-                "team:\n  name: mcp-fixture\n  objective: path contract\nagents: []\ntasks: []\ncontext:\n  state_file: {state_file}\n"
-            ),
-        )
-        .unwrap();
-    }
-
-    fn state_file(&self, relative: &str) -> PathBuf {
-        self.workspace.join(relative)
-    }
-
-    fn record_provenance(&self, raw_workspace: &Path, state_file: &Path) -> PathBuf {
-        let canonical_workspace =
-            crate::model::paths::canonical_run_workspace(raw_workspace).unwrap();
-        assert!(self.under_root(raw_workspace));
-        assert!(self.under_root(&canonical_workspace));
-        assert!(self.under_root(state_file));
-        let team_dir = self.workspace.join(".team");
-        let runtime_dir = team_dir.join("runtime");
-        let runtime_state = crate::state::persist::runtime_state_path(&self.workspace);
-        let paths = [
-            ("root", self.root.as_path()),
-            ("raw_workspace", raw_workspace),
-            ("canonical_workspace", canonical_workspace.as_path()),
-            ("team_dir", team_dir.as_path()),
-            ("runtime_dir", runtime_dir.as_path()),
-            ("state_parent", state_file.parent().unwrap()),
-            ("runtime_state", runtime_state.as_path()),
-        ];
-        let mut facts = paths
-            .into_iter()
-            .map(|(name, path)| {
-                let metadata = std::fs::symlink_metadata(path).unwrap();
-                json!({
-                    "name": name,
-                    "path": path.display().to_string(),
-                    "uid": metadata_uid(&metadata),
-                    "mode": metadata_mode(&metadata),
-                    "device": metadata_device(&metadata)
-                })
-            })
-            .collect::<Vec<_>>();
-        if let Ok(metadata) = std::fs::symlink_metadata(state_file) {
-            facts.push(json!({
-                "name": "state_file",
-                "path": state_file.display().to_string(),
-                "uid": metadata_uid(&metadata),
-                "mode": metadata_mode(&metadata),
-                "device": metadata_device(&metadata)
-            }));
-        }
-        let payload = json!({
-            "raw_workspace": raw_workspace.display().to_string(),
-            "canonical_workspace": canonical_workspace.display().to_string(),
-            "resolved_state_file": state_file.display().to_string(),
-            "runtime_state_path": runtime_state.display().to_string(),
-            "facts": facts
-        });
-        let payload_bytes = serde_json::to_vec(&payload).unwrap();
-        let payload_sha256 = format!("{:x}", Sha256::digest(&payload_bytes));
-        let receipt = json!({
-            "schema": "mcp-state-provenance-v1",
-            "payload": payload,
-            "payload_sha256": payload_sha256
-        });
-        let receipt_bytes = serde_json::to_vec_pretty(&receipt).unwrap();
-        use std::io::Write;
-        let mut file = std::fs::OpenOptions::new()
-            .write(true)
-            .create_new(true)
-            .open(&self.receipt)
-            .unwrap();
-        file.write_all(&receipt_bytes).unwrap();
-        file.sync_all().unwrap();
-        self.receipt.clone()
-    }
-
-    fn under_root(&self, path: &Path) -> bool {
-        let candidate = if path.exists() {
-            std::fs::canonicalize(path).unwrap()
-        } else {
-            path.to_path_buf()
-        };
-        candidate.starts_with(&self.root)
-    }
-}
-
-impl Drop for McpStateFixture {
-    fn drop(&mut self) {
-        let _ = std::fs::remove_dir_all(&self.root);
-    }
-}
-
-#[cfg(unix)]
-fn metadata_uid(metadata: &std::fs::Metadata) -> u32 {
-    use std::os::unix::fs::MetadataExt;
-    metadata.uid()
-}
-
-#[cfg(not(unix))]
-fn metadata_uid(_: &std::fs::Metadata) -> u32 {
-    0
-}
-
-#[cfg(unix)]
-fn metadata_mode(metadata: &std::fs::Metadata) -> u32 {
-    use std::os::unix::fs::MetadataExt;
-    metadata.mode()
-}
-
-#[cfg(not(unix))]
-fn metadata_mode(_: &std::fs::Metadata) -> u32 {
-    0
-}
-
-#[cfg(unix)]
-fn metadata_device(metadata: &std::fs::Metadata) -> u64 {
-    use std::os::unix::fs::MetadataExt;
-    metadata.dev()
-}
-
-#[cfg(not(unix))]
-fn metadata_device(_: &std::fs::Metadata) -> u64 {
-    0
-}
-
 include!("tests/normalize.rs");
 include!("tests/wire.rs");
 include!("tests/send.rs");