@team-agent/installer 0.5.101 → 0.5.103

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

@@ -5,135 +5,9 @@ use serde_json::Value;
 
 use crate::model::ids::TeamKey;
 
-use super::super::helpers::{ensure_object, object_fields, tool_runtime_error};
+use super::super::helpers::{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 state = crate::state::repository::StateRepository::new(&selected.run_workspace).commit(
-        crate::state::repository::StateWriteIntent::McpUpdateStateNote {
-            team_key: Some(&selected.team_key),
-        },
-        |latest| {
-            ensure_object(latest);
-            append_note(latest, note);
-        },
-    )
-    .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 state = crate::state::repository::StateRepository::new(&selected.run_workspace).commit(
-        crate::state::repository::StateWriteIntent::McpUpdateStateNote {
-            team_key: Some(&selected.team_key),
-        },
-        |latest| {
-            ensure_object(latest);
-            seed_legacy_team_key(latest, &selected.run_workspace, &selected.team_key);
-            append_note(latest, note);
-        },
-    )
-    .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,

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

@@ -4,8 +4,8 @@
 //! Card: `docs/phase0/subsystems/14-mcp_cli.md` (MCP half).
 //! Truth source (READ-ONLY) `team-agent-public` @ v0.2.11 / `439bef8`:
 //!   - `mcp_server/server.py`    — stdio loop + JSON-RPC route (`dispatch`/`handle_mcp`/`main`)
-//!   - `mcp_server/tools.py`     — `TeamOrchestratorTools`: the 12 typed tool handlers
-//!   - `mcp_server/contracts.py` — `TOOLS`: name/description/inputSchema (wire single-truth)
+//!   - `mcp_server/tools.py`     — `TeamOrchestratorTools`: the three retained handlers
+//!   - `mcp_server/contracts.py` — retained tool names/descriptions/inputSchema
 //!   - `mcp_server/normalize.py` — result envelope / compact-result regularization
 //!   - `mcp_server/__init__.py`  — package re-export surface locked by boundary tests
 //!
@@ -17,13 +17,9 @@
 //! `unimplemented!("step14 port: …")`.
 //!
 //! REUSE (do NOT redefine):
-//!   - [`MessageStore`] (step 7) — `request_human` creates the leader message row.
-//!   - [`EventLog`] (step 4) — `mcp.scope_resolved` / `mcp.send_message_refused` /
-//!     `mcp.identity_inference_failed` / `mcp.task_inference_failed` audit events.
-//!   - [`load_runtime_state`] / [`save_runtime_state`] (step 5 persist) — `assign_task`
-//!     / `update_state` read-modify-write; `get_visible_peers` reads team scope.
-//!   - [`messaging`] (step 11) — `send_message` / auto-finalizing `report_result` /
-//!     `stuck_list` / `stuck_cancel` delegated by the tool handlers.
+//!   - [`EventLog`] (step 4) — retained message/result audit events.
+//!   - [`load_runtime_state`] (step 5 persist) — message scope and peer checks.
+//!   - [`messaging`] (step 11) — `send_message` and durable `report_result` delegation.
 //!   - [`crate::model::enums`] (step 2) — [`ResultStatus`] / [`ChangeKind`] /
 //!     [`TestStatus`] / [`RiskSeverity`] are the normalized result-envelope value
 //!     enums; this layer ONLY does string-alias regularization onto them.
@@ -43,9 +39,8 @@
 //!     a frame here would corrupt the stdout JSON-RPC stream.
 //!   - **stdout 是传输通道** (server.py:135): every error is surfaced ON stdout as a
 //!     JSON-RPC frame; logs/warnings MUST go to stderr/file, never stdout.
-//!   - **worker-recipient 异步 accepted** (tools.py:176-183): a worker recipient with
-//!     a message_id → [`SendOutcome::WorkerAccepted`] carrying the byte-stable
-//!     `poll_via = "team-agent inbox <id>"`; leader/`*` → [`SendOutcome::Direct`].
+//!   - **worker-recipient 异步 accepted**: a worker recipient with a message_id →
+//!     [`SendOutcome::WorkerAccepted`]; leader/`*` → [`SendOutcome::Direct`].
 //!   - **兜底字符串字节级保留** (bug-085): `_infer_task_id` failure → `"manual"` (not
 //!     None); `_infer_agent_id` failure → `None` → caller routes to `"unknown"`.
 //!

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

@@ -1,72 +1,4 @@
-/// ---
-/// purpose: scoped MCP no-compaction update_state filesystem contract
-/// contract:
-///   provides:
-///     - name: update_state_path_contracts
-///       what: proves the raw no-compaction response preserves its state-file path in an owned fixture
-///   depends:
-///     - name: mcp_state_fixture
-///       what: fixture-owned root and provenance from tests.rs
-/// boundary:
-///   - retain the raw {ok,state_file} result shape
-///   - the owned selector checks workspace, state-file, and runtime paths remain fixture-owned
-/// maturity: wired
-/// ---
-
-fn verify_cleanup_surviving_receipt(
-    receipt_path: &std::path::Path,
-    raw_workspace: &std::path::Path,
-    canonical_workspace: &std::path::Path,
-    state_file: &std::path::Path,
-    runtime_state: &std::path::Path,
-) {
-    let bytes = std::fs::read(receipt_path)
-        .expect("provenance receipt must survive fixture Drop");
-    let receipt: Value = serde_json::from_slice(&bytes).expect("provenance receipt must be JSON");
-    assert_eq!(receipt["schema"], json!("mcp-state-provenance-v1"));
-    let payload = &receipt["payload"];
-    let payload_bytes = serde_json::to_vec(payload).unwrap();
-    assert_eq!(
-        receipt["payload_sha256"],
-        json!(format!("{:x}", sha2::Sha256::digest(&payload_bytes)))
-    );
-    assert_eq!(
-        payload["raw_workspace"],
-        json!(raw_workspace.display().to_string())
-    );
-    assert_eq!(
-        payload["canonical_workspace"],
-        json!(canonical_workspace.display().to_string())
-    );
-    assert_eq!(
-        payload["resolved_state_file"],
-        json!(state_file.display().to_string())
-    );
-    assert_eq!(
-        payload["runtime_state_path"],
-        json!(runtime_state.display().to_string())
-    );
-    let facts = payload["facts"].as_array().unwrap();
-    for name in [
-        "root",
-        "raw_workspace",
-        "canonical_workspace",
-        "team_dir",
-        "runtime_dir",
-        "state_parent",
-        "runtime_state",
-        "state_file",
-    ] {
-        let fact = facts
-            .iter()
-            .find(|fact| fact["name"] == json!(name))
-            .unwrap_or_else(|| panic!("provenance fact missing: {name}"));
-        assert!(fact["path"].as_str().is_some());
-        assert!(fact["uid"].as_u64().is_some());
-        assert!(fact["mode"].as_u64().is_some());
-        assert!(fact["device"].as_u64().is_some());
-    }
-}
+/// Scoped retained-tool contracts exercise owner binding and team isolation.
 
     #[test]
     fn dispatch_send_message_worker_accepted_returned_verbatim() {
@@ -100,69 +32,6 @@ fn verify_cleanup_surviving_receipt(
         assert_eq!(v.get("poll_via"), Some(&json!(format!("team-agent inbox {mid}"))));
     }
 
-    // ── #32/#47 request_human key order ok,message_id,status (no compaction) ────
-    // GOLDEN (probe_events_red.py REQUEST_HUMAN-KEYS): ['ok','message_id','status'].
-    // Rust compact_tool_result reorders to ok,status,message_id.
-    #[test]
-    fn request_human_key_order_is_ok_message_id_status() {
-        let tools = TeamOrchestratorTools::with_identity(
-            &unique_ws("reqhuman-order"),
-            Some(AgentId::new("worker-3")),
-            None,
-        );
-        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!(keys(&v), vec!["ok", "message_id", "status"]);
-        assert_eq!(v.get("status"), Some(&json!("needs_human")));
-    }
-
-    // ── #32 update_state returns RAW {ok, state_file} (NO compaction) ───────────
-    // GOLDEN (tools.py:316-325 + probe_passthrough): update_state is NOT compacted;
-    // state_file survives. Rust runs compact_tool_result whose ok-whitelist DROPS
-    // state_file (not a golden whitelist key), so the key vanishes.
-    #[test]
-    fn update_state_state_file_survives_no_compaction() {
-        let fixture = McpStateFixture::new("writable");
-        let expected = fixture.state_file("team_state.md");
-        let tools = TeamOrchestratorTools::with_identity(
-            &fixture.workspace,
-            Some(AgentId::new("leader")),
-            None,
-        );
-        let ok = tools.update_state("note").expect("update_state ok");
-        let v = serde_json::to_value(&ok).unwrap();
-        assert!(v.get("state_file").and_then(Value::as_str).is_some(),
-            "state_file must survive (update_state is not _compact_tool_result'd)");
-        assert_eq!(keys(&v), vec!["ok", "state_file"]);
-        let returned_state_file = PathBuf::from(v["state_file"].as_str().unwrap());
-        assert_eq!(returned_state_file, expected);
-        let runtime_state = crate::state::persist::runtime_state_path(&fixture.workspace);
-        assert!(fixture.under_root(&returned_state_file));
-        assert!(fixture.under_root(&runtime_state));
-        let canonical_workspace =
-            crate::model::paths::canonical_run_workspace(&fixture.workspace).unwrap();
-        let receipt = fixture.record_provenance(&fixture.workspace, &returned_state_file);
-        let root = fixture.root.clone();
-        drop(fixture);
-        assert!(!root.exists(), "fixture root must be removed before receipt verification");
-        verify_cleanup_surviving_receipt(
-            &receipt,
-            &root.join("workspace"),
-            &canonical_workspace,
-            &returned_state_file,
-            &runtime_state,
-        );
-        let receipt_bytes = std::fs::read(&receipt).unwrap();
-        println!(
-            "F10_PROVENANCE_RECEIPT path={} sha256={:x} payload={}",
-            receipt.display(),
-            sha2::Sha256::digest(&receipt_bytes),
-            String::from_utf8_lossy(&receipt_bytes)
-        );
-        std::fs::remove_file(&receipt).unwrap();
-        assert!(!receipt.exists(), "cleanup must remove only the exact receipt path");
-    }
-
     // ── #36 report_result identity: neither envelope nor args can override capture ─
     #[test]
     fn report_result_rejects_envelope_and_argument_identity_mismatch() {

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

@@ -43,31 +43,6 @@ fn is_worker_recipient_classification() {
     ])));
 }
 
-// ════════════════════════════════════════════════════════════════════════
-// 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,
@@ -171,7 +146,7 @@ fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
 }
 
 #[test]
-fn ordinary_send_assign_shape_has_no_recovery_marker() {
+fn ordinary_send_shape_has_no_recovery_marker() {
     let ws = seed_current_worker_state("ordinary-no-recovery");
     let tools = TeamOrchestratorTools::with_identity(
         &ws,
@@ -198,46 +173,6 @@ fn ordinary_send_assign_shape_has_no_recovery_marker() {
         "ordinary send must not carry acceptance marker: {sent}"
     );
 
-    let assigned = tools
-        .assign_task(
-            &json!({"id": "ordinary-task", "assignee": "worker-1", "title": "ordinary"}),
-            None,
-        )
-        .expect("ordinary assign ok");
-    let assigned_value = serde_json::to_value(&assigned).expect("serialize ordinary assign");
-    assert!(
-        !assigned_value.as_object().unwrap().contains_key("recovery"),
-        "ordinary assign must not carry recovery marker: {assigned_value}"
-    );
-    assert!(
-        assigned_value.get("acceptance_marker").is_none(),
-        "ordinary assign must not carry acceptance marker: {assigned_value}"
-    );
-
-    let recovery_false_assigned = tools
-        .assign_task(
-            &json!({
-                "id": "ordinary-recovery-false-task",
-                "assignee": "worker-1",
-                "title": "ordinary recovery false",
-                "recovery": false,
-            }),
-            None,
-        )
-        .expect("recovery=false assign ok");
-    let recovery_false_value =
-        serde_json::to_value(&recovery_false_assigned).expect("serialize recovery=false assign");
-    assert!(
-        !recovery_false_value
-            .as_object()
-            .unwrap()
-            .contains_key("recovery"),
-        "recovery=false assign must not carry recovery marker: {recovery_false_value}"
-    );
-    assert!(
-        recovery_false_value.get("acceptance_marker").is_none(),
-        "recovery=false assign must not carry acceptance marker: {recovery_false_value}"
-    );
 }
 
 #[test]
@@ -256,33 +191,6 @@ fn send_message_without_framework_identity_fails_closed() {
     assert_eq!(error.reason, ToolErrorReason::McpScopeRefused);
 }
 
-#[test]
-fn recovery_assign_shape_has_structured_marker() {
-    let ws = seed_current_worker_state("recovery-marker");
-    let tools = TeamOrchestratorTools::with_identity(
-        &ws,
-        Some(AgentId::new("leader")),
-        Some(TeamKey::new("current")),
-    );
-
-    let assigned = tools
-        .assign_task(
-            &json!({
-                "id": "recovery-task",
-                "assignee": "worker-1",
-                "title": "recover",
-                "recovery": true,
-            }),
-            None,
-        )
-        .expect("recovery assign ok");
-    assert_eq!(assigned.fields.get("recovery"), Some(&json!(true)));
-    assert_eq!(
-        assigned.fields.get("acceptance_marker"),
-        Some(&json!("recovery"))
-    );
-}
-
 #[test]
 fn send_message_worker_recipient_surfaces_dead_coordinator_warning() {
     let ws = unique_ws("send-worker-dead-coord");

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]