@team-agent/installer 0.2.11 → 0.3.1

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

@@ -0,0 +1,222 @@
+    #[test]
+    fn requires_ack_for_target_leader_vs_worker() {
+        assert!(!requires_ack_for_target(&MessageTarget::Single("leader".to_string())));
+        assert!(!requires_ack_for_target(&MessageTarget::Single("Leader".to_string())));
+        assert!(requires_ack_for_target(&MessageTarget::Single("alice".to_string())));
+        // list: all-leader → false; any non-leader → true
+        assert!(!requires_ack_for_target(&MessageTarget::Fanout(vec![
+            "leader".to_string(), "Leader".to_string()
+        ])));
+        assert!(requires_ack_for_target(&MessageTarget::Fanout(vec![
+            "leader".to_string(), "alice".to_string()
+        ])));
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // is_worker_recipient — single str not in {"","*","leader","Leader"} (tools.py:22)
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    fn is_worker_recipient_classification() {
+        assert!(is_worker_recipient(&MessageTarget::Single("alice".to_string())));
+        assert!(!is_worker_recipient(&MessageTarget::Single("".to_string())));
+        assert!(!is_worker_recipient(&MessageTarget::Single("leader".to_string())));
+        assert!(!is_worker_recipient(&MessageTarget::Single("Leader".to_string())));
+        // Broadcast "*" is NOT a worker recipient
+        assert!(!is_worker_recipient(&MessageTarget::Broadcast));
+        // Fanout list is NOT a worker recipient (not a single str)
+        assert!(!is_worker_recipient(&MessageTarget::Fanout(vec!["alice".to_string()])));
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // merge_tasks_by_id — prefer wins, prefer-first insertion order (tools.py:30)
+    // Golden: prefer t1(done),t2 + fallback t1(pending),t3,{no id},"notdict"
+    //   → [t1(done), t2, t3]  (t1 from prefer wins; non-dict / no-id dropped)
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    fn merge_tasks_by_id_prefer_wins_no_done_regression() {
+        let prefer = vec![
+            json!({"id": "t1", "status": "done"}),
+            json!({"id": "t2", "status": "pending"}),
+        ];
+        let fallback = vec![
+            json!({"id": "t1", "status": "pending"}), // must NOT regress t1
+            json!({"id": "t3", "status": "ready"}),
+            json!({"no": "id"}),                       // dropped (no id)
+            json!("notdict"),                          // dropped (not object)
+        ];
+        let merged = merge_tasks_by_id(&prefer, &fallback);
+        assert_eq!(merged.len(), 3);
+        assert_eq!(merged[0]["id"], json!("t1"));
+        assert_eq!(merged[0]["status"], json!("done")); // prefer wins → no regression
+        assert_eq!(merged[1]["id"], json!("t2"));
+        assert_eq!(merged[2]["id"], json!("t3"));
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // SendOutcome::to_value — worker-accepted async envelope (tools.py:177-182)
+    // byte-stable: {status:"accepted",delivery_pending:true,
+    //               poll_via:"team-agent inbox <id>",message_id:<id>}
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    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(),
+        };
+        let v = outcome.to_value();
+        assert_eq!(keys(&v), vec!["status", "delivery_pending", "poll_via", "message_id"]);
+        assert_eq!(s(&v),
+            r#"{"status":"accepted","delivery_pending":true,"poll_via":"team-agent inbox 42","message_id":"42"}"#);
+    }
+
+    #[test]
+    fn send_outcome_direct_renders_compact_body() {
+        // leader / * / broadcast path → compacted delegate body, not the accepted envelope.
+        let ok = ToolOk {
+            fields: {
+                let mut m = serde_json::Map::new();
+                m.insert("ok".to_string(), json!(true));
+                m.insert("status".to_string(), json!("queued"));
+                m
+            },
+        };
+        let v = SendOutcome::Direct(ok).to_value();
+        assert_eq!(v.get("status"), Some(&json!("queued")));
+        assert!(v.get("delivery_pending").is_none(), "Direct is NOT the accepted envelope");
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // CONTROL-PLANE: send_message worker recipient → WorkerAccepted (tools.py:135-183)
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
+        // A worker recipient w/ a delivered message_id → async accepted carrying the
+        // byte-stable poll hint. Identity anchored on injected env (no candidate scan).
+        // golden: a leader WITH owner_team_id on an unseeded ws would hit the C23 cross-team
+        // refusal first (worker-1 not in visible peers) -> PeerNotInScope. owner_team_id=None
+        // (legacy single-team) bypasses that, isolating the worker-recipient accepted path.
+        // The cross-team refusal has its own tests (refuse_cross_team_peer_* / send_message_cross_team_*).
+        let tools = TeamOrchestratorTools::with_identity(
+            &unique_ws("send-worker"),
+            Some(AgentId::new("leader")),
+            None,
+        );
+        let outcome = tools.send_message(
+            &MessageTarget::Single("worker-1".to_string()),
+            "do the thing",
+            None, None, None, None,
+        );
+        match outcome {
+            Ok(SendOutcome::WorkerAccepted { message_id, poll_via }) => {
+                assert!(!message_id.is_empty());
+                assert_eq!(poll_via, format!("team-agent inbox {message_id}"));
+            }
+            other => panic!("worker recipient must be WorkerAccepted, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn send_message_leader_recipient_is_direct_not_accepted() {
+        let tools = TeamOrchestratorTools::with_identity(
+            &unique_ws("send-leader"),
+            Some(AgentId::new("worker-1")),
+            Some(TeamKey::new("teamA")),
+        );
+        let outcome = tools.send_message(
+            &MessageTarget::Single("leader".to_string()),
+            "status update",
+            None, None, None, None,
+        ).expect("leader send ok");
+        assert!(matches!(outcome, SendOutcome::Direct(_)),
+            "leader recipient → Direct (synchronous), not WorkerAccepted");
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // CROSS-TEAM PRE-REFUSAL (C23) — refuse_cross_team_peer (tools.py:185-213)
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    fn refuse_cross_team_peer_blocks_unknown_peer_without_workspace_scope() {
+        // owner_team set, target a peer NOT in scope, scope != workspace → PeerNotInScope.
+        let tools = TeamOrchestratorTools::with_identity(
+            Path::new("/tmp/ws"),
+            Some(AgentId::new("worker-1")),
+            Some(TeamKey::new("teamA")),
+        );
+        let refusal = tools.refuse_cross_team_peer(
+            &MessageTarget::Single("other-team-bob".to_string()),
+            None,
+        );
+        let te = refusal.expect("cross-team peer must be refused");
+        assert_eq!(te.reason, ToolErrorReason::PeerNotInScope);
+        // hint preserved in extra (tools.py:208-213 status:"refused" + hint)
+        let env = te.to_envelope();
+        assert_eq!(env.get("status"), Some(&json!("refused")));
+        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."))
+        );
+    }
+
+    #[test]
+    fn refuse_cross_team_peer_allows_workspace_scope_optin() {
+        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(
+            &MessageTarget::Single("other-team-bob".to_string()),
+            Some(Scope::Workspace),
+        ).is_none(), "workspace scope opts in to cross-team addressing");
+    }
+
+    #[test]
+    fn refuse_cross_team_peer_allows_leader_broadcast_and_self() {
+        let tools = TeamOrchestratorTools::with_identity(
+            Path::new("/tmp/ws"),
+            Some(AgentId::new("worker-1")),
+            Some(TeamKey::new("teamA")),
+        );
+        // leader / "*" / "" / self are never refused (tools.py:190,195)
+        assert!(tools.refuse_cross_team_peer(&MessageTarget::Single("leader".to_string()), None).is_none());
+        assert!(tools.refuse_cross_team_peer(&MessageTarget::Broadcast, None).is_none());
+        assert!(tools.refuse_cross_team_peer(&MessageTarget::Single("worker-1".to_string()), None).is_none());
+    }
+
+    #[test]
+    fn refuse_cross_team_peer_no_owner_team_is_legacy_passthrough() {
+        // No owner_team_id (legacy single-team) → never refuse (tools.py:192).
+        let tools = TeamOrchestratorTools::with_identity(
+            Path::new("/tmp/ws"),
+            Some(AgentId::new("worker-1")),
+            None,
+        );
+        assert!(tools.refuse_cross_team_peer(
+            &MessageTarget::Single("anybody".to_string()),
+            None,
+        ).is_none());
+    }
+
+    #[test]
+    fn send_message_cross_team_peer_surfaces_peer_not_in_scope_error() {
+        // End-to-end: send_message to an out-of-scope peer → Err(ToolError{PeerNotInScope})
+        // BEFORE any runtime delivery (server-side guard, no peer-name leak).
+        let tools = TeamOrchestratorTools::with_identity(
+            Path::new("/tmp/ws"),
+            Some(AgentId::new("worker-1")),
+            Some(TeamKey::new("teamA")),
+        );
+        let err = tools.send_message(
+            &MessageTarget::Single("other-team-bob".to_string()),
+            "leak attempt",
+            None, None, None, None,
+        ).expect_err("out-of-scope peer must be refused");
+        assert_eq!(err.reason, ToolErrorReason::PeerNotInScope);
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // WORKER-ID INFERENCE FALLBACK (bug-085, C17) — report_result identity.
+    // explicit > env > "unknown"; task → "manual". NEVER treat worker as leader.
+    // ════════════════════════════════════════════════════════════════════════

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

@@ -0,0 +1,158 @@
+    #[test]
+    fn report_result_infers_agent_from_env_when_not_explicit() {
+        // env identity present, no explicit agent_id → envelope.agent_id == env id.
+        let tools = TeamOrchestratorTools::with_identity(
+            &unique_ws("report-env"),
+            Some(AgentId::new("worker-7")),
+            Some(TeamKey::new("teamA")),
+        );
+        let ok = tools.report_result(
+            None, Some("done it"), ResultStatus::Success,
+            None, None, None, None, None,
+            None, None, // no explicit task/agent
+        ).expect("report ok");
+        let v = serde_json::to_value(&ok).unwrap();
+        // C17/bug-085: env id wins over leader/unknown. agent_id is a guaranteed-present
+        // ok-whitelist key (normalize.py:46) — runtime.report_result echoes envelope
+        // ["agent_id"], which _infer_agent_id sourced from self.agent_id (the injected
+        // TEAM_AGENT_ID). UNCONDITIONAL assert: a vacuous skip here would silently fail
+        // to lock the exact invariant this lane exists for.
+        assert_eq!(
+            v.get("agent_id"),
+            Some(&json!("worker-7")),
+            "env id wins, never leader/unknown"
+        );
+    }
+
+    #[test]
+    fn report_result_explicit_agent_overrides_env() {
+        let tools = TeamOrchestratorTools::with_identity(
+            &unique_ws("report-explicit"),
+            Some(AgentId::new("worker-7")),
+            Some(TeamKey::new("teamA")),
+        );
+        let ok = tools.report_result(
+            None, Some("done"), ResultStatus::Success,
+            None, None, None, None, None,
+            Some("task-9"), Some("explicit-agent"),
+        ).expect("report ok");
+        let v = serde_json::to_value(&ok).unwrap();
+        // explicit > env: both task_id and agent_id are ok-whitelist keys
+        // (normalize.py:45-46) echoed by runtime.report_result, so present on success.
+        // UNCONDITIONAL asserts — the override must be proven, not silently skipped.
+        assert_eq!(
+            v.get("agent_id"),
+            Some(&json!("explicit-agent")),
+            "explicit agent_id overrides env"
+        );
+        assert_eq!(
+            v.get("task_id"),
+            Some(&json!("task-9")),
+            "explicit task_id flows through"
+        );
+    }
+
+    #[test]
+    fn report_result_no_env_no_explicit_falls_back_unknown_and_manual() {
+        // bug-085: env missing + nothing explicit → agent "unknown", task "manual"
+        // (NOT None, NOT "leader"). The envelope-builder is the asserted seam.
+        let env = normalize_report_envelope(&json!({"summary": "x"}));
+        assert_eq!(env.agent_id, AgentId::new("unknown"));
+        assert_eq!(env.task_id, TaskId::new("manual"));
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // 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 tools = TeamOrchestratorTools::with_identity(
+            &unique_ws("update-state"),
+            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.
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    fn rpc_response_error_frame_serializes_without_result_key() {
+        // server.py: error frames carry NO result key; result frames carry NO error key.
+        let frame = RpcResponse {
+            jsonrpc: "2.0".to_string(),
+            id: RpcId::Int(7),
+            result: None,
+            error: Some(RpcError { code: -32601, message: "unknown method 'x'".to_string() }),
+        };
+        let v = serde_json::to_value(&frame).unwrap();
+        assert!(v.get("result").is_none(), "error frame omits result");
+        assert_eq!(v["error"]["code"], json!(-32601));
+        assert_eq!(v["jsonrpc"], json!("2.0"));
+    }
+
+    #[test]
+    fn rpc_id_null_roundtrips() {
+        // request.get("id") absent/null → echoed back as null
+        let frame = RpcResponse {
+            jsonrpc: "2.0".to_string(),
+            id: RpcId::Null,
+            result: Some(json!({"ok": true})),
+            error: None,
+        };
+        let v = serde_json::to_value(&frame).unwrap();
+        assert_eq!(v["id"], Value::Null);
+        assert!(v.get("error").is_none(), "result frame omits error");
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // STEP-14 DIVERGENCE-FIX RED TESTS (Phase 1). Each encodes the EXACT Python
+    // golden v0.2.11 value (probed via PYTHONPATH=.../src python3) and FAILS against
+    // current Rust. The P2 porter greens these. Do NOT weaken existing assertions.
+    // ════════════════════════════════════════════════════════════════════════
+
+    /// Seed `<ws>/.team/runtime/state.json` and return the CANONICAL workspace path
+    /// so `with_identity` (which canonicalizes) reads the same file we wrote.
+    fn seed_state_ws(tag: &str, state: &Value) -> std::path::PathBuf {
+        let ws = unique_ws(tag);
+        let cws = std::fs::canonicalize(&ws).unwrap_or(ws);
+        let rt = cws.join(".team").join("runtime");
+        std::fs::create_dir_all(&rt).unwrap();
+        std::fs::write(rt.join("state.json"), serde_json::to_string_pretty(state).unwrap()).unwrap();
+        cws
+    }
+
+    // ── #29/#43/#49 compact ok-whitelist: EXACT 23-key golden list + order ──────
+    // GOLDEN (probe_mcp_red.py OK-FULL-KEYS): the 23 keys in normalize.py:32-56 order

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

@@ -0,0 +1,187 @@
+    #[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::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);
+            assert_eq!(McpTool::parse(name), Some(tool));
+        }
+        // unknown → None (server.py:43 maps to UnknownTool)
+        assert_eq!(McpTool::parse("nope"), None);
+        assert_eq!(McpTool::parse("AssignTask"), None); // case-sensitive snake_case
+    }
+
+    #[test]
+    fn rpc_method_classify() {
+        assert_eq!(RpcMethod::classify("initialize"), RpcMethod::Initialize);
+        assert_eq!(RpcMethod::classify("tools/list"), RpcMethod::ToolsList);
+        assert_eq!(RpcMethod::classify("tools/call"), RpcMethod::ToolsCall);
+        // notifications/* → Notification (no reply path)
+        assert!(matches!(
+            RpcMethod::classify("notifications/initialized"),
+            RpcMethod::Notification(_)
+        ));
+        // unknown → Unknown
+        assert_eq!(
+            RpcMethod::classify("foo/bar"),
+            RpcMethod::Unknown("foo/bar".to_string())
+        );
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // tools_contract — TOOLS wire list (contracts.py): 12 tools, exact names+order
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    fn tools_contract_has_twelve_tools_in_order() {
+        let tools = tools_contract();
+        assert_eq!(tools.len(), 12);
+        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",
+            "fork_agent", "request_human", "stuck_list", "stuck_cancel",
+        ]);
+        // each carries description + inputSchema
+        for t in &tools {
+            assert!(t.get("description").and_then(Value::as_str).is_some());
+            assert!(t.get("inputSchema").is_some());
+        }
+        // spot-check byte-stable description + schema for send_message
+        let send = tools.iter().find(|t| t["name"] == json!("send_message")).unwrap();
+        assert_eq!(
+            send["description"],
+            json!("Send a message to a teammate, the leader, or '*' for all other team members. Provide only target and content; Team Agent fills sender, task id, ack policy, and delivery metadata.")
+        );
+        assert_eq!(send["inputSchema"]["additionalProperties"], json!(false));
+        assert_eq!(send["inputSchema"]["required"], json!(["to", "content"]));
+    }
+
+    #[test]
+    fn tools_contract_input_schemas_are_openai_strict_top_level_objects() {
+        let forbidden = ["oneOf", "anyOf", "allOf", "enum", "not"];
+        for tool in tools_contract() {
+            let schema = tool["inputSchema"].as_object().unwrap();
+            assert_eq!(schema.get("type"), Some(&json!("object")), "schema must be a top-level object: {tool}");
+            for key in forbidden {
+                assert!(
+                    !schema.contains_key(key),
+                    "OpenAI rejects top-level `{key}` in MCP tool schema: {tool}"
+                );
+            }
+            let properties = schema
+                .get("properties")
+                .and_then(Value::as_object)
+                .unwrap_or_else(|| panic!("schema properties must be an object: {tool}"));
+            for required in schema.get("required").and_then(Value::as_array).into_iter().flatten() {
+                let Some(name) = required.as_str() else {
+                    panic!("required entries must be strings: {tool}");
+                };
+                assert!(
+                    properties.contains_key(name),
+                    "required property `{name}` must be declared in properties: {tool}"
+                );
+            }
+        }
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // handle_mcp — JSON-RPC routing (server.py:46-91)
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    fn handle_mcp_initialize_echoes_protocol_and_serverinfo() {
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let resp = handle_mcp(&tools, &json!({
+            "jsonrpc": "2.0", "id": 1, "method": "initialize",
+            "params": {"protocolVersion": "X"}
+        })).unwrap().expect("initialize yields a frame");
+        assert_eq!(resp.jsonrpc, "2.0");
+        assert_eq!(resp.id, RpcId::Int(1));
+        let result = resp.result.unwrap();
+        assert_eq!(result["protocolVersion"], json!("X"));
+        assert_eq!(result["serverInfo"]["name"], json!("team_orchestrator"));
+        assert_eq!(result["serverInfo"]["version"], json!("0.1.4"));
+        assert_eq!(result["capabilities"], json!({"tools": {}}));
+    }
+
+    #[test]
+    fn handle_mcp_initialize_defaults_protocol_version() {
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let resp = handle_mcp(&tools, &json!({
+            "jsonrpc": "2.0", "id": "abc", "method": "initialize"
+        })).unwrap().unwrap();
+        assert_eq!(resp.id, RpcId::Str("abc".to_string()));
+        assert_eq!(resp.result.unwrap()["protocolVersion"], json!("2024-11-05"));
+    }
+
+    #[test]
+    fn handle_mcp_notifications_return_none_no_frame() {
+        // 铁律: notifications/* MUST NOT emit a frame (would corrupt stdout stream).
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let resp = handle_mcp(&tools, &json!({
+            "jsonrpc": "2.0", "method": "notifications/initialized"
+        })).unwrap();
+        assert!(resp.is_none(), "notifications/* → None (loop continues)");
+    }
+
+    #[test]
+    fn handle_mcp_unknown_method_is_minus_32601() {
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let resp = handle_mcp(&tools, &json!({
+            "jsonrpc": "2.0", "id": 7, "method": "foo/bar"
+        })).unwrap().unwrap();
+        assert!(resp.result.is_none());
+        let err = resp.error.unwrap();
+        assert_eq!(err.code, -32601);
+        assert_eq!(err.message, "unknown method 'foo/bar'"); // exact Python repr w/ quotes
+    }
+
+    #[test]
+    fn handle_mcp_unknown_tool_call_is_error_with_envelope_text() {
+        // tools/call with unknown tool → isError:true, content[0].text == json.dumps(envelope)
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let resp = handle_mcp(&tools, &json!({
+            "jsonrpc": "2.0", "id": 9, "method": "tools/call",
+            "params": {"name": "nope", "arguments": {}}
+        })).unwrap().unwrap();
+        let result = resp.result.unwrap();
+        assert_eq!(result["isError"], json!(true));
+        let text = result["content"][0]["text"].as_str().unwrap();
+        // the text is a JSON-encoded error envelope with redundant keys
+        let env: Value = serde_json::from_str(text).unwrap();
+        assert_eq!(env["ok"], json!(false));
+        assert_eq!(env["reason"], json!("unknown_tool"));
+        assert_eq!(env["error_code"], json!("unknown_tool"));
+        assert_eq!(env["exc_type"], json!("UnknownTool"));
+        assert_eq!(env["message"], json!("unknown tool 'nope'"));
+        assert_eq!(env["error"], json!("unknown tool 'nope'"));
+        assert_eq!(result["content"][0]["type"], json!("text"));
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // dispatch — unknown tool → Err(UnknownTool) (server.py:43)
+    // ════════════════════════════════════════════════════════════════════════
+    #[test]
+    fn dispatch_unknown_tool_returns_unknown_tool_error() {
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let r = dispatch(&tools, &json!({"tool": "nope"}));
+        let err = r.expect_err("unknown tool ⇒ Err");
+        assert_eq!(err.reason, ToolErrorReason::UnknownTool);
+        assert_eq!(err.exc_type, "UnknownTool");
+        assert_eq!(err.message, "unknown tool 'nope'");
+    }
+
+    // ════════════════════════════════════════════════════════════════════════
+    // requires_ack_for_target — leader-only → false (tools.py:16)
+    // ════════════════════════════════════════════════════════════════════════

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

@@ -0,0 +1,38 @@
+//! step 14a · mcp_server::tests — WAVE-2 RED contracts (Python v0.2.11 golden).
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+
+use super::*;
+use serde_json::json;
+
+// ── helpers ──────────────────────────────────────────────────────────────
+
+/// Serialize a serde_json::Value to a string — used to assert byte-stable
+/// key ORDER (preserve_order is enabled workspace-wide).
+fn s(v: &Value) -> String {
+    serde_json::to_string(v).unwrap()
+}
+
+/// Ordered list of keys as they appear in a JSON object Value.
+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 {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static N: AtomicU64 = AtomicU64::new(0);
+    let n = N.fetch_add(1, Ordering::Relaxed);
+    let p = std::env::temp_dir().join(format!("ta-rs-mcp-{tag}-{}-{n}", std::process::id()));
+    std::fs::create_dir_all(&p).unwrap();
+    p
+}
+
+include!("tests/normalize.rs");
+include!("tests/wire.rs");
+include!("tests/send.rs");
+include!("tests/tools.rs");
+include!("tests/golden.rs");
+include!("tests/scoped.rs");