path: root/makima/src/llm/mesh_tools.rs

//! Tool definitions for task mesh orchestration via LLM.
//!
//! These tools allow the LLM to create, manage, and coordinate tasks across
//! connected daemons running Claude Code containers.

use serde_json::json;
use uuid::Uuid;

use super::tools::Tool;

/// Available tools for mesh/task orchestration
pub static MESH_TOOLS: once_cell::sync::Lazy<Vec<Tool>> = once_cell::sync::Lazy::new(|| {
    vec![
        // =============================================================================
        // Task Lifecycle Tools
        // =============================================================================
        Tool {
            name: "create_task".to_string(),
            description: "Create a new task (or subtask if parent_task_id provided). The task will be in 'pending' status until run_task is called.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "Name of the task"
                    },
                    "plan": {
                        "type": "string",
                        "description": "Detailed instructions/plan for what the task should accomplish"
                    },
                    "parent_task_id": {
                        "type": "string",
                        "description": "Optional parent task ID to create this as a subtask"
                    },
                    "repository_url": {
                        "type": "string",
                        "description": "Git repository URL or local path for the task (required)"
                    },
                    "base_branch": {
                        "type": "string",
                        "description": "Optional base branch to start from (default: main)"
                    },
                    "merge_mode": {
                        "type": "string",
                        "enum": ["pr", "auto", "manual"],
                        "description": "How to handle completion: 'pr' creates PR, 'auto' auto-merges, 'manual' leaves changes for review"
                    },
                    "priority": {
                        "type": "integer",
                        "description": "Task priority (higher = more important, default: 0)"
                    }
                },
                "required": ["name", "plan", "repository_url"]
            }),
        },
        Tool {
            name: "run_task".to_string(),
            description: "Start executing a pending task on an available daemon. The task must be in 'pending' or 'paused' status.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to run"
                    },
                    "daemon_id": {
                        "type": "string",
                        "description": "Optional specific daemon ID to run on. If not specified, an available daemon will be selected."
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "pause_task".to_string(),
            description: "Pause a running task. The container state will be preserved.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to pause"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "resume_task".to_string(),
            description: "Resume a paused task.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to resume"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "interrupt_task".to_string(),
            description: "Interrupt a running task. Use graceful=true to allow current operation to complete.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to interrupt"
                    },
                    "graceful": {
                        "type": "boolean",
                        "description": "If true, wait for current operation to complete before stopping"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "discard_task".to_string(),
            description: "Discard a task and delete its overlay. All changes will be lost. Use with caution.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to discard"
                    },
                    "confirm": {
                        "type": "boolean",
                        "description": "Must be true to confirm deletion"
                    }
                },
                "required": ["task_id", "confirm"]
            }),
        },
        // =============================================================================
        // Task Query Tools
        // =============================================================================
        Tool {
            name: "query_task_status".to_string(),
            description: "Get detailed status and information about a task.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to query"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "list_tasks".to_string(),
            description: "List all tasks, optionally filtered by status or parent.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "status_filter": {
                        "type": "string",
                        "enum": ["pending", "running", "paused", "blocked", "done", "failed", "merged"],
                        "description": "Optional filter by task status"
                    },
                    "parent_task_id": {
                        "type": "string",
                        "description": "Optional filter to list only subtasks of this parent"
                    }
                }
            }),
        },
        Tool {
            name: "list_subtasks".to_string(),
            description: "List all subtasks of a specific task.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the parent task"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "list_siblings".to_string(),
            description: "List sibling tasks (tasks with the same parent) of a specific task.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to find siblings for"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "list_daemons".to_string(),
            description: "List all connected daemons and their current status.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {}
            }),
        },
        Tool {
            name: "list_daemon_directories".to_string(),
            description: "List all available directories from connected daemons. Use this to find existing repositories and suggested working directories when creating tasks. Returns directories like the daemon's working directory and home directory where repos can be cloned.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {}
            }),
        },
        // =============================================================================
        // File Access Tools
        // =============================================================================
        Tool {
            name: "list_files".to_string(),
            description: "List all files available in the system. Returns file IDs, names, and descriptions.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {}
            }),
        },
        Tool {
            name: "read_file".to_string(),
            description: "Read the contents of a file from the files system. Returns the file's name, description, summary, body content (headings and paragraphs), and transcript entries with speaker and timing information.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "file_id": {
                        "type": "string",
                        "description": "ID of the file to read"
                    }
                },
                "required": ["file_id"]
            }),
        },
        // =============================================================================
        // Task Communication Tools
        // =============================================================================
        Tool {
            name: "send_message_to_task".to_string(),
            description: "Send a message to a running task's Claude Code instance. Use this to provide additional context, answer questions, or give new instructions.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the running task"
                    },
                    "message": {
                        "type": "string",
                        "description": "Message to send to the task"
                    }
                },
                "required": ["task_id", "message"]
            }),
        },
        Tool {
            name: "update_task_plan".to_string(),
            description: "Update the plan/instructions for a task. Can optionally interrupt a running task to apply new plan.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to update"
                    },
                    "new_plan": {
                        "type": "string",
                        "description": "New plan/instructions for the task"
                    },
                    "interrupt_if_running": {
                        "type": "boolean",
                        "description": "If true and task is running, interrupt it to apply new plan"
                    }
                },
                "required": ["task_id", "new_plan"]
            }),
        },
        // =============================================================================
        // Overlay/Merge Tools
        // =============================================================================
        Tool {
            name: "peek_sibling_overlay".to_string(),
            description: "View the changes made by a sibling task's overlay. Useful for understanding what other tasks have done before merging.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "sibling_task_id": {
                        "type": "string",
                        "description": "ID of the sibling task to peek at"
                    }
                },
                "required": ["sibling_task_id"]
            }),
        },
        Tool {
            name: "get_overlay_diff".to_string(),
            description: "Get a git diff of all changes in a task's overlay.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "preview_merge".to_string(),
            description: "Preview what a merge would look like without actually merging. Shows potential conflicts.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to preview merge for"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "merge_subtask".to_string(),
            description: "Merge a completed subtask's changes to its parent branch.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the subtask to merge"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "complete_task".to_string(),
            description: "Mark a task as complete and trigger the merge flow based on merge_mode. For 'pr' mode, creates a pull request. For 'auto' mode, merges directly.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to complete"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "set_merge_mode".to_string(),
            description: "Change the merge mode for a task.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task"
                    },
                    "mode": {
                        "type": "string",
                        "enum": ["pr", "auto", "manual"],
                        "description": "New merge mode: 'pr' (create PR), 'auto' (auto-merge), 'manual' (leave for manual review)"
                    }
                },
                "required": ["task_id", "mode"]
            }),
        },
        // =============================================================================
        // Interactive Tools
        // =============================================================================
        Tool {
            name: "ask_user".to_string(),
            description: "Ask the user one or more questions. Use this when you need clarification, want to offer choices, or need user input before proceeding. Questions can be single-select (user picks one option) or multi-select (user can pick multiple options). The question text supports markdown formatting.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "questions": {
                        "type": "array",
                        "description": "List of questions to ask the user",
                        "items": {
                            "type": "object",
                            "properties": {
                                "id": {
                                    "type": "string",
                                    "description": "Unique identifier for this question"
                                },
                                "question": {
                                    "type": "string",
                                    "description": "The question to ask the user. Supports markdown formatting (bold, code, lists, etc.)"
                                },
                                "options": {
                                    "type": "array",
                                    "items": { "type": "string" },
                                    "description": "Multiple choice options for the user to select from"
                                },
                                "allowMultiple": {
                                    "type": "boolean",
                                    "description": "If true, user can select multiple options (multi-select). If false or omitted, user selects exactly one option (single-select). Default: false"
                                },
                                "allowCustom": {
                                    "type": "boolean",
                                    "description": "If true, user can provide a custom text answer instead of selecting from options. Default: true"
                                }
                            },
                            "required": ["id", "question", "options"]
                        }
                    }
                },
                "required": ["questions"]
            }),
        },
        // =============================================================================
        // Supervisor Tools (only available to supervisor tasks)
        // =============================================================================
        Tool {
            name: "get_all_contract_tasks".to_string(),
            description: "Get status of all tasks in the contract tree. Only available to supervisor tasks.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "contract_id": {
                        "type": "string",
                        "description": "ID of the contract to query tasks for"
                    }
                },
                "required": ["contract_id"]
            }),
        },
        Tool {
            name: "wait_for_task_completion".to_string(),
            description: "Block until a task completes or timeout. Only available to supervisor tasks.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to wait for"
                    },
                    "timeout_seconds": {
                        "type": "integer",
                        "description": "Maximum time to wait in seconds (default: 300)",
                        "default": 300
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "read_task_worktree".to_string(),
            description: "Read a file from any task's worktree. Only available to supervisor tasks.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task whose worktree to read from"
                    },
                    "file_path": {
                        "type": "string",
                        "description": "Path to the file within the worktree"
                    }
                },
                "required": ["task_id", "file_path"]
            }),
        },
        Tool {
            name: "spawn_task".to_string(),
            description: "Create and start a child task (fire and forget). Only available to supervisor tasks.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "Name of the task"
                    },
                    "plan": {
                        "type": "string",
                        "description": "Detailed instructions/plan for what the task should accomplish"
                    },
                    "parent_task_id": {
                        "type": "string",
                        "description": "Optional parent task to branch from"
                    },
                    "checkpoint_sha": {
                        "type": "string",
                        "description": "Optional checkpoint SHA to branch from"
                    },
                    "repository_url": {
                        "type": "string",
                        "description": "Git repository URL (optional - inherits from contract if not provided)"
                    },
                    "base_branch": {
                        "type": "string",
                        "description": "Optional base branch to start from"
                    }
                },
                "required": ["name", "plan"]
            }),
        },
        Tool {
            name: "create_checkpoint".to_string(),
            description: "Create a git checkpoint (commit) in the current task's worktree. Only available to supervisor tasks.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to checkpoint"
                    },
                    "message": {
                        "type": "string",
                        "description": "Commit message for the checkpoint"
                    }
                },
                "required": ["task_id", "message"]
            }),
        },
        Tool {
            name: "list_task_checkpoints".to_string(),
            description: "List all checkpoints for a task.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the task to list checkpoints for"
                    }
                },
                "required": ["task_id"]
            }),
        },
        Tool {
            name: "get_task_tree".to_string(),
            description: "Get the full task tree starting from a specific task.".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "type": "string",
                        "description": "ID of the root task"
                    }
                },
                "required": ["task_id"]
            }),
        },
    ]
});

/// Request for mesh tool operations that require async database/daemon access
#[derive(Debug, Clone)]
pub enum MeshToolRequest {
    // Task lifecycle
    CreateTask {
        name: String,
        plan: String,
        parent_task_id: Option<Uuid>,
        repository_url: Option<String>,
        base_branch: Option<String>,
        merge_mode: Option<String>,
        priority: Option<i32>,
    },
    RunTask {
        task_id: Uuid,
        daemon_id: Option<Uuid>,
    },
    PauseTask {
        task_id: Uuid,
    },
    ResumeTask {
        task_id: Uuid,
    },
    InterruptTask {
        task_id: Uuid,
        graceful: bool,
    },
    DiscardTask {
        task_id: Uuid,
    },

    // Task queries
    QueryTaskStatus {
        task_id: Uuid,
    },
    ListTasks {
        status_filter: Option<String>,
        parent_task_id: Option<Uuid>,
    },
    ListSubtasks {
        task_id: Uuid,
    },
    ListSiblings {
        task_id: Uuid,
    },
    ListDaemons,
    ListDaemonDirectories,

    // File access
    ListFiles,
    ReadFile {
        file_id: Uuid,
    },

    // Task communication
    SendMessageToTask {
        task_id: Uuid,
        message: String,
    },
    UpdateTaskPlan {
        task_id: Uuid,
        new_plan: String,
        interrupt_if_running: bool,
    },

    // Overlay/merge operations
    PeekSiblingOverlay {
        sibling_task_id: Uuid,
    },
    GetOverlayDiff {
        task_id: Uuid,
    },
    PreviewMerge {
        task_id: Uuid,
    },
    MergeSubtask {
        task_id: Uuid,
    },
    CompleteTask {
        task_id: Uuid,
    },
    SetMergeMode {
        task_id: Uuid,
        mode: String,
    },

    // Supervisor tools (only for supervisor tasks)
    GetAllContractTasks {
        contract_id: Uuid,
    },
    WaitForTaskCompletion {
        task_id: Uuid,
        timeout_seconds: i32,
    },
    ReadTaskWorktree {
        task_id: Uuid,
        file_path: String,
    },
    SpawnTask {
        name: String,
        plan: String,
        parent_task_id: Option<Uuid>,
        checkpoint_sha: Option<String>,
        repository_url: Option<String>,
        base_branch: Option<String>,
    },
    CreateCheckpoint {
        task_id: Uuid,
        message: String,
    },
    ListTaskCheckpoints {
        task_id: Uuid,
    },
    GetTaskTree {
        task_id: Uuid,
    },
}

/// Result from executing a mesh tool
#[derive(Debug)]
pub struct MeshToolExecutionResult {
    pub success: bool,
    pub message: String,
    pub data: Option<serde_json::Value>,
    /// Request for async operations (handled by mesh_chat handler)
    pub request: Option<MeshToolRequest>,
    /// Questions to ask the user (pauses conversation)
    pub pending_questions: Option<Vec<super::tools::UserQuestion>>,
}

/// Parse and validate a mesh tool call, returning a MeshToolRequest for async handling
pub fn parse_mesh_tool_call(
    call: &super::tools::ToolCall,
) -> MeshToolExecutionResult {
    match call.name.as_str() {
        // Task lifecycle
        "create_task" => parse_create_task(call),
        "run_task" => parse_run_task(call),
        "pause_task" => parse_pause_task(call),
        "resume_task" => parse_resume_task(call),
        "interrupt_task" => parse_interrupt_task(call),
        "discard_task" => parse_discard_task(call),

        // Task queries
        "query_task_status" => parse_query_task_status(call),
        "list_tasks" => parse_list_tasks(call),
        "list_subtasks" => parse_list_subtasks(call),
        "list_siblings" => parse_list_siblings(call),
        "list_daemons" => parse_list_daemons(),
        "list_daemon_directories" => parse_list_daemon_directories(),

        // File access
        "list_files" => parse_list_files(),
        "read_file" => parse_read_file(call),

        // Task communication
        "send_message_to_task" => parse_send_message_to_task(call),
        "update_task_plan" => parse_update_task_plan(call),

        // Overlay/merge operations
        "peek_sibling_overlay" => parse_peek_sibling_overlay(call),
        "get_overlay_diff" => parse_get_overlay_diff(call),
        "preview_merge" => parse_preview_merge(call),
        "merge_subtask" => parse_merge_subtask(call),
        "complete_task" => parse_complete_task(call),
        "set_merge_mode" => parse_set_merge_mode(call),

        // Interactive tools
        "ask_user" => parse_ask_user(call),

        // Supervisor tools
        "get_all_contract_tasks" => parse_get_all_contract_tasks(call),
        "wait_for_task_completion" => parse_wait_for_task_completion(call),
        "read_task_worktree" => parse_read_task_worktree(call),
        "spawn_task" => parse_spawn_task(call),
        "create_checkpoint" => parse_create_checkpoint(call),
        "list_task_checkpoints" => parse_list_task_checkpoints(call),
        "get_task_tree" => parse_get_task_tree(call),

        _ => MeshToolExecutionResult {
            success: false,
            message: format!("Unknown mesh tool: {}", call.name),
            data: None,
            request: None,
            pending_questions: None,
        },
    }
}

// =============================================================================
// Tool Parsing Functions
// =============================================================================

fn parse_create_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let name = call.arguments.get("name").and_then(|v| v.as_str());
    let plan = call.arguments.get("plan").and_then(|v| v.as_str());
    let repository_url = call
        .arguments
        .get("repository_url")
        .and_then(|v| v.as_str());

    let Some(name) = name else {
        return error_result("Missing required parameter: name");
    };
    let Some(plan) = plan else {
        return error_result("Missing required parameter: plan");
    };
    let Some(repository_url) = repository_url else {
        return error_result("Missing required parameter: repository_url");
    };

    let parent_task_id = call
        .arguments
        .get("parent_task_id")
        .and_then(|v| v.as_str())
        .and_then(|s| Uuid::parse_str(s).ok());

    let repository_url = Some(repository_url.to_string());

    let base_branch = call
        .arguments
        .get("base_branch")
        .and_then(|v| v.as_str())
        .map(|s| s.to_string());

    let merge_mode = call
        .arguments
        .get("merge_mode")
        .and_then(|v| v.as_str())
        .map(|s| s.to_string());

    let priority = call
        .arguments
        .get("priority")
        .and_then(|v| v.as_i64())
        .map(|v| v as i32);

    MeshToolExecutionResult {
        success: true,
        message: "Creating task...".to_string(),
        data: None,
        request: Some(MeshToolRequest::CreateTask {
            name: name.to_string(),
            plan: plan.to_string(),
            parent_task_id,
            repository_url,
            base_branch,
            merge_mode,
            priority,
        }),
        pending_questions: None,
    }
}

fn parse_run_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    let daemon_id = call
        .arguments
        .get("daemon_id")
        .and_then(|v| v.as_str())
        .and_then(|s| Uuid::parse_str(s).ok());

    MeshToolExecutionResult {
        success: true,
        message: "Starting task...".to_string(),
        data: None,
        request: Some(MeshToolRequest::RunTask { task_id, daemon_id }),
        pending_questions: None,
    }
}

fn parse_pause_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Pausing task...".to_string(),
        data: None,
        request: Some(MeshToolRequest::PauseTask { task_id }),
        pending_questions: None,
    }
}

fn parse_resume_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Resuming task...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ResumeTask { task_id }),
        pending_questions: None,
    }
}

fn parse_interrupt_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    let graceful = call
        .arguments
        .get("graceful")
        .and_then(|v| v.as_bool())
        .unwrap_or(true);

    MeshToolExecutionResult {
        success: true,
        message: if graceful {
            "Gracefully interrupting task...".to_string()
        } else {
            "Force interrupting task...".to_string()
        },
        data: None,
        request: Some(MeshToolRequest::InterruptTask { task_id, graceful }),
        pending_questions: None,
    }
}

fn parse_discard_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    let confirm = call
        .arguments
        .get("confirm")
        .and_then(|v| v.as_bool())
        .unwrap_or(false);

    if !confirm {
        return error_result("Must set confirm=true to discard a task");
    }

    MeshToolExecutionResult {
        success: true,
        message: "Discarding task...".to_string(),
        data: None,
        request: Some(MeshToolRequest::DiscardTask { task_id }),
        pending_questions: None,
    }
}

fn parse_query_task_status(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Querying task status...".to_string(),
        data: None,
        request: Some(MeshToolRequest::QueryTaskStatus { task_id }),
        pending_questions: None,
    }
}

fn parse_list_tasks(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let status_filter = call
        .arguments
        .get("status_filter")
        .and_then(|v| v.as_str())
        .map(|s| s.to_string());

    let parent_task_id = call
        .arguments
        .get("parent_task_id")
        .and_then(|v| v.as_str())
        .and_then(|s| Uuid::parse_str(s).ok());

    MeshToolExecutionResult {
        success: true,
        message: "Listing tasks...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ListTasks {
            status_filter,
            parent_task_id,
        }),
        pending_questions: None,
    }
}

fn parse_list_subtasks(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Listing subtasks...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ListSubtasks { task_id }),
        pending_questions: None,
    }
}

fn parse_list_siblings(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Listing sibling tasks...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ListSiblings { task_id }),
        pending_questions: None,
    }
}

fn parse_list_daemons() -> MeshToolExecutionResult {
    MeshToolExecutionResult {
        success: true,
        message: "Listing daemons...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ListDaemons),
        pending_questions: None,
    }
}

fn parse_list_daemon_directories() -> MeshToolExecutionResult {
    MeshToolExecutionResult {
        success: true,
        message: "Listing daemon directories...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ListDaemonDirectories),
        pending_questions: None,
    }
}

fn parse_list_files() -> MeshToolExecutionResult {
    MeshToolExecutionResult {
        success: true,
        message: "Listing files...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ListFiles),
        pending_questions: None,
    }
}

fn parse_read_file(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let file_id = parse_uuid_arg(call, "file_id");
    let Some(file_id) = file_id else {
        return error_result("Missing or invalid required parameter: file_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Reading file...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ReadFile { file_id }),
        pending_questions: None,
    }
}

fn parse_send_message_to_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    let message = call.arguments.get("message").and_then(|v| v.as_str());
    let Some(message) = message else {
        return error_result("Missing required parameter: message");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Sending message to task...".to_string(),
        data: None,
        request: Some(MeshToolRequest::SendMessageToTask {
            task_id,
            message: message.to_string(),
        }),
        pending_questions: None,
    }
}

fn parse_update_task_plan(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    let new_plan = call.arguments.get("new_plan").and_then(|v| v.as_str());
    let Some(new_plan) = new_plan else {
        return error_result("Missing required parameter: new_plan");
    };

    let interrupt_if_running = call
        .arguments
        .get("interrupt_if_running")
        .and_then(|v| v.as_bool())
        .unwrap_or(false);

    MeshToolExecutionResult {
        success: true,
        message: "Updating task plan...".to_string(),
        data: None,
        request: Some(MeshToolRequest::UpdateTaskPlan {
            task_id,
            new_plan: new_plan.to_string(),
            interrupt_if_running,
        }),
        pending_questions: None,
    }
}

fn parse_peek_sibling_overlay(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let sibling_task_id = parse_uuid_arg(call, "sibling_task_id");
    let Some(sibling_task_id) = sibling_task_id else {
        return error_result("Missing or invalid required parameter: sibling_task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Peeking at sibling overlay...".to_string(),
        data: None,
        request: Some(MeshToolRequest::PeekSiblingOverlay { sibling_task_id }),
        pending_questions: None,
    }
}

fn parse_get_overlay_diff(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Getting overlay diff...".to_string(),
        data: None,
        request: Some(MeshToolRequest::GetOverlayDiff { task_id }),
        pending_questions: None,
    }
}

fn parse_preview_merge(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Previewing merge...".to_string(),
        data: None,
        request: Some(MeshToolRequest::PreviewMerge { task_id }),
        pending_questions: None,
    }
}

fn parse_merge_subtask(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Merging subtask...".to_string(),
        data: None,
        request: Some(MeshToolRequest::MergeSubtask { task_id }),
        pending_questions: None,
    }
}

fn parse_complete_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Completing task...".to_string(),
        data: None,
        request: Some(MeshToolRequest::CompleteTask { task_id }),
        pending_questions: None,
    }
}

fn parse_set_merge_mode(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let task_id = parse_uuid_arg(call, "task_id");
    let Some(task_id) = task_id else {
        return error_result("Missing or invalid required parameter: task_id");
    };

    let mode = call.arguments.get("mode").and_then(|v| v.as_str());
    let Some(mode) = mode else {
        return error_result("Missing required parameter: mode");
    };

    if !["pr", "auto", "manual"].contains(&mode) {
        return error_result("Invalid mode. Must be 'pr', 'auto', or 'manual'");
    }

    MeshToolExecutionResult {
        success: true,
        message: format!("Setting merge mode to '{}'...", mode),
        data: None,
        request: Some(MeshToolRequest::SetMergeMode {
            task_id,
            mode: mode.to_string(),
        }),
        pending_questions: None,
    }
}

fn parse_ask_user(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let questions_value = call.arguments.get("questions");

    let Some(questions_array) = questions_value.and_then(|v| v.as_array()) else {
        return error_result("Missing or invalid 'questions' parameter");
    };

    let mut questions: Vec<super::tools::UserQuestion> = Vec::new();

    for q in questions_array {
        let id = q.get("id").and_then(|v| v.as_str()).unwrap_or("").to_string();
        let question = q.get("question").and_then(|v| v.as_str()).unwrap_or("").to_string();
        let options: Vec<String> = q
            .get("options")
            .and_then(|v| v.as_array())
            .map(|arr| {
                arr.iter()
                    .filter_map(|o| o.as_str())
                    .map(|s| s.to_string())
                    .collect()
            })
            .unwrap_or_default();
        let allow_multiple = q.get("allowMultiple").and_then(|v| v.as_bool()).unwrap_or(false);
        let allow_custom = q.get("allowCustom").and_then(|v| v.as_bool()).unwrap_or(true);

        if id.is_empty() || question.is_empty() || options.is_empty() {
            continue;
        }

        questions.push(super::tools::UserQuestion {
            id,
            question,
            options,
            allow_multiple,
            allow_custom,
        });
    }

    if questions.is_empty() {
        return error_result("No valid questions provided");
    }

    let question_count = questions.len();
    MeshToolExecutionResult {
        success: true,
        message: format!("Asking user {} question(s). Waiting for response...", question_count),
        data: None,
        request: None,
        pending_questions: Some(questions),
    }
}

// =============================================================================
// Supervisor Tool Parsing Functions
// =============================================================================

fn parse_get_all_contract_tasks(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let Some(contract_id) = parse_uuid_arg(call, "contract_id") else {
        return error_result("Missing or invalid contract_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Querying all contract tasks...".to_string(),
        data: None,
        request: Some(MeshToolRequest::GetAllContractTasks { contract_id }),
        pending_questions: None,
    }
}

fn parse_wait_for_task_completion(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let Some(task_id) = parse_uuid_arg(call, "task_id") else {
        return error_result("Missing or invalid task_id");
    };

    let timeout_seconds = call
        .arguments
        .get("timeout_seconds")
        .and_then(|v| v.as_i64())
        .map(|v| v as i32)
        .unwrap_or(300);

    MeshToolExecutionResult {
        success: true,
        message: format!("Waiting for task completion (timeout: {}s)...", timeout_seconds),
        data: None,
        request: Some(MeshToolRequest::WaitForTaskCompletion {
            task_id,
            timeout_seconds,
        }),
        pending_questions: None,
    }
}

fn parse_read_task_worktree(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let Some(task_id) = parse_uuid_arg(call, "task_id") else {
        return error_result("Missing or invalid task_id");
    };

    let Some(file_path) = call.arguments.get("file_path").and_then(|v| v.as_str()) else {
        return error_result("Missing required parameter: file_path");
    };

    MeshToolExecutionResult {
        success: true,
        message: format!("Reading file from task worktree: {}", file_path),
        data: None,
        request: Some(MeshToolRequest::ReadTaskWorktree {
            task_id,
            file_path: file_path.to_string(),
        }),
        pending_questions: None,
    }
}

fn parse_spawn_task(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let Some(name) = call.arguments.get("name").and_then(|v| v.as_str()) else {
        return error_result("Missing required parameter: name");
    };

    let Some(plan) = call.arguments.get("plan").and_then(|v| v.as_str()) else {
        return error_result("Missing required parameter: plan");
    };

    let parent_task_id = parse_uuid_arg(call, "parent_task_id");

    let checkpoint_sha = call
        .arguments
        .get("checkpoint_sha")
        .and_then(|v| v.as_str())
        .map(|s| s.to_string());

    let repository_url = call
        .arguments
        .get("repository_url")
        .and_then(|v| v.as_str())
        .map(|s| s.to_string());

    let base_branch = call
        .arguments
        .get("base_branch")
        .and_then(|v| v.as_str())
        .map(|s| s.to_string());

    MeshToolExecutionResult {
        success: true,
        message: format!("Spawning task: {}", name),
        data: None,
        request: Some(MeshToolRequest::SpawnTask {
            name: name.to_string(),
            plan: plan.to_string(),
            parent_task_id,
            checkpoint_sha,
            repository_url,
            base_branch,
        }),
        pending_questions: None,
    }
}

fn parse_create_checkpoint(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let Some(task_id) = parse_uuid_arg(call, "task_id") else {
        return error_result("Missing or invalid task_id");
    };

    let Some(message) = call.arguments.get("message").and_then(|v| v.as_str()) else {
        return error_result("Missing required parameter: message");
    };

    MeshToolExecutionResult {
        success: true,
        message: format!("Creating checkpoint: {}", message),
        data: None,
        request: Some(MeshToolRequest::CreateCheckpoint {
            task_id,
            message: message.to_string(),
        }),
        pending_questions: None,
    }
}

fn parse_list_task_checkpoints(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let Some(task_id) = parse_uuid_arg(call, "task_id") else {
        return error_result("Missing or invalid task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Listing task checkpoints...".to_string(),
        data: None,
        request: Some(MeshToolRequest::ListTaskCheckpoints { task_id }),
        pending_questions: None,
    }
}

fn parse_get_task_tree(call: &super::tools::ToolCall) -> MeshToolExecutionResult {
    let Some(task_id) = parse_uuid_arg(call, "task_id") else {
        return error_result("Missing or invalid task_id");
    };

    MeshToolExecutionResult {
        success: true,
        message: "Getting task tree...".to_string(),
        data: None,
        request: Some(MeshToolRequest::GetTaskTree { task_id }),
        pending_questions: None,
    }
}

// =============================================================================
// Helper Functions
// =============================================================================

fn parse_uuid_arg(call: &super::tools::ToolCall, key: &str) -> Option<Uuid> {
    call.arguments
        .get(key)
        .and_then(|v| v.as_str())
        .and_then(|s| Uuid::parse_str(s).ok())
}

fn error_result(message: &str) -> MeshToolExecutionResult {
    MeshToolExecutionResult {
        success: false,
        message: message.to_string(),
        data: None,
        request: None,
        pending_questions: None,
    }
}