@team-agent/installer 0.5.52 → 0.5.53

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

@@ -1,193 +1,269 @@
-    #[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 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);
+        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())
+#[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, exact names+order
+// ════════════════════════════════════════════════════════════════════════
+#[test]
+fn tools_contract_has_thirteen_tools_in_order() {
+    let tools = tools_contract();
+    assert_eq!(tools.len(), 13);
+    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",
+        ]
+    );
+    // 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"]));
+    for internal in ["sender", "task_id", "requires_ack"] {
+        assert!(
+            send["inputSchema"]["properties"].get(internal).is_none(),
+            "{internal} is framework-owned, not caller-supplied"
         );
     }
+    let clone = tools
+        .iter()
+        .find(|tool| tool["name"] == json!("clone_agent"))
+        .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(),
+        ])
+    );
+}
 
-    // ════════════════════════════════════════════════════════════════════════
-    // 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();
+#[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!(
-            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.")
+            schema.get("type"),
+            Some(&json!("object")),
+            "schema must be a top-level object: {tool}"
         );
-        assert_eq!(send["inputSchema"]["additionalProperties"], json!(false));
-        assert_eq!(send["inputSchema"]["required"], json!(["to", "content"]));
-        for internal in ["sender", "task_id", "requires_ack"] {
+        for key in forbidden {
             assert!(
-                send["inputSchema"]["properties"].get(internal).is_none(),
-                "{internal} is framework-owned, not caller-supplied"
+                !schema.contains_key(key),
+                "OpenAI rejects top-level `{key}` in MCP tool schema: {tool}"
             );
         }
-    }
-
-    #[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}"
-                );
-            }
+        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!({
+// ════════════════════════════════════════════════════════════════════════
+// 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": {}}));
-    }
+        }),
+    )
+    .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!({
+#[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"));
-    }
+        }),
+    )
+    .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!({
+#[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)");
-    }
+        }),
+    )
+    .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!({
+#[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
-    }
+        }),
+    )
+    .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!({
+#[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"));
-    }
+        }),
+    )
+    .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'");
-    }
+// ════════════════════════════════════════════════════════════════════════
+// 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)
-    // ════════════════════════════════════════════════════════════════════════
+// ════════════════════════════════════════════════════════════════════════
+// requires_ack_for_target — leader-only → false (tools.py:16)
+// ════════════════════════════════════════════════════════════════════════

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

@@ -139,7 +139,7 @@ impl TeamOrchestratorTools {
                     reconcile_assigned_task(latest, latest_team_key.as_deref(), &task_value);
                 },
             )
-        .map_err(tool_runtime_error)?;
+            .map_err(tool_runtime_error)?;
 
         let content = assignment_message(task, message);
         let out = self.send_message(
@@ -572,6 +572,22 @@ impl TeamOrchestratorTools {
         )
     }
 
+    pub fn clone_agent(
+        &self,
+        source_agent_id: &str,
+        as_agent_id: &str,
+        label: Option<&str>,
+    ) -> ToolResult {
+        let owner_team = self.canonical_owner_team_key()?;
+        super::lifecycle_tools::clone_agent(
+            &self.workspace,
+            owner_team.as_ref(),
+            source_agent_id,
+            as_agent_id,
+            label,
+        )
+    }
+
     /// `request_human` (`tools.py:342-346`): create a `requires_ack` leader message via
     /// the shared leader-delivery funnel; sender = env / inferred / `"unknown"`.
     /// Returns `{ok:true, message_id, status:"needs_human"}`.
@@ -797,9 +813,7 @@ impl TeamOrchestratorTools {
             .collect();
         let best = ranked.first().cloned();
         let hint = if let Some(best) = best.as_deref() {
-            format!(
-                "the requested peer is not in your owner team; did you mean `{best}`?"
-            )
+            format!("the requested peer is not in your owner team; did you mean `{best}`?")
         } else {
             "the requested peer is not part of your team; worker-origin MCP cannot widen team scope.".to_string()
         };

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

@@ -63,6 +63,7 @@ pub enum McpTool {
     StopAgent,
     ResetAgent,
     AddAgent,
+    CloneAgent,
     ForkAgent,
     RequestHuman,
     StuckList,
@@ -82,6 +83,7 @@ impl McpTool {
             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",
@@ -101,6 +103,7 @@ impl McpTool {
             "stop_agent" => Some(McpTool::StopAgent),
             "reset_agent" => Some(McpTool::ResetAgent),
             "add_agent" => Some(McpTool::AddAgent),
+            "clone_agent" => Some(McpTool::CloneAgent),
             "fork_agent" => Some(McpTool::ForkAgent),
             "request_human" => Some(McpTool::RequestHuman),
             "stuck_list" => Some(McpTool::StuckList),

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

@@ -33,6 +33,7 @@ pub fn tools_contract() -> Vec<Value> {
         McpTool::StopAgent,
         McpTool::ResetAgent,
         McpTool::AddAgent,
+        McpTool::CloneAgent,
         McpTool::ForkAgent,
         McpTool::RequestHuman,
         McpTool::StuckList,
@@ -378,6 +379,7 @@ fn tool_contract(tool: McpTool) -> Value {
         McpTool::StopAgent => ("Stop a running worker.", vec!["agent_id"]),
         McpTool::ResetAgent => ("Reset one worker to a fresh session.", vec!["agent_id", "discard_session"]),
         McpTool::AddAgent => ("Add a first-class worker from a role file.", vec!["new_agent_id", "role_file_path"]),
+        McpTool::CloneAgent => ("Clone a worker role into a fresh provider session.", vec!["source_agent_id", "as_agent_id"]),
         McpTool::ForkAgent => ("Fork a running worker.", vec!["source_agent_id", "as_agent_id"]),
         McpTool::RequestHuman => ("Ask the leader or user for human input.", vec!["question"]),
         McpTool::StuckList => ("List manually suppressed idle alerts.", Vec::new()),
@@ -522,6 +524,23 @@ fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
                 string_property("Optional display label."),
             );
         }
+        McpTool::CloneAgent => {
+            insert_property(
+                &mut properties,
+                "source_agent_id",
+                string_property("Agent id to clone from."),
+            );
+            insert_property(
+                &mut properties,
+                "as_agent_id",
+                string_property("Agent id for the cloned worker."),
+            );
+            insert_property(
+                &mut properties,
+                "label",
+                string_property("Optional display label."),
+            );
+        }
         McpTool::RequestHuman => {
             insert_property(
                 &mut properties,
@@ -591,13 +610,7 @@ pub(crate) fn dispatch_tool(
         McpTool::SendMessage => {
             let target = message_target_from_value(args.get("to"));
             let content = args.get("content").and_then(Value::as_str).unwrap_or("");
-            let outcome = tools.send_message(
-                &target,
-                content,
-                None,
-                None,
-                None,
-            )?;
+            let outcome = tools.send_message(&target, content, None, None, None)?;
             match outcome {
                 SendOutcome::WorkerAccepted { .. } => Ok(ToolOk {
                     fields: object_fields(outcome.to_value()),
@@ -668,6 +681,15 @@ pub(crate) fn dispatch_tool(
                 .unwrap_or(""),
             args.get("label").and_then(Value::as_str),
         ),
+        McpTool::CloneAgent => tools.clone_agent(
+            args.get("source_agent_id")
+                .and_then(Value::as_str)
+                .unwrap_or(""),
+            args.get("as_agent_id")
+                .and_then(Value::as_str)
+                .unwrap_or(""),
+            args.get("label").and_then(Value::as_str),
+        ),
         McpTool::RequestHuman => tools.request_human(
             args.get("question").and_then(Value::as_str).unwrap_or(""),
             args.get("task_id").and_then(Value::as_str),
@@ -695,6 +717,7 @@ fn scope_ceiling_tool(tool: McpTool) -> bool {
             | McpTool::GetTeamStatus
             | McpTool::StopAgent
             | McpTool::ResetAgent
+            | McpTool::CloneAgent
             | McpTool::ForkAgent
     )
 }

package/crates/team-agent/src/messaging/leader_channel.rs

@@ -101,6 +101,7 @@ pub fn resolve_live_leader_channel(
         .current_path
         .as_deref()
         .is_some_and(|path| !path_is_in_workspace(path, workspace))
+        && !explicit_claim_authority_matches(workspace, receiver, &observed)
     {
         return LeaderChannelResolution::Unbound(LeaderChannelUnbound::PaneWorkspaceMismatch);
     }
@@ -113,14 +114,40 @@ pub fn resolve_live_leader_channel(
     }))
 }
 
-fn path_is_in_workspace(path: &Path, workspace: &Path) -> bool {
-    let path = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
-    let workspace = workspace
-        .canonicalize()
-        .unwrap_or_else(|_| workspace.to_path_buf());
+fn explicit_claim_authority_matches(
+    workspace: &Path,
+    receiver: &Value,
+    observed: &PaneInfo,
+) -> bool {
+    if string_field(receiver, "scope_authority") != Some("explicit_claim") {
+        return false;
+    }
+    let Some(authorized_workspace) = string_field(receiver, "authorized_team_workspace") else {
+        return false;
+    };
+    if canonical_path(Path::new(authorized_workspace)) != canonical_path(workspace) {
+        return false;
+    }
+    let Some(recorded_nonce) = string_field(receiver, "binding_nonce") else {
+        return false;
+    };
+    observed
+        .leader_env
+        .get(crate::tmux_backend::PANE_BINDING_NONCE_METADATA_KEY)
+        .filter(|nonce| !nonce.is_empty())
+        .is_some_and(|live_nonce| live_nonce == recorded_nonce)
+}
+
+pub(crate) fn path_is_in_workspace(path: &Path, workspace: &Path) -> bool {
+    let path = canonical_path(path);
+    let workspace = canonical_path(workspace);
     path == workspace || path.starts_with(workspace)
 }
 
+fn canonical_path(path: &Path) -> std::path::PathBuf {
+    path.canonicalize().unwrap_or_else(|_| path.to_path_buf())
+}
+
 fn receiver_transport_conflicts(receiver: &Value) -> bool {
     let mode = receiver.get("mode").and_then(Value::as_str);
     let transport_kind = receiver.get("transport_kind").and_then(Value::as_str);