overture-mcp 0.1.0

package/dist/chunk-LFRCKLZZ.js

@@ -0,0 +1,2688 @@
+// src/storage/history-storage.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+var HISTORY_DIR = path.join(os.homedir(), ".overture");
+var HISTORY_FILE = path.join(HISTORY_DIR, "history.json");
+var MAX_HISTORY_ENTRIES = 100;
+var HistoryStorage = class {
+  cache = null;
+  writeDebounceTimer = null;
+  writePromise = null;
+  /**
+   * Ensure the history directory exists
+   */
+  async ensureDirectory() {
+    try {
+      await fs.mkdir(HISTORY_DIR, { recursive: true });
+    } catch (error) {
+    }
+  }
+  /**
+   * Load history from disk (with caching)
+   */
+  async load() {
+    if (this.cache) return this.cache;
+    try {
+      await this.ensureDirectory();
+      const data = await fs.readFile(HISTORY_FILE, "utf-8");
+      const parsed = JSON.parse(data);
+      if (!parsed || typeof parsed.version !== "number") {
+        console.error("[Overture] Invalid history file format, but preserving file");
+        this.cache = {
+          version: 1,
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+          entries: [],
+          plans: {}
+        };
+        return this.cache;
+      }
+      this.cache = parsed;
+      console.error(`[Overture] Loaded history: ${this.cache.entries.length} entries`);
+      return this.cache;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.error("[Overture] History file does not exist, creating new one");
+        this.cache = {
+          version: 1,
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+          entries: [],
+          plans: {}
+        };
+        await this.ensureDirectory();
+        await fs.writeFile(HISTORY_FILE, JSON.stringify(this.cache, null, 2));
+        console.error("[Overture] Created new history file at", HISTORY_FILE);
+        return this.cache;
+      }
+      console.error("[Overture] Error loading history file:", error.message);
+      console.error("[Overture] NOT overwriting existing file - using empty cache");
+      this.cache = {
+        version: 1,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        entries: [],
+        plans: {}
+      };
+      return this.cache;
+    }
+  }
+  /**
+   * Initialize history storage (call this on server start)
+   */
+  async initialize() {
+    const history = await this.load();
+    console.error("[Overture] History storage initialized");
+    console.error("[Overture] History file:", HISTORY_FILE);
+    console.error("[Overture] Entries loaded:", history.entries.length);
+    if (history.entries.length > 0) {
+      console.error("[Overture] Most recent plan:", history.entries[0].title);
+    }
+  }
+  /**
+   * Save history to disk (debounced to avoid excessive writes)
+   */
+  async save() {
+    if (this.writeDebounceTimer) {
+      clearTimeout(this.writeDebounceTimer);
+    }
+    if (this.writePromise) {
+      return this.writePromise;
+    }
+    this.writePromise = new Promise((resolve, reject) => {
+      this.writeDebounceTimer = setTimeout(async () => {
+        try {
+          if (!this.cache) {
+            resolve();
+            return;
+          }
+          this.cache.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+          await this.ensureDirectory();
+          await fs.writeFile(HISTORY_FILE, JSON.stringify(this.cache, null, 2));
+          console.error("[Overture] History saved to", HISTORY_FILE);
+          resolve();
+        } catch (error) {
+          console.error("[Overture] Failed to save history:", error);
+          reject(error);
+        } finally {
+          this.writePromise = null;
+        }
+      }, 1e3);
+    });
+    return this.writePromise;
+  }
+  /**
+   * Force immediate save (bypass debounce)
+   */
+  async saveNow() {
+    if (this.writeDebounceTimer) {
+      clearTimeout(this.writeDebounceTimer);
+      this.writeDebounceTimer = null;
+    }
+    if (!this.cache) return;
+    this.cache.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await this.ensureDirectory();
+    await fs.writeFile(HISTORY_FILE, JSON.stringify(this.cache, null, 2));
+    console.error("[Overture] History saved (immediate) to", HISTORY_FILE);
+  }
+  /**
+   * Save or update a plan in history
+   */
+  async savePlan(plan) {
+    const history = await this.load();
+    const entry = {
+      id: plan.plan.id,
+      projectId: plan.plan.projectId,
+      workspacePath: plan.plan.workspacePath,
+      projectName: path.basename(plan.plan.workspacePath),
+      title: plan.plan.title,
+      agent: plan.plan.agent,
+      status: plan.plan.status,
+      createdAt: plan.plan.createdAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeCount: plan.nodes.length,
+      completedNodeCount: plan.nodes.filter((n) => n.status === "completed").length
+    };
+    const existingIndex = history.entries.findIndex((e) => e.id === plan.plan.id);
+    if (existingIndex >= 0) {
+      history.entries[existingIndex] = entry;
+    } else {
+      history.entries.unshift(entry);
+    }
+    history.plans[plan.plan.id] = plan;
+    if (history.entries.length > MAX_HISTORY_ENTRIES) {
+      const removed = history.entries.splice(MAX_HISTORY_ENTRIES);
+      removed.forEach((e) => delete history.plans[e.id]);
+      console.error(`[Overture] Pruned ${removed.length} old history entries`);
+    }
+    await this.save();
+  }
+  /**
+   * Get a full plan by ID
+   */
+  async getPlan(planId) {
+    const history = await this.load();
+    return history.plans[planId] || null;
+  }
+  /**
+   * Get history entries filtered by project
+   */
+  async getEntriesByProject(projectId) {
+    const history = await this.load();
+    return history.entries.filter((e) => e.projectId === projectId);
+  }
+  /**
+   * Get all history entries
+   */
+  async getAllEntries() {
+    const history = await this.load();
+    return history.entries;
+  }
+  /**
+   * Delete a plan from history
+   */
+  async deletePlan(planId) {
+    const history = await this.load();
+    history.entries = history.entries.filter((e) => e.id !== planId);
+    delete history.plans[planId];
+    await this.save();
+  }
+  /**
+   * Clear all history
+   */
+  async clearAll() {
+    this.cache = {
+      version: 1,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      entries: [],
+      plans: {}
+    };
+    await this.saveNow();
+  }
+  /**
+   * Get the history file path (for debugging)
+   */
+  getHistoryPath() {
+    return HISTORY_FILE;
+  }
+};
+var historyStorage = new HistoryStorage();
+
+// src/websocket/ws-server.ts
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/utils/plan-diff.ts
+function calculatePlanDiff(oldPlan, newPlan) {
+  const oldNodeMap = new Map(oldPlan.nodes.map((n) => [n.id, n]));
+  const newNodeMap = new Map(newPlan.nodes.map((n) => [n.id, n]));
+  const addedNodes = [];
+  const removedNodes = [];
+  const modifiedNodes = [];
+  for (const [nodeId, newNode] of newNodeMap) {
+    const oldNode = oldNodeMap.get(nodeId);
+    if (!oldNode) {
+      addedNodes.push(newNode);
+    } else if (!nodesAreEqual(oldNode, newNode)) {
+      modifiedNodes.push({ before: oldNode, after: newNode });
+    }
+  }
+  for (const [nodeId, oldNode] of oldNodeMap) {
+    if (!newNodeMap.has(nodeId)) {
+      removedNodes.push(oldNode);
+    }
+  }
+  const oldEdgeSet = new Set(oldPlan.edges.map((e) => `${e.from}->${e.to}`));
+  const newEdgeSet = new Set(newPlan.edges.map((e) => `${e.from}->${e.to}`));
+  const addedEdges = newPlan.edges.filter((e) => !oldEdgeSet.has(`${e.from}->${e.to}`));
+  const removedEdges = oldPlan.edges.filter((e) => !newEdgeSet.has(`${e.from}->${e.to}`));
+  return {
+    addedNodes,
+    removedNodes,
+    modifiedNodes,
+    addedEdges,
+    removedEdges
+  };
+}
+function nodesAreEqual(a, b) {
+  if (a.title !== b.title) return false;
+  if (a.description !== b.description) return false;
+  if (a.type !== b.type) return false;
+  if (a.complexity !== b.complexity) return false;
+  if (a.expectedOutput !== b.expectedOutput) return false;
+  if (a.risks !== b.risks) return false;
+  if (a.dynamicFields.length !== b.dynamicFields.length) return false;
+  for (let i = 0; i < a.dynamicFields.length; i++) {
+    const fieldA = a.dynamicFields[i];
+    const fieldB = b.dynamicFields.find((f) => f.id === fieldA.id);
+    if (!fieldB) return false;
+    if (fieldA.name !== fieldB.name) return false;
+    if (fieldA.type !== fieldB.type) return false;
+    if (fieldA.title !== fieldB.title) return false;
+    if (fieldA.required !== fieldB.required) return false;
+  }
+  if (a.branches?.length !== b.branches?.length) return false;
+  if (a.branches && b.branches) {
+    for (let i = 0; i < a.branches.length; i++) {
+      const branchA = a.branches[i];
+      const branchB = b.branches.find((br) => br.id === branchA.id);
+      if (!branchB) return false;
+      if (branchA.label !== branchB.label) return false;
+      if (branchA.description !== branchB.description) return false;
+    }
+  }
+  return true;
+}
+
+// src/store/plan-store.ts
+import path2 from "path";
+var DEFAULT_PROJECT_ID = "default";
+var MultiProjectPlanStore = class {
+  projects = /* @__PURE__ */ new Map();
+  // Per-project control state
+  approvalResolvers = /* @__PURE__ */ new Map();
+  approvalPromises = /* @__PURE__ */ new Map();
+  pendingRerunRequests = /* @__PURE__ */ new Map();
+  rerunResolvers = /* @__PURE__ */ new Map();
+  rerunPromises = /* @__PURE__ */ new Map();
+  pauseStates = /* @__PURE__ */ new Map();
+  pauseResolvers = /* @__PURE__ */ new Map();
+  pausePromises = /* @__PURE__ */ new Map();
+  // Store previous plan state for diff calculation
+  previousPlanStates = /* @__PURE__ */ new Map();
+  // Auto-save interval
+  autoSaveInterval = null;
+  constructor() {
+    this.startAutoSave();
+  }
+  /**
+   * Start auto-save interval to persist all active projects every 3 seconds
+   */
+  startAutoSave() {
+    console.error("[Overture] Starting auto-save interval (every 3 seconds)");
+    this.autoSaveInterval = setInterval(async () => {
+      const activeProjects = Array.from(this.projects.entries()).filter(([, state]) => state.plan);
+      if (activeProjects.length > 0) {
+        console.error(`[Overture] Auto-saving ${activeProjects.length} active project(s)...`);
+        for (const [projectId, state] of activeProjects) {
+          try {
+            const persisted = {
+              plan: state.plan,
+              nodes: state.nodes,
+              edges: state.edges,
+              fieldValues: state.fieldValues,
+              selectedBranches: state.selectedBranches,
+              nodeConfigs: state.nodeConfigs
+            };
+            await historyStorage.savePlan(persisted);
+            await historyStorage.saveNow();
+            console.error(`[Overture] Auto-saved project ${projectId} (plan: ${state.plan.id})`);
+          } catch (error) {
+            console.error(`[Overture] Auto-save failed for project ${projectId}:`, error);
+          }
+        }
+      }
+    }, 3e3);
+  }
+  /**
+   * Get or initialize project state
+   */
+  getProjectState(projectId) {
+    return this.projects.get(projectId) || null;
+  }
+  /**
+   * Initialize a new project
+   */
+  initializeProject(context) {
+    if (!this.projects.has(context.projectId)) {
+      this.projects.set(context.projectId, {
+        projectId: context.projectId,
+        workspacePath: context.workspacePath,
+        plan: null,
+        nodes: [],
+        edges: [],
+        fieldValues: {},
+        selectedBranches: {},
+        nodeConfigs: {}
+      });
+      console.error(`[Overture] Initialized project: ${context.projectName} (${context.projectId})`);
+    }
+  }
+  /**
+   * Get all active projects
+   */
+  getAllProjects() {
+    const contexts = [];
+    for (const [projectId, state] of this.projects) {
+      contexts.push({
+        projectId,
+        workspacePath: state.workspacePath,
+        projectName: path2.basename(state.workspacePath),
+        agentType: state.plan?.agent || "unknown"
+      });
+    }
+    return contexts;
+  }
+  /**
+   * Get all active plans across all projects
+   */
+  getAllActivePlans() {
+    const result = [];
+    for (const [projectId, state] of this.projects) {
+      if (state.plan) {
+        result.push({
+          projectId,
+          plan: state.plan,
+          nodes: state.nodes
+        });
+      }
+    }
+    return result;
+  }
+  // === Plan Management ===
+  /**
+   * Start a new plan for a project
+   */
+  startPlan(projectId, plan) {
+    let state = this.projects.get(projectId);
+    if (!state) {
+      this.initializeProject({
+        projectId,
+        workspacePath: process.cwd(),
+        projectName: "default",
+        agentType: plan.agent
+      });
+      state = this.projects.get(projectId);
+    }
+    const planWithProject = {
+      ...plan,
+      projectId,
+      workspacePath: state.workspacePath
+    };
+    state.plan = planWithProject;
+    state.nodes = [];
+    state.edges = [];
+    state.fieldValues = {};
+    state.selectedBranches = {};
+    state.nodeConfigs = {};
+    console.error(`[Overture] Plan stored for project: ${projectId}, planId: ${planWithProject.id}`);
+    console.error(`[Overture] All projects after startPlan:`, Array.from(this.projects.keys()));
+    console.error(`[Overture] Creating approval promise for project: ${projectId}`);
+    this.approvalPromises.set(projectId, new Promise((resolve) => {
+      this.approvalResolvers.set(projectId, resolve);
+    }));
+    this.pauseStates.set(projectId, false);
+    console.error(`[Overture] Plan started. Projects with promises:`, Array.from(this.approvalPromises.keys()));
+    this.persistToHistory(projectId);
+    return planWithProject;
+  }
+  getPlan(projectId) {
+    return this.projects.get(projectId)?.plan ?? null;
+  }
+  getNodes(projectId) {
+    return this.projects.get(projectId)?.nodes ?? [];
+  }
+  getEdges(projectId) {
+    return this.projects.get(projectId)?.edges ?? [];
+  }
+  getState(projectId) {
+    const state = this.projects.get(projectId);
+    if (!state) return null;
+    return {
+      plan: state.plan,
+      nodes: state.nodes,
+      edges: state.edges,
+      fieldValues: state.fieldValues,
+      selectedBranches: state.selectedBranches,
+      nodeConfigs: state.nodeConfigs
+    };
+  }
+  getFieldValues(projectId) {
+    return this.projects.get(projectId)?.fieldValues ?? {};
+  }
+  getSelectedBranches(projectId) {
+    return this.projects.get(projectId)?.selectedBranches ?? {};
+  }
+  getNodeConfigs(projectId) {
+    return this.projects.get(projectId)?.nodeConfigs ?? {};
+  }
+  addNode(projectId, node) {
+    const state = this.projects.get(projectId);
+    if (state) {
+      state.nodes.push(node);
+      this.persistToHistory(projectId);
+    }
+  }
+  addEdge(projectId, edge) {
+    const state = this.projects.get(projectId);
+    if (state) {
+      state.edges.push(edge);
+      this.persistToHistory(projectId);
+    }
+  }
+  updatePlanStatus(projectId, status) {
+    const state = this.projects.get(projectId);
+    if (state?.plan) {
+      state.plan.status = status;
+      this.persistToHistory(projectId);
+    }
+  }
+  updateNodeStatus(projectId, nodeId, status, output) {
+    const state = this.projects.get(projectId);
+    if (!state) return;
+    const node = state.nodes.find((n) => n.id === nodeId);
+    if (node) {
+      node.status = status;
+      if (output) {
+        node.output = output;
+      }
+      this.persistToHistory(projectId);
+    }
+  }
+  // === Approval ===
+  async setApproval(projectId, fieldValues, selectedBranches, nodeConfigs = {}) {
+    console.error(`[Overture] setApproval called for project: ${projectId}`);
+    console.error(`[Overture] Available projects:`, Array.from(this.projects.keys()));
+    console.error(`[Overture] Available resolvers:`, Array.from(this.approvalResolvers.keys()));
+    let state = this.projects.get(projectId);
+    if (!state) {
+      console.error(`[Overture] No state found for project ${projectId}, attempting to restore from history...`);
+      const restored = await this.restoreProjectFromHistory(projectId);
+      if (restored) {
+        state = this.projects.get(projectId);
+        console.error(`[Overture] Successfully restored project from history`);
+      }
+    }
+    if (!state) {
+      console.error(`[Overture] ERROR: No state found for project ${projectId} and could not restore from history`);
+      return;
+    }
+    state.fieldValues = fieldValues;
+    state.selectedBranches = selectedBranches;
+    state.nodeConfigs = nodeConfigs;
+    if (state.plan) {
+      state.plan.status = "approved";
+      console.error(`[Overture] Plan status set to 'approved'`);
+    }
+    const resolver = this.approvalResolvers.get(projectId);
+    if (resolver) {
+      console.error(`[Overture] Resolving approval promise for project: ${projectId}`);
+      resolver(true);
+      this.approvalResolvers.delete(projectId);
+    } else {
+      console.error(`[Overture] WARNING: No resolver found for project ${projectId}`);
+    }
+    this.persistToHistory(projectId);
+  }
+  cancelApproval(projectId) {
+    const resolver = this.approvalResolvers.get(projectId);
+    if (resolver) {
+      resolver(false);
+      this.approvalResolvers.delete(projectId);
+    }
+  }
+  async waitForApproval(projectId, timeoutMs = 6e4) {
+    console.error(`[Overture] waitForApproval called for project: ${projectId}`);
+    console.error(`[Overture] Available promises:`, Array.from(this.approvalPromises.keys()));
+    let promise = this.approvalPromises.get(projectId);
+    if (!promise) {
+      console.error(`[Overture] No approval promise found, attempting to restore project from history...`);
+      const restored = await this.restoreProjectFromHistory(projectId);
+      if (restored) {
+        promise = this.approvalPromises.get(projectId);
+        console.error(`[Overture] Project restored, approval promise created`);
+      }
+    }
+    if (!promise) {
+      const state = this.projects.get(projectId);
+      if (state?.plan) {
+        console.error(`[Overture] Project exists but no promise, creating one...`);
+        promise = new Promise((resolve) => {
+          this.approvalResolvers.set(projectId, resolve);
+        });
+        this.approvalPromises.set(projectId, promise);
+      } else {
+        console.error(`[Overture] ERROR: No project found for ${projectId}, cannot create approval promise`);
+        return "cancelled";
+      }
+    }
+    console.error(`[Overture] Waiting for approval (timeout: ${timeoutMs}ms)...`);
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => resolve("pending"), timeoutMs);
+    });
+    const result = await Promise.race([
+      promise.then((approved) => approved ? "approved" : "cancelled"),
+      timeoutPromise
+    ]);
+    console.error(`[Overture] waitForApproval result: ${result}`);
+    return result;
+  }
+  // === Rerun ===
+  setRerunRequest(projectId, nodeId, mode) {
+    const request = { nodeId, mode, timestamp: Date.now() };
+    this.pendingRerunRequests.set(projectId, request);
+    const resolver = this.rerunResolvers.get(projectId);
+    if (resolver) {
+      resolver(request);
+      this.rerunResolvers.delete(projectId);
+      this.rerunPromises.delete(projectId);
+    }
+  }
+  getPendingRerun(projectId) {
+    return this.pendingRerunRequests.get(projectId) || null;
+  }
+  clearPendingRerun(projectId) {
+    this.pendingRerunRequests.delete(projectId);
+  }
+  async waitForRerun(projectId, timeoutMs = 6e4) {
+    const pending = this.pendingRerunRequests.get(projectId);
+    if (pending) {
+      this.pendingRerunRequests.delete(projectId);
+      return pending;
+    }
+    const promise = new Promise((resolve) => {
+      this.rerunResolvers.set(projectId, resolve);
+    });
+    this.rerunPromises.set(projectId, promise);
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => resolve(null), timeoutMs);
+    });
+    const result = await Promise.race([promise, timeoutPromise]);
+    if (result) {
+      this.pendingRerunRequests.delete(projectId);
+    }
+    return result;
+  }
+  resetNodesForRerun(projectId, startNodeId, mode) {
+    const state = this.projects.get(projectId);
+    if (!state) return [];
+    const nodeIds = [];
+    if (mode === "single") {
+      const node = state.nodes.find((n) => n.id === startNodeId);
+      if (node) {
+        node.status = "pending";
+        node.output = void 0;
+        nodeIds.push(node.id);
+      }
+    } else {
+      const startIndex = state.nodes.findIndex((n) => n.id === startNodeId);
+      if (startIndex !== -1) {
+        for (let i = startIndex; i < state.nodes.length; i++) {
+          const node = state.nodes[i];
+          node.status = "pending";
+          node.output = void 0;
+          nodeIds.push(node.id);
+        }
+      }
+    }
+    return nodeIds;
+  }
+  // === Pause/Resume ===
+  pause(projectId) {
+    this.pauseStates.set(projectId, true);
+    const state = this.projects.get(projectId);
+    if (state?.plan) {
+      state.plan.status = "paused";
+    }
+  }
+  resume(projectId) {
+    this.pauseStates.set(projectId, false);
+    const state = this.projects.get(projectId);
+    if (state?.plan) {
+      state.plan.status = "executing";
+    }
+    const resolver = this.pauseResolvers.get(projectId);
+    if (resolver) {
+      resolver();
+      this.pauseResolvers.delete(projectId);
+      this.pausePromises.delete(projectId);
+    }
+  }
+  getIsPaused(projectId) {
+    return this.pauseStates.get(projectId) || false;
+  }
+  async waitIfPaused(projectId) {
+    if (!this.pauseStates.get(projectId)) {
+      return false;
+    }
+    const promise = new Promise((resolve) => {
+      this.pauseResolvers.set(projectId, resolve);
+    });
+    this.pausePromises.set(projectId, promise);
+    await promise;
+    return true;
+  }
+  // === Node Operations ===
+  insertNodes(projectId, afterNodeId, newNodes, newEdges) {
+    const state = this.projects.get(projectId);
+    if (!state) return { removedEdgeIds: [], reconnectionEdges: [] };
+    const edgesToRemove = state.edges.filter((e) => e.from === afterNodeId);
+    const removedEdgeIds = edgesToRemove.map((e) => e.id);
+    const targetNodeIds = edgesToRemove.map((e) => e.to);
+    state.edges = state.edges.filter((e) => e.from !== afterNodeId);
+    state.nodes.push(...newNodes);
+    state.edges.push(...newEdges);
+    const newNodeIds = new Set(newNodes.map((n) => n.id));
+    const exitNodeIds = newNodes.filter((n) => !newEdges.some((e) => e.from === n.id && newNodeIds.has(e.to))).map((n) => n.id);
+    const reconnectionEdges = [];
+    let edgeCounter = Date.now();
+    for (const exitNodeId of exitNodeIds) {
+      for (const targetNodeId of targetNodeIds) {
+        const reconnectEdge = {
+          id: `e_inserted_${edgeCounter++}`,
+          from: exitNodeId,
+          to: targetNodeId
+        };
+        state.edges.push(reconnectEdge);
+        reconnectionEdges.push(reconnectEdge);
+      }
+    }
+    return { removedEdgeIds, reconnectionEdges };
+  }
+  removeNode(projectId, nodeId) {
+    const state = this.projects.get(projectId);
+    if (!state) return { newEdges: [], removedEdgeIds: [] };
+    const incomingEdges = state.edges.filter((e) => e.to === nodeId);
+    const outgoingEdges = state.edges.filter((e) => e.from === nodeId);
+    const removedEdgeIds = [
+      ...incomingEdges.map((e) => e.id),
+      ...outgoingEdges.map((e) => e.id)
+    ];
+    const newEdges = [];
+    let edgeCounter = Date.now();
+    for (const incoming of incomingEdges) {
+      for (const outgoing of outgoingEdges) {
+        newEdges.push({
+          id: `e_bridge_${edgeCounter++}`,
+          from: incoming.from,
+          to: outgoing.to
+        });
+      }
+    }
+    state.nodes = state.nodes.filter((n) => n.id !== nodeId);
+    state.edges = [
+      ...state.edges.filter((e) => e.to !== nodeId && e.from !== nodeId),
+      ...newEdges
+    ];
+    return { newEdges, removedEdgeIds };
+  }
+  // === Plan Update Support ===
+  /**
+   * Store the current plan state before an update for diff calculation
+   */
+  storePreviousPlanState(projectId) {
+    const state = this.projects.get(projectId);
+    if (!state) return;
+    this.previousPlanStates.set(projectId, {
+      nodes: JSON.parse(JSON.stringify(state.nodes)),
+      edges: JSON.parse(JSON.stringify(state.edges))
+    });
+    console.error(`[Overture] Stored previous plan state for project ${projectId} (${state.nodes.length} nodes, ${state.edges.length} edges)`);
+  }
+  /**
+   * Get the previous plan state for diff calculation
+   */
+  getPreviousPlanState(projectId) {
+    return this.previousPlanStates.get(projectId) || null;
+  }
+  /**
+   * Clear the previous plan state after diff has been calculated
+   */
+  clearPreviousPlanState(projectId) {
+    this.previousPlanStates.delete(projectId);
+  }
+  /**
+   * Calculate diff between previous and current plan states
+   */
+  calculateDiff(projectId) {
+    const previousState = this.previousPlanStates.get(projectId);
+    const currentState = this.projects.get(projectId);
+    if (!previousState || !currentState) {
+      return null;
+    }
+    return calculatePlanDiff(previousState, {
+      nodes: currentState.nodes,
+      edges: currentState.edges
+    });
+  }
+  /**
+   * Clear the current plan for a project to prepare for a new unrelated plan
+   */
+  clearProjectPlan(projectId) {
+    const state = this.projects.get(projectId);
+    if (!state) return;
+    state.plan = null;
+    state.nodes = [];
+    state.edges = [];
+    state.fieldValues = {};
+    state.selectedBranches = {};
+    state.nodeConfigs = {};
+    this.approvalResolvers.delete(projectId);
+    this.approvalPromises.delete(projectId);
+    this.pendingRerunRequests.delete(projectId);
+    this.pauseStates.delete(projectId);
+    this.previousPlanStates.delete(projectId);
+    console.error(`[Overture] Cleared plan for project ${projectId}`);
+  }
+  // === History/Persistence ===
+  /**
+   * Persist current project state to history
+   * Uses immediate write to ensure data is not lost
+   */
+  async persistToHistory(projectId) {
+    const state = this.projects.get(projectId);
+    if (!state?.plan) return;
+    try {
+      const persisted = {
+        plan: state.plan,
+        nodes: state.nodes,
+        edges: state.edges,
+        fieldValues: state.fieldValues,
+        selectedBranches: state.selectedBranches,
+        nodeConfigs: state.nodeConfigs
+      };
+      await historyStorage.savePlan(persisted);
+      await historyStorage.saveNow();
+      console.error(`[Overture] Persisted to history: ${state.plan.id} (${state.nodes.length} nodes)`);
+    } catch (error) {
+      console.error("[Overture] Failed to persist plan to history:", error);
+    }
+  }
+  /**
+   * Force immediate persist to history (for UI-triggered saves)
+   */
+  async forcePersist(projectId) {
+    console.error(`[Overture] forcePersist called for project: ${projectId}`);
+    console.error(`[Overture] Available projects:`, Array.from(this.projects.keys()));
+    const state = this.projects.get(projectId);
+    if (!state?.plan) {
+      console.error(`[Overture] No plan found for project ${projectId}. State exists: ${!!state}, Plan exists: ${!!state?.plan}`);
+      return { success: false };
+    }
+    try {
+      const persisted = {
+        plan: state.plan,
+        nodes: state.nodes,
+        edges: state.edges,
+        fieldValues: state.fieldValues,
+        selectedBranches: state.selectedBranches,
+        nodeConfigs: state.nodeConfigs
+      };
+      await historyStorage.savePlan(persisted);
+      await historyStorage.saveNow();
+      console.error(`[Overture] Plan ${state.plan.id} force-persisted to history`);
+      return { success: true, planId: state.plan.id };
+    } catch (error) {
+      console.error("[Overture] Failed to force persist plan:", error);
+      return { success: false };
+    }
+  }
+  /**
+   * Load a plan from history into a project
+   */
+  async loadFromHistory(planId) {
+    const persisted = await historyStorage.getPlan(planId);
+    if (!persisted) return null;
+    const state = {
+      projectId: persisted.plan.projectId,
+      workspacePath: persisted.plan.workspacePath,
+      plan: persisted.plan,
+      nodes: persisted.nodes,
+      edges: persisted.edges,
+      fieldValues: persisted.fieldValues,
+      selectedBranches: persisted.selectedBranches,
+      nodeConfigs: persisted.nodeConfigs
+    };
+    this.projects.set(state.projectId, state);
+    return state;
+  }
+  /**
+   * Restore a project from history by projectId
+   * Finds the most recent plan for this project and loads it
+   */
+  async restoreProjectFromHistory(projectId) {
+    try {
+      const entries = await historyStorage.getEntriesByProject(projectId);
+      if (entries.length === 0) {
+        console.error(`[Overture] No history entries found for project ${projectId}`);
+        return false;
+      }
+      const mostRecent = entries[0];
+      console.error(`[Overture] Found history entry: ${mostRecent.title} (${mostRecent.id})`);
+      const persisted = await historyStorage.getPlan(mostRecent.id);
+      if (!persisted) {
+        console.error(`[Overture] Could not load plan data for ${mostRecent.id}`);
+        return false;
+      }
+      const state = {
+        projectId: persisted.plan.projectId,
+        workspacePath: persisted.plan.workspacePath,
+        plan: persisted.plan,
+        nodes: persisted.nodes,
+        edges: persisted.edges,
+        fieldValues: persisted.fieldValues,
+        selectedBranches: persisted.selectedBranches,
+        nodeConfigs: persisted.nodeConfigs
+      };
+      this.projects.set(state.projectId, state);
+      console.error(`[Overture] Creating approval promise for restored project: ${projectId}`);
+      this.approvalPromises.set(projectId, new Promise((resolve) => {
+        this.approvalResolvers.set(projectId, resolve);
+      }));
+      this.pauseStates.set(projectId, false);
+      console.error(`[Overture] Project ${projectId} restored from history with ${state.nodes.length} nodes`);
+      return true;
+    } catch (error) {
+      console.error(`[Overture] Failed to restore project from history:`, error);
+      return false;
+    }
+  }
+  // === Resume Info ===
+  /**
+   * Generate resume info for a paused/failed plan
+   */
+  getResumeInfo(projectId) {
+    const state = this.projects.get(projectId);
+    if (!state?.plan) return null;
+    const plan = state.plan;
+    let currentNode = null;
+    for (const node of state.nodes) {
+      if (node.status === "active" || node.status === "failed") {
+        currentNode = node;
+        break;
+      }
+    }
+    if (!currentNode) {
+      const completedNodes2 = state.nodes.filter((n) => n.status === "completed");
+      if (completedNodes2.length > 0) {
+        currentNode = completedNodes2[completedNodes2.length - 1];
+      }
+    }
+    const completedNodes = state.nodes.filter((n) => n.status === "completed").map((n) => ({
+      id: n.id,
+      title: n.title,
+      output: n.output
+    }));
+    const pendingNodes = state.nodes.filter((n) => n.status === "pending").map((n) => ({
+      id: n.id,
+      title: n.title,
+      description: n.description
+    }));
+    const failedNodes = state.nodes.filter((n) => n.status === "failed").map((n) => ({
+      id: n.id,
+      title: n.title,
+      output: n.output
+    }));
+    const resumeInfo = {
+      planId: plan.id,
+      planTitle: plan.title,
+      agent: plan.agent,
+      status: plan.status,
+      projectId: state.projectId,
+      workspacePath: state.workspacePath,
+      currentNodeId: currentNode?.id || null,
+      currentNodeTitle: currentNode?.title || null,
+      currentNodeStatus: currentNode?.status || null,
+      completedNodes,
+      pendingNodes,
+      failedNodes,
+      fieldValues: state.fieldValues,
+      selectedBranches: state.selectedBranches,
+      nodeConfigs: state.nodeConfigs,
+      createdAt: plan.createdAt,
+      pausedAt: plan.status === "paused" ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+    };
+    return resumeInfo;
+  }
+  // === Cleanup ===
+  clear(projectId) {
+    this.projects.delete(projectId);
+    this.approvalResolvers.delete(projectId);
+    this.approvalPromises.delete(projectId);
+    this.pendingRerunRequests.delete(projectId);
+    this.rerunResolvers.delete(projectId);
+    this.rerunPromises.delete(projectId);
+    this.pauseStates.delete(projectId);
+    this.pauseResolvers.delete(projectId);
+    this.pausePromises.delete(projectId);
+    this.previousPlanStates.delete(projectId);
+  }
+  clearAll() {
+    this.projects.clear();
+    this.approvalResolvers.clear();
+    this.approvalPromises.clear();
+    this.pendingRerunRequests.clear();
+    this.rerunResolvers.clear();
+    this.rerunPromises.clear();
+    this.pauseStates.clear();
+    this.pauseResolvers.clear();
+    this.pausePromises.clear();
+    this.previousPlanStates.clear();
+  }
+};
+var multiProjectPlanStore = new MultiProjectPlanStore();
+var LegacyPlanStore = class {
+  get projectId() {
+    return DEFAULT_PROJECT_ID;
+  }
+  getPlan() {
+    return multiProjectPlanStore.getPlan(this.projectId);
+  }
+  getNodes() {
+    return multiProjectPlanStore.getNodes(this.projectId);
+  }
+  getEdges() {
+    return multiProjectPlanStore.getEdges(this.projectId);
+  }
+  getState() {
+    return multiProjectPlanStore.getState(this.projectId) || {
+      plan: null,
+      nodes: [],
+      edges: [],
+      fieldValues: {},
+      selectedBranches: {},
+      nodeConfigs: {}
+    };
+  }
+  getFieldValues() {
+    return multiProjectPlanStore.getFieldValues(this.projectId);
+  }
+  getSelectedBranches() {
+    return multiProjectPlanStore.getSelectedBranches(this.projectId);
+  }
+  getNodeConfigs() {
+    return multiProjectPlanStore.getNodeConfigs(this.projectId);
+  }
+  startPlan(plan) {
+    multiProjectPlanStore.initializeProject({
+      projectId: this.projectId,
+      workspacePath: process.cwd(),
+      projectName: "default",
+      agentType: plan.agent
+    });
+    multiProjectPlanStore.startPlan(this.projectId, plan);
+  }
+  addNode(node) {
+    multiProjectPlanStore.addNode(this.projectId, node);
+  }
+  addEdge(edge) {
+    multiProjectPlanStore.addEdge(this.projectId, edge);
+  }
+  updatePlanStatus(status) {
+    multiProjectPlanStore.updatePlanStatus(this.projectId, status);
+  }
+  updateNodeStatus(nodeId, status, output) {
+    multiProjectPlanStore.updateNodeStatus(this.projectId, nodeId, status, output);
+  }
+  setApproval(fieldValues, selectedBranches, nodeConfigs = {}) {
+    multiProjectPlanStore.setApproval(this.projectId, fieldValues, selectedBranches, nodeConfigs);
+  }
+  cancelApproval() {
+    multiProjectPlanStore.cancelApproval(this.projectId);
+  }
+  async waitForApproval(timeoutMs = 6e4) {
+    return multiProjectPlanStore.waitForApproval(this.projectId, timeoutMs);
+  }
+  setRerunRequest(nodeId, mode) {
+    multiProjectPlanStore.setRerunRequest(this.projectId, nodeId, mode);
+  }
+  getPendingRerun() {
+    return multiProjectPlanStore.getPendingRerun(this.projectId);
+  }
+  clearPendingRerun() {
+    multiProjectPlanStore.clearPendingRerun(this.projectId);
+  }
+  async waitForRerun(timeoutMs = 6e4) {
+    return multiProjectPlanStore.waitForRerun(this.projectId, timeoutMs);
+  }
+  resetNodesForRerun(startNodeId, mode) {
+    return multiProjectPlanStore.resetNodesForRerun(this.projectId, startNodeId, mode);
+  }
+  pause() {
+    multiProjectPlanStore.pause(this.projectId);
+  }
+  resume() {
+    multiProjectPlanStore.resume(this.projectId);
+  }
+  getIsPaused() {
+    return multiProjectPlanStore.getIsPaused(this.projectId);
+  }
+  async waitIfPaused() {
+    return multiProjectPlanStore.waitIfPaused(this.projectId);
+  }
+  insertNodes(afterNodeId, newNodes, newEdges) {
+    return multiProjectPlanStore.insertNodes(this.projectId, afterNodeId, newNodes, newEdges);
+  }
+  removeNode(nodeId) {
+    return multiProjectPlanStore.removeNode(this.projectId, nodeId);
+  }
+  clear() {
+    multiProjectPlanStore.clear(this.projectId);
+  }
+};
+var planStore = new LegacyPlanStore();
+
+// src/websocket/ws-server.ts
+var WebSocketManager = class {
+  wss = null;
+  clients = /* @__PURE__ */ new Map();
+  relayClient = null;
+  port = 3030;
+  start(port) {
+    this.port = port;
+    try {
+      this.wss = new WebSocketServer({ port });
+    } catch (err) {
+      console.error(`[Overture] WebSocket server failed to start on port ${port}, will try relay mode`);
+      this.connectAsRelay(port);
+      return;
+    }
+    this.wss.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.error(`[Overture] WebSocket port ${port} already in use - connecting as relay client`);
+        this.wss = null;
+        this.connectAsRelay(port);
+      } else {
+        console.error(`[Overture] WebSocket server error:`, err);
+      }
+    });
+    console.error(`[Overture] WebSocket server listening on ws://localhost:${port}`);
+    this.wss.on("connection", (ws) => {
+      console.error("[Overture] Client connected");
+      this.clients.set(ws, {
+        ws,
+        projectId: null,
+        projectName: null,
+        workspacePath: null
+      });
+      this.send(ws, { type: "connected" });
+      const projects = multiProjectPlanStore.getAllProjects();
+      if (projects.length > 0) {
+        this.send(ws, { type: "projects_list", projects });
+      }
+      const plan = planStore.getPlan();
+      if (plan) {
+        this.send(ws, { type: "plan_started", plan });
+        for (const node of planStore.getNodes()) {
+          this.send(ws, { type: "node_added", node });
+        }
+        for (const edge of planStore.getEdges()) {
+          this.send(ws, { type: "edge_added", edge });
+        }
+        if (plan.status === "ready") {
+          this.send(ws, { type: "plan_ready" });
+        }
+      }
+      ws.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          if (message.type === "relay" && message.payload) {
+            const payload = message.payload;
+            console.error("[Overture] Relaying message:", payload.type);
+            try {
+              this.syncStateFromRelay(payload);
+            } catch (err) {
+              console.error("[Overture] Error syncing state from relay:", err);
+            }
+            const relayData = JSON.stringify(payload);
+            for (const [clientWs] of this.clients) {
+              if (clientWs !== ws && clientWs.readyState === WebSocket.OPEN) {
+                clientWs.send(relayData);
+              }
+            }
+            return;
+          }
+          this.handleClientMessage(ws, message);
+        } catch (error) {
+          console.error("[Overture] Failed to parse client message:", error);
+        }
+      });
+      ws.on("close", () => {
+        console.error("[Overture] Client disconnected");
+        this.clients.delete(ws);
+      });
+      ws.on("error", (error) => {
+        console.error("[Overture] WebSocket error:", error);
+        this.clients.delete(ws);
+      });
+    });
+  }
+  async handleClientMessage(ws, message) {
+    const projectId = "projectId" in message && message.projectId ? message.projectId : "default";
+    switch (message.type) {
+      case "register_project": {
+        const { projectContext } = message;
+        console.error(`[Overture] Project registered: ${projectContext.projectName} (${projectContext.projectId})`);
+        multiProjectPlanStore.initializeProject(projectContext);
+        const client = this.clients.get(ws);
+        if (client) {
+          client.projectId = projectContext.projectId;
+          client.projectName = projectContext.projectName;
+          client.workspacePath = projectContext.workspacePath;
+        }
+        this.broadcastAll({
+          type: "project_registered",
+          projectId: projectContext.projectId,
+          projectName: projectContext.projectName,
+          workspacePath: projectContext.workspacePath
+        });
+        const projects = multiProjectPlanStore.getAllProjects();
+        this.broadcastAll({ type: "projects_list", projects });
+        break;
+      }
+      case "subscribe_project": {
+        console.error(`[Overture] Client subscribed to project: ${message.projectId}`);
+        const client = this.clients.get(ws);
+        if (client) {
+          client.projectId = message.projectId;
+          const state = multiProjectPlanStore.getState(message.projectId);
+          if (state?.plan) {
+            this.send(ws, { type: "plan_started", plan: state.plan, projectId: message.projectId });
+            for (const node of state.nodes) {
+              this.send(ws, { type: "node_added", node, projectId: message.projectId });
+            }
+            for (const edge of state.edges) {
+              this.send(ws, { type: "edge_added", edge, projectId: message.projectId });
+            }
+            if (state.plan.status === "ready") {
+              this.send(ws, { type: "plan_ready", projectId: message.projectId });
+            }
+          }
+        }
+        break;
+      }
+      case "unsubscribe_project": {
+        console.error(`[Overture] Client unsubscribed from project: ${message.projectId}`);
+        const client = this.clients.get(ws);
+        if (client && client.projectId === message.projectId) {
+          client.projectId = null;
+        }
+        break;
+      }
+      case "get_history": {
+        console.error("[Overture] History requested");
+        let entries;
+        if (message.projectId) {
+          entries = await historyStorage.getEntriesByProject(message.projectId);
+        } else {
+          entries = await historyStorage.getAllEntries();
+        }
+        this.send(ws, { type: "history_entries", entries });
+        break;
+      }
+      case "load_plan": {
+        console.error(`[Overture] Loading plan from history: ${message.planId}`);
+        const state = await multiProjectPlanStore.loadFromHistory(message.planId);
+        if (state?.plan) {
+          const client = this.clients.get(ws);
+          if (client) {
+            client.projectId = state.projectId;
+          }
+          this.send(ws, {
+            type: "plan_loaded",
+            plan: {
+              plan: {
+                ...state.plan,
+                projectId: state.projectId,
+                workspacePath: state.workspacePath || ""
+              },
+              nodes: state.nodes,
+              edges: state.edges,
+              fieldValues: state.fieldValues,
+              selectedBranches: state.selectedBranches,
+              nodeConfigs: state.nodeConfigs
+            },
+            projectId: state.projectId
+          });
+        } else {
+          this.send(ws, { type: "error", message: `Plan not found: ${message.planId}` });
+        }
+        break;
+      }
+      case "get_resume_info": {
+        console.error(`[Overture] Resume info requested for project: ${message.projectId || projectId}`);
+        const effectiveProjectId = message.projectId || projectId;
+        if (message.planId) {
+          const state = await multiProjectPlanStore.loadFromHistory(message.planId);
+          if (state) {
+            const resumeInfo = multiProjectPlanStore.getResumeInfo(state.projectId);
+            if (resumeInfo) {
+              this.send(ws, { type: "resume_plan_info", resumeInfo });
+            } else {
+              this.send(ws, { type: "error", message: `No resume info available for plan: ${message.planId}` });
+            }
+          } else {
+            this.send(ws, { type: "error", message: `Plan not found: ${message.planId}` });
+          }
+        } else {
+          const resumeInfo = multiProjectPlanStore.getResumeInfo(effectiveProjectId);
+          if (resumeInfo) {
+            this.send(ws, { type: "resume_plan_info", resumeInfo });
+          } else {
+            this.send(ws, { type: "error", message: `No active plan for project: ${effectiveProjectId}` });
+          }
+        }
+        break;
+      }
+      case "save_plan": {
+        const effectiveProjectId = message.projectId || projectId;
+        console.error(`[Overture] Save plan requested for project: ${effectiveProjectId}`);
+        console.error(`[Overture] Message projectId: ${message.projectId}, Default projectId: ${projectId}`);
+        const result = await multiProjectPlanStore.forcePersist(effectiveProjectId);
+        if (result.success && result.planId) {
+          this.send(ws, { type: "plan_saved", projectId: effectiveProjectId, planId: result.planId });
+        } else {
+          this.send(ws, { type: "error", message: `No active plan to save for project: ${effectiveProjectId}` });
+        }
+        break;
+      }
+      case "approve_plan": {
+        const effectiveProjectId = message.projectId || projectId;
+        console.error(`[Overture] Plan approved by user (project: ${effectiveProjectId})`);
+        console.error(`[Overture] Message projectId: ${message.projectId}, Default projectId: ${projectId}`);
+        console.error(`[Overture] Field values:`, Object.keys(message.fieldValues || {}).length);
+        console.error(`[Overture] Node configs:`, Object.keys(message.nodeConfigs || {}).length);
+        const existingProject = multiProjectPlanStore.getProjectState(effectiveProjectId);
+        console.error(`[Overture] Project exists in store: ${!!existingProject}`);
+        if (existingProject) {
+          console.error(`[Overture] Project plan status: ${existingProject.plan?.status}`);
+          console.error(`[Overture] Project nodes: ${existingProject.nodes.length}`);
+        }
+        await multiProjectPlanStore.setApproval(
+          effectiveProjectId,
+          message.fieldValues,
+          message.selectedBranches,
+          message.nodeConfigs || {}
+        );
+        this.broadcastAll({
+          type: "approval_granted",
+          projectId: effectiveProjectId,
+          fieldValues: message.fieldValues,
+          selectedBranches: message.selectedBranches,
+          nodeConfigs: message.nodeConfigs || {}
+        });
+        break;
+      }
+      case "cancel_plan":
+        console.error(`[Overture] Plan cancelled by user (project: ${projectId})`);
+        multiProjectPlanStore.cancelApproval(projectId);
+        break;
+      case "rerun_request":
+        console.error(`[Overture] Rerun requested: node=${message.nodeId}, mode=${message.mode} (project: ${projectId})`);
+        multiProjectPlanStore.setRerunRequest(projectId, message.nodeId, message.mode);
+        break;
+      case "pause_execution":
+        console.error(`[Overture] Execution paused by user (project: ${projectId})`);
+        multiProjectPlanStore.pause(projectId);
+        this.broadcastToProject(projectId, { type: "plan_paused", projectId });
+        break;
+      case "resume_execution":
+        console.error(`[Overture] Execution resumed by user (project: ${projectId})`);
+        multiProjectPlanStore.resume(projectId);
+        this.broadcastToProject(projectId, { type: "plan_resumed", projectId });
+        break;
+      case "insert_nodes": {
+        console.error(`[Overture] Inserting ${message.nodes.length} node(s) after ${message.afterNodeId} (project: ${projectId})`);
+        const insertResult = multiProjectPlanStore.insertNodes(projectId, message.afterNodeId, message.nodes, message.edges);
+        const allEdges = [...message.edges, ...insertResult.reconnectionEdges];
+        this.broadcastToProject(projectId, {
+          type: "nodes_inserted",
+          nodes: message.nodes,
+          edges: allEdges,
+          removedEdgeIds: insertResult.removedEdgeIds,
+          projectId
+        });
+        break;
+      }
+      case "remove_node": {
+        console.error(`[Overture] Removing node ${message.nodeId} (project: ${projectId})`);
+        const removeResult = multiProjectPlanStore.removeNode(projectId, message.nodeId);
+        this.broadcastToProject(projectId, {
+          type: "node_removed",
+          nodeId: message.nodeId,
+          newEdges: removeResult.newEdges,
+          removedEdgeIds: removeResult.removedEdgeIds,
+          projectId
+        });
+        break;
+      }
+      case "request_plan_update": {
+        const effectiveProjectId = message.projectId || projectId;
+        console.error(`[Overture] Plan update requested for project: ${effectiveProjectId}`);
+        const currentState = multiProjectPlanStore.getState(effectiveProjectId);
+        if (currentState?.plan) {
+          multiProjectPlanStore.storePreviousPlanState(effectiveProjectId);
+          console.error(`[Overture] Stored previous plan state, waiting for updated plan`);
+        } else {
+          this.send(ws, { type: "error", message: `No active plan for project: ${effectiveProjectId}` });
+        }
+        break;
+      }
+      case "create_new_plan": {
+        const effectiveProjectId = message.projectId || projectId;
+        console.error(`[Overture] New plan requested for project: ${effectiveProjectId}`);
+        this.broadcastToProject(effectiveProjectId, {
+          type: "new_plan_created",
+          planId: "",
+          // Will be set when the new plan arrives
+          projectId: effectiveProjectId
+        });
+        break;
+      }
+    }
+  }
+  /**
+   * Sync local state when receiving relay messages from another MCP instance.
+   * This ensures the main server has the project state needed to handle approve_plan.
+   */
+  syncStateFromRelay(payload) {
+    const projectId = "projectId" in payload && payload.projectId ? payload.projectId : "default";
+    switch (payload.type) {
+      case "project_registered": {
+        const msg = payload;
+        console.error(`[Overture] Syncing project_registered: ${msg.projectId}`);
+        multiProjectPlanStore.initializeProject({
+          projectId: msg.projectId,
+          projectName: msg.projectName,
+          workspacePath: msg.workspacePath,
+          agentType: "unknown"
+        });
+        break;
+      }
+      case "plan_started": {
+        const msg = payload;
+        console.error(`[Overture] Syncing plan_started: ${msg.plan?.id} for project ${projectId}`);
+        if (msg.plan) {
+          multiProjectPlanStore.startPlan(projectId, msg.plan);
+        }
+        break;
+      }
+      case "node_added": {
+        const msg = payload;
+        console.error(`[Overture] Syncing node_added: ${msg.node?.id} for project ${projectId}`);
+        if (msg.node) {
+          multiProjectPlanStore.addNode(projectId, msg.node);
+        }
+        break;
+      }
+      case "edge_added": {
+        const msg = payload;
+        if (msg.edge) {
+          multiProjectPlanStore.addEdge(projectId, msg.edge);
+        }
+        break;
+      }
+      case "plan_ready": {
+        console.error(`[Overture] Syncing plan_ready for project ${projectId}`);
+        multiProjectPlanStore.updatePlanStatus(projectId, "ready");
+        break;
+      }
+      case "node_status_updated": {
+        const msg = payload;
+        multiProjectPlanStore.updateNodeStatus(projectId, msg.nodeId, msg.status, msg.output);
+        break;
+      }
+      // Other message types don't need state sync
+      default:
+        break;
+    }
+  }
+  connectAsRelay(port) {
+    try {
+      this.relayClient = new WebSocket(`ws://localhost:${port}`);
+      this.relayClient.on("open", () => {
+        console.error("[Overture] Connected as relay client to existing server");
+      });
+      this.relayClient.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          console.error("[Overture] Relay client received:", message.type);
+          if (message.type === "approval_granted") {
+            console.error("[Overture] Relay client: Resolving approval for project:", message.projectId);
+            multiProjectPlanStore.setApproval(
+              message.projectId,
+              message.fieldValues || {},
+              message.selectedBranches || {},
+              message.nodeConfigs || {}
+            );
+          }
+        } catch (err) {
+          console.error("[Overture] Relay client: Failed to parse message:", err);
+        }
+      });
+      this.relayClient.on("error", (err) => {
+        console.error("[Overture] Relay client error:", err.message);
+        this.relayClient = null;
+      });
+      this.relayClient.on("close", () => {
+        console.error("[Overture] Relay client disconnected");
+        this.relayClient = null;
+      });
+    } catch (err) {
+      console.error("[Overture] Failed to connect as relay:", err);
+    }
+  }
+  /**
+   * Broadcast message to all clients subscribed to a specific project
+   */
+  broadcastToProject(projectId, message) {
+    const data = JSON.stringify(message);
+    if (this.relayClient && this.relayClient.readyState === WebSocket.OPEN) {
+      this.relayClient.send(JSON.stringify({ type: "relay", payload: message }));
+      return;
+    }
+    for (const [clientWs, client] of this.clients) {
+      if (clientWs.readyState === WebSocket.OPEN) {
+        if (client.projectId === projectId || client.projectId === null) {
+          clientWs.send(data);
+        }
+      }
+    }
+  }
+  /**
+   * Broadcast message to ALL connected clients (for global events)
+   */
+  broadcastAll(message) {
+    const data = JSON.stringify(message);
+    if (this.relayClient && this.relayClient.readyState === WebSocket.OPEN) {
+      this.relayClient.send(JSON.stringify({ type: "relay", payload: message }));
+      return;
+    }
+    for (const [clientWs] of this.clients) {
+      if (clientWs.readyState === WebSocket.OPEN) {
+        clientWs.send(data);
+      }
+    }
+  }
+  /**
+   * Legacy broadcast - broadcasts to all clients (backwards compatibility)
+   */
+  broadcast(message) {
+    const projectId = "projectId" in message && message.projectId ? message.projectId : null;
+    if (projectId) {
+      this.broadcastToProject(projectId, message);
+    } else {
+      this.broadcastAll(message);
+    }
+  }
+  send(ws, message) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(message));
+    }
+  }
+  /**
+   * Get all active projects from connected clients
+   */
+  getActiveProjects() {
+    return multiProjectPlanStore.getAllProjects();
+  }
+  /**
+   * Get clients subscribed to a specific project
+   */
+  getProjectClients(projectId) {
+    let count = 0;
+    for (const client of this.clients.values()) {
+      if (client.projectId === projectId) {
+        count++;
+      }
+    }
+    return count;
+  }
+  stop() {
+    if (this.wss) {
+      for (const [clientWs] of this.clients) {
+        clientWs.close();
+      }
+      this.wss.close();
+      this.wss = null;
+    }
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+};
+var wsManager = new WebSocketManager();
+
+// src/tools/handlers.ts
+import { createHash } from "crypto";
+import path3 from "path";
+import fs2 from "fs/promises";
+import { fileURLToPath } from "url";
+
+// src/parser/xml-parser.ts
+import sax from "sax";
+var StreamingXMLParser = class {
+  parser;
+  state;
+  callback;
+  nodeCounter = 0;
+  edgeCounter = 0;
+  fieldCounter = 0;
+  branchCounter = 0;
+  constructor(callback) {
+    this.callback = callback;
+    this.parser = sax.parser(true, { trim: true });
+    this.state = this.createInitialState();
+    this.setupParser();
+  }
+  createInitialState() {
+    return {
+      currentNode: null,
+      currentBranch: null,
+      currentField: null,
+      currentEdge: null,
+      currentElement: null,
+      textBuffer: "",
+      plan: {}
+    };
+  }
+  setupParser() {
+    this.parser.onerror = (error) => {
+      this.callback({ type: "error", error });
+    };
+    this.parser.onopentag = (tag) => {
+      this.state.textBuffer = "";
+      this.state.currentElement = tag.name;
+      switch (tag.name) {
+        case "plan":
+          this.state.plan = {
+            id: tag.attributes.id || `plan_${Date.now()}`,
+            title: tag.attributes.title || "Untitled Plan",
+            agent: tag.attributes.agent || "unknown",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            status: "streaming"
+          };
+          this.callback({ type: "plan", plan: this.state.plan });
+          break;
+        case "node":
+          this.state.currentNode = {
+            id: tag.attributes.id || `n${++this.nodeCounter}`,
+            type: tag.attributes.type || "task",
+            status: "pending",
+            title: "",
+            description: "",
+            dynamicFields: [],
+            branches: [],
+            branchParent: tag.attributes.branch_parent,
+            branchId: tag.attributes.branch_id
+          };
+          break;
+        case "branch":
+          this.state.currentBranch = {
+            id: tag.attributes.id || `b${++this.branchCounter}`,
+            label: tag.attributes.label || "",
+            description: ""
+          };
+          break;
+        case "dynamic_field":
+          this.state.currentField = {
+            id: tag.attributes.id || `f${++this.fieldCounter}`,
+            name: tag.attributes.name || "",
+            type: tag.attributes.type || "string",
+            required: tag.attributes.required === "true",
+            title: tag.attributes.title || "",
+            description: tag.attributes.description || "",
+            value: tag.attributes.value,
+            options: tag.attributes.options,
+            setupInstructions: tag.attributes.setup_instructions
+          };
+          break;
+        case "edge":
+          this.state.currentEdge = {
+            id: tag.attributes.id || `e${++this.edgeCounter}`,
+            from: tag.attributes.from,
+            to: tag.attributes.to
+          };
+          break;
+      }
+    };
+    this.parser.onclosetag = (tagName) => {
+      const text = this.state.textBuffer.trim();
+      switch (tagName) {
+        case "plan":
+          this.callback({ type: "complete" });
+          break;
+        case "node":
+          if (this.state.currentNode) {
+            this.callback({
+              type: "node",
+              node: this.state.currentNode
+            });
+            this.state.currentNode = null;
+          }
+          break;
+        case "branch":
+          if (this.state.currentBranch && this.state.currentNode) {
+            if (!this.state.currentNode.branches) {
+              this.state.currentNode.branches = [];
+            }
+            this.state.currentNode.branches.push(this.state.currentBranch);
+            this.state.currentBranch = null;
+          }
+          break;
+        case "dynamic_field":
+          if (this.state.currentField && this.state.currentNode) {
+            if (!this.state.currentNode.dynamicFields) {
+              this.state.currentNode.dynamicFields = [];
+            }
+            this.state.currentNode.dynamicFields.push(
+              this.state.currentField
+            );
+            this.state.currentField = null;
+          }
+          break;
+        case "edge":
+          if (this.state.currentEdge) {
+            this.callback({
+              type: "edge",
+              edge: this.state.currentEdge
+            });
+            this.state.currentEdge = null;
+          }
+          break;
+        // Node child elements
+        case "title":
+          if (this.state.currentNode) {
+            this.state.currentNode.title = text;
+          }
+          break;
+        case "description":
+          if (this.state.currentBranch) {
+            this.state.currentBranch.description = text;
+          } else if (this.state.currentNode) {
+            this.state.currentNode.description = text;
+          }
+          break;
+        case "complexity":
+          if (this.state.currentNode) {
+            this.state.currentNode.complexity = text;
+          }
+          break;
+        case "expected_output":
+          if (this.state.currentNode) {
+            this.state.currentNode.expectedOutput = text;
+          }
+          break;
+        case "risks":
+          if (this.state.currentNode) {
+            this.state.currentNode.risks = text;
+          }
+          break;
+        // Branch child elements
+        case "label":
+          if (this.state.currentBranch) {
+            this.state.currentBranch.label = text;
+          }
+          break;
+        case "pros":
+          if (this.state.currentBranch) {
+            this.state.currentBranch.pros = text;
+          }
+          break;
+        case "cons":
+          if (this.state.currentBranch) {
+            this.state.currentBranch.cons = text;
+          }
+          break;
+      }
+      this.state.currentElement = null;
+      this.state.textBuffer = "";
+    };
+    this.parser.ontext = (text) => {
+      this.state.textBuffer += text;
+    };
+    this.parser.oncdata = (cdata) => {
+      this.state.textBuffer += cdata;
+    };
+  }
+  write(chunk) {
+    this.parser.write(chunk);
+  }
+  close() {
+    this.parser.close();
+  }
+  reset() {
+    this.parser = sax.parser(true, { trim: true });
+    this.state = this.createInitialState();
+    this.nodeCounter = 0;
+    this.edgeCounter = 0;
+    this.fieldCounter = 0;
+    this.branchCounter = 0;
+    this.setupParser();
+  }
+};
+
+// src/tools/handlers.ts
+var currentParsers = /* @__PURE__ */ new Map();
+var currentProjectId = "default";
+function generateProjectId(workspacePath) {
+  return createHash("sha256").update(workspacePath).digest("hex").substring(0, 12);
+}
+function getProviderMcpSetupInstructions(provider, serverName) {
+  const normalizedProvider = provider.toLowerCase();
+  const configServerName = serverName.includes("/") ? serverName : serverName.toLowerCase().replace(/\s+/g, "-");
+  switch (normalizedProvider) {
+    case "cline":
+      return `
+### Cline MCP Setup Instructions
+
+**Configuration File Locations:**
+- macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
+- Windows: %APPDATA%\\Code\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json
+- Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
+
+**Steps:**
+1. Open the MCP settings file at the location above
+2. Add the server configuration to the "mcpServers" object
+3. Save the file
+
+**Example Configuration:**
+\`\`\`json
+{
+  "mcpServers": {
+    "${configServerName}": {
+      "command": "uvx",
+      "args": ["mcp-server-name"],
+      "disabled": false
+    }
+  }
+}
+\`\`\`
+
+**Important:** Read the existing file first - DO NOT overwrite other servers!
+`;
+    case "sixth":
+    case "sixth-ai":
+      return `
+### Sixth AI MCP Setup Instructions
+
+**Configuration File Locations:**
+- macOS: ~/Library/Application Support/Code/User/globalStorage/sixth.sixth-ai/settings/sixth-mcp-settings.json
+- Windows: %APPDATA%\\Code\\User\\globalStorage\\sixth.sixth-ai\\settings\\sixth-mcp-settings.json
+- Linux: ~/.config/Code/User/globalStorage/sixth.sixth-ai/settings/sixth-mcp-settings.json
+
+**Steps:**
+1. Open the MCP settings file at the location above
+2. Add the server configuration to the "mcpServers" object
+3. Save the file
+
+**Example Configuration:**
+\`\`\`json
+{
+  "mcpServers": {
+    "${configServerName}": {
+      "command": "uvx",
+      "args": ["mcp-server-name"],
+      "disabled": false
+    }
+  }
+}
+\`\`\`
+
+**Important:** Read the existing file first - DO NOT overwrite other servers!
+`;
+    case "cursor":
+      return `
+### Cursor MCP Setup Instructions
+
+**Configuration File Locations:**
+- Project-level: .cursor/mcp.json (in project root)
+- Global: ~/.cursor/mcp.json (user home directory)
+
+**Steps:**
+1. Create or open the mcp.json file at one of the locations above
+2. Add the server configuration
+3. Save the file
+4. Restart Cursor or reload the window
+
+**Example Configuration:**
+\`\`\`json
+{
+  "mcpServers": {
+    "${configServerName}": {
+      "command": "uvx",
+      "args": ["mcp-server-name"]
+    }
+  }
+}
+\`\`\`
+
+**Tip:** Use project-level config for project-specific tools, global for tools you want everywhere.
+`;
+    case "claude-code":
+    case "claude":
+      return `
+### Claude Code MCP Setup Instructions
+
+**Option 1: Using CLI (Recommended)**
+\`\`\`bash
+claude mcp add ${configServerName} --scope user
+\`\`\`
+
+**Option 2: Direct Configuration**
+- User scope: ~/.claude.json
+- Project scope: .mcp.json (in project root)
+
+**Steps for manual setup:**
+1. Open ~/.claude.json (create if it doesn't exist)
+2. Add the server configuration
+3. Save the file
+
+**Example Configuration:**
+\`\`\`json
+{
+  "mcpServers": {
+    "${configServerName}": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["mcp-server-name"]
+    }
+  }
+}
+\`\`\`
+
+**Verify Installation:**
+\`\`\`bash
+claude mcp list
+claude mcp get ${configServerName}
+\`\`\`
+`;
+    default:
+      return `
+### MCP Setup Instructions
+
+Please configure the MCP server according to your AI assistant's documentation.
+The server name to use: ${configServerName}
+
+**Common Configuration Format:**
+\`\`\`json
+{
+  "mcpServers": {
+    "${configServerName}": {
+      "command": "uvx",
+      "args": ["mcp-server-name"]
+    }
+  }
+}
+\`\`\`
+`;
+  }
+}
+function formatSingleMcpServer(mcpServer, provider) {
+  const usageDesc = mcpServer.usageDescription || "";
+  const providerSetupInstructions = getProviderMcpSetupInstructions(provider, mcpServer.mcpId || mcpServer.name);
+  const formattedInstructions = `
+=== MCP SERVER INTEGRATION ===
+Server: ${mcpServer.name} by ${mcpServer.author}
+Description: ${mcpServer.description}
+GitHub: ${mcpServer.githubUrl}
+
+${usageDesc ? `=== USER'S INTENDED USAGE ===
+${usageDesc}
+` : ""}
+=== CRITICAL INSTRUCTIONS ===
+**YOU MUST** use this MCP server exactly as described by the user above.
+${usageDesc ? `The user has specified their intent - follow it precisely.` : ""}
+
+**IF THE MCP SERVER IS NOT AVAILABLE OR NOT CONFIGURED:**
+You **MUST** install and configure it NOW. DO NOT skip to the next node.
+DO NOT proceed with the task until the MCP server is working.
+
+${providerSetupInstructions}
+
+${mcpServer.requiresApiKey ? `**NOTE:** This MCP server requires an API key. Ensure the API key is configured before use.
+` : ""}
+=== README / Installation Guide ===
+${mcpServer.readmeContent ? mcpServer.readmeContent.substring(0, 3e3) : "Refer to the GitHub repository for setup instructions: " + mcpServer.githubUrl}
+${"=".repeat(50)}
+`.trim();
+  return {
+    ...mcpServer,
+    formattedInstructions
+  };
+}
+function formatMcpServersWithInstructions(mcpServers, provider) {
+  if (!mcpServers || mcpServers.length === 0) return void 0;
+  const agentProvider = provider || "unknown";
+  return mcpServers.map((mcpServer) => formatSingleMcpServer(mcpServer, agentProvider));
+}
+function handleStreamPlanChunk(xmlChunk, workspacePath, agentType) {
+  const effectivePath = workspacePath || process.cwd();
+  const projectId = workspacePath ? generateProjectId(effectivePath) : currentProjectId;
+  currentProjectId = projectId;
+  if (!currentParsers.has(projectId)) {
+    const parser = new StreamingXMLParser((event) => {
+      switch (event.type) {
+        case "plan":
+          const plan = {
+            id: event.plan.id || `plan_${Date.now()}`,
+            title: event.plan.title || "Untitled Plan",
+            agent: event.plan.agent || agentType || "unknown",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            status: "streaming"
+          };
+          multiProjectPlanStore.initializeProject({
+            projectId,
+            workspacePath: effectivePath,
+            projectName: path3.basename(effectivePath),
+            agentType: plan.agent
+          });
+          multiProjectPlanStore.startPlan(projectId, plan);
+          wsManager.broadcastToProject(projectId, { type: "plan_started", plan, projectId });
+          break;
+        case "node":
+          multiProjectPlanStore.addNode(projectId, event.node);
+          wsManager.broadcastToProject(projectId, { type: "node_added", node: event.node, projectId });
+          break;
+        case "edge":
+          multiProjectPlanStore.addEdge(projectId, event.edge);
+          wsManager.broadcastToProject(projectId, { type: "edge_added", edge: event.edge, projectId });
+          break;
+        case "complete":
+          multiProjectPlanStore.updatePlanStatus(projectId, "ready");
+          wsManager.broadcastToProject(projectId, { type: "plan_ready", projectId });
+          currentParsers.delete(projectId);
+          break;
+        case "error":
+          console.error("[Overture] XML parse error:", event.error);
+          wsManager.broadcastToProject(projectId, { type: "error", message: event.error.message });
+          break;
+      }
+    });
+    currentParsers.set(projectId, parser);
+  }
+  try {
+    const parser = currentParsers.get(projectId);
+    parser.write(xmlChunk);
+    return {
+      success: true,
+      message: "Chunk processed",
+      projectId,
+      expected_project_id: projectId
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, message, projectId };
+  }
+}
+function handleSubmitPlan(planXml, workspacePath, agentType) {
+  const effectivePath = workspacePath || process.cwd();
+  const projectId = workspacePath ? generateProjectId(effectivePath) : "default";
+  currentProjectId = projectId;
+  currentParsers.delete(projectId);
+  console.error("[Overture] submit_plan called, XML length:", planXml.length);
+  console.error("[Overture] Project:", projectId, "Path:", effectivePath);
+  console.error("[Overture] Connected clients:", wsManager.getClientCount());
+  const parser = new StreamingXMLParser((event) => {
+    switch (event.type) {
+      case "plan":
+        const plan = {
+          id: event.plan.id || `plan_${Date.now()}`,
+          title: event.plan.title || "Untitled Plan",
+          agent: event.plan.agent || agentType || "unknown",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "streaming"
+        };
+        const projectContext = {
+          projectId,
+          workspacePath: effectivePath,
+          projectName: path3.basename(effectivePath),
+          agentType: plan.agent
+        };
+        multiProjectPlanStore.initializeProject(projectContext);
+        multiProjectPlanStore.startPlan(projectId, plan);
+        console.error("[Overture] Broadcasting plan_started:", plan.title, "to project:", projectId);
+        wsManager.broadcastToProject(projectId, { type: "plan_started", plan, projectId });
+        wsManager.broadcastAll({
+          type: "project_registered",
+          projectId,
+          projectName: projectContext.projectName,
+          workspacePath: projectContext.workspacePath
+        });
+        break;
+      case "node":
+        console.error("[Overture] Broadcasting node_added:", event.node.id);
+        multiProjectPlanStore.addNode(projectId, event.node);
+        wsManager.broadcastToProject(projectId, { type: "node_added", node: event.node, projectId });
+        break;
+      case "edge":
+        console.error("[Overture] Broadcasting edge_added:", event.edge.id);
+        multiProjectPlanStore.addEdge(projectId, event.edge);
+        wsManager.broadcastToProject(projectId, { type: "edge_added", edge: event.edge, projectId });
+        break;
+      case "complete":
+        console.error("[Overture] Broadcasting plan_ready");
+        multiProjectPlanStore.updatePlanStatus(projectId, "ready");
+        wsManager.broadcastToProject(projectId, { type: "plan_ready", projectId });
+        break;
+      case "error":
+        console.error("[Overture] XML parse error:", event.error);
+        wsManager.broadcastToProject(projectId, { type: "error", message: event.error.message });
+        break;
+    }
+  });
+  try {
+    parser.write(planXml);
+    parser.close();
+    const nodes = multiProjectPlanStore.getNodes(projectId);
+    const edges = multiProjectPlanStore.getEdges(projectId);
+    console.error("[Overture] Plan parsing complete. Nodes:", nodes.length, "Edges:", edges.length);
+    console.error("[Overture] Project stored with ID:", projectId);
+    console.error("[Overture] All projects after submit:", Array.from(multiProjectPlanStore.getAllProjects().map((p) => p.projectId)));
+    return {
+      success: true,
+      message: `Plan submitted successfully. IMPORTANT: Use project_id "${projectId}" in ALL subsequent calls (get_approval, update_node_status, etc.)`,
+      projectId,
+      // Explicit field to make it clear what ID to use
+      expected_project_id: projectId
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error("[Overture] Plan parsing failed:", message);
+    return { success: false, message, projectId };
+  }
+}
+async function handleGetApproval(projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  console.error(`[Overture] get_approval called for project: ${effectiveProjectId}`);
+  console.error(`[Overture] Provided projectId: ${projectId}, currentProjectId: ${currentProjectId}`);
+  console.error(`[Overture] All projects in store:`, multiProjectPlanStore.getAllProjects().map((p) => p.projectId));
+  console.error(`[Overture] Current plan status:`, multiProjectPlanStore.getPlan(effectiveProjectId)?.status);
+  const result = await multiProjectPlanStore.waitForApproval(effectiveProjectId, 6e4);
+  console.error(`[Overture] waitForApproval returned: ${result}`);
+  if (result === "approved") {
+    multiProjectPlanStore.updatePlanStatus(effectiveProjectId, "executing");
+    const plan = multiProjectPlanStore.getPlan(effectiveProjectId);
+    const provider = plan?.agent || "unknown";
+    const nodes = multiProjectPlanStore.getNodes(effectiveProjectId);
+    const edges = multiProjectPlanStore.getEdges(effectiveProjectId);
+    const nodeConfigs = multiProjectPlanStore.getNodeConfigs(effectiveProjectId);
+    const nodesWithIncomingEdges = new Set(edges.map((e) => e.to));
+    const firstNode = nodes.find((n) => !nodesWithIncomingEdges.has(n.id));
+    let firstNodeInfo;
+    if (firstNode) {
+      const config = nodeConfigs[firstNode.id] || { fieldValues: {}, attachments: [] };
+      firstNodeInfo = {
+        id: firstNode.id,
+        title: firstNode.title,
+        type: firstNode.type,
+        description: firstNode.description,
+        fieldValues: config.fieldValues || {},
+        attachments: config.attachments || [],
+        metaInstructions: config.metaInstructions,
+        mcpServers: formatMcpServersWithInstructions(config.mcpServers, provider)
+      };
+    }
+    return {
+      status: "approved",
+      firstNode: firstNodeInfo,
+      message: "Plan approved by user. Execute firstNode, then call update_node_status to get the next node.",
+      projectId: effectiveProjectId
+    };
+  }
+  if (result === "cancelled") {
+    return {
+      status: "cancelled",
+      message: "Plan cancelled by user",
+      projectId: effectiveProjectId
+    };
+  }
+  return {
+    status: "pending",
+    message: "Waiting for user approval. Call get_approval again to continue waiting.",
+    projectId: effectiveProjectId
+  };
+}
+async function handleCheckPause(wait = false, projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  const isPaused = multiProjectPlanStore.getIsPaused(effectiveProjectId);
+  if (!isPaused) {
+    return {
+      isPaused: false,
+      wasResumed: false,
+      message: "Execution is not paused",
+      projectId: effectiveProjectId
+    };
+  }
+  if (!wait) {
+    return {
+      isPaused: true,
+      wasResumed: false,
+      message: "Execution is paused. Call with wait=true to block until resumed.",
+      projectId: effectiveProjectId
+    };
+  }
+  await multiProjectPlanStore.waitIfPaused(effectiveProjectId);
+  return {
+    isPaused: false,
+    wasResumed: true,
+    message: "Execution was paused and has now been resumed",
+    projectId: effectiveProjectId
+  };
+}
+function handleUpdateNodeStatus(nodeId, status, output, projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  const plan = multiProjectPlanStore.getPlan(effectiveProjectId);
+  const provider = plan?.agent || "unknown";
+  const nodes = multiProjectPlanStore.getNodes(effectiveProjectId);
+  const edges = multiProjectPlanStore.getEdges(effectiveProjectId);
+  const nodeConfigs = multiProjectPlanStore.getNodeConfigs(effectiveProjectId);
+  const node = nodes.find((n) => n.id === nodeId);
+  if (!node) {
+    return { success: false, message: `Node ${nodeId} not found`, projectId: effectiveProjectId };
+  }
+  multiProjectPlanStore.updateNodeStatus(effectiveProjectId, nodeId, status, output);
+  wsManager.broadcastToProject(effectiveProjectId, { type: "node_status_updated", nodeId, status, output, projectId: effectiveProjectId });
+  const isPaused = multiProjectPlanStore.getIsPaused(effectiveProjectId);
+  if (status === "active") {
+    const config = nodeConfigs[nodeId] || { fieldValues: {}, attachments: [] };
+    const currentNodeInfo = {
+      id: node.id,
+      title: node.title,
+      type: node.type,
+      description: node.description,
+      fieldValues: config.fieldValues || {},
+      attachments: config.attachments || [],
+      metaInstructions: config.metaInstructions,
+      mcpServers: formatMcpServersWithInstructions(config.mcpServers, provider)
+    };
+    return {
+      success: true,
+      message: `Node ${nodeId} status updated to ${status}. Execute this node now.`,
+      currentNode: currentNodeInfo,
+      isPaused,
+      projectId: effectiveProjectId
+    };
+  }
+  if (status === "completed") {
+    const nextNodeInfo = findNextNode(effectiveProjectId, nodeId, nodes, edges, provider);
+    if (nextNodeInfo) {
+      return {
+        success: true,
+        message: `Node ${nodeId} status updated to ${status}`,
+        nextNode: nextNodeInfo,
+        isPaused,
+        projectId: effectiveProjectId
+      };
+    } else {
+      return {
+        success: true,
+        message: `Node ${nodeId} status updated to ${status}. This was the last node.`,
+        isLastNode: true,
+        isPaused,
+        projectId: effectiveProjectId
+      };
+    }
+  }
+  return {
+    success: true,
+    message: `Node ${nodeId} status updated to ${status}`,
+    isPaused,
+    projectId: effectiveProjectId
+  };
+}
+function findNextNode(projectId, currentNodeId, nodes, edges, provider) {
+  const selectedBranches = multiProjectPlanStore.getSelectedBranches(projectId);
+  const nodeConfigs = multiProjectPlanStore.getNodeConfigs(projectId);
+  const outgoingEdges = edges.filter((e) => e.from === currentNodeId);
+  if (outgoingEdges.length === 0) {
+    return null;
+  }
+  for (const edge of outgoingEdges) {
+    const nextNode = nodes.find((n) => n.id === edge.to);
+    if (!nextNode) continue;
+    if (nextNode.branchParent && nextNode.branchId) {
+      const selectedBranch = selectedBranches[nextNode.branchParent];
+      if (selectedBranch && selectedBranch !== nextNode.branchId) {
+        continue;
+      }
+    }
+    const config = nodeConfigs[nextNode.id] || { fieldValues: {}, attachments: [] };
+    return {
+      id: nextNode.id,
+      title: nextNode.title,
+      type: nextNode.type,
+      description: nextNode.description,
+      fieldValues: config.fieldValues || {},
+      attachments: config.attachments || [],
+      metaInstructions: config.metaInstructions,
+      mcpServers: formatMcpServersWithInstructions(config.mcpServers, provider)
+    };
+  }
+  for (const edge of outgoingEdges) {
+    const skippedNode = nodes.find((n) => n.id === edge.to);
+    if (skippedNode) {
+      const nextAfterSkipped = findNextNode(projectId, skippedNode.id, nodes, edges, provider);
+      if (nextAfterSkipped) {
+        return nextAfterSkipped;
+      }
+    }
+  }
+  return null;
+}
+function handlePlanCompleted(projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  multiProjectPlanStore.updatePlanStatus(effectiveProjectId, "completed");
+  wsManager.broadcastToProject(effectiveProjectId, { type: "plan_completed", projectId: effectiveProjectId });
+  return { success: true, message: "Plan completed", projectId: effectiveProjectId };
+}
+function handlePlanFailed(error, projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  multiProjectPlanStore.updatePlanStatus(effectiveProjectId, "failed");
+  wsManager.broadcastToProject(effectiveProjectId, { type: "plan_failed", error, projectId: effectiveProjectId });
+  return { success: true, message: "Plan failed", projectId: effectiveProjectId };
+}
+async function handleCheckRerun(timeoutMs = 5e3, projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  const rerunRequest = await multiProjectPlanStore.waitForRerun(effectiveProjectId, timeoutMs);
+  if (!rerunRequest) {
+    return {
+      hasRerun: false,
+      message: "No rerun request pending",
+      projectId: effectiveProjectId
+    };
+  }
+  const resetNodeIds = multiProjectPlanStore.resetNodesForRerun(effectiveProjectId, rerunRequest.nodeId, rerunRequest.mode);
+  for (const nodeId of resetNodeIds) {
+    wsManager.broadcastToProject(effectiveProjectId, { type: "node_status_updated", nodeId, status: "pending", projectId: effectiveProjectId });
+  }
+  multiProjectPlanStore.updatePlanStatus(effectiveProjectId, "executing");
+  const plan = multiProjectPlanStore.getPlan(effectiveProjectId);
+  const provider = plan?.agent || "unknown";
+  wsManager.broadcastToProject(effectiveProjectId, { type: "plan_started", plan, projectId: effectiveProjectId });
+  const nodes = multiProjectPlanStore.getNodes(effectiveProjectId);
+  const nodeConfigs = multiProjectPlanStore.getNodeConfigs(effectiveProjectId);
+  const startNode = nodes.find((n) => n.id === rerunRequest.nodeId);
+  let nodeInfo;
+  if (startNode) {
+    const config = nodeConfigs[startNode.id] || { fieldValues: {}, attachments: [] };
+    nodeInfo = {
+      id: startNode.id,
+      title: startNode.title,
+      type: startNode.type,
+      description: startNode.description,
+      fieldValues: config.fieldValues || {},
+      attachments: config.attachments || [],
+      metaInstructions: config.metaInstructions,
+      mcpServers: formatMcpServersWithInstructions(config.mcpServers, provider)
+    };
+  }
+  return {
+    hasRerun: true,
+    nodeId: rerunRequest.nodeId,
+    mode: rerunRequest.mode,
+    nodeInfo,
+    message: `Rerun requested from node ${rerunRequest.nodeId} (${rerunRequest.mode})`,
+    projectId: effectiveProjectId
+  };
+}
+function handleGetResumeInfo(projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  const resumeInfo = multiProjectPlanStore.getResumeInfo(effectiveProjectId);
+  if (!resumeInfo) {
+    return {
+      success: false,
+      message: `No active plan found for project: ${effectiveProjectId}`,
+      projectId: effectiveProjectId
+    };
+  }
+  return {
+    success: true,
+    resumeInfo,
+    message: `Resume info retrieved. Plan is at status '${resumeInfo.status}'. ${resumeInfo.currentNodeId ? `Current node: ${resumeInfo.currentNodeTitle} (${resumeInfo.currentNodeStatus})` : "No current node."} Completed: ${resumeInfo.completedNodes.length}, Pending: ${resumeInfo.pendingNodes.length}, Failed: ${resumeInfo.failedNodes.length}`,
+    projectId: effectiveProjectId
+  };
+}
+function handleRequestPlanUpdate(operations, projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  const currentPlan = multiProjectPlanStore.getPlan(effectiveProjectId);
+  if (!currentPlan) {
+    return {
+      success: false,
+      message: `No active plan found for project: ${effectiveProjectId}. Submit a new plan instead.`,
+      results: [],
+      projectId: effectiveProjectId
+    };
+  }
+  multiProjectPlanStore.storePreviousPlanState(effectiveProjectId);
+  console.error(`[Overture] Processing ${operations.length} plan update operations for project: ${effectiveProjectId}`);
+  const results = [];
+  for (const operation of operations) {
+    try {
+      switch (operation.op) {
+        case "insert_after":
+        case "insert_before": {
+          const position = operation.op === "insert_after" ? "after" : "before";
+          const result = applyInsertOperation(
+            effectiveProjectId,
+            operation.reference_node_id,
+            position,
+            operation.node
+          );
+          results.push({ op: operation.op, ...result });
+          break;
+        }
+        case "delete": {
+          const result = applyDeleteOperation(effectiveProjectId, operation.node_id);
+          results.push({ op: "delete", ...result });
+          break;
+        }
+        case "replace": {
+          const result = applyReplaceOperation(effectiveProjectId, operation.node_id, operation.node);
+          results.push({ op: "replace", ...result });
+          break;
+        }
+        default:
+          results.push({ op: "unknown", success: false, message: "Unknown operation type" });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      results.push({ op: operation.op || "unknown", success: false, message });
+    }
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.length - successCount;
+  wsManager.broadcastToProject(effectiveProjectId, {
+    type: "plan_updated_incrementally",
+    operationCount: operations.length,
+    successCount,
+    failCount,
+    projectId: effectiveProjectId
+  });
+  console.error(`[Overture] Plan update complete: ${successCount} succeeded, ${failCount} failed`);
+  return {
+    success: failCount === 0,
+    message: `Applied ${successCount}/${operations.length} operations. ${failCount > 0 ? "Some operations failed." : "All operations succeeded."} Call get_approval to confirm changes with user.`,
+    results,
+    projectId: effectiveProjectId
+  };
+}
+function applyInsertOperation(projectId, referenceNodeId, position, nodeData) {
+  const nodes = multiProjectPlanStore.getNodes(projectId);
+  const edges = multiProjectPlanStore.getEdges(projectId);
+  const refNode = nodes.find((n) => n.id === referenceNodeId);
+  if (!refNode) {
+    return { success: false, message: `Reference node ${referenceNodeId} not found` };
+  }
+  const newNode = {
+    id: nodeData.id,
+    type: nodeData.type,
+    title: nodeData.title,
+    description: nodeData.description,
+    complexity: nodeData.complexity,
+    expectedOutput: nodeData.expectedOutput,
+    risks: nodeData.risks,
+    status: "pending",
+    dynamicFields: [],
+    attachments: []
+  };
+  if (position === "after") {
+    const edgeToNewNode = { id: `e_${referenceNodeId}_${nodeData.id}`, from: referenceNodeId, to: nodeData.id };
+    const result = multiProjectPlanStore.insertNodes(
+      projectId,
+      referenceNodeId,
+      [newNode],
+      [edgeToNewNode]
+    );
+    const allNewEdges = [edgeToNewNode, ...result.reconnectionEdges];
+    wsManager.broadcastToProject(projectId, {
+      type: "nodes_inserted",
+      nodes: [newNode],
+      edges: allNewEdges,
+      removedEdgeIds: result.removedEdgeIds,
+      projectId
+    });
+  } else {
+    const incomingEdges = edges.filter((e) => e.to === referenceNodeId);
+    if (incomingEdges.length === 0) {
+      multiProjectPlanStore.addNode(projectId, newNode);
+      const newEdge = { id: `e_${nodeData.id}_${referenceNodeId}`, from: nodeData.id, to: referenceNodeId };
+      multiProjectPlanStore.addEdge(projectId, newEdge);
+      wsManager.broadcastToProject(projectId, { type: "node_added", node: newNode, projectId });
+      wsManager.broadcastToProject(projectId, { type: "edge_added", edge: newEdge, projectId });
+    } else {
+      const firstIncoming = incomingEdges[0];
+      multiProjectPlanStore.addNode(projectId, newNode);
+      wsManager.broadcastToProject(projectId, { type: "node_added", node: newNode, projectId });
+      for (const edge of incomingEdges) {
+        const state = multiProjectPlanStore.getState(projectId);
+        if (state) {
+          const edgeIndex = state.edges.findIndex((e) => e.id === edge.id);
+          if (edgeIndex >= 0) {
+            state.edges.splice(edgeIndex, 1);
+          }
+        }
+      }
+      const edgeToNew = { id: `e_${firstIncoming.from}_${nodeData.id}`, from: firstIncoming.from, to: nodeData.id };
+      const edgeToRef = { id: `e_${nodeData.id}_${referenceNodeId}`, from: nodeData.id, to: referenceNodeId };
+      multiProjectPlanStore.addEdge(projectId, edgeToNew);
+      multiProjectPlanStore.addEdge(projectId, edgeToRef);
+      wsManager.broadcastToProject(projectId, { type: "edge_added", edge: edgeToNew, projectId });
+      wsManager.broadcastToProject(projectId, { type: "edge_added", edge: edgeToRef, projectId });
+    }
+  }
+  console.error(`[Overture] Node ${nodeData.id} inserted ${position} ${referenceNodeId}`);
+  return { success: true, message: `Node "${nodeData.title}" inserted ${position} node ${referenceNodeId}` };
+}
+function applyDeleteOperation(projectId, nodeId) {
+  const nodes = multiProjectPlanStore.getNodes(projectId);
+  const node = nodes.find((n) => n.id === nodeId);
+  if (!node) {
+    return { success: false, message: `Node ${nodeId} not found` };
+  }
+  const result = multiProjectPlanStore.removeNode(projectId, nodeId);
+  wsManager.broadcastToProject(projectId, {
+    type: "node_removed",
+    nodeId,
+    newEdges: result.newEdges,
+    removedEdgeIds: result.removedEdgeIds,
+    projectId
+  });
+  console.error(`[Overture] Node ${nodeId} deleted from plan`);
+  return { success: true, message: `Node "${node.title}" deleted from plan` };
+}
+function applyReplaceOperation(projectId, nodeId, newNodeData) {
+  const state = multiProjectPlanStore.getState(projectId);
+  if (!state) {
+    return { success: false, message: `No plan found for project ${projectId}` };
+  }
+  const nodeIndex = state.nodes.findIndex((n) => n.id === nodeId);
+  if (nodeIndex < 0) {
+    return { success: false, message: `Node ${nodeId} not found` };
+  }
+  const oldNode = state.nodes[nodeIndex];
+  const updatedNode = {
+    ...oldNode,
+    id: newNodeData.id || oldNode.id,
+    type: newNodeData.type || oldNode.type,
+    title: newNodeData.title,
+    description: newNodeData.description,
+    complexity: newNodeData.complexity || oldNode.complexity,
+    expectedOutput: newNodeData.expectedOutput || oldNode.expectedOutput,
+    risks: newNodeData.risks || oldNode.risks
+  };
+  state.nodes[nodeIndex] = updatedNode;
+  if (newNodeData.id && newNodeData.id !== oldNode.id) {
+    for (const edge of state.edges) {
+      if (edge.from === oldNode.id) {
+        edge.from = newNodeData.id;
+      }
+      if (edge.to === oldNode.id) {
+        edge.to = newNodeData.id;
+      }
+    }
+  }
+  wsManager.broadcastToProject(projectId, {
+    type: "node_replaced",
+    oldNodeId: nodeId,
+    node: updatedNode,
+    projectId
+  });
+  console.error(`[Overture] Node ${nodeId} replaced with new content`);
+  return { success: true, message: `Node "${oldNode.title}" replaced with "${updatedNode.title}"` };
+}
+function handleCreateNewPlan(projectId) {
+  const effectiveProjectId = projectId || currentProjectId;
+  wsManager.broadcastToProject(effectiveProjectId, {
+    type: "new_plan_created",
+    planId: "",
+    projectId: effectiveProjectId
+  });
+  console.error(`[Overture] New plan requested for project: ${effectiveProjectId}`);
+  console.error(`[Overture] Existing plans preserved. New plan will be added alongside them.`);
+  return {
+    success: true,
+    message: `Ready to receive new plan. Submit the new plan using submit_plan or stream_plan_chunk, then call get_approval to wait for user approval. Note: Existing plans will be preserved on the canvas.`,
+    projectId: effectiveProjectId
+  };
+}
+async function handleGetUsageInstructions(agentType) {
+  const availableAgents = ["claude-code", "cline", "cursor", "sixth"];
+  const normalizedType = agentType.toLowerCase().trim();
+  const agentMap = {
+    "claude-code": "claude-code",
+    "claude": "claude-code",
+    "claudecode": "claude-code",
+    "cline": "cline",
+    "cursor": "cursor",
+    "sixth": "sixth",
+    "6th": "sixth"
+  };
+  const mappedType = agentMap[normalizedType];
+  if (!mappedType) {
+    return {
+      success: false,
+      agentType: normalizedType,
+      message: `Unknown agent type "${agentType}". Available agents: ${availableAgents.join(", ")}`,
+      availableAgents
+    };
+  }
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = path3.dirname(__filename2);
+  const possiblePaths = [
+    path3.resolve(__dirname2, "../../prompts"),
+    // npm installed (dist/tools -> prompts)
+    path3.resolve(__dirname2, "../prompts"),
+    // Alternative npm location
+    path3.resolve(__dirname2, "../../../../prompts"),
+    // Development (monorepo root)
+    path3.resolve(__dirname2, "../../../prompts"),
+    // Alternative dev location
+    path3.resolve(process.cwd(), "prompts")
+    // Relative to cwd
+  ];
+  let promptFile = null;
+  let instructions = null;
+  for (const promptsDir of possiblePaths) {
+    const candidatePath = path3.join(promptsDir, `${mappedType}.md`);
+    try {
+      instructions = await fs2.readFile(candidatePath, "utf-8");
+      promptFile = candidatePath;
+      console.error(`[Overture] Found instructions at: ${candidatePath}`);
+      break;
+    } catch {
+      continue;
+    }
+  }
+  if (instructions && promptFile) {
+    console.error(`[Overture] Loaded instructions for ${mappedType} (${instructions.length} chars)`);
+    return {
+      success: true,
+      agentType: mappedType,
+      instructions,
+      message: `Instructions loaded for ${mappedType}. Follow these instructions to use Overture MCP effectively.`,
+      availableAgents
+    };
+  }
+  console.error(`[Overture] Failed to find instructions for ${mappedType}. Searched paths:`);
+  possiblePaths.forEach((p) => console.error(`  - ${path3.join(p, `${mappedType}.md`)}`));
+  return {
+    success: false,
+    agentType: mappedType,
+    message: `Failed to load instructions for ${mappedType}. Instructions file not found.`,
+    availableAgents
+  };
+}
+
+// src/http/server.ts
+import express from "express";
+import path4 from "path";
+import { createServer } from "http";
+import fs3 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = path4.dirname(__filename);
+function startHttpServer(port) {
+  const app = express();
+  app.use(express.json());
+  const possiblePaths = [
+    path4.resolve(__dirname, "../ui-dist"),
+    // packages/mcp-server/dist/../ui-dist
+    path4.resolve(__dirname, "../../ui-dist"),
+    // packages/mcp-server/ui-dist
+    path4.resolve(__dirname, "../../../ui/dist"),
+    // packages/ui/dist
+    path4.resolve(process.cwd(), "ui-dist"),
+    // fallback to cwd
+    path4.resolve(process.cwd(), "packages/mcp-server/ui-dist")
+  ];
+  let staticPath = possiblePaths[0];
+  for (const p of possiblePaths) {
+    if (fs3.existsSync(path4.join(p, "index.html"))) {
+      staticPath = p;
+      break;
+    }
+  }
+  console.error(`[Overture] Serving UI from: ${staticPath}`);
+  app.post("/api/test-plan", (req, res) => {
+    const { plan_xml } = req.body;
+    if (!plan_xml) {
+      return res.status(400).json({ error: "plan_xml is required" });
+    }
+    const result = handleSubmitPlan(plan_xml);
+    res.json(result);
+  });
+  app.get("/api/mcp-marketplace", async (req, res) => {
+    try {
+      const response = await fetch("https://api.cline.bot/v1/mcp/marketplace");
+      if (!response.ok) {
+        return res.status(response.status).json({ error: "Failed to fetch MCP marketplace" });
+      }
+      const data = await response.json();
+      res.json(data);
+    } catch (error) {
+      console.error("[Overture] Failed to fetch MCP marketplace:", error);
+      res.status(500).json({ error: "Failed to fetch MCP marketplace" });
+    }
+  });
+  app.use(express.static(staticPath));
+  app.get("*", (req, res) => {
+    res.sendFile(path4.join(staticPath, "index.html"));
+  });
+  const server = createServer(app);
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`[Overture] Port ${port} already in use - another instance may be running`);
+    } else {
+      console.error(`[Overture] HTTP server error:`, err);
+    }
+  });
+  server.listen(port, () => {
+    console.error(`[Overture] UI server listening on http://localhost:${port}`);
+  });
+}
+
+export {
+  historyStorage,
+  wsManager,
+  handleStreamPlanChunk,
+  handleSubmitPlan,
+  handleGetApproval,
+  handleCheckPause,
+  handleUpdateNodeStatus,
+  handlePlanCompleted,
+  handlePlanFailed,
+  handleCheckRerun,
+  handleGetResumeInfo,
+  handleRequestPlanUpdate,
+  handleCreateNewPlan,
+  handleGetUsageInstructions,
+  startHttpServer
+};