Initial Control system

3 files changed, 1285 insertions, 3 deletions

diff --git a/makima/src/llm/mesh_tools.rs b/makima/src/llm/mesh_tools.rs
new file mode 100644
index 0000000..1d12c66
--- /dev/null
+++ b/makima/src/llm/mesh_tools.rs
@@ -0,0 +1,1080 @@
+//! 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.".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"
+                                },
+                                "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"
+                                },
+                                "allowCustom": {
+                                    "type": "boolean",
+                                    "description": "If true, user can provide a custom answer"
+                                }
+                            },
+                            "required": ["id", "question", "options"]
+                        }
+                    }
+                },
+                "required": ["questions"]
+            }),
+        },
+    ]
+});
+
+/// 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,
+    },
+}
+
+/// 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),
+
+        _ => 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),
+    }
+}
+
+// =============================================================================
+// 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,
+    }
+}
diff --git a/makima/src/llm/mod.rs b/makima/src/llm/mod.rs
index 1001854..39cdbdd 100644
--- a/makima/src/llm/mod.rs
+++ b/makima/src/llm/mod.rs
@@ -2,10 +2,12 @@
 
 pub mod claude;
 pub mod groq;
+pub mod mesh_tools;
 pub mod tools;
 
 pub use claude::{ClaudeClient, ClaudeModel};
 pub use groq::GroqClient;
+pub use mesh_tools::{parse_mesh_tool_call, MeshToolExecutionResult, MeshToolRequest, MESH_TOOLS};
 pub use tools::{
     execute_tool_call, Tool, ToolCall, ToolResult, UserAnswer, UserQuestion, VersionToolRequest,
     AVAILABLE_TOOLS,
diff --git a/makima/src/llm/tools.rs b/makima/src/llm/tools.rs
index 77fc8c6..649633e 100644
--- a/makima/src/llm/tools.rs
+++ b/makima/src/llm/tools.rs
@@ -73,6 +73,51 @@ pub static AVAILABLE_TOOLS: once_cell::sync::Lazy<Vec<Tool>> =
                 }),
             },
             Tool {
+                name: "add_code".to_string(),
+                description: "Add a code block element to the file body".to_string(),
+                parameters: json!({
+                    "type": "object",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "The code content"
+                        },
+                        "language": {
+                            "type": "string",
+                            "description": "Optional programming language for syntax highlighting (e.g., 'javascript', 'python', 'rust')"
+                        },
+                        "position": {
+                            "type": "integer",
+                            "description": "Optional position to insert at (0-indexed). If not specified, appends to end."
+                        }
+                    },
+                    "required": ["content"]
+                }),
+            },
+            Tool {
+                name: "add_list".to_string(),
+                description: "Add a list element (ordered or unordered) to the file body".to_string(),
+                parameters: json!({
+                    "type": "object",
+                    "properties": {
+                        "items": {
+                            "type": "array",
+                            "items": { "type": "string" },
+                            "description": "Array of list item strings"
+                        },
+                        "ordered": {
+                            "type": "boolean",
+                            "description": "If true, creates a numbered list; if false (default), creates a bullet list"
+                        },
+                        "position": {
+                            "type": "integer",
+                            "description": "Optional position to insert at (0-indexed). If not specified, appends to end."
+                        }
+                    },
+                    "required": ["items"]
+                }),
+            },
+            Tool {
                 name: "add_chart".to_string(),
                 description: "Add a chart visualization to the file body. Supports line, bar, pie, and area charts.".to_string(),
                 parameters: json!({
@@ -122,7 +167,7 @@ pub static AVAILABLE_TOOLS: once_cell::sync::Lazy<Vec<Tool>> =
             },
             Tool {
                 name: "update_element".to_string(),
-                description: "Update an existing element in the file body. IMPORTANT: You must provide ALL required fields. For heading: type, level (1-6), text. For paragraph: type, text. For chart: type, chartType (line/bar/pie/area), data (array of objects).".to_string(),
+                description: "Update an existing element in the file body. IMPORTANT: You must provide ALL required fields. For heading: type, level (1-6), text. For paragraph: type, text. For code: type, content, language (optional). For list: type, items (array of strings), ordered (boolean). For chart: type, chartType (line/bar/pie/area), data (array of objects).".to_string(),
                 parameters: json!({
                     "type": "object",
                     "properties": {
@@ -132,7 +177,7 @@ pub static AVAILABLE_TOOLS: once_cell::sync::Lazy<Vec<Tool>> =
                         },
                         "element_type": {
                             "type": "string",
-                            "enum": ["heading", "paragraph", "chart"],
+                            "enum": ["heading", "paragraph", "code", "list", "chart"],
                             "description": "Type of element"
                         },
                         "text": {
@@ -143,6 +188,23 @@ pub static AVAILABLE_TOOLS: once_cell::sync::Lazy<Vec<Tool>> =
                             "type": "integer",
                             "description": "Heading level 1-6 (required for heading)"
                         },
+                        "content": {
+                            "type": "string",
+                            "description": "Code content (required for code)"
+                        },
+                        "language": {
+                            "type": "string",
+                            "description": "Programming language for syntax highlighting (optional for code)"
+                        },
+                        "items": {
+                            "type": "array",
+                            "items": { "type": "string" },
+                            "description": "List items (required for list)"
+                        },
+                        "ordered": {
+                            "type": "boolean",
+                            "description": "If true, numbered list; if false, bullet list (for list)"
+                        },
                         "chartType": {
                             "type": "string",
                             "enum": ["line", "bar", "pie", "area"],
@@ -418,6 +480,8 @@ pub fn execute_tool_call(
     match call.name.as_str() {
         "add_heading" => execute_add_heading(call, current_body),
         "add_paragraph" => execute_add_paragraph(call, current_body),
+        "add_code" => execute_add_code(call, current_body),
+        "add_list" => execute_add_list(call, current_body),
         "add_chart" => execute_add_chart(call, current_body),
         "remove_element" => execute_remove_element(call, current_body),
         "update_element" => execute_update_element(call, current_body),
@@ -605,6 +669,103 @@ fn execute_add_paragraph(call: &ToolCall, current_body: &[BodyElement]) -> ToolE
     }
 }
 
+fn execute_add_code(call: &ToolCall, current_body: &[BodyElement]) -> ToolExecutionResult {
+    let language = call
+        .arguments
+        .get("language")
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string());
+    let content = call
+        .arguments
+        .get("content")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let position = call.arguments.get("position").and_then(|v| v.as_u64());
+
+    let element = BodyElement::Code {
+        language: language.clone(),
+        content: content.clone(),
+    };
+    let mut new_body = current_body.to_vec();
+
+    if let Some(pos) = position {
+        let pos = pos as usize;
+        if pos <= new_body.len() {
+            new_body.insert(pos, element);
+        } else {
+            new_body.push(element);
+        }
+    } else {
+        new_body.push(element);
+    }
+
+    let lang_str = language.as_deref().unwrap_or("plain");
+    let preview: String = content.chars().take(50).collect();
+
+    ToolExecutionResult {
+        result: ToolResult {
+            success: true,
+            message: format!("Added code block ({}): {}", lang_str, preview),
+        },
+        new_body: Some(new_body),
+        new_summary: None,
+        parsed_data: None,
+        version_request: None,
+        pending_questions: None,
+    }
+}
+
+fn execute_add_list(call: &ToolCall, current_body: &[BodyElement]) -> ToolExecutionResult {
+    let ordered = call
+        .arguments
+        .get("ordered")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false);
+    let items: Vec<String> = call
+        .arguments
+        .get("items")
+        .and_then(|v| v.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                .collect()
+        })
+        .unwrap_or_default();
+    let position = call.arguments.get("position").and_then(|v| v.as_u64());
+
+    let element = BodyElement::List {
+        ordered,
+        items: items.clone(),
+    };
+    let mut new_body = current_body.to_vec();
+
+    if let Some(pos) = position {
+        let pos = pos as usize;
+        if pos <= new_body.len() {
+            new_body.insert(pos, element);
+        } else {
+            new_body.push(element);
+        }
+    } else {
+        new_body.push(element);
+    }
+
+    let list_type = if ordered { "ordered" } else { "unordered" };
+
+    ToolExecutionResult {
+        result: ToolResult {
+            success: true,
+            message: format!("Added {} list with {} items", list_type, items.len()),
+        },
+        new_body: Some(new_body),
+        new_summary: None,
+        parsed_data: None,
+        version_request: None,
+        pending_questions: None,
+    }
+}
+
 fn execute_add_chart(call: &ToolCall, current_body: &[BodyElement]) -> ToolExecutionResult {
     let chart_type_str = call
         .arguments
@@ -778,6 +939,19 @@ fn execute_update_element(call: &ToolCall, current_body: &[BodyElement]) -> Tool
             let text = call.arguments.get("text").and_then(|v| v.as_str()).unwrap_or("").to_string();
             BodyElement::Paragraph { text }
         }
+        "code" => {
+            let language = call.arguments.get("language").and_then(|v| v.as_str()).map(|s| s.to_string());
+            let content = call.arguments.get("content").and_then(|v| v.as_str()).unwrap_or("").to_string();
+            BodyElement::Code { language, content }
+        }
+        "list" => {
+            let ordered = call.arguments.get("ordered").and_then(|v| v.as_bool()).unwrap_or(false);
+            let items = call.arguments.get("items")
+                .and_then(|v| v.as_array())
+                .map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect())
+                .unwrap_or_default();
+            BodyElement::List { ordered, items }
+        }
         "chart" => {
             let chart_type_str = call.arguments.get("chartType").and_then(|v| v.as_str()).unwrap_or("bar");
             let chart_type = match chart_type_str {
@@ -796,7 +970,7 @@ fn execute_update_element(call: &ToolCall, current_body: &[BodyElement]) -> Tool
             return ToolExecutionResult {
                 result: ToolResult {
                     success: false,
-                    message: format!("Unknown element_type: {}. Must be heading, paragraph, or chart.", element_type),
+                    message: format!("Unknown element_type: {}. Must be heading, paragraph, code, list, or chart.", element_type),
                 },
                 new_body: None,
                 new_summary: None,
@@ -1149,6 +1323,18 @@ fn execute_view_body(current_body: &[BodyElement]) -> ToolExecutionResult {
                     "type": "paragraph",
                     "text": text
                 }),
+                BodyElement::Code { language, content } => json!({
+                    "index": i,
+                    "type": "code",
+                    "language": language,
+                    "content": content
+                }),
+                BodyElement::List { ordered, items } => json!({
+                    "index": i,
+                    "type": "list",
+                    "ordered": ordered,
+                    "items": items
+                }),
                 BodyElement::Chart { chart_type, title, data, config } => json!({
                     "index": i,
                     "type": "chart",
@@ -1226,6 +1412,18 @@ fn execute_read_element(call: &ToolCall, current_body: &[BodyElement]) -> ToolEx
             "type": "paragraph",
             "text": text
         }),
+        BodyElement::Code { language, content } => json!({
+            "index": index,
+            "type": "code",
+            "language": language,
+            "content": content
+        }),
+        BodyElement::List { ordered, items } => json!({
+            "index": index,
+            "type": "list",
+            "ordered": ordered,
+            "items": items
+        }),
         BodyElement::Chart { chart_type, title, data, config } => json!({
             "index": index,
             "type": "chart",
@@ -1246,6 +1444,8 @@ fn execute_read_element(call: &ToolCall, current_body: &[BodyElement]) -> ToolEx
     let type_str = match element {
         BodyElement::Heading { .. } => "heading",
         BodyElement::Paragraph { .. } => "paragraph",
+        BodyElement::Code { .. } => "code",
+        BodyElement::List { .. } => "list",
         BodyElement::Chart { .. } => "chart",
         BodyElement::Image { .. } => "image",
     };