devsh-memory-mcp 0.1.1 → 0.2.0

package/dist/chunk-YTXBZTQ2.js

@@ -0,0 +1,1307 @@
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+var DEFAULT_MEMORY_DIR = "/root/lifecycle/memory";
+function createMemoryMcpServer(config) {
+  const memoryDir = config?.memoryDir ?? DEFAULT_MEMORY_DIR;
+  const resolvedAgentName = config?.agentName ?? process.env.CMUX_AGENT_NAME;
+  const agentName = resolvedAgentName ?? "external-client";
+  if (!resolvedAgentName) {
+    console.error(
+      '[devsh-memory-mcp] Warning: no agent identity provided; falling back to "external-client". Pass --agent <name> or set CMUX_AGENT_NAME to preserve mailbox sender identity.'
+    );
+  }
+  const knowledgeDir = path.join(memoryDir, "knowledge");
+  const dailyDir = path.join(memoryDir, "daily");
+  const orchestrationDir = path.join(memoryDir, "orchestration");
+  const mailboxPath = path.join(memoryDir, "MAILBOX.json");
+  const tasksPath = path.join(memoryDir, "TASKS.json");
+  const planPath = path.join(orchestrationDir, "PLAN.json");
+  const agentsPath = path.join(orchestrationDir, "AGENTS.json");
+  const eventsPath = path.join(orchestrationDir, "EVENTS.jsonl");
+  function readFile(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) return null;
+      return fs.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  function writeFile(filePath, content) {
+    try {
+      fs.writeFileSync(filePath, content, "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function readTasks() {
+    const content = readFile(tasksPath);
+    if (!content) return { version: 1, tasks: [] };
+    try {
+      return JSON.parse(content);
+    } catch {
+      return { version: 1, tasks: [] };
+    }
+  }
+  function writeTasks(tasks) {
+    return writeFile(tasksPath, JSON.stringify(tasks, null, 2));
+  }
+  function generateTaskId() {
+    return "task_" + crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+  }
+  function getTodayDateString() {
+    const iso = (/* @__PURE__ */ new Date()).toISOString();
+    return iso.slice(0, iso.indexOf("T"));
+  }
+  function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+  function readPlan() {
+    const content = readFile(planPath);
+    if (!content) return null;
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  function writePlan(plan) {
+    ensureDir(orchestrationDir);
+    plan.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return writeFile(planPath, JSON.stringify(plan, null, 2));
+  }
+  function appendEvent(event) {
+    ensureDir(orchestrationDir);
+    const line = JSON.stringify(event) + "\n";
+    try {
+      fs.appendFileSync(eventsPath, line, "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function readMailbox() {
+    const content = readFile(mailboxPath);
+    if (!content) return { version: 1, messages: [] };
+    try {
+      return JSON.parse(content);
+    } catch {
+      return { version: 1, messages: [] };
+    }
+  }
+  function writeMailbox(mailbox) {
+    return writeFile(mailboxPath, JSON.stringify(mailbox, null, 2));
+  }
+  function generateMessageId() {
+    return "msg_" + crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+  }
+  function listDailyLogs() {
+    try {
+      if (!fs.existsSync(dailyDir)) return [];
+      const files = fs.readdirSync(dailyDir);
+      return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", "")).sort().reverse();
+    } catch {
+      return [];
+    }
+  }
+  function searchMemory(query) {
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    const knowledge = readFile(path.join(knowledgeDir, "MEMORY.md"));
+    if (knowledge?.toLowerCase().includes(lowerQuery)) {
+      const lines = knowledge.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].toLowerCase().includes(lowerQuery)) {
+          results.push({
+            source: "knowledge/MEMORY.md",
+            line: i + 1,
+            content: lines[i].trim()
+          });
+        }
+      }
+    }
+    const tasks = readFile(tasksPath);
+    if (tasks?.toLowerCase().includes(lowerQuery)) {
+      results.push({ source: "TASKS.json", content: "Match found in tasks file" });
+    }
+    const mailbox = readFile(mailboxPath);
+    if (mailbox?.toLowerCase().includes(lowerQuery)) {
+      results.push({ source: "MAILBOX.json", content: "Match found in mailbox file" });
+    }
+    const dailyLogs = listDailyLogs();
+    for (const date of dailyLogs.slice(0, 7)) {
+      const logContent = readFile(path.join(dailyDir, `${date}.md`));
+      if (logContent?.toLowerCase().includes(lowerQuery)) {
+        const lines = logContent.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].toLowerCase().includes(lowerQuery)) {
+            results.push({
+              source: `daily/${date}.md`,
+              line: i + 1,
+              content: lines[i].trim()
+            });
+          }
+        }
+      }
+    }
+    return results;
+  }
+  const server = new Server(
+    {
+      name: "devsh-memory",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "read_memory",
+        description: 'Read a memory file. Type can be "knowledge", "tasks", or "mailbox".',
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["knowledge", "tasks", "mailbox"],
+              description: "The type of memory to read"
+            }
+          },
+          required: ["type"]
+        }
+      },
+      {
+        name: "list_daily_logs",
+        description: "List available daily log dates (newest first).",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "read_daily_log",
+        description: "Read a specific daily log by date (YYYY-MM-DD format).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            date: {
+              type: "string",
+              description: "The date in YYYY-MM-DD format"
+            }
+          },
+          required: ["date"]
+        }
+      },
+      {
+        name: "search_memory",
+        description: "Search across all memory files for a query string.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "The search query"
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "send_message",
+        description: 'Send a message to another agent on the same task. Use "*" to broadcast to all agents.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            to: {
+              type: "string",
+              description: 'Recipient agent name (e.g., "claude/opus-4.5") or "*" for broadcast'
+            },
+            message: {
+              type: "string",
+              description: "The message content"
+            },
+            type: {
+              type: "string",
+              enum: ["handoff", "request", "status"],
+              description: "Message type: handoff (work transfer), request (ask to do something), status (progress update)"
+            }
+          },
+          required: ["to", "message"]
+        }
+      },
+      {
+        name: "get_my_messages",
+        description: "Get all messages addressed to this agent (including broadcasts). Returns unread messages first.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            includeRead: {
+              type: "boolean",
+              description: "Include messages already marked as read (default: false)"
+            }
+          }
+        }
+      },
+      {
+        name: "mark_read",
+        description: "Mark a message as read by its ID.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            messageId: {
+              type: "string",
+              description: "The message ID to mark as read"
+            }
+          },
+          required: ["messageId"]
+        }
+      },
+      // Write tools
+      {
+        name: "append_daily_log",
+        description: "Append content to today's daily log. Creates the file if it doesn't exist.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "Content to append to the daily log"
+            }
+          },
+          required: ["content"]
+        }
+      },
+      {
+        name: "update_knowledge",
+        description: "Update a specific priority section in the knowledge file (MEMORY.md). Appends a new entry with today's date.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            section: {
+              type: "string",
+              enum: ["P0", "P1", "P2"],
+              description: "Priority section to update (P0=Core, P1=Active, P2=Reference)"
+            },
+            content: {
+              type: "string",
+              description: "Content to add to the section (will be prefixed with today's date)"
+            }
+          },
+          required: ["section", "content"]
+        }
+      },
+      {
+        name: "add_task",
+        description: "Add a new task to the TASKS.json file.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            subject: {
+              type: "string",
+              description: "Brief title for the task"
+            },
+            description: {
+              type: "string",
+              description: "Detailed description of what needs to be done"
+            }
+          },
+          required: ["subject", "description"]
+        }
+      },
+      {
+        name: "update_task",
+        description: "Update the status of an existing task in TASKS.json.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: {
+              type: "string",
+              description: "The ID of the task to update"
+            },
+            status: {
+              type: "string",
+              enum: ["pending", "in_progress", "completed"],
+              description: "New status for the task"
+            }
+          },
+          required: ["taskId", "status"]
+        }
+      },
+      // Orchestration tools
+      {
+        name: "read_orchestration",
+        description: "Read an orchestration file (PLAN.json, AGENTS.json, or EVENTS.jsonl).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["plan", "agents", "events"],
+              description: "Type of orchestration file to read"
+            }
+          },
+          required: ["type"]
+        }
+      },
+      {
+        name: "append_event",
+        description: "Append an orchestration event to EVENTS.jsonl.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            event: {
+              type: "string",
+              description: "Event type (e.g., agent_spawned, agent_completed, message_sent)"
+            },
+            message: {
+              type: "string",
+              description: "Human-readable message describing the event"
+            },
+            agentName: {
+              type: "string",
+              description: "Agent name associated with the event (optional)"
+            },
+            taskRunId: {
+              type: "string",
+              description: "Task run ID associated with the event (optional)"
+            }
+          },
+          required: ["event", "message"]
+        }
+      },
+      {
+        name: "update_plan_task",
+        description: "Update the status of a task in the orchestration PLAN.json.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: {
+              type: "string",
+              description: "The ID of the orchestration task to update"
+            },
+            status: {
+              type: "string",
+              description: "New status (pending, assigned, running, completed, failed, cancelled)"
+            },
+            result: {
+              type: "string",
+              description: "Result message (for completed tasks)"
+            },
+            errorMessage: {
+              type: "string",
+              description: "Error message (for failed tasks)"
+            }
+          },
+          required: ["taskId", "status"]
+        }
+      },
+      {
+        name: "pull_orchestration_updates",
+        description: "Sync local orchestration state (PLAN.json) with the server. Fetches latest task statuses, messages, and aggregated progress. Requires CMUX_TASK_RUN_JWT environment variable.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            orchestrationId: {
+              type: "string",
+              description: "The orchestration ID to sync. Uses CMUX_ORCHESTRATION_ID env var if not provided."
+            }
+          }
+        }
+      },
+      {
+        name: "spawn_agent",
+        description: "Spawn a sub-agent to work on a task. Requires CMUX_TASK_RUN_JWT for authentication. The sub-agent runs in a new sandbox and works on the specified prompt.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            prompt: {
+              type: "string",
+              description: "The task prompt for the sub-agent"
+            },
+            agentName: {
+              type: "string",
+              description: "Agent to use (e.g., 'claude/haiku-4.5', 'codex/gpt-5.1-codex-mini')"
+            },
+            repo: {
+              type: "string",
+              description: "GitHub repository in owner/repo format (optional)"
+            },
+            branch: {
+              type: "string",
+              description: "Base branch to checkout (optional, defaults to main)"
+            },
+            dependsOn: {
+              type: "array",
+              items: { type: "string" },
+              description: "Array of orchestration task IDs this task depends on (optional)"
+            },
+            priority: {
+              type: "number",
+              description: "Task priority (0=highest, 10=lowest, default 5)"
+            }
+          },
+          required: ["prompt", "agentName"]
+        }
+      },
+      {
+        name: "get_agent_status",
+        description: "Get the status of a spawned sub-agent by orchestration task ID. Returns current status, result, and linked task run info.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            orchestrationTaskId: {
+              type: "string",
+              description: "The orchestration task ID returned from spawn_agent"
+            }
+          },
+          required: ["orchestrationTaskId"]
+        }
+      },
+      {
+        name: "wait_for_agent",
+        description: "Wait for a spawned sub-agent to reach a terminal state (completed, failed, or cancelled). Polls every 5 seconds until the agent finishes or timeout.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            orchestrationTaskId: {
+              type: "string",
+              description: "The orchestration task ID to wait for"
+            },
+            timeout: {
+              type: "number",
+              description: "Maximum wait time in milliseconds (default: 300000 = 5 minutes)"
+            }
+          },
+          required: ["orchestrationTaskId"]
+        }
+      },
+      {
+        name: "list_spawned_agents",
+        description: "List all sub-agents spawned by this orchestration. Returns status summary of all tasks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            status: {
+              type: "string",
+              enum: ["pending", "assigned", "running", "completed", "failed", "cancelled"],
+              description: "Filter by status (optional)"
+            }
+          }
+        }
+      },
+      {
+        name: "cancel_agent",
+        description: "Cancel a running or pending sub-agent. The agent will stop and its status will be set to cancelled.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            orchestrationTaskId: {
+              type: "string",
+              description: "The orchestration task ID to cancel"
+            },
+            cascade: {
+              type: "boolean",
+              description: "Also cancel dependent tasks (default: false)"
+            }
+          },
+          required: ["orchestrationTaskId"]
+        }
+      },
+      {
+        name: "get_orchestration_summary",
+        description: "Get a summary of the current orchestration including task counts by status, active agents, and recent completions.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+      case "read_memory": {
+        const type = args.type;
+        let content = null;
+        if (type === "knowledge") {
+          content = readFile(path.join(knowledgeDir, "MEMORY.md"));
+        } else if (type === "tasks") {
+          content = readFile(tasksPath);
+        } else if (type === "mailbox") {
+          content = readFile(mailboxPath);
+        }
+        return {
+          content: [{ type: "text", text: content ?? `No ${type} content found.` }]
+        };
+      }
+      case "list_daily_logs": {
+        const dates = listDailyLogs();
+        return {
+          content: [{ type: "text", text: dates.length > 0 ? dates.join("\n") : "No daily logs found." }]
+        };
+      }
+      case "read_daily_log": {
+        const date = args.date;
+        const content = readFile(path.join(dailyDir, `${date}.md`));
+        return {
+          content: [{ type: "text", text: content ?? `No log found for ${date}.` }]
+        };
+      }
+      case "search_memory": {
+        const query = args.query;
+        const results = searchMemory(query);
+        if (results.length === 0) {
+          return { content: [{ type: "text", text: `No results found for "${query}".` }] };
+        }
+        const formatted = results.map((r) => `[${r.source}${r.line ? `:${r.line}` : ""}] ${r.content}`).join("\n");
+        return { content: [{ type: "text", text: formatted }] };
+      }
+      case "send_message": {
+        const { to, message, type } = args;
+        const mailbox = readMailbox();
+        const newMessage = {
+          id: generateMessageId(),
+          from: agentName,
+          to,
+          type: type ?? "request",
+          message,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          read: false
+        };
+        mailbox.messages.push(newMessage);
+        writeMailbox(mailbox);
+        return { content: [{ type: "text", text: `Message sent successfully. ID: ${newMessage.id}` }] };
+      }
+      case "get_my_messages": {
+        const includeRead = args.includeRead ?? false;
+        const mailbox = readMailbox();
+        const myMessages = mailbox.messages.filter(
+          (m) => m.to === agentName || m.to === "*"
+        );
+        const filtered = includeRead ? myMessages : myMessages.filter((m) => !m.read);
+        if (filtered.length === 0) {
+          return { content: [{ type: "text", text: "No messages for you." }] };
+        }
+        const formatted = filtered.map((m) => `[${m.id}] ${m.type ?? "message"} from ${m.from}: ${m.message}`).join("\n\n");
+        return { content: [{ type: "text", text: formatted }] };
+      }
+      case "mark_read": {
+        const messageId = args.messageId;
+        const mailbox = readMailbox();
+        const message = mailbox.messages.find((m) => m.id === messageId);
+        if (!message) {
+          return { content: [{ type: "text", text: `Message ${messageId} not found.` }] };
+        }
+        message.read = true;
+        writeMailbox(mailbox);
+        return { content: [{ type: "text", text: `Message ${messageId} marked as read.` }] };
+      }
+      // Write tool handlers
+      case "append_daily_log": {
+        const { content } = args;
+        const today = getTodayDateString();
+        ensureDir(dailyDir);
+        const logPath = path.join(dailyDir, `${today}.md`);
+        const existing = readFile(logPath) ?? `# Daily Log: ${today}
+
+> Session-specific observations. Temporary notes go here.
+
+---
+`;
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[1].split(".")[0];
+        const newContent = existing + `
+- [${timestamp}] ${content}`;
+        if (writeFile(logPath, newContent)) {
+          return { content: [{ type: "text", text: `Appended to daily/${today}.md` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to append to daily log` }] };
+      }
+      case "update_knowledge": {
+        const { section, content } = args;
+        ensureDir(knowledgeDir);
+        const knowledgePath = path.join(knowledgeDir, "MEMORY.md");
+        let existing = readFile(knowledgePath);
+        if (!existing) {
+          existing = `# Project Knowledge
+
+> Curated insights organized by priority. Add date tags for TTL tracking.
+
+## P0 - Core (Never Expires)
+<!-- Fundamental project facts, configuration, invariants -->
+
+## P1 - Active (90-day TTL)
+<!-- Ongoing work context, current strategies, recent decisions -->
+
+## P2 - Reference (30-day TTL)
+<!-- Temporary findings, debug notes, one-off context -->
+
+---
+*Priority guide: P0 = permanent truth, P1 = active context, P2 = temporary reference*
+*Format: - [YYYY-MM-DD] Your insight here*
+`;
+        }
+        const today = getTodayDateString();
+        const newEntry = `- [${today}] ${content}`;
+        const sectionHeaders = {
+          P0: "## P0 - Core (Never Expires)",
+          P1: "## P1 - Active (90-day TTL)",
+          P2: "## P2 - Reference (30-day TTL)"
+        };
+        const header = sectionHeaders[section];
+        const headerIndex = existing.indexOf(header);
+        if (headerIndex === -1) {
+          return { content: [{ type: "text", text: `Section ${section} not found in MEMORY.md` }] };
+        }
+        const afterHeader = existing.slice(headerIndex + header.length);
+        const nextSectionMatch = afterHeader.match(/\n## /);
+        const insertPoint = nextSectionMatch ? headerIndex + header.length + (nextSectionMatch.index ?? afterHeader.length) : existing.length;
+        const commentEndMatch = afterHeader.match(/<!--[^>]*-->\n/);
+        const commentEnd = commentEndMatch ? headerIndex + header.length + (commentEndMatch.index ?? 0) + commentEndMatch[0].length : headerIndex + header.length + 1;
+        const actualInsertPoint = Math.min(commentEnd, insertPoint);
+        const updated = existing.slice(0, actualInsertPoint) + newEntry + "\n" + existing.slice(actualInsertPoint);
+        if (writeFile(knowledgePath, updated)) {
+          return { content: [{ type: "text", text: `Added entry to ${section} section in MEMORY.md` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to update MEMORY.md` }] };
+      }
+      case "add_task": {
+        const { subject, description } = args;
+        const tasks = readTasks();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const newTask = {
+          id: generateTaskId(),
+          subject,
+          description,
+          status: "pending",
+          createdAt: now,
+          updatedAt: now
+        };
+        tasks.tasks.push(newTask);
+        if (writeTasks(tasks)) {
+          return { content: [{ type: "text", text: `Task created with ID: ${newTask.id}` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to create task` }] };
+      }
+      case "update_task": {
+        const { taskId, status } = args;
+        const tasks = readTasks();
+        const task = tasks.tasks.find((t) => t.id === taskId);
+        if (!task) {
+          return { content: [{ type: "text", text: `Task ${taskId} not found` }] };
+        }
+        task.status = status;
+        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (writeTasks(tasks)) {
+          return { content: [{ type: "text", text: `Task ${taskId} updated to status: ${status}` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to update task` }] };
+      }
+      // Orchestration tool handlers
+      case "read_orchestration": {
+        const type = args.type;
+        let content = null;
+        if (type === "plan") {
+          content = readFile(planPath);
+        } else if (type === "agents") {
+          content = readFile(agentsPath);
+        } else if (type === "events") {
+          content = readFile(eventsPath);
+        }
+        return {
+          content: [{ type: "text", text: content ?? `No ${type} file found in orchestration directory.` }]
+        };
+      }
+      case "append_event": {
+        const { event, message, agentName: agentName2, taskRunId } = args;
+        const eventObj = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          event,
+          message
+        };
+        if (agentName2) eventObj.agentName = agentName2;
+        if (taskRunId) eventObj.taskRunId = taskRunId;
+        if (appendEvent(eventObj)) {
+          return { content: [{ type: "text", text: `Event appended to EVENTS.jsonl` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to append event` }] };
+      }
+      case "update_plan_task": {
+        const { taskId, status, result, errorMessage } = args;
+        const plan = readPlan();
+        if (!plan) {
+          return { content: [{ type: "text", text: `No PLAN.json found in orchestration directory` }] };
+        }
+        const task = plan.tasks.find((t) => t.id === taskId);
+        if (!task) {
+          return { content: [{ type: "text", text: `Task ${taskId} not found in PLAN.json` }] };
+        }
+        task.status = status;
+        if (result !== void 0) task.result = result;
+        if (errorMessage !== void 0) task.errorMessage = errorMessage;
+        if (status === "running" && !task.startedAt) {
+          task.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        if (status === "completed" || status === "failed" || status === "cancelled") {
+          task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        if (writePlan(plan)) {
+          return { content: [{ type: "text", text: `Plan task ${taskId} updated to status: ${status}` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to update plan task` }] };
+      }
+      case "pull_orchestration_updates": {
+        const { orchestrationId: argOrchId } = args;
+        const orchestrationId = argOrchId ?? process.env.CMUX_ORCHESTRATION_ID;
+        const jwt = process.env.CMUX_TASK_RUN_JWT;
+        const apiBaseUrl = process.env.CMUX_API_BASE_URL ?? "https://cmux.sh";
+        if (!orchestrationId) {
+          return {
+            content: [{
+              type: "text",
+              text: "No orchestration ID provided. Pass orchestrationId parameter or set CMUX_ORCHESTRATION_ID env var."
+            }]
+          };
+        }
+        if (!jwt) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_TASK_RUN_JWT environment variable not set. This tool requires JWT authentication."
+            }]
+          };
+        }
+        try {
+          const url = `${apiBaseUrl}/api/v1/cmux/orchestration/${orchestrationId}/sync`;
+          const response = await fetch(url, {
+            method: "GET",
+            headers: {
+              "Authorization": `Bearer ${jwt}`,
+              "Content-Type": "application/json"
+            }
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to fetch orchestration updates: ${response.status} ${errorText}`
+              }]
+            };
+          }
+          const serverData = await response.json();
+          let plan = readPlan();
+          if (!plan) {
+            plan = {
+              version: 1,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              status: "running",
+              headAgent: agentName,
+              orchestrationId,
+              tasks: []
+            };
+          }
+          for (const serverTask of serverData.tasks) {
+            const localTask = plan.tasks.find((t) => t.id === serverTask.id);
+            if (localTask) {
+              localTask.status = serverTask.status;
+              localTask.taskRunId = serverTask.taskRunId;
+              localTask.result = serverTask.result;
+              localTask.errorMessage = serverTask.errorMessage;
+              localTask.startedAt = serverTask.startedAt;
+              localTask.completedAt = serverTask.completedAt;
+            } else {
+              plan.tasks.push(serverTask);
+            }
+          }
+          const agg = serverData.aggregatedStatus;
+          if (agg.failed > 0) {
+            plan.status = "failed";
+          } else if (agg.completed === agg.total && agg.total > 0) {
+            plan.status = "completed";
+          } else if (agg.running > 0) {
+            plan.status = "running";
+          } else {
+            plan.status = "pending";
+          }
+          writePlan(plan);
+          const mailbox = readMailbox();
+          for (const msg of serverData.messages) {
+            if (!mailbox.messages.find((m) => m.id === msg.id)) {
+              mailbox.messages.push(msg);
+            }
+          }
+          writeMailbox(mailbox);
+          appendEvent({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            event: "orchestration_synced",
+            message: `Synced ${serverData.tasks.length} tasks, ${serverData.messages.length} messages`,
+            metadata: serverData.aggregatedStatus
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                synced: true,
+                orchestrationId,
+                tasks: serverData.tasks.length,
+                messages: serverData.messages.length,
+                aggregatedStatus: serverData.aggregatedStatus
+              }, null, 2)
+            }]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{
+              type: "text",
+              text: `Error syncing orchestration updates: ${errorMsg}`
+            }]
+          };
+        }
+      }
+      case "spawn_agent": {
+        const { prompt, agentName: spawnAgentName, repo, branch, dependsOn, priority } = args;
+        const jwt = process.env.CMUX_TASK_RUN_JWT;
+        const apiBaseUrl = process.env.CMUX_API_BASE_URL ?? "https://cmux.sh";
+        const orchestrationId = process.env.CMUX_ORCHESTRATION_ID;
+        if (!jwt) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_TASK_RUN_JWT environment variable not set. This tool requires JWT authentication."
+            }]
+          };
+        }
+        try {
+          const url = `${apiBaseUrl}/api/v1/cmux/orchestration/spawn`;
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${jwt}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              prompt,
+              agent: spawnAgentName,
+              repo,
+              branch,
+              dependsOn,
+              priority: priority ?? 5,
+              orchestrationId
+            })
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to spawn agent: ${response.status} ${errorText}`
+              }]
+            };
+          }
+          const result = await response.json();
+          let plan = readPlan();
+          if (!plan && orchestrationId) {
+            plan = {
+              version: 1,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              status: "running",
+              headAgent: agentName,
+              orchestrationId,
+              tasks: []
+            };
+          }
+          if (plan) {
+            plan.tasks.push({
+              id: result.orchestrationTaskId,
+              prompt,
+              agentName: spawnAgentName,
+              status: result.status,
+              taskRunId: result.taskRunId,
+              dependsOn,
+              priority: priority ?? 5,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            writePlan(plan);
+          }
+          appendEvent({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            event: "agent_spawned",
+            message: `Spawned ${spawnAgentName} for: ${prompt.slice(0, 50)}...`,
+            agentName: spawnAgentName,
+            taskRunId: result.taskRunId
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{
+              type: "text",
+              text: `Error spawning agent: ${errorMsg}`
+            }]
+          };
+        }
+      }
+      case "get_agent_status": {
+        const { orchestrationTaskId } = args;
+        const jwt = process.env.CMUX_TASK_RUN_JWT;
+        const apiBaseUrl = process.env.CMUX_API_BASE_URL ?? "https://cmux.sh";
+        if (!jwt) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_TASK_RUN_JWT environment variable not set. This tool requires JWT authentication."
+            }]
+          };
+        }
+        try {
+          const url = `${apiBaseUrl}/api/v1/cmux/orchestration/tasks/${orchestrationTaskId}`;
+          const response = await fetch(url, {
+            method: "GET",
+            headers: {
+              "Authorization": `Bearer ${jwt}`,
+              "Content-Type": "application/json"
+            }
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to get agent status: ${response.status} ${errorText}`
+              }]
+            };
+          }
+          const result = await response.json();
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{
+              type: "text",
+              text: `Error getting agent status: ${errorMsg}`
+            }]
+          };
+        }
+      }
+      case "wait_for_agent": {
+        const { orchestrationTaskId, timeout = 3e5 } = args;
+        const jwt = process.env.CMUX_TASK_RUN_JWT;
+        const apiBaseUrl = process.env.CMUX_API_BASE_URL ?? "https://cmux.sh";
+        if (!jwt) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_TASK_RUN_JWT environment variable not set. This tool requires JWT authentication."
+            }]
+          };
+        }
+        const startTime = Date.now();
+        const pollInterval = 5e3;
+        try {
+          while (Date.now() - startTime < timeout) {
+            const url = `${apiBaseUrl}/api/orchestrate/status/${orchestrationTaskId}`;
+            const response = await fetch(url, {
+              method: "GET",
+              headers: {
+                "X-Task-Run-JWT": jwt,
+                "Content-Type": "application/json"
+              }
+            });
+            if (!response.ok) {
+              const errorText = await response.text();
+              return {
+                content: [{
+                  type: "text",
+                  text: `Failed to get agent status: ${response.status} ${errorText}`
+                }]
+              };
+            }
+            const result = await response.json();
+            const status = result.task.status;
+            if (status === "completed" || status === "failed" || status === "cancelled") {
+              appendEvent({
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                event: "agent_wait_completed",
+                message: `Agent ${orchestrationTaskId} reached terminal state: ${status}`,
+                taskRunId: orchestrationTaskId,
+                status
+              });
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    orchestrationTaskId,
+                    status,
+                    result: result.task.result ?? null,
+                    errorMessage: result.task.errorMessage ?? null,
+                    waitDuration: Date.now() - startTime
+                  }, null, 2)
+                }]
+              };
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                orchestrationTaskId,
+                status: "timeout",
+                message: `Timed out waiting for agent after ${timeout}ms`,
+                waitDuration: Date.now() - startTime
+              }, null, 2)
+            }]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{
+              type: "text",
+              text: `Error waiting for agent: ${errorMsg}`
+            }]
+          };
+        }
+      }
+      case "list_spawned_agents": {
+        const { status: filterStatus } = args;
+        const jwt = process.env.CMUX_TASK_RUN_JWT;
+        const apiBaseUrl = process.env.CMUX_API_BASE_URL ?? "https://cmux.sh";
+        const orchestrationId = process.env.CMUX_ORCHESTRATION_ID;
+        if (!jwt) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_TASK_RUN_JWT environment variable not set. This tool requires JWT authentication."
+            }]
+          };
+        }
+        if (!orchestrationId) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_ORCHESTRATION_ID environment variable not set."
+            }]
+          };
+        }
+        try {
+          let url = `${apiBaseUrl}/api/v1/cmux/orchestration/${orchestrationId}/tasks`;
+          if (filterStatus) {
+            url += `?status=${filterStatus}`;
+          }
+          const response = await fetch(url, {
+            method: "GET",
+            headers: {
+              "Authorization": `Bearer ${jwt}`,
+              "Content-Type": "application/json"
+            }
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to list agents: ${response.status} ${errorText}`
+              }]
+            };
+          }
+          const result = await response.json();
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{
+              type: "text",
+              text: `Error listing agents: ${errorMsg}`
+            }]
+          };
+        }
+      }
+      case "cancel_agent": {
+        const { orchestrationTaskId, cascade = false } = args;
+        const jwt = process.env.CMUX_TASK_RUN_JWT;
+        const apiBaseUrl = process.env.CMUX_API_BASE_URL ?? "https://cmux.sh";
+        if (!jwt) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_TASK_RUN_JWT environment variable not set. This tool requires JWT authentication."
+            }]
+          };
+        }
+        try {
+          const url = `${apiBaseUrl}/api/orchestrate/cancel/${orchestrationTaskId}`;
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "X-Task-Run-JWT": jwt,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ cascade })
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to cancel agent: ${response.status} ${errorText}`
+              }]
+            };
+          }
+          const result = await response.json();
+          appendEvent({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            event: "agent_cancelled",
+            message: `Cancelled agent ${orchestrationTaskId}${cascade ? ` (cascade: ${result.cancelledCount} total)` : ""}`,
+            taskRunId: orchestrationTaskId
+          });
+          const plan = readPlan();
+          if (plan) {
+            const task = plan.tasks.find((t) => t.id === orchestrationTaskId);
+            if (task) {
+              task.status = "cancelled";
+              task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              writePlan(plan);
+            }
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                ok: true,
+                orchestrationTaskId,
+                cancelled: true,
+                cascade,
+                cancelledCount: result.cancelledCount ?? 1
+              }, null, 2)
+            }]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{
+              type: "text",
+              text: `Error cancelling agent: ${errorMsg}`
+            }]
+          };
+        }
+      }
+      case "get_orchestration_summary": {
+        const jwt = process.env.CMUX_TASK_RUN_JWT;
+        const apiBaseUrl = process.env.CMUX_API_BASE_URL ?? "https://cmux.sh";
+        const orchestrationId = process.env.CMUX_ORCHESTRATION_ID;
+        if (!jwt) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_TASK_RUN_JWT environment variable not set. This tool requires JWT authentication."
+            }]
+          };
+        }
+        if (!orchestrationId) {
+          return {
+            content: [{
+              type: "text",
+              text: "CMUX_ORCHESTRATION_ID environment variable not set."
+            }]
+          };
+        }
+        try {
+          const url = `${apiBaseUrl}/api/v1/cmux/orchestration/${orchestrationId}/sync`;
+          const response = await fetch(url, {
+            method: "GET",
+            headers: {
+              "Authorization": `Bearer ${jwt}`,
+              "Content-Type": "application/json"
+            }
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to get orchestration summary: ${response.status} ${errorText}`
+              }]
+            };
+          }
+          const data = await response.json();
+          const activeAgents = data.tasks.filter((t) => t.status === "running").map((t) => t.agentName);
+          const recentCompletions = data.tasks.filter((t) => t.status === "completed" || t.status === "failed").slice(-5).map((t) => ({
+            id: t.id,
+            status: t.status,
+            prompt: t.prompt.slice(0, 50) + (t.prompt.length > 50 ? "..." : ""),
+            result: t.result?.slice(0, 100),
+            error: t.errorMessage?.slice(0, 100)
+          }));
+          const summary = {
+            orchestrationId,
+            status: data.aggregatedStatus,
+            activeAgents,
+            activeAgentCount: activeAgents.length,
+            recentCompletions,
+            allTasksComplete: data.aggregatedStatus.pending === 0 && data.aggregatedStatus.running === 0,
+            hasFailures: data.aggregatedStatus.failed > 0
+          };
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(summary, null, 2)
+            }]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{
+              type: "text",
+              text: `Error getting orchestration summary: ${errorMsg}`
+            }]
+          };
+        }
+      }
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+    }
+  });
+  return server;
+}
+async function runServer(config) {
+  const server = createMemoryMcpServer(config);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+export {
+  createMemoryMcpServer,
+  runServer
+};