cc-claw 0.13.1 → 0.14.0

package/dist/agents/mcp-server.js

@@ -46,347 +46,623 @@ async function callApi(path, body) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function ok(text) {
+  return { content: [{ type: "text", text }] };
+}
+function fail(msg) {
+  return { content: [{ type: "text", text: msg }], isError: true };
+}
 var server = new McpServer({
   name: "cc-claw-orchestrator",
-  version: "1.0.0"
+  version: "2.0.0"
 });
-if (!IS_SUB_AGENT) {
-  server.tool(
-    "spawn_agent",
-    `Spawn a sub-agent using a specific CLI runner to execute a task.
-
-CRITICAL \u2014 Path verification:
-Before calling this tool with a cwd, you MUST verify the path exists using your file system tools (Glob, Read, ls, etc.).
-User-provided paths are often approximate (wrong name, missing suffix, typo). Always confirm the exact path yourself.
-A non-existent cwd will cause the agent to fail immediately. Never pass an unverified path.
-
-Typical workflow:
-1. User says "scan the foo-bar folder under dev_projects"
-2. You run: ls /Users/.../dev_projects/ (or Glob) to find the actual folder name
-3. You confirm the exact path exists (e.g., it might be foo-bars, foobar, foo_bar, etc.)
-4. Only then call spawn_agent with the verified cwd`,
-    {
-      runner: z.string().describe("CLI runner ID (e.g., 'claude', 'gemini', 'codex', 'cursor', 'opencode')"),
-      task: z.string().describe("Task description for the sub-agent"),
-      name: z.string().optional().describe("Human-readable agent name (e.g., 'security-reviewer', 'linkedin-writer')"),
-      description: z.string().optional().describe("Short description of what this agent does"),
-      model: z.string().optional().describe("Model override for the sub-agent"),
-      skills: z.array(z.string()).optional().describe("Skills to inject into the sub-agent"),
-      permMode: z.string().optional().describe("Permission mode: yolo, safe, plan (defaults to chat's mode)"),
-      role: z.string().optional().describe("Agent role. Presets: worker, reviewer, planner, researcher, writer, analyst, debugger, critic, synthesizer. Custom roles accepted as labels."),
-      persona: z.string().optional().describe("Custom system prompt for the agent. Replaces the role's default prompt while preserving orchestrator tools and task."),
-      allowedTools: z.array(z.string()).optional().describe("Restrict agent to specific tools (Claude-only). E.g., ['Read', 'Grep', 'Glob']"),
-      maxRuntimeMs: z.number().optional().describe("Max runtime in ms before timeout (default: 600000 = 10 min)"),
-      summarizeResult: z.boolean().optional().describe("Summarize agent output before posting to inbox"),
-      mcps: z.array(z.string()).optional().describe("MCP servers to inject into the sub-agent"),
-      cwd: z.string().optional().describe("Working directory for the sub-agent. MUST be a verified, existing absolute path \u2014 check it before calling."),
-      template: z.string().optional().describe("Name of an agent template from ~/.cc-claw/agents/ to use as defaults. Call list_templates to discover available templates. Call-time params override template defaults.")
-    },
-    async (params) => {
-      try {
-        const result = await callApi("/api/orchestrator/spawn", { chatId: CHAT_ID, ...params });
-        const status = result.queued ? "queued (at capacity, will start when a slot opens)" : "spawning";
-        return {
-          content: [{ type: "text", text: `Agent ${result.agentId} \u2014 ${status}` }]
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `spawn_agent failed: ${msg}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "list_templates",
-    "List available agent templates from ~/.cc-claw/agents/. Use a template name with spawn_agent's template parameter to spawn a pre-configured agent.",
-    {},
-    async () => {
-      const templates = await callApi("/api/orchestrator/list-templates");
-      if (!templates.length) {
-        return { content: [{ type: "text", text: "No agent templates found. Create .md files in ~/.cc-claw/agents/ with YAML frontmatter." }] };
-      }
-      const lines = templates.map(
-        (t) => `\u2022 **${t.name}**${t.description ? ` \u2014 ${t.description}` : ""}${t.runner ? ` (runner: ${t.runner})` : ""}${t.model ? ` [${t.model}]` : ""}`
-      );
-      return { content: [{ type: "text", text: lines.join("\n") }] };
-    }
-  );
-  server.tool(
-    "cancel_agent",
-    "Cancel a specific sub-agent",
-    {
-      agentId: z.string().describe("The agent ID to cancel"),
-      reason: z.string().optional().describe("Reason for cancellation")
-    },
-    async ({ agentId, reason }) => {
-      const result = await callApi("/api/orchestrator/cancel", { agentId, reason });
-      return {
-        content: [{ type: "text", text: result.success ? `Agent ${agentId} cancelled.` : `Agent ${agentId} not found or already completed.` }]
-      };
-    }
-  );
-  server.tool(
-    "create_task",
-    "Add a task to the shared task list",
-    {
-      subject: z.string().describe("Short imperative title for the task"),
-      description: z.string().describe("Detailed task requirements"),
-      assignee: z.string().optional().describe("Agent ID to assign the task to"),
-      blockedBy: z.array(z.number()).optional().describe("Task IDs that must complete before this task can start")
-    },
-    async (params) => {
-      const result = await callApi("/api/orchestrator/create-task", {
-        chatId: CHAT_ID,
-        task: { ...params, createdBy: AGENT_ID }
-      });
-      return {
-        content: [{ type: "text", text: `Task #${result.taskId} created.` }]
-      };
-    }
-  );
-}
 server.tool(
-  "list_agents",
-  "List all active and queued sub-agents",
-  {},
-  async () => {
-    const agents = await callApi("/api/agents");
-    if (!agents.length) {
-      return { content: [{ type: "text", text: "No active agents." }] };
-    }
-    const lines = agents.map((a) => {
-      const label = a.name ?? a.id.slice(0, 8);
-      return `\u2022 ${label} (${a.runnerId}) \u2014 ${a.status}${a.task ? ` \u2192 ${a.task.slice(0, 80)}` : ""}`;
-    });
-    return { content: [{ type: "text", text: lines.join("\n") }] };
-  }
-);
-server.tool(
-  "check_agent",
-  "Get detailed status of a specific agent",
+  "cc_claw_agents",
+  `Agent lifecycle management. Actions:
+\u2022 spawn \u2014 Spawn a sub-agent (main agent only). CRITICAL: verify cwd paths exist before calling.
+\u2022 cancel \u2014 Cancel a running agent (main agent only)
+\u2022 list \u2014 List all active/queued agents
+\u2022 status \u2014 Get detailed agent status (requires agentId)
+\u2022 templates \u2014 List available agent templates from ~/.cc-claw/agents/
+\u2022 runners \u2014 List registered CLI runners
+\u2022 mcps \u2014 List MCP servers in registry`,
   {
-    agentId: z.string().describe("The agent ID to check")
+    action: z.enum(["spawn", "cancel", "list", "status", "templates", "runners", "mcps"]).describe("Action to perform"),
+    // spawn params
+    runner: z.string().optional().describe("CLI runner ID (e.g., 'claude', 'gemini', 'codex')"),
+    task: z.string().optional().describe("Task description for the sub-agent"),
+    name: z.string().optional().describe("Human-readable agent name"),
+    description: z.string().optional().describe("Short description of what this agent does"),
+    model: z.string().optional().describe("Model override"),
+    skills: z.array(z.string()).optional().describe("Skills to inject"),
+    permMode: z.string().optional().describe("Permission mode: yolo, safe, plan"),
+    role: z.string().optional().describe("Agent role (worker, reviewer, planner, etc.)"),
+    persona: z.string().optional().describe("Custom system prompt"),
+    allowedTools: z.array(z.string()).optional().describe("Restrict agent to specific tools"),
+    maxRuntimeMs: z.number().optional().describe("Max runtime in ms before timeout"),
+    summarizeResult: z.boolean().optional().describe("Summarize agent output"),
+    mcps: z.array(z.string()).optional().describe("MCP servers to inject"),
+    cwd: z.string().optional().describe("Working directory (must be verified, existing absolute path)"),
+    template: z.string().optional().describe("Agent template name from ~/.cc-claw/agents/"),
+    // cancel params
+    agentId: z.string().optional().describe("Agent ID (for cancel, status)"),
+    reason: z.string().optional().describe("Reason for cancellation")
   },
-  async ({ agentId }) => {
-    const agent = await callApi("/api/orchestrator/check-agent", { agentId });
-    if (!agent) {
-      return { content: [{ type: "text", text: `Agent ${agentId} not found.` }] };
-    }
-    return {
-      content: [{
-        type: "text",
-        text: [
-          `Agent: ${agent.name ?? agent.id.slice(0, 8)} (${agent.runnerId})`,
-          agent.name ? `ID: ${agent.id.slice(0, 8)}` : null,
-          agent.description ? `Description: ${agent.description}` : null,
-          `Status: ${agent.status}`,
-          `Task: ${agent.task ?? "none"}`,
-          `Role: ${agent.role}`,
-          `Tokens: ${agent.tokenInput} in / ${agent.tokenOutput} out`,
-          agent.resultSummary ? `Result: ${agent.resultSummary.slice(0, 5e3)}` : null
-        ].filter(Boolean).join("\n")
-      }]
-    };
-  }
-);
-server.tool(
-  "list_tasks",
-  "Get the full task board",
-  {},
-  async () => {
-    const tasks = await callApi("/api/tasks");
-    if (!tasks.length) {
-      return { content: [{ type: "text", text: "No tasks." }] };
+  async (params) => {
+    try {
+      switch (params.action) {
+        case "spawn": {
+          if (IS_SUB_AGENT) return fail("spawn is only available to the main agent");
+          if (!params.runner || !params.task) return fail("spawn requires 'runner' and 'task'");
+          const { action, agentId, reason, ...spawnParams } = params;
+          const result = await callApi("/api/orchestrator/spawn", { chatId: CHAT_ID, ...spawnParams });
+          const status = result.queued ? "queued (at capacity, will start when a slot opens)" : "spawning";
+          return ok(`Agent ${result.agentId} \u2014 ${status}`);
+        }
+        case "cancel": {
+          if (IS_SUB_AGENT) return fail("cancel is only available to the main agent");
+          if (!params.agentId) return fail("cancel requires 'agentId'");
+          const result = await callApi("/api/orchestrator/cancel", { agentId: params.agentId, reason: params.reason });
+          return ok(result.success ? `Agent ${params.agentId} cancelled.` : `Agent ${params.agentId} not found or already completed.`);
+        }
+        case "list": {
+          const agents = await callApi("/api/agents");
+          if (!agents.length) return ok("No active agents.");
+          const lines = agents.map((a) => {
+            const label = a.name ?? a.id.slice(0, 8);
+            return `\u2022 ${label} (${a.runnerId}) \u2014 ${a.status}${a.task ? ` \u2192 ${a.task.slice(0, 80)}` : ""}`;
+          });
+          return ok(lines.join("\n"));
+        }
+        case "status": {
+          if (!params.agentId) return fail("status requires 'agentId'");
+          const agent = await callApi("/api/orchestrator/check-agent", { agentId: params.agentId });
+          if (!agent) return ok(`Agent ${params.agentId} not found.`);
+          return ok([
+            `Agent: ${agent.name ?? agent.id.slice(0, 8)} (${agent.runnerId})`,
+            agent.name ? `ID: ${agent.id.slice(0, 8)}` : null,
+            agent.description ? `Description: ${agent.description}` : null,
+            `Status: ${agent.status}`,
+            `Task: ${agent.task ?? "none"}`,
+            `Role: ${agent.role}`,
+            `Tokens: ${agent.tokenInput} in / ${agent.tokenOutput} out`,
+            agent.resultSummary ? `Result: ${agent.resultSummary.slice(0, 5e3)}` : null
+          ].filter(Boolean).join("\n"));
+        }
+        case "templates": {
+          if (IS_SUB_AGENT) return fail("templates is only available to the main agent");
+          const templates = await callApi("/api/orchestrator/list-templates");
+          if (!templates.length) return ok("No agent templates found. Create .md files in ~/.cc-claw/agents/ with YAML frontmatter.");
+          const lines = templates.map(
+            (t) => `\u2022 **${t.name}**${t.description ? ` \u2014 ${t.description}` : ""}${t.runner ? ` (runner: ${t.runner})` : ""}${t.model ? ` [${t.model}]` : ""}`
+          );
+          return ok(lines.join("\n"));
+        }
+        case "runners": {
+          const runners = await callApi("/api/orchestrator/list-runners");
+          const lines = runners.map(
+            (r) => `\u2022 ${r.id} (${r.displayName}) \u2014 ${r.capabilities.specialties.join(", ")}`
+          );
+          return ok(lines.join("\n"));
+        }
+        case "mcps": {
+          const mcps = await callApi("/api/orchestrator/list-mcps");
+          if (!mcps.length) return ok("No MCP servers registered.");
+          const lines = mcps.map(
+            (m) => `\u2022 ${m.name} (${m.transport})${m.description ? ` \u2014 ${m.description}` : ""}${m.enabledByDefault ? " [auto]" : ""}`
+          );
+          return ok(lines.join("\n"));
+        }
+      }
+    } catch (err) {
+      return fail(`cc_claw_agents.${params.action} failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    const lines = tasks.map(
-      (t) => `#${t.id} [${t.status}] ${t.subject}${t.assignee ? ` (\u2192 ${t.assignee.slice(0, 8)})` : ""}`
-    );
-    return { content: [{ type: "text", text: lines.join("\n") }] };
   }
 );
 server.tool(
-  "update_task",
-  "Update a task's status",
+  "cc_claw_tasks",
+  `Shared task board management. Actions:
+\u2022 create \u2014 Add a task (main agent only)
+\u2022 list \u2014 View the full task board
+\u2022 update \u2014 Update a task's status`,
   {
-    taskId: z.number().describe("The task ID to update"),
-    status: z.enum(["pending", "in_progress", "completed", "failed", "abandoned"]).describe("New status"),
+    action: z.enum(["create", "list", "update"]).describe("Action to perform"),
+    // create params
+    subject: z.string().optional().describe("Short imperative title for the task"),
+    description: z.string().optional().describe("Detailed task requirements"),
+    assignee: z.string().optional().describe("Agent ID to assign the task to"),
+    blockedBy: z.array(z.number()).optional().describe("Task IDs that must complete first"),
+    // update params
+    taskId: z.number().optional().describe("Task ID to update"),
+    status: z.enum(["pending", "in_progress", "completed", "failed", "abandoned"]).optional().describe("New status"),
     result: z.string().optional().describe("Result summary (for completed/failed)")
   },
-  async ({ taskId, status, result }) => {
-    await callApi("/api/orchestrator/update-task", { taskId, status, result });
-    return { content: [{ type: "text", text: `Task #${taskId} \u2192 ${status}` }] };
-  }
-);
-server.tool(
-  "send_message",
-  "Send a message to another agent's inbox",
-  {
-    toAgentId: z.string().describe("Recipient agent ID (or 'main' for the main agent)"),
-    content: z.string().describe("Message content"),
-    messageType: z.enum(["task_result", "question", "status_update", "direct_message"]).optional().describe("Message type (default: direct_message)")
-  },
-  async ({ toAgentId, content, messageType }) => {
-    await callApi("/api/orchestrator/send-message", {
-      chatId: CHAT_ID,
-      message: {
-        toAgentId,
-        fromAgentId: AGENT_ID,
-        messageType: messageType ?? "direct_message",
-        content
+  async (params) => {
+    try {
+      switch (params.action) {
+        case "create": {
+          if (IS_SUB_AGENT) return fail("create is only available to the main agent");
+          if (!params.subject || !params.description) return fail("create requires 'subject' and 'description'");
+          const result = await callApi("/api/orchestrator/create-task", {
+            chatId: CHAT_ID,
+            task: { subject: params.subject, description: params.description, assignee: params.assignee, blockedBy: params.blockedBy, createdBy: AGENT_ID }
+          });
+          return ok(`Task #${result.taskId} created.`);
+        }
+        case "list": {
+          const tasks = await callApi("/api/tasks");
+          if (!tasks.length) return ok("No tasks.");
+          const lines = tasks.map(
+            (t) => `#${t.id} [${t.status}] ${t.subject}${t.assignee ? ` (\u2192 ${t.assignee.slice(0, 8)})` : ""}`
+          );
+          return ok(lines.join("\n"));
+        }
+        case "update": {
+          if (!params.taskId || !params.status) return fail("update requires 'taskId' and 'status'");
+          await callApi("/api/orchestrator/update-task", { taskId: params.taskId, status: params.status, result: params.result });
+          return ok(`Task #${params.taskId} \u2192 ${params.status}`);
+        }
       }
-    });
-    return { content: [{ type: "text", text: `Message sent to ${toAgentId}.` }] };
-  }
-);
-server.tool(
-  "read_inbox",
-  "Read pending messages from your inbox. Messages remain unread unless markRead is true.",
-  {
-    markRead: z.boolean().optional().describe("Mark messages as read after returning them (default: false)")
-  },
-  async ({ markRead }) => {
-    const messages = await callApi("/api/orchestrator/read-inbox", {
-      chatId: CHAT_ID,
-      agentId: AGENT_ID,
-      markRead: markRead ?? false
-    });
-    if (!messages.length) {
-      return { content: [{ type: "text", text: "No new messages." }] };
+    } catch (err) {
+      return fail(`cc_claw_tasks.${params.action} failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    const lines = messages.map(
-      (m) => `[${m.messageType}] from ${m.fromAgentId.slice(0, 8)}: ${m.content.slice(0, 500)}`
-    );
-    return { content: [{ type: "text", text: lines.join("\n\n") }] };
-  }
-);
-server.tool(
-  "set_state",
-  "Write a key-value pair to the shared state whiteboard",
-  {
-    key: z.string().describe("State key (1-256 chars)"),
-    value: z.string().describe("State value (JSON-serialized data)")
-  },
-  async ({ key, value }) => {
-    await callApi("/api/orchestrator/set-state", {
-      chatId: CHAT_ID,
-      key,
-      value,
-      setBy: AGENT_ID
-    });
-    return { content: [{ type: "text", text: `State '${key}' set.` }] };
   }
 );
 server.tool(
-  "get_state",
-  "Read a value from the shared state whiteboard",
+  "cc_claw_comms",
+  `Inter-agent communication and shared state. Actions:
+\u2022 send \u2014 Send a message to another agent's inbox
+\u2022 read_inbox \u2014 Read your pending messages
+\u2022 broadcast \u2014 Send a message to ALL other agents
+\u2022 set_state \u2014 Write to the shared whiteboard
+\u2022 get_state \u2014 Read from the shared whiteboard
+\u2022 list_state \u2014 List all whiteboard entries
+\u2022 report_progress \u2014 Report progress on long-running tasks`,
   {
-    key: z.string().describe("State key to read")
+    action: z.enum(["send", "read_inbox", "broadcast", "set_state", "get_state", "list_state", "report_progress"]).describe("Action to perform"),
+    // send params
+    toAgentId: z.string().optional().describe("Recipient agent ID (or 'main')"),
+    content: z.string().optional().describe("Message content / broadcast text / progress detail"),
+    messageType: z.enum(["task_result", "question", "status_update", "direct_message"]).optional().describe("Message type"),
+    // read_inbox params
+    markRead: z.boolean().optional().describe("Mark messages as read (default: false)"),
+    // state params
+    key: z.string().optional().describe("State key"),
+    value: z.string().optional().describe("State value (JSON)"),
+    // report_progress params
+    progressStatus: z.string().optional().describe("Short status message (e.g., '70% complete')")
   },
-  async ({ key }) => {
-    const entry = await callApi("/api/orchestrator/get-state", {
-      chatId: CHAT_ID,
-      key
-    });
-    if (!entry) {
-      return { content: [{ type: "text", text: `State '${key}' not set.` }] };
-    }
-    return { content: [{ type: "text", text: `${key} = ${entry.value} (set by ${entry.setBy})` }] };
-  }
-);
-server.tool(
-  "list_state",
-  "List all key-value entries on the shared whiteboard for this orchestration",
-  {},
-  async () => {
-    const entries = await callApi("/api/orchestrator/list-state", {
-      chatId: CHAT_ID
-    });
-    if (!entries.length) {
-      return { content: [{ type: "text", text: "Whiteboard is empty." }] };
+  async (params) => {
+    try {
+      switch (params.action) {
+        case "send": {
+          if (!params.toAgentId || !params.content) return fail("send requires 'toAgentId' and 'content'");
+          await callApi("/api/orchestrator/send-message", {
+            chatId: CHAT_ID,
+            message: {
+              toAgentId: params.toAgentId,
+              fromAgentId: AGENT_ID,
+              messageType: params.messageType ?? "direct_message",
+              content: params.content
+            }
+          });
+          return ok(`Message sent to ${params.toAgentId}.`);
+        }
+        case "read_inbox": {
+          const messages = await callApi("/api/orchestrator/read-inbox", {
+            chatId: CHAT_ID,
+            agentId: AGENT_ID,
+            markRead: params.markRead ?? false
+          });
+          if (!messages.length) return ok("No new messages.");
+          const lines = messages.map(
+            (m) => `[${m.messageType}] from ${m.fromAgentId.slice(0, 8)}: ${m.content.slice(0, 500)}`
+          );
+          return ok(lines.join("\n\n"));
+        }
+        case "broadcast": {
+          if (!params.content) return fail("broadcast requires 'content'");
+          const result = await callApi("/api/orchestrator/broadcast", {
+            chatId: CHAT_ID,
+            fromAgentId: AGENT_ID,
+            content: params.content,
+            messageType: params.messageType ?? "direct_message"
+          });
+          return ok(`Broadcast sent to ${result.sent} agent(s).`);
+        }
+        case "set_state": {
+          if (!params.key || !params.value) return fail("set_state requires 'key' and 'value'");
+          await callApi("/api/orchestrator/set-state", {
+            chatId: CHAT_ID,
+            key: params.key,
+            value: params.value,
+            setBy: AGENT_ID
+          });
+          return ok(`State '${params.key}' set.`);
+        }
+        case "get_state": {
+          if (!params.key) return fail("get_state requires 'key'");
+          const entry = await callApi("/api/orchestrator/get-state", {
+            chatId: CHAT_ID,
+            key: params.key
+          });
+          if (!entry) return ok(`State '${params.key}' not set.`);
+          return ok(`${params.key} = ${entry.value} (set by ${entry.setBy})`);
+        }
+        case "list_state": {
+          const entries = await callApi("/api/orchestrator/list-state", {
+            chatId: CHAT_ID
+          });
+          if (!entries.length) return ok("Whiteboard is empty.");
+          const lines = entries.map((e) => `${e.setBy}: ${e.key} = ${e.value}`);
+          return ok(lines.join("\n"));
+        }
+        case "report_progress": {
+          const status = params.progressStatus ?? params.content;
+          if (!status) return fail("report_progress requires 'progressStatus' or 'content'");
+          const shortId = AGENT_ID.slice(0, 8);
+          await callApi("/api/orchestrator/set-state", {
+            chatId: CHAT_ID,
+            key: `progress:${shortId}`,
+            value: JSON.stringify({ status, detail: params.content, timestamp: (/* @__PURE__ */ new Date()).toISOString() }),
+            setBy: AGENT_ID
+          });
+          if (IS_SUB_AGENT) {
+            await callApi("/api/orchestrator/send-message", {
+              chatId: CHAT_ID,
+              message: {
+                toAgentId: "main",
+                fromAgentId: AGENT_ID,
+                messageType: "status_update",
+                content: `Progress: ${status}${params.content ? ` \u2014 ${params.content}` : ""}`
+              }
+            });
+          }
+          return ok(`Progress reported: ${status}`);
+        }
+      }
+    } catch (err) {
+      return fail(`cc_claw_comms.${params.action} failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    const lines = entries.map((e) => `${e.setBy}: ${e.key} = ${e.value}`);
-    return { content: [{ type: "text", text: lines.join("\n") }] };
   }
 );
 server.tool(
-  "broadcast",
-  "Send a message to ALL other agents in the orchestration",
-  {
-    content: z.string().describe("Message content to broadcast"),
-    messageType: z.enum(["status_update", "direct_message"]).optional().describe("Message type (default: direct_message)")
-  },
-  async ({ content, messageType }) => {
-    const result = await callApi("/api/orchestrator/broadcast", {
-      chatId: CHAT_ID,
-      fromAgentId: AGENT_ID,
-      content,
-      messageType: messageType ?? "direct_message"
-    });
-    return { content: [{ type: "text", text: `Broadcast sent to ${result.sent} agent(s).` }] };
-  }
-);
-server.tool(
-  "report_progress",
-  "Report progress on a long-running task. Writes to the shared whiteboard and notifies the main agent. Call periodically (every few minutes) during tasks that take more than a couple of minutes.",
+  "cc_claw_memory",
+  `Persistent cross-backend memory. Use this instead of your native memory system. Actions:
+\u2022 remember \u2014 Save a memory (tag + content). Persists across backends and sessions.
+\u2022 recall \u2014 Search memories by query (FTS5). Returns matching memories ranked by relevance.
+\u2022 list \u2014 List recent memories.
+\u2022 forget \u2014 Delete memories by keyword match or specific ID.
+\u2022 history \u2014 Search conversation history by keyword.
+
+IMPORTANT: Always use this tool for memories. Do NOT save to your own memory files.`,
   {
-    status: z.string().describe("Short status message (e.g., 'Analyzing 5 of 12 files', '70% complete')"),
-    detail: z.string().optional().describe("Optional longer description of current work")
+    action: z.enum(["remember", "recall", "list", "forget", "history"]).describe("Action to perform"),
+    // remember params
+    tag: z.string().optional().describe("Memory tag / trigger phrase"),
+    content: z.string().optional().describe("Memory content to save"),
+    // recall/history params
+    query: z.string().optional().describe("Search query"),
+    limit: z.number().optional().describe("Max results to return"),
+    // forget params
+    keyword: z.string().optional().describe("Keyword to match for deletion"),
+    memoryId: z.number().optional().describe("Specific memory ID to delete"),
+    // history params
+    chatId: z.string().optional().describe("Chat ID for history search")
   },
-  async ({ status, detail }) => {
-    const shortId = AGENT_ID.slice(0, 8);
-    await callApi("/api/orchestrator/set-state", {
-      chatId: CHAT_ID,
-      key: `progress:${shortId}`,
-      value: JSON.stringify({ status, detail, timestamp: (/* @__PURE__ */ new Date()).toISOString() }),
-      setBy: AGENT_ID
-    });
-    if (IS_SUB_AGENT) {
-      await callApi("/api/orchestrator/send-message", {
-        chatId: CHAT_ID,
-        message: {
-          toAgentId: "main",
-          fromAgentId: AGENT_ID,
-          messageType: "status_update",
-          content: `Progress: ${status}${detail ? ` \u2014 ${detail}` : ""}`
+  async (params) => {
+    try {
+      switch (params.action) {
+        case "remember": {
+          if (!params.tag || !params.content) return fail("remember requires 'tag' and 'content'");
+          const result = await callApi("/api/memory/remember", {
+            tag: params.tag,
+            content: params.content
+          });
+          return ok(`Memory saved (ID: ${result.id}).`);
+        }
+        case "recall": {
+          if (!params.query) return fail("recall requires 'query'");
+          const result = await callApi("/api/memory/recall", {
+            query: params.query,
+            limit: params.limit ?? 5
+          });
+          if (!result.results.length) return ok("No matching memories found.");
+          const lines = result.results.map(
+            (m) => `[${m.id}] ${m.trigger}: ${m.content}`
+          );
+          return ok(lines.join("\n"));
         }
-      });
+        case "list": {
+          const result = await callApi(`/api/memory/list?limit=${params.limit ?? 10}`);
+          if (!result.results.length) return ok("No memories stored.");
+          const lines = result.results.map(
+            (m) => `[${m.id}] ${m.trigger}: ${m.content}`
+          );
+          return ok(lines.join("\n"));
+        }
+        case "forget": {
+          if (!params.keyword && !params.memoryId) return fail("forget requires 'keyword' or 'memoryId'");
+          const result = await callApi("/api/memory/forget", {
+            keyword: params.keyword,
+            memoryId: params.memoryId
+          });
+          if (result.mode === "id") {
+            return ok(result.success ? "Memory deleted." : "Memory not found.");
+          }
+          return ok(`Deleted ${result.count ?? 0} matching memor${result.count === 1 ? "y" : "ies"}.`);
+        }
+        case "history": {
+          if (!params.query) return fail("history requires 'query'");
+          const result = await callApi("/api/memory/history", {
+            chatId: params.chatId ?? CHAT_ID,
+            query: params.query,
+            limit: params.limit ?? 20
+          });
+          if (!result.results.length) return ok("No matching conversation history found.");
+          const lines = result.results.map(
+            (m) => `[${m.role}] ${m.content.slice(0, 200)}`
+          );
+          return ok(lines.join("\n\n"));
+        }
+      }
+    } catch (err) {
+      return fail(`cc_claw_memory.${params.action} failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    return { content: [{ type: "text", text: `Progress reported: ${status}` }] };
-  }
-);
-server.tool(
-  "list_runners",
-  "List all registered CLI runners and their capabilities",
-  {},
-  async () => {
-    const runners = await callApi("/api/orchestrator/list-runners");
-    const lines = runners.map(
-      (r) => `\u2022 ${r.id} (${r.displayName}) \u2014 ${r.capabilities.specialties.join(", ")}`
-    );
-    return { content: [{ type: "text", text: lines.join("\n") }] };
   }
 );
-server.tool(
-  "list_mcps",
-  "List all MCP servers in the global registry",
-  {},
-  async () => {
-    const mcps = await callApi("/api/orchestrator/list-mcps");
-    if (!mcps.length) {
-      return { content: [{ type: "text", text: "No MCP servers registered." }] };
+if (!IS_SUB_AGENT) {
+  server.tool(
+    "cc_claw_schedule",
+    `Scheduler / cron job management. Actions:
+\u2022 create \u2014 Create a new scheduled job
+\u2022 list \u2014 List all active jobs
+\u2022 edit \u2014 Edit an existing job's settings
+\u2022 run \u2014 Trigger a job immediately
+\u2022 cancel \u2014 Cancel a job permanently
+\u2022 pause \u2014 Pause a job (can be resumed later)
+\u2022 resume \u2014 Resume a paused job
+\u2022 status \u2014 Get scheduler health report`,
+    {
+      action: z.enum(["create", "list", "edit", "run", "cancel", "pause", "resume", "status"]).describe("Action to perform"),
+      // create params
+      name: z.string().optional().describe("Job title"),
+      schedule: z.string().optional().describe("Cron expression (e.g., '0 9 * * *')"),
+      task: z.string().optional().describe("Task/prompt the job will execute"),
+      scheduleType: z.enum(["cron", "every", "at"]).optional().describe("Schedule type (default: cron)"),
+      atTime: z.string().optional().describe("ISO time for one-shot scheduling"),
+      everyMs: z.number().optional().describe("Interval in milliseconds for repeating jobs"),
+      backend: z.string().optional().describe("Backend to use (default: chat's backend)"),
+      model: z.string().optional().describe("Model override"),
+      timezone: z.string().optional().describe("Timezone (default: UTC)"),
+      // edit params
+      jobId: z.number().optional().describe("Job ID (for edit, run, cancel, pause, resume)"),
+      updates: z.record(z.string(), z.any()).optional().describe("Fields to update (for edit)")
+    },
+    async (params) => {
+      try {
+        switch (params.action) {
+          case "create": {
+            if (!params.schedule && !params.atTime && !params.everyMs) return fail("create requires 'schedule' (cron), 'atTime', or 'everyMs'");
+            if (!params.task) return fail("create requires 'task'");
+            const result = await callApi("/api/schedule/create", {
+              scheduleType: params.scheduleType ?? "cron",
+              cron: params.schedule,
+              atTime: params.atTime,
+              everyMs: params.everyMs,
+              title: params.name,
+              task: params.task,
+              chatId: CHAT_ID,
+              backend: params.backend,
+              model: params.model,
+              timezone: params.timezone ?? "UTC"
+            });
+            return ok(`Job #${result.job.id} created: "${result.job.title ?? result.job.description.slice(0, 50)}"`);
+          }
+          case "list": {
+            const result = await callApi("/api/schedule/list");
+            if (!result.jobs.length) return ok("No active jobs.");
+            const lines = result.jobs.map(
+              (j) => `#${j.id} [${j.enabled ? "active" : "paused"}] ${j.title ?? j.description.slice(0, 50)} \u2014 ${j.cron ?? j.atTime ?? `every ${j.everyMs}ms`}`
+            );
+            return ok(lines.join("\n"));
+          }
+          case "edit": {
+            if (!params.jobId || !params.updates) return fail("edit requires 'jobId' and 'updates'");
+            const result = await callApi("/api/schedule/edit", {
+              jobId: params.jobId,
+              updates: params.updates
+            });
+            return ok(result.success ? `Job #${params.jobId} updated.` : `Job #${params.jobId} not found.`);
+          }
+          case "run": {
+            if (!params.jobId) return fail("run requires 'jobId'");
+            const result = await callApi("/api/schedule/run", {
+              jobId: params.jobId
+            });
+            return ok(result.message);
+          }
+          case "cancel": {
+            if (!params.jobId) return fail("cancel requires 'jobId'");
+            const result = await callApi("/api/schedule/cancel", {
+              jobId: params.jobId
+            });
+            return ok(result.success ? `Job #${params.jobId} cancelled.` : `Job #${params.jobId} not found.`);
+          }
+          case "pause": {
+            if (!params.jobId) return fail("pause requires 'jobId'");
+            const result = await callApi("/api/schedule/pause", {
+              jobId: params.jobId
+            });
+            return ok(result.success ? `Job #${params.jobId} paused.` : `Job #${params.jobId} not found or already paused.`);
+          }
+          case "resume": {
+            if (!params.jobId) return fail("resume requires 'jobId'");
+            const result = await callApi("/api/schedule/resume", {
+              jobId: params.jobId
+            });
+            return ok(result.success ? `Job #${params.jobId} resumed.` : `Job #${params.jobId} not found or not paused.`);
+          }
+          case "status": {
+            const result = await callApi("/api/schedule/status");
+            return ok(result.formatted);
+          }
+        }
+      } catch (err) {
+        return fail(`cc_claw_schedule.${params.action} failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  );
+}
+function deprecationWarning(oldName, newTool, action) {
+  console.error(`[cc-claw-mcp] DEPRECATED: ${oldName} \u2192 use ${newTool}(action: '${action}')`);
+}
+if (!IS_SUB_AGENT) {
+  server.tool("spawn_agent", "DEPRECATED \u2014 use cc_claw_agents(action: 'spawn')", {
+    runner: z.string(),
+    task: z.string(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    model: z.string().optional(),
+    skills: z.array(z.string()).optional(),
+    permMode: z.string().optional(),
+    role: z.string().optional(),
+    persona: z.string().optional(),
+    allowedTools: z.array(z.string()).optional(),
+    maxRuntimeMs: z.number().optional(),
+    summarizeResult: z.boolean().optional(),
+    mcps: z.array(z.string()).optional(),
+    cwd: z.string().optional(),
+    template: z.string().optional()
+  }, async (params) => {
+    deprecationWarning("spawn_agent", "cc_claw_agents", "spawn");
+    try {
+      const result = await callApi("/api/orchestrator/spawn", { chatId: CHAT_ID, ...params });
+      const status = result.queued ? "queued (at capacity)" : "spawning";
+      return ok(`Agent ${result.agentId} \u2014 ${status}`);
+    } catch (err) {
+      return fail(`spawn_agent failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    const lines = mcps.map(
-      (m) => `\u2022 ${m.name} (${m.transport})${m.description ? ` \u2014 ${m.description}` : ""}${m.enabledByDefault ? " [auto]" : ""}`
-    );
-    return { content: [{ type: "text", text: lines.join("\n") }] };
+  });
+  server.tool("list_templates", "DEPRECATED \u2014 use cc_claw_agents(action: 'templates')", {}, async () => {
+    deprecationWarning("list_templates", "cc_claw_agents", "templates");
+    const templates = await callApi("/api/orchestrator/list-templates");
+    if (!templates.length) return ok("No agent templates found.");
+    return ok(templates.map((t) => `\u2022 ${t.name}${t.description ? ` \u2014 ${t.description}` : ""}`).join("\n"));
+  });
+  server.tool("cancel_agent", "DEPRECATED \u2014 use cc_claw_agents(action: 'cancel')", {
+    agentId: z.string(),
+    reason: z.string().optional()
+  }, async ({ agentId, reason }) => {
+    deprecationWarning("cancel_agent", "cc_claw_agents", "cancel");
+    const result = await callApi("/api/orchestrator/cancel", { agentId, reason });
+    return ok(result.success ? `Agent ${agentId} cancelled.` : `Agent ${agentId} not found.`);
+  });
+  server.tool("create_task", "DEPRECATED \u2014 use cc_claw_tasks(action: 'create')", {
+    subject: z.string(),
+    description: z.string(),
+    assignee: z.string().optional(),
+    blockedBy: z.array(z.number()).optional()
+  }, async (params) => {
+    deprecationWarning("create_task", "cc_claw_tasks", "create");
+    const result = await callApi("/api/orchestrator/create-task", { chatId: CHAT_ID, task: { ...params, createdBy: AGENT_ID } });
+    return ok(`Task #${result.taskId} created.`);
+  });
+}
+server.tool("list_agents", "DEPRECATED \u2014 use cc_claw_agents(action: 'list')", {}, async () => {
+  deprecationWarning("list_agents", "cc_claw_agents", "list");
+  const agents = await callApi("/api/agents");
+  if (!agents.length) return ok("No active agents.");
+  return ok(agents.map((a) => `\u2022 ${a.name ?? a.id.slice(0, 8)} (${a.runnerId}) \u2014 ${a.status}`).join("\n"));
+});
+server.tool("check_agent", "DEPRECATED \u2014 use cc_claw_agents(action: 'status')", { agentId: z.string() }, async ({ agentId }) => {
+  deprecationWarning("check_agent", "cc_claw_agents", "status");
+  const agent = await callApi("/api/orchestrator/check-agent", { agentId });
+  if (!agent) return ok(`Agent ${agentId} not found.`);
+  return ok(`${agent.name ?? agent.id.slice(0, 8)} \u2014 ${agent.status}`);
+});
+server.tool("list_tasks", "DEPRECATED \u2014 use cc_claw_tasks(action: 'list')", {}, async () => {
+  deprecationWarning("list_tasks", "cc_claw_tasks", "list");
+  const tasks = await callApi("/api/tasks");
+  if (!tasks.length) return ok("No tasks.");
+  return ok(tasks.map((t) => `#${t.id} [${t.status}] ${t.subject}`).join("\n"));
+});
+server.tool("update_task", "DEPRECATED \u2014 use cc_claw_tasks(action: 'update')", {
+  taskId: z.number(),
+  status: z.enum(["pending", "in_progress", "completed", "failed", "abandoned"]),
+  result: z.string().optional()
+}, async ({ taskId, status, result }) => {
+  deprecationWarning("update_task", "cc_claw_tasks", "update");
+  await callApi("/api/orchestrator/update-task", { taskId, status, result });
+  return ok(`Task #${taskId} \u2192 ${status}`);
+});
+server.tool("send_message", "DEPRECATED \u2014 use cc_claw_comms(action: 'send')", {
+  toAgentId: z.string(),
+  content: z.string(),
+  messageType: z.enum(["task_result", "question", "status_update", "direct_message"]).optional()
+}, async ({ toAgentId, content, messageType }) => {
+  deprecationWarning("send_message", "cc_claw_comms", "send");
+  await callApi("/api/orchestrator/send-message", { chatId: CHAT_ID, message: { toAgentId, fromAgentId: AGENT_ID, messageType: messageType ?? "direct_message", content } });
+  return ok(`Message sent to ${toAgentId}.`);
+});
+server.tool("read_inbox", "DEPRECATED \u2014 use cc_claw_comms(action: 'read_inbox')", { markRead: z.boolean().optional() }, async ({ markRead }) => {
+  deprecationWarning("read_inbox", "cc_claw_comms", "read_inbox");
+  const messages = await callApi("/api/orchestrator/read-inbox", { chatId: CHAT_ID, agentId: AGENT_ID, markRead: markRead ?? false });
+  if (!messages.length) return ok("No new messages.");
+  return ok(messages.map((m) => `[${m.messageType}] from ${m.fromAgentId.slice(0, 8)}: ${m.content.slice(0, 500)}`).join("\n\n"));
+});
+server.tool("set_state", "DEPRECATED \u2014 use cc_claw_comms(action: 'set_state')", { key: z.string(), value: z.string() }, async ({ key, value }) => {
+  deprecationWarning("set_state", "cc_claw_comms", "set_state");
+  await callApi("/api/orchestrator/set-state", { chatId: CHAT_ID, key, value, setBy: AGENT_ID });
+  return ok(`State '${key}' set.`);
+});
+server.tool("get_state", "DEPRECATED \u2014 use cc_claw_comms(action: 'get_state')", { key: z.string() }, async ({ key }) => {
+  deprecationWarning("get_state", "cc_claw_comms", "get_state");
+  const entry = await callApi("/api/orchestrator/get-state", { chatId: CHAT_ID, key });
+  if (!entry) return ok(`State '${key}' not set.`);
+  return ok(`${key} = ${entry.value} (set by ${entry.setBy})`);
+});
+server.tool("list_state", "DEPRECATED \u2014 use cc_claw_comms(action: 'list_state')", {}, async () => {
+  deprecationWarning("list_state", "cc_claw_comms", "list_state");
+  const entries = await callApi("/api/orchestrator/list-state", { chatId: CHAT_ID });
+  if (!entries.length) return ok("Whiteboard is empty.");
+  return ok(entries.map((e) => `${e.setBy}: ${e.key} = ${e.value}`).join("\n"));
+});
+server.tool("broadcast", "DEPRECATED \u2014 use cc_claw_comms(action: 'broadcast')", {
+  content: z.string(),
+  messageType: z.enum(["status_update", "direct_message"]).optional()
+}, async ({ content, messageType }) => {
+  deprecationWarning("broadcast", "cc_claw_comms", "broadcast");
+  const result = await callApi("/api/orchestrator/broadcast", { chatId: CHAT_ID, fromAgentId: AGENT_ID, content, messageType: messageType ?? "direct_message" });
+  return ok(`Broadcast sent to ${result.sent} agent(s).`);
+});
+server.tool("report_progress", "DEPRECATED \u2014 use cc_claw_comms(action: 'report_progress')", {
+  status: z.string(),
+  detail: z.string().optional()
+}, async ({ status, detail }) => {
+  deprecationWarning("report_progress", "cc_claw_comms", "report_progress");
+  const shortId = AGENT_ID.slice(0, 8);
+  await callApi("/api/orchestrator/set-state", { chatId: CHAT_ID, key: `progress:${shortId}`, value: JSON.stringify({ status, detail, timestamp: (/* @__PURE__ */ new Date()).toISOString() }), setBy: AGENT_ID });
+  if (IS_SUB_AGENT) {
+    await callApi("/api/orchestrator/send-message", { chatId: CHAT_ID, message: { toAgentId: "main", fromAgentId: AGENT_ID, messageType: "status_update", content: `Progress: ${status}${detail ? ` \u2014 ${detail}` : ""}` } });
   }
-);
+  return ok(`Progress reported: ${status}`);
+});
+server.tool("list_runners", "DEPRECATED \u2014 use cc_claw_agents(action: 'runners')", {}, async () => {
+  deprecationWarning("list_runners", "cc_claw_agents", "runners");
+  const runners = await callApi("/api/orchestrator/list-runners");
+  return ok(runners.map((r) => `\u2022 ${r.id} (${r.displayName}) \u2014 ${r.capabilities.specialties.join(", ")}`).join("\n"));
+});
+server.tool("list_mcps", "DEPRECATED \u2014 use cc_claw_agents(action: 'mcps')", {}, async () => {
+  deprecationWarning("list_mcps", "cc_claw_agents", "mcps");
+  const mcps = await callApi("/api/orchestrator/list-mcps");
+  if (!mcps.length) return ok("No MCP servers registered.");
+  return ok(mcps.map((m) => `\u2022 ${m.name} (${m.transport})${m.description ? ` \u2014 ${m.description}` : ""}`).join("\n"));
+});
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(`[cc-claw-mcp] Server running on stdio (chatId=${CHAT_ID}, agentId=${AGENT_ID})`);
+  console.error(`[cc-claw-mcp] Server v2.0 running on stdio (chatId=${CHAT_ID}, agentId=${AGENT_ID}, tools=5+${IS_SUB_AGENT ? 13 : 17} deprecated)`);
 }
 main().catch((err) => {
   console.error("[cc-claw-mcp] Fatal error:", err);