@team-agent/installer 0.5.51 → 0.5.53

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

@@ -666,6 +666,23 @@ pub struct ForkAgentReport {
     pub session_id: Option<SessionId>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CloneAgentReport {
+    pub source_agent_id: AgentId,
+    pub new_agent_id: AgentId,
+    pub env: AgentActionEnvelope,
+    pub session_id: Option<SessionId>,
+    pub backing_path: Option<PathBuf>,
+    pub backing_state: CloneBackingState,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CloneBackingState {
+    Verified,
+    PendingFirstTurn,
+}
+
 /// Read-only remove-agent flag requirements for the target's current state.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RemoveAgentFlagRequirements {

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

@@ -134,6 +134,41 @@ pub(crate) fn fork_agent(
     })
 }
 
+pub(crate) fn clone_agent(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+    source_agent_id: &str,
+    as_agent_id: &str,
+    label: Option<&str>,
+) -> ToolResult {
+    emit_newer_daemon_preserved_if_present(workspace)?;
+    let lifecycle_workspace = lifecycle_workspace(workspace, owner_team, false)?;
+    let report = crate::lifecycle::launch::clone_agent(
+        &lifecycle_workspace,
+        &AgentId::new(source_agent_id),
+        &AgentId::new(as_agent_id),
+        label,
+        false,
+        owner_team.map(TeamKey::as_str),
+    )
+    .map_err(tool_runtime_error)?;
+    Ok(ToolOk {
+        fields: object_fields(serde_json::json!({
+            "ok": true,
+            "status": "cloned",
+            "source_agent_id": report.source_agent_id.as_str(),
+            "agent_id": report.new_agent_id.as_str(),
+            "new_agent_id": report.new_agent_id.as_str(),
+            "state_file": report.env.state_file.to_string_lossy().to_string(),
+            "coordinator_started": report.env.coordinator_started,
+            "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+            "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
+            "backing_path": report.backing_path.as_ref().map(|path| path.to_string_lossy().to_string()),
+            "backing_state": report.backing_state,
+        })),
+    })
+}
+
 fn reset_refusal_reason(reason: ResetRefusal) -> Value {
     match reason {
         ResetRefusal::DiscardSessionRequired => {
@@ -440,9 +475,9 @@ fn prepare_selected_team_state(
             state,
         )
         .map_err(|e| {
-        tool_runtime_error(format!(
-            "save MCP lifecycle scoped state {}: {e}",
-            workspace.display()
-        ))
-    })
+            tool_runtime_error(format!(
+                "save MCP lifecycle scoped state {}: {e}",
+                workspace.display()
+            ))
+        })
 }

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

@@ -6,5 +6,5 @@
 mod agent_ops;
 mod state_status;
 
-pub(crate) use agent_ops::{fork_agent, reset_agent, stop_agent};
+pub(crate) use agent_ops::{clone_agent, fork_agent, reset_agent, stop_agent};
 pub(crate) use state_status::{get_team_status, update_state};

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

@@ -311,8 +311,25 @@
     // ════════════════════════════════════════════════════════════════════════
     #[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(
-            &unique_ws("update-state"),
+            &ws,
             Some(AgentId::new("leader")),
             Some(TeamKey::new("teamA")),
         );

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/tests.rs

@@ -22,12 +22,19 @@ fn keys(v: &Value) -> Vec<String> {
 /// `/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::io::ErrorKind;
     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
+    loop {
+        let n = N.fetch_add(1, Ordering::Relaxed);
+        let p =
+            std::env::temp_dir().join(format!("ta-rs-mcp-{tag}-{}-{n}", std::process::id()));
+        match std::fs::create_dir(&p) {
+            Ok(()) => return p,
+            Err(error) if error.kind() == ErrorKind::AlreadyExists => {}
+            Err(error) => panic!("create unique workspace {}: {error}", p.display()),
+        }
+    }
 }
 
 include!("tests/normalize.rs");

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),