overture-mcp 0.1.7 → 0.1.8

package/dist/{chunk-BYH4GX7P.js → chunk-SNLEFIK4.js}

@@ -209,6 +209,289 @@ var historyStorage = new HistoryStorage();
 // src/websocket/ws-server.ts
 import { WebSocketServer, WebSocket } from "ws";
 
+// src/storage/project-storage.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var MAX_PROJECT_HISTORY_ENTRIES = 50;
+var ProjectStorage = class {
+  workspacePath;
+  filePath;
+  projectId;
+  cache = null;
+  writeDebounceTimer = null;
+  writePromise = null;
+  writePermissionDenied = false;
+  constructor(workspacePath, projectId) {
+    this.workspacePath = workspacePath;
+    this.projectId = projectId;
+    this.filePath = path2.join(workspacePath, ".overture.json");
+  }
+  /**
+   * Get the storage file path
+   */
+  getFilePath() {
+    return this.filePath;
+  }
+  /**
+   * Check if write permission was denied (should fall back to global storage)
+   */
+  isWritePermissionDenied() {
+    return this.writePermissionDenied;
+  }
+  /**
+   * Check if project storage file exists
+   */
+  async exists() {
+    try {
+      await fs2.access(this.filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Load project configuration from disk (with caching)
+   */
+  async load() {
+    if (this.cache) return this.cache;
+    try {
+      const data = await fs2.readFile(this.filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      if (!parsed || typeof parsed.version !== "number") {
+        console.error("[Overture] Invalid project config format, creating new one");
+        this.cache = this.createEmptyConfig();
+        return this.cache;
+      }
+      this.cache = parsed;
+      console.error(`[Overture] Loaded project config: ${this.cache.history.length} history entries`);
+      return this.cache;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.error("[Overture] Project config does not exist, creating new one");
+        this.cache = this.createEmptyConfig();
+        return this.cache;
+      }
+      if (error.code === "EACCES") {
+        console.error("[Overture] Permission denied reading project config, will use global storage");
+        this.writePermissionDenied = true;
+        this.cache = this.createEmptyConfig();
+        return this.cache;
+      }
+      console.error("[Overture] Error loading project config:", error.message);
+      this.cache = this.createEmptyConfig();
+      return this.cache;
+    }
+  }
+  /**
+   * Create an empty project configuration
+   */
+  createEmptyConfig() {
+    return {
+      version: 1,
+      projectId: this.projectId,
+      history: []
+    };
+  }
+  /**
+   * Save project configuration to disk (debounced)
+   */
+  async save() {
+    if (this.writePermissionDenied) {
+      console.error("[Overture] Write permission denied, skipping project storage save");
+      return;
+    }
+    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;
+          }
+          await fs2.writeFile(this.filePath, JSON.stringify(this.cache, null, 2));
+          console.error("[Overture] Project config saved to", this.filePath);
+          resolve();
+        } catch (error) {
+          if (error.code === "EACCES") {
+            console.error("[Overture] Permission denied writing project config, will use global storage");
+            this.writePermissionDenied = true;
+            resolve();
+          } else {
+            console.error("[Overture] Failed to save project config:", error);
+            reject(error);
+          }
+        } finally {
+          this.writePromise = null;
+        }
+      }, 1e3);
+    });
+    return this.writePromise;
+  }
+  /**
+   * Force immediate save (bypass debounce)
+   */
+  async saveNow() {
+    if (this.writePermissionDenied) {
+      console.error("[Overture] Write permission denied, skipping project storage save");
+      return;
+    }
+    if (this.writeDebounceTimer) {
+      clearTimeout(this.writeDebounceTimer);
+      this.writeDebounceTimer = null;
+    }
+    if (!this.cache) return;
+    try {
+      await fs2.writeFile(this.filePath, JSON.stringify(this.cache, null, 2));
+      console.error("[Overture] Project config saved (immediate) to", this.filePath);
+    } catch (error) {
+      if (error.code === "EACCES") {
+        console.error("[Overture] Permission denied writing project config");
+        this.writePermissionDenied = true;
+      } else {
+        console.error("[Overture] Failed to save project config:", error);
+        throw error;
+      }
+    }
+  }
+  /**
+   * Add or update a plan in history
+   */
+  async addPlanToHistory(plan) {
+    const config = await this.load();
+    const existingIndex = config.history.findIndex((p) => p.plan.id === plan.plan.id);
+    if (existingIndex >= 0) {
+      config.history[existingIndex] = plan;
+    } else {
+      config.history.unshift(plan);
+    }
+    if (config.history.length > MAX_PROJECT_HISTORY_ENTRIES) {
+      const removed = config.history.splice(MAX_PROJECT_HISTORY_ENTRIES);
+      console.error(`[Overture] Pruned ${removed.length} old project history entries`);
+    }
+    await this.save();
+  }
+  /**
+   * Get all history entries for this project
+   */
+  async getHistory() {
+    const config = await this.load();
+    return config.history;
+  }
+  /**
+   * Get history entries as lightweight HistoryEntry objects
+   */
+  async getHistoryEntries() {
+    const config = await this.load();
+    return config.history.map((persisted) => ({
+      id: persisted.plan.id,
+      projectId: persisted.plan.projectId,
+      workspacePath: persisted.plan.workspacePath,
+      projectName: path2.basename(persisted.plan.workspacePath),
+      title: persisted.plan.title,
+      agent: persisted.plan.agent,
+      status: persisted.plan.status,
+      createdAt: persisted.plan.createdAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      // We don't store updatedAt per plan, so use now
+      nodeCount: persisted.nodes.length,
+      completedNodeCount: persisted.nodes.filter((n) => n.status === "completed").length
+    }));
+  }
+  /**
+   * Get a specific plan by ID
+   */
+  async getPlan(planId) {
+    const config = await this.load();
+    return config.history.find((p) => p.plan.id === planId) || null;
+  }
+  /**
+   * Delete a plan from history
+   */
+  async deletePlan(planId) {
+    const config = await this.load();
+    config.history = config.history.filter((p) => p.plan.id !== planId);
+    await this.save();
+  }
+  /**
+   * Get project settings
+   */
+  async getSettings() {
+    const config = await this.load();
+    return config.settings;
+  }
+  /**
+   * Update project settings
+   */
+  async updateSettings(settings) {
+    const config = await this.load();
+    config.settings = {
+      ...config.settings,
+      ...settings
+    };
+    await this.save();
+  }
+  /**
+   * Clear all history
+   */
+  async clearHistory() {
+    const config = await this.load();
+    config.history = [];
+    await this.saveNow();
+  }
+  /**
+   * Invalidate cache (force reload from disk on next access)
+   */
+  invalidateCache() {
+    this.cache = null;
+  }
+};
+var ProjectStorageRegistry = class {
+  storages = /* @__PURE__ */ new Map();
+  /**
+   * Get or create a ProjectStorage instance for a workspace path
+   */
+  getStorage(workspacePath, projectId) {
+    const key = workspacePath;
+    let storage = this.storages.get(key);
+    if (!storage) {
+      storage = new ProjectStorage(workspacePath, projectId);
+      this.storages.set(key, storage);
+      console.error(`[Overture] Created project storage for: ${workspacePath}`);
+    }
+    return storage;
+  }
+  /**
+   * Check if a project has local storage
+   */
+  hasStorage(workspacePath) {
+    return this.storages.has(workspacePath);
+  }
+  /**
+   * Remove storage instance from registry
+   */
+  removeStorage(workspacePath) {
+    this.storages.delete(workspacePath);
+  }
+  /**
+   * Get all active storage instances
+   */
+  getAllStorages() {
+    return Array.from(this.storages.values());
+  }
+  /**
+   * Clear all storage instances
+   */
+  clear() {
+    this.storages.clear();
+  }
+};
+var projectStorageRegistry = new ProjectStorageRegistry();
+
 // src/utils/plan-diff.ts
 function calculatePlanDiff(oldPlan, newPlan) {
   const oldNodeMap = new Map(oldPlan.nodes.map((n) => [n.id, n]));
@@ -272,7 +555,7 @@ function nodesAreEqual(a, b) {
 }
 
 // src/store/plan-store.ts
-import path2 from "path";
+import path3 from "path";
 var DEFAULT_PROJECT_ID = "default";
 var MultiProjectPlanStore = class {
   projects = /* @__PURE__ */ new Map();
@@ -292,6 +575,21 @@ var MultiProjectPlanStore = class {
   constructor() {
     this.startAutoSave();
   }
+  /**
+   * Get project storage for a project, or null if it should use global storage
+   * Uses project-local .overture.json if workspace path is available
+   */
+  getProjectStorage(projectId) {
+    const state = this.projects.get(projectId);
+    if (!state || !state.workspacePath || state.workspacePath === process.cwd()) {
+      return null;
+    }
+    const storage = projectStorageRegistry.getStorage(state.workspacePath, projectId);
+    if (storage.isWritePermissionDenied()) {
+      return null;
+    }
+    return storage;
+  }
   /**
    * Start auto-save interval to persist all active projects every 3 seconds
    */
@@ -311,9 +609,16 @@ var MultiProjectPlanStore = class {
               selectedBranches: state.selectedBranches,
               nodeConfigs: state.nodeConfigs
             };
-            await historyStorage.savePlan(persisted);
-            await historyStorage.saveNow();
-            console.error(`[Overture] Auto-saved project ${projectId} (plan: ${state.plan.id})`);
+            const projectStorage = this.getProjectStorage(projectId);
+            if (projectStorage) {
+              await projectStorage.addPlanToHistory(persisted);
+              await projectStorage.saveNow();
+              console.error(`[Overture] Auto-saved project ${projectId} to project storage (plan: ${state.plan.id})`);
+            } else {
+              await historyStorage.savePlan(persisted);
+              await historyStorage.saveNow();
+              console.error(`[Overture] Auto-saved project ${projectId} to global storage (plan: ${state.plan.id})`);
+            }
           } catch (error) {
             console.error(`[Overture] Auto-save failed for project ${projectId}:`, error);
           }
@@ -354,7 +659,7 @@ var MultiProjectPlanStore = class {
       contexts.push({
         projectId,
         workspacePath: state.workspacePath,
-        projectName: path2.basename(state.workspacePath),
+        projectName: path3.basename(state.workspacePath),
         agentType: state.plan?.agent || "unknown"
       });
     }
@@ -464,6 +769,19 @@ var MultiProjectPlanStore = class {
       this.persistToHistory(projectId);
     }
   }
+  updatePlanSettings(projectId, planId, settings) {
+    const state = this.projects.get(projectId);
+    if (!state?.plan || state.plan.id !== planId) return false;
+    if (settings.model !== void 0) {
+      state.plan.model = settings.model || void 0;
+    }
+    if (settings.provider !== void 0) {
+      state.plan.provider = settings.provider || void 0;
+    }
+    this.persistToHistory(projectId);
+    console.error(`[Overture] Plan settings updated for ${planId}: model=${settings.model}, provider=${settings.provider}`);
+    return true;
+  }
   updateNodeStatus(projectId, nodeId, status, output, structuredOutput) {
     const state = this.projects.get(projectId);
     if (!state) return;
@@ -479,6 +797,17 @@ var MultiProjectPlanStore = class {
       this.persistToHistory(projectId);
     }
   }
+  updateNodeDescription(projectId, nodeId, description) {
+    const state = this.projects.get(projectId);
+    if (!state) return false;
+    const node = state.nodes.find((n) => n.id === nodeId);
+    if (node) {
+      node.description = description;
+      this.persistToHistory(projectId);
+      return true;
+    }
+    return false;
+  }
   // === Approval ===
   async setApproval(projectId, fieldValues, selectedBranches, nodeConfigs = {}) {
     console.error(`[Overture] setApproval called for project: ${projectId}`);
@@ -679,6 +1008,45 @@ var MultiProjectPlanStore = class {
     }
     return { removedEdgeIds, reconnectionEdges };
   }
+  /**
+   * Insert nodes BEFORE a reference node.
+   * Used when inserting before the first node in a plan.
+   */
+  insertNodesBefore(projectId, beforeNodeId, newNodes, newEdges) {
+    const state = this.projects.get(projectId);
+    if (!state) return { removedEdgeIds: [], allEdges: [] };
+    const incomingEdges = state.edges.filter((e) => e.to === beforeNodeId);
+    const removedEdgeIds = incomingEdges.map((e) => e.id);
+    state.edges = state.edges.filter((e) => e.to !== beforeNodeId);
+    state.nodes.push(...newNodes);
+    state.edges.push(...newEdges);
+    const newNodeIds = new Set(newNodes.map((n) => n.id));
+    const entryNodeIds = newNodes.filter((n) => !newEdges.some((e) => e.to === n.id && newNodeIds.has(e.from))).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 allNewEdges = [...newEdges];
+    let edgeCounter = Date.now();
+    for (const incomingEdge of incomingEdges) {
+      for (const entryNodeId of entryNodeIds) {
+        const reconnectEdge = {
+          id: `e_inserted_${edgeCounter++}`,
+          from: incomingEdge.from,
+          to: entryNodeId
+        };
+        state.edges.push(reconnectEdge);
+        allNewEdges.push(reconnectEdge);
+      }
+    }
+    for (const exitNodeId of exitNodeIds) {
+      const exitEdge = {
+        id: `e_inserted_${edgeCounter++}`,
+        from: exitNodeId,
+        to: beforeNodeId
+      };
+      state.edges.push(exitEdge);
+      allNewEdges.push(exitEdge);
+    }
+    return { removedEdgeIds, allEdges: allNewEdges };
+  }
   removeNode(projectId, nodeId) {
     const state = this.projects.get(projectId);
     if (!state) return { newEdges: [], removedEdgeIds: [] };
@@ -767,7 +1135,8 @@ var MultiProjectPlanStore = class {
   // === History/Persistence ===
   /**
    * Persist current project state to history
-   * Uses immediate write to ensure data is not lost
+   * Uses project-local storage (.overture.json) if workspace path is available,
+   * otherwise falls back to global storage (~/.overture/history.json)
    */
   async persistToHistory(projectId) {
     const state = this.projects.get(projectId);
@@ -781,9 +1150,16 @@ var MultiProjectPlanStore = class {
         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)`);
+      const projectStorage = this.getProjectStorage(projectId);
+      if (projectStorage) {
+        await projectStorage.addPlanToHistory(persisted);
+        await projectStorage.saveNow();
+        console.error(`[Overture] Persisted to project storage: ${state.plan.id} (${state.nodes.length} nodes)`);
+      } else {
+        await historyStorage.savePlan(persisted);
+        await historyStorage.saveNow();
+        console.error(`[Overture] Persisted to global storage: ${state.plan.id} (${state.nodes.length} nodes)`);
+      }
     } catch (error) {
       console.error("[Overture] Failed to persist plan to history:", error);
     }
@@ -808,20 +1184,62 @@ var MultiProjectPlanStore = class {
         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 };
+      const projectStorage = this.getProjectStorage(projectId);
+      if (projectStorage) {
+        await projectStorage.addPlanToHistory(persisted);
+        await projectStorage.saveNow();
+        console.error(`[Overture] Plan ${state.plan.id} force-persisted to project storage`);
+        return { success: true, planId: state.plan.id, storageType: "project" };
+      } else {
+        await historyStorage.savePlan(persisted);
+        await historyStorage.saveNow();
+        console.error(`[Overture] Plan ${state.plan.id} force-persisted to global storage`);
+        return { success: true, planId: state.plan.id, storageType: "global" };
+      }
     } catch (error) {
       console.error("[Overture] Failed to force persist plan:", error);
       return { success: false };
     }
   }
+  /**
+   * Load a plan from a PersistedPlan object directly into the store
+   * Used when loading from project storage
+   */
+  async loadFromPersistedPlan(persisted) {
+    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] Loaded plan from PersistedPlan: ${persisted.plan.id}`);
+    return state;
+  }
   /**
    * Load a plan from history into a project
+   * Checks both project-local storage and global storage
    */
-  async loadFromHistory(planId) {
-    const persisted = await historyStorage.getPlan(planId);
+  async loadFromHistory(planId, workspacePath) {
+    let persisted = null;
+    if (workspacePath) {
+      const tempProjectId = "temp_lookup";
+      const projectStorage = projectStorageRegistry.getStorage(workspacePath, tempProjectId);
+      persisted = await projectStorage.getPlan(planId);
+      if (persisted) {
+        console.error(`[Overture] Loaded plan ${planId} from project storage`);
+      }
+    }
+    if (!persisted) {
+      persisted = await historyStorage.getPlan(planId);
+      if (persisted) {
+        console.error(`[Overture] Loaded plan ${planId} from global storage`);
+      }
+    }
     if (!persisted) return null;
     const state = {
       projectId: persisted.plan.projectId,
@@ -839,19 +1257,33 @@ var MultiProjectPlanStore = class {
   /**
    * Restore a project from history by projectId
    * Finds the most recent plan for this project and loads it
+   * Checks both project-local storage and global storage
    */
-  async restoreProjectFromHistory(projectId) {
+  async restoreProjectFromHistory(projectId, workspacePath) {
     try {
-      const entries = await historyStorage.getEntriesByProject(projectId);
-      if (entries.length === 0) {
-        console.error(`[Overture] No history entries found for project ${projectId}`);
-        return false;
+      let entries = [];
+      let persisted = null;
+      if (workspacePath) {
+        const projectStorage = projectStorageRegistry.getStorage(workspacePath, projectId);
+        entries = await projectStorage.getHistoryEntries();
+        if (entries.length > 0) {
+          const mostRecent = entries[0];
+          console.error(`[Overture] Found project storage entry: ${mostRecent.title} (${mostRecent.id})`);
+          persisted = await projectStorage.getPlan(mostRecent.id);
+        }
+      }
+      if (!persisted) {
+        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 global storage entry: ${mostRecent.title} (${mostRecent.id})`);
+        persisted = await historyStorage.getPlan(mostRecent.id);
       }
-      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}`);
+        console.error(`[Overture] Could not load plan data for project ${projectId}`);
         return false;
       }
       const state = {
@@ -877,6 +1309,89 @@ var MultiProjectPlanStore = class {
       return false;
     }
   }
+  /**
+   * Get all history entries for a project
+   * Combines entries from project-local storage and global storage
+   */
+  async getProjectHistory(projectId, workspacePath) {
+    const allEntries = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    if (workspacePath) {
+      try {
+        const projectStorage = projectStorageRegistry.getStorage(workspacePath, projectId);
+        const projectEntries = await projectStorage.getHistoryEntries();
+        for (const entry of projectEntries) {
+          if (!seenIds.has(entry.id)) {
+            seenIds.add(entry.id);
+            allEntries.push(entry);
+          }
+        }
+        console.error(`[Overture] Found ${projectEntries.length} entries in project storage`);
+      } catch (error) {
+        console.error("[Overture] Failed to get project storage history:", error);
+      }
+    }
+    try {
+      const globalEntries = await historyStorage.getEntriesByProject(projectId);
+      for (const entry of globalEntries) {
+        if (!seenIds.has(entry.id)) {
+          seenIds.add(entry.id);
+          allEntries.push(entry);
+        }
+      }
+      console.error(`[Overture] Found ${globalEntries.length} entries in global storage`);
+    } catch (error) {
+      console.error("[Overture] Failed to get global storage history:", error);
+    }
+    allEntries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    return allEntries;
+  }
+  /**
+   * Get all history entries grouped by project
+   * Combines entries from all project storages and global storage
+   */
+  async getAllHistoryGroupedByProject() {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const storage of projectStorageRegistry.getAllStorages()) {
+      try {
+        const entries = await storage.getHistoryEntries();
+        for (const entry of entries) {
+          if (!grouped.has(entry.projectId)) {
+            grouped.set(entry.projectId, {
+              projectName: entry.projectName,
+              workspacePath: entry.workspacePath,
+              entries: []
+            });
+          }
+          grouped.get(entry.projectId).entries.push(entry);
+        }
+      } catch (error) {
+        console.error("[Overture] Failed to get project storage history:", error);
+      }
+    }
+    try {
+      const globalEntries = await historyStorage.getAllEntries();
+      for (const entry of globalEntries) {
+        if (!grouped.has(entry.projectId)) {
+          grouped.set(entry.projectId, {
+            projectName: entry.projectName,
+            workspacePath: entry.workspacePath,
+            entries: []
+          });
+        }
+        const group = grouped.get(entry.projectId);
+        if (!group.entries.some((e) => e.id === entry.id)) {
+          group.entries.push(entry);
+        }
+      }
+    } catch (error) {
+      console.error("[Overture] Failed to get global storage history:", error);
+    }
+    for (const group of grouped.values()) {
+      group.entries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    return grouped;
+  }
   // === Resume Info ===
   /**
    * Generate resume info for a paused/failed plan
@@ -1062,6 +1577,49 @@ var LegacyPlanStore = class {
 };
 var planStore = new LegacyPlanStore();
 
+// src/store/settings-store.ts
+var DEFAULT_SETTINGS = {
+  minNodesPerPlan: 1
+};
+var MIN_NODES_MIN = 1;
+var MIN_NODES_MAX = 20;
+var SettingsStore = class {
+  settings = { ...DEFAULT_SETTINGS };
+  /**
+   * Get current settings
+   */
+  getSettings() {
+    return { ...this.settings };
+  }
+  /**
+   * Get minimum nodes per plan setting
+   */
+  getMinNodesPerPlan() {
+    return this.settings.minNodesPerPlan;
+  }
+  /**
+   * Update settings from UI
+   */
+  updateSettings(newSettings) {
+    if (newSettings.minNodesPerPlan !== void 0) {
+      const value = Math.min(
+        Math.max(newSettings.minNodesPerPlan, MIN_NODES_MIN),
+        MIN_NODES_MAX
+      );
+      this.settings.minNodesPerPlan = value;
+      console.error(`[Overture] Settings updated: minNodesPerPlan = ${value}`);
+    }
+  }
+  /**
+   * Reset settings to defaults
+   */
+  reset() {
+    this.settings = { ...DEFAULT_SETTINGS };
+    console.error("[Overture] Settings reset to defaults");
+  }
+};
+var settingsStore = new SettingsStore();
+
 // src/websocket/ws-server.ts
 var WebSocketManager = class {
   wss = null;
@@ -1215,7 +1773,25 @@ var WebSocketManager = class {
       case "get_history": {
         console.error("[Overture] History requested");
         let entries;
-        if (message.projectId) {
+        if (message.workspacePath && message.projectId) {
+          const projectStorage = projectStorageRegistry.getStorage(message.workspacePath, message.projectId);
+          if (projectStorage.isWritePermissionDenied()) {
+            console.error("[Overture] Project storage permission denied, using global storage");
+            entries = await historyStorage.getEntriesByProject(message.projectId);
+          } else {
+            const projectEntries = await projectStorage.getHistoryEntries();
+            const globalEntries = await historyStorage.getEntriesByProject(message.projectId);
+            const entryMap = /* @__PURE__ */ new Map();
+            for (const entry of globalEntries) {
+              entryMap.set(entry.id, entry);
+            }
+            for (const entry of projectEntries) {
+              entryMap.set(entry.id, entry);
+            }
+            entries = Array.from(entryMap.values());
+            entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+          }
+        } else if (message.projectId) {
           entries = await historyStorage.getEntriesByProject(message.projectId);
         } else {
           entries = await historyStorage.getAllEntries();
@@ -1225,7 +1801,19 @@ var WebSocketManager = class {
       }
       case "load_plan": {
         console.error(`[Overture] Loading plan from history: ${message.planId}`);
-        const state = await multiProjectPlanStore.loadFromHistory(message.planId);
+        let state = null;
+        if (message.workspacePath && message.projectId) {
+          const projectStorage = projectStorageRegistry.getStorage(message.workspacePath, message.projectId);
+          if (!projectStorage.isWritePermissionDenied()) {
+            const persistedPlan = await projectStorage.getPlan(message.planId);
+            if (persistedPlan) {
+              state = await multiProjectPlanStore.loadFromPersistedPlan(persistedPlan);
+            }
+          }
+        }
+        if (!state) {
+          state = await multiProjectPlanStore.loadFromHistory(message.planId);
+        }
         if (state?.plan) {
           const client = this.clients.get(ws);
           if (client) {
@@ -1341,16 +1929,30 @@ var WebSocketManager = class {
         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
-        });
+        if (message.afterNodeId) {
+          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
+          });
+        } else if (message.beforeNodeId) {
+          console.error(`[Overture] Inserting ${message.nodes.length} node(s) before ${message.beforeNodeId} (project: ${projectId})`);
+          const insertResult = multiProjectPlanStore.insertNodesBefore(projectId, message.beforeNodeId, message.nodes, message.edges);
+          this.broadcastToProject(projectId, {
+            type: "nodes_inserted",
+            nodes: message.nodes,
+            edges: insertResult.allEdges,
+            removedEdgeIds: insertResult.removedEdgeIds,
+            projectId
+          });
+        } else {
+          console.error(`[Overture] insert_nodes called without afterNodeId or beforeNodeId`);
+        }
         break;
       }
       case "remove_node": {
@@ -1388,6 +1990,48 @@ var WebSocketManager = class {
         });
         break;
       }
+      case "update_node_description": {
+        const effectiveProjectId = message.projectId || projectId;
+        console.error(`[Overture] Updating node description: ${message.nodeId} (project: ${effectiveProjectId})`);
+        const success = multiProjectPlanStore.updateNodeDescription(
+          effectiveProjectId,
+          message.nodeId,
+          message.description
+        );
+        if (success) {
+          this.broadcastToProject(effectiveProjectId, {
+            type: "node_description_updated",
+            nodeId: message.nodeId,
+            description: message.description,
+            projectId: effectiveProjectId
+          });
+        }
+        break;
+      }
+      case "sync_settings": {
+        console.error("[Overture] Received settings sync:", message.settings);
+        settingsStore.updateSettings(message.settings);
+        break;
+      }
+      case "update_plan_settings": {
+        const effectiveProjectId = message.projectId || projectId;
+        console.error(`[Overture] Updating plan settings for plan: ${message.planId} (project: ${effectiveProjectId})`);
+        const success = multiProjectPlanStore.updatePlanSettings(
+          effectiveProjectId,
+          message.planId,
+          { model: message.model, provider: message.provider }
+        );
+        if (success) {
+          this.broadcastToProject(effectiveProjectId, {
+            type: "plan_settings_updated",
+            planId: message.planId,
+            model: message.model,
+            provider: message.provider,
+            projectId: effectiveProjectId
+          });
+        }
+        break;
+      }
     }
   }
   /**
@@ -1564,8 +2208,8 @@ var wsManager = new WebSocketManager();
 
 // src/tools/handlers.ts
 import { createHash } from "crypto";
-import path3 from "path";
-import fs2 from "fs/promises";
+import path4 from "path";
+import fs3 from "fs/promises";
 import { fileURLToPath } from "url";
 
 // src/parser/xml-parser.ts
@@ -1609,7 +2253,9 @@ var StreamingXMLParser = class {
             title: tag.attributes.title || "Untitled Plan",
             agent: tag.attributes.agent || "unknown",
             createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-            status: "streaming"
+            status: "streaming",
+            model: tag.attributes.model,
+            provider: tag.attributes.provider
           };
           this.callback({ type: "plan", plan: this.state.plan });
           break;
@@ -1778,6 +2424,38 @@ var StreamingXMLParser = class {
 
 // src/parser/output-parser.ts
 import sax2 from "sax";
+function normalizeDiffContent(content) {
+  if (!content) return "";
+  let normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  let lines = normalized.split("\n");
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  if (lines.length === 0) return "";
+  const nonDiffLines = lines.filter(
+    (line) => line.trim() !== "" && !/^[+\-@]/.test(line.trimStart())
+  );
+  let commonIndent = Infinity;
+  for (const line of nonDiffLines) {
+    const match = line.match(/^(\s*)/);
+    if (match) {
+      commonIndent = Math.min(commonIndent, match[1].length);
+    }
+  }
+  if (commonIndent > 0 && commonIndent !== Infinity && commonIndent <= 8) {
+    lines = lines.map((line) => {
+      if (line.trim() === "") return "";
+      if (line.length >= commonIndent) {
+        return line.slice(commonIndent);
+      }
+      return line;
+    });
+  }
+  return lines.join("\n");
+}
 function parseStructuredOutput(output) {
   const startTag = "<execution_output>";
   const endTag = "</execution_output>";
@@ -1905,7 +2583,12 @@ function parseStructuredOutput(output) {
         break;
       case "diff":
         if (state.currentFile) {
-          state.currentFile.diff = text;
+          state.currentFile.diff = normalizeDiffContent(state.textBuffer);
+        }
+        break;
+      case "content":
+        if (state.currentFileCreated) {
+          state.currentFileCreated.content = normalizeDiffContent(state.textBuffer);
         }
         break;
       case "config":
@@ -2348,7 +3031,7 @@ function handleSubmitPlan(planXml, workspacePath, agentType) {
         const projectContext = {
           projectId,
           workspacePath: effectivePath,
-          projectName: path3.basename(effectivePath),
+          projectName: path4.basename(effectivePath),
           agentType: plan.agent
         };
         multiProjectPlanStore.initializeProject(projectContext);
@@ -2404,6 +3087,16 @@ function handleSubmitPlan(planXml, workspacePath, agentType) {
   console.error("[Overture] Plan parsing result. 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)));
+  const minNodesRequired = settingsStore.getMinNodesPerPlan();
+  if (nodes.length > 0 && nodes.length < minNodesRequired) {
+    console.error(`[Overture] Plan rejected: ${nodes.length} nodes < minimum ${minNodesRequired}`);
+    multiProjectPlanStore.clearProjectPlan(projectId);
+    return {
+      success: false,
+      message: `Plan rejected: Only ${nodes.length} node(s) provided, but minimum ${minNodesRequired} node(s) required. Please create a more detailed plan.`,
+      projectId
+    };
+  }
   if (nodes.length > 0) {
     return {
       success: true,
@@ -2419,8 +3112,9 @@ function handleSubmitPlan(planXml, workspacePath, agentType) {
     projectId
   };
 }
-async function handleGetApproval(projectId) {
+async function handleGetApproval(projectId, workspacePath) {
   const effectiveProjectId = projectId || currentProjectId;
+  const effectiveWorkspacePath = workspacePath;
   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));
@@ -2454,23 +3148,26 @@ async function handleGetApproval(projectId) {
       status: "approved",
       firstNode: firstNodeInfo,
       message: "Plan approved by user. Execute firstNode, then call update_node_status to get the next node.",
-      projectId: effectiveProjectId
+      projectId: effectiveProjectId,
+      workspacePath: effectiveWorkspacePath
     };
   }
   if (result === "cancelled") {
     return {
       status: "cancelled",
       message: "Plan cancelled by user",
-      projectId: effectiveProjectId
+      projectId: effectiveProjectId,
+      workspacePath: effectiveWorkspacePath
     };
   }
   return {
     status: "pending",
     message: "Waiting for user approval. Call get_approval again to continue waiting.",
-    projectId: effectiveProjectId
+    projectId: effectiveProjectId,
+    workspacePath: effectiveWorkspacePath
   };
 }
-async function handleCheckPause(wait = false, projectId) {
+async function handleCheckPause(wait = false, projectId, workspacePath) {
   const effectiveProjectId = projectId || currentProjectId;
   const isPaused = multiProjectPlanStore.getIsPaused(effectiveProjectId);
   if (!isPaused) {
@@ -2478,7 +3175,8 @@ async function handleCheckPause(wait = false, projectId) {
       isPaused: false,
       wasResumed: false,
       message: "Execution is not paused",
-      projectId: effectiveProjectId
+      projectId: effectiveProjectId,
+      workspacePath
     };
   }
   if (!wait) {
@@ -2486,7 +3184,8 @@ async function handleCheckPause(wait = false, projectId) {
       isPaused: true,
       wasResumed: false,
       message: "Execution is paused. Call with wait=true to block until resumed.",
-      projectId: effectiveProjectId
+      projectId: effectiveProjectId,
+      workspacePath
     };
   }
   await multiProjectPlanStore.waitIfPaused(effectiveProjectId);
@@ -2494,10 +3193,11 @@ async function handleCheckPause(wait = false, projectId) {
     isPaused: false,
     wasResumed: true,
     message: "Execution was paused and has now been resumed",
-    projectId: effectiveProjectId
+    projectId: effectiveProjectId,
+    workspacePath
   };
 }
-function handleUpdateNodeStatus(nodeId, status, output, projectId) {
+function handleUpdateNodeStatus(nodeId, status, output, projectId, workspacePath) {
   const effectiveProjectId = projectId || currentProjectId;
   const plan = multiProjectPlanStore.getPlan(effectiveProjectId);
   const provider = plan?.agent || "unknown";
@@ -2506,7 +3206,7 @@ function handleUpdateNodeStatus(nodeId, status, output, projectId) {
   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 };
+    return { success: false, message: `Node ${nodeId} not found`, projectId: effectiveProjectId, workspacePath };
   }
   if (plan && (plan.status === "ready" || plan.status === "streaming")) {
     console.error(`[Overture] Auto-approving plan - agent called update_node_status before get_approval (manual approval detected)`);
@@ -2542,7 +3242,8 @@ function handleUpdateNodeStatus(nodeId, status, output, projectId) {
       message: `Node ${nodeId} status updated to ${status}. Execute this node now.`,
       currentNode: currentNodeInfo,
       isPaused,
-      projectId: effectiveProjectId
+      projectId: effectiveProjectId,
+      workspacePath
     };
   }
   if (status === "completed") {
@@ -2553,7 +3254,8 @@ function handleUpdateNodeStatus(nodeId, status, output, projectId) {
         message: `Node ${nodeId} status updated to ${status}`,
         nextNode: nextNodeInfo,
         isPaused,
-        projectId: effectiveProjectId
+        projectId: effectiveProjectId,
+        workspacePath
       };
     } else {
       return {
@@ -2561,7 +3263,8 @@ function handleUpdateNodeStatus(nodeId, status, output, projectId) {
         message: `Node ${nodeId} status updated to ${status}. This was the last node.`,
         isLastNode: true,
         isPaused,
-        projectId: effectiveProjectId
+        projectId: effectiveProjectId,
+        workspacePath
       };
     }
   }
@@ -2569,7 +3272,8 @@ function handleUpdateNodeStatus(nodeId, status, output, projectId) {
     success: true,
     message: `Node ${nodeId} status updated to ${status}`,
     isPaused,
-    projectId: effectiveProjectId
+    projectId: effectiveProjectId,
+    workspacePath
   };
 }
 function findNextNode(projectId, currentNodeId, nodes, edges, provider) {
@@ -2646,26 +3350,27 @@ function findNextNode(projectId, currentNodeId, nodes, edges, provider) {
   }
   return null;
 }
-function handlePlanCompleted(projectId) {
+function handlePlanCompleted(projectId, workspacePath) {
   const effectiveProjectId = projectId || currentProjectId;
   multiProjectPlanStore.updatePlanStatus(effectiveProjectId, "completed");
   wsManager.broadcastToProject(effectiveProjectId, { type: "plan_completed", projectId: effectiveProjectId });
-  return { success: true, message: "Plan completed", projectId: effectiveProjectId };
+  return { success: true, message: "Plan completed", projectId: effectiveProjectId, workspacePath };
 }
-function handlePlanFailed(error, projectId) {
+function handlePlanFailed(error, projectId, workspacePath) {
   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 };
+  return { success: true, message: "Plan failed", projectId: effectiveProjectId, workspacePath };
 }
-async function handleCheckRerun(timeoutMs = 5e3, projectId) {
+async function handleCheckRerun(timeoutMs = 5e3, projectId, workspacePath) {
   const effectiveProjectId = projectId || currentProjectId;
   const rerunRequest = await multiProjectPlanStore.waitForRerun(effectiveProjectId, timeoutMs);
   if (!rerunRequest) {
     return {
       hasRerun: false,
       message: "No rerun request pending",
-      projectId: effectiveProjectId
+      projectId: effectiveProjectId,
+      workspacePath
     };
   }
   const resetNodeIds = multiProjectPlanStore.resetNodesForRerun(effectiveProjectId, rerunRequest.nodeId, rerunRequest.mode);
@@ -2699,27 +3404,30 @@ async function handleCheckRerun(timeoutMs = 5e3, projectId) {
     mode: rerunRequest.mode,
     nodeInfo,
     message: `Rerun requested from node ${rerunRequest.nodeId} (${rerunRequest.mode})`,
-    projectId: effectiveProjectId
+    projectId: effectiveProjectId,
+    workspacePath
   };
 }
-function handleGetResumeInfo(projectId) {
+function handleGetResumeInfo(projectId, workspacePath) {
   const effectiveProjectId = projectId || currentProjectId;
   const resumeInfo = multiProjectPlanStore.getResumeInfo(effectiveProjectId);
   if (!resumeInfo) {
     return {
       success: false,
       message: `No active plan found for project: ${effectiveProjectId}`,
-      projectId: effectiveProjectId
+      projectId: effectiveProjectId,
+      workspacePath
     };
   }
   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
+    projectId: effectiveProjectId,
+    workspacePath
   };
 }
-function handleRequestPlanUpdate(operations, projectId) {
+function handleRequestPlanUpdate(operations, projectId, workspacePath) {
   const effectiveProjectId = projectId || currentProjectId;
   const currentPlan = multiProjectPlanStore.getPlan(effectiveProjectId);
   if (!currentPlan) {
@@ -2727,7 +3435,8 @@ function handleRequestPlanUpdate(operations, projectId) {
       success: false,
       message: `No active plan found for project: ${effectiveProjectId}. Submit a new plan instead.`,
       results: [],
-      projectId: effectiveProjectId
+      projectId: effectiveProjectId,
+      workspacePath
     };
   }
   multiProjectPlanStore.storePreviousPlanState(effectiveProjectId);
@@ -2780,7 +3489,8 @@ function handleRequestPlanUpdate(operations, projectId) {
     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
+    projectId: effectiveProjectId,
+    workspacePath
   };
 }
 function applyInsertOperation(projectId, referenceNodeId, position, nodeData) {
@@ -2907,7 +3617,7 @@ function applyReplaceOperation(projectId, nodeId, newNodeData) {
   console.error(`[Overture] Node ${nodeId} replaced with new content`);
   return { success: true, message: `Node "${oldNode.title}" replaced with "${updatedNode.title}"` };
 }
-function handleCreateNewPlan(projectId) {
+function handleCreateNewPlan(projectId, workspacePath) {
   const effectiveProjectId = projectId || currentProjectId;
   wsManager.broadcastToProject(effectiveProjectId, {
     type: "new_plan_created",
@@ -2919,7 +3629,8 @@ function handleCreateNewPlan(projectId) {
   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
+    projectId: effectiveProjectId,
+    workspacePath
   };
 }
 async function handleGetUsageInstructions(agentType) {
@@ -2950,25 +3661,25 @@ async function handleGetUsageInstructions(agentType) {
     };
   }
   const __filename2 = fileURLToPath(import.meta.url);
-  const __dirname2 = path3.dirname(__filename2);
+  const __dirname2 = path4.dirname(__filename2);
   const possiblePaths = [
-    path3.resolve(__dirname2, "../../prompts"),
+    path4.resolve(__dirname2, "../../prompts"),
     // npm installed (dist/tools -> prompts)
-    path3.resolve(__dirname2, "../prompts"),
+    path4.resolve(__dirname2, "../prompts"),
     // Alternative npm location
-    path3.resolve(__dirname2, "../../../../prompts"),
+    path4.resolve(__dirname2, "../../../../prompts"),
     // Development (monorepo root)
-    path3.resolve(__dirname2, "../../../prompts"),
+    path4.resolve(__dirname2, "../../../prompts"),
     // Alternative dev location
-    path3.resolve(process.cwd(), "prompts")
+    path4.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`);
+    const candidatePath = path4.join(promptsDir, `${mappedType}.md`);
     try {
-      instructions = await fs2.readFile(candidatePath, "utf-8");
+      instructions = await fs3.readFile(candidatePath, "utf-8");
       promptFile = candidatePath;
       console.error(`[Overture] Found instructions at: ${candidatePath}`);
       break;
@@ -2987,7 +3698,7 @@ async function handleGetUsageInstructions(agentType) {
     };
   }
   console.error(`[Overture] Failed to find instructions for ${mappedType}. Searched paths:`);
-  possiblePaths.forEach((p) => console.error(`  - ${path3.join(p, `${mappedType}.md`)}`));
+  possiblePaths.forEach((p) => console.error(`  - ${path4.join(p, `${mappedType}.md`)}`));
   return {
     success: false,
     agentType: mappedType,
@@ -2995,34 +3706,210 @@ async function handleGetUsageInstructions(agentType) {
     availableAgents
   };
 }
+function handleGetNodeInfo(nodeId, projectId, workspacePath) {
+  const effectiveProjectId = projectId || currentProjectId;
+  const nodes = multiProjectPlanStore.getNodes(effectiveProjectId);
+  const nodeConfigs = multiProjectPlanStore.getNodeConfigs(effectiveProjectId);
+  const selectedBranches = multiProjectPlanStore.getSelectedBranches(effectiveProjectId);
+  const node = nodes.find((n) => n.id === nodeId);
+  if (!node) {
+    return {
+      success: false,
+      error: `Node ${nodeId} not found in project ${effectiveProjectId}`,
+      projectId: effectiveProjectId,
+      workspacePath
+    };
+  }
+  const config = nodeConfigs[nodeId] || { fieldValues: {}, attachments: [] };
+  let selectedBranchId;
+  if (node.isBranchPoint) {
+    selectedBranchId = selectedBranches[nodeId];
+  }
+  return {
+    success: true,
+    node: {
+      id: node.id,
+      title: node.title,
+      type: node.type,
+      status: node.status,
+      description: node.description,
+      complexity: node.complexity,
+      expectedOutput: node.expectedOutput,
+      risks: node.risks,
+      fieldValues: config.fieldValues || {},
+      attachments: config.attachments || [],
+      mcpServers: config.mcpServers || [],
+      metaInstructions: config.metaInstructions,
+      isBranchPoint: node.isBranchPoint,
+      branchTargetIds: node.branchTargetIds,
+      selectedBranchId,
+      branchSourceId: node.branchSourceId,
+      output: node.output
+    },
+    projectId: effectiveProjectId,
+    workspacePath
+  };
+}
+function handleUpdateNodesDetail(updates, projectId, workspacePath) {
+  const effectiveProjectId = projectId || currentProjectId;
+  const state = multiProjectPlanStore.getState(effectiveProjectId);
+  if (!state) {
+    return {
+      success: false,
+      updatedCount: 0,
+      errors: [`No active plan found for project: ${effectiveProjectId}`],
+      projectId: effectiveProjectId,
+      workspacePath
+    };
+  }
+  const errors = [];
+  let updatedCount = 0;
+  const appliedUpdates = [];
+  for (const update of updates) {
+    const nodeIndex = state.nodes.findIndex((n) => n.id === update.node_id);
+    if (nodeIndex < 0) {
+      errors.push(`Node ${update.node_id} not found`);
+      continue;
+    }
+    const node = state.nodes[nodeIndex];
+    const nodeUpdates = {};
+    if (update.title !== void 0) {
+      node.title = update.title;
+      nodeUpdates.title = update.title;
+    }
+    if (update.description !== void 0) {
+      node.description = update.description;
+      nodeUpdates.description = update.description;
+    }
+    if (update.complexity !== void 0) {
+      node.complexity = update.complexity;
+      nodeUpdates.complexity = update.complexity;
+    }
+    if (update.expectedOutput !== void 0) {
+      node.expectedOutput = update.expectedOutput;
+      nodeUpdates.expectedOutput = update.expectedOutput;
+    }
+    if (update.risks !== void 0) {
+      node.risks = update.risks;
+      nodeUpdates.risks = update.risks;
+    }
+    if (Object.keys(nodeUpdates).length > 0) {
+      appliedUpdates.push({ nodeId: update.node_id, updates: nodeUpdates });
+      updatedCount++;
+    }
+  }
+  if (appliedUpdates.length > 0) {
+    wsManager.broadcastToProject(effectiveProjectId, {
+      type: "nodes_detail_updated",
+      updates: appliedUpdates,
+      projectId: effectiveProjectId
+    });
+    console.error(`[Overture] Updated details for ${updatedCount} node(s) in project ${effectiveProjectId}`);
+  }
+  return {
+    success: errors.length === 0,
+    updatedCount,
+    errors: errors.length > 0 ? errors : void 0,
+    projectId: effectiveProjectId,
+    workspacePath
+  };
+}
+function handleUpdateNodeDetail(nodeId, updates, projectId, workspacePath) {
+  const effectiveProjectId = projectId || currentProjectId;
+  const state = multiProjectPlanStore.getState(effectiveProjectId);
+  if (!state) {
+    return {
+      success: false,
+      message: `No active plan found for project: ${effectiveProjectId}`,
+      projectId: effectiveProjectId,
+      workspacePath
+    };
+  }
+  const nodeIndex = state.nodes.findIndex((n) => n.id === nodeId);
+  if (nodeIndex < 0) {
+    return {
+      success: false,
+      message: `Node ${nodeId} not found in project ${effectiveProjectId}`,
+      projectId: effectiveProjectId,
+      workspacePath
+    };
+  }
+  const node = state.nodes[nodeIndex];
+  const nodeUpdates = {};
+  if (updates.title !== void 0) {
+    node.title = updates.title;
+    nodeUpdates.title = updates.title;
+  }
+  if (updates.description !== void 0) {
+    node.description = updates.description;
+    nodeUpdates.description = updates.description;
+  }
+  if (updates.complexity !== void 0) {
+    node.complexity = updates.complexity;
+    nodeUpdates.complexity = updates.complexity;
+  }
+  if (updates.expectedOutput !== void 0) {
+    node.expectedOutput = updates.expectedOutput;
+    nodeUpdates.expectedOutput = updates.expectedOutput;
+  }
+  if (updates.risks !== void 0) {
+    node.risks = updates.risks;
+    nodeUpdates.risks = updates.risks;
+  }
+  if (Object.keys(nodeUpdates).length > 0) {
+    wsManager.broadcastToProject(effectiveProjectId, {
+      type: "node_detail_updated",
+      nodeId,
+      updates: nodeUpdates,
+      projectId: effectiveProjectId
+    });
+    console.error(`[Overture] Updated details for node ${nodeId} in project ${effectiveProjectId}`);
+  }
+  return {
+    success: true,
+    message: `Node ${nodeId} updated successfully`,
+    node: {
+      id: node.id,
+      title: node.title,
+      type: node.type,
+      status: node.status,
+      description: node.description,
+      complexity: node.complexity,
+      expectedOutput: node.expectedOutput,
+      risks: node.risks
+    },
+    projectId: effectiveProjectId,
+    workspacePath
+  };
+}
 
 // src/http/server.ts
 import express from "express";
-import path4 from "path";
+import path5 from "path";
 import { createServer } from "http";
-import fs3 from "fs";
+import fs4 from "fs";
 import fsp from "fs/promises";
 import os2 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path4.dirname(__filename);
+var __dirname = path5.dirname(__filename);
 function startHttpServer(port) {
   const app = express();
   app.use(express.json({ limit: "25mb" }));
   const possiblePaths = [
-    path4.resolve(__dirname, "../ui-dist"),
+    path5.resolve(__dirname, "../ui-dist"),
     // packages/mcp-server/dist/../ui-dist
-    path4.resolve(__dirname, "../../ui-dist"),
+    path5.resolve(__dirname, "../../ui-dist"),
     // packages/mcp-server/ui-dist
-    path4.resolve(__dirname, "../../../ui/dist"),
+    path5.resolve(__dirname, "../../../ui/dist"),
     // packages/ui/dist
-    path4.resolve(process.cwd(), "ui-dist"),
+    path5.resolve(process.cwd(), "ui-dist"),
     // fallback to cwd
-    path4.resolve(process.cwd(), "packages/mcp-server/ui-dist")
+    path5.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"))) {
+    if (fs4.existsSync(path5.join(p, "index.html"))) {
       staticPath = p;
       break;
     }
@@ -3049,17 +3936,46 @@ function startHttpServer(port) {
       res.status(500).json({ error: "Failed to fetch MCP marketplace" });
     }
   });
+  app.post("/api/read-file", async (req, res) => {
+    try {
+      const { filePath } = req.body;
+      if (!filePath) {
+        return res.status(400).json({ error: "filePath is required" });
+      }
+      const normalizedPath = path5.normalize(filePath);
+      if (normalizedPath.includes("..") && !path5.isAbsolute(normalizedPath)) {
+        return res.status(400).json({ error: "Invalid file path" });
+      }
+      try {
+        await fsp.access(normalizedPath, fs4.constants.R_OK);
+      } catch {
+        return res.status(404).json({ error: "File not found or not readable" });
+      }
+      const content = await fsp.readFile(normalizedPath, "utf-8");
+      const stats = await fsp.stat(normalizedPath);
+      const lineCount = content.split("\n").length;
+      res.json({
+        content,
+        lineCount,
+        size: stats.size,
+        lastModified: stats.mtime.toISOString()
+      });
+    } catch (error) {
+      console.error("[Overture] Failed to read file:", error);
+      res.status(500).json({ error: "Failed to read file" });
+    }
+  });
   app.post("/api/attachments/save", async (req, res) => {
     try {
       const { fileName, contentBase64 } = req.body;
       if (!fileName || !contentBase64) {
         return res.status(400).json({ error: "fileName and contentBase64 are required" });
       }
-      const safeFileName = path4.basename(fileName).replace(/[^\w.-]/g, "_");
-      const attachmentDir = path4.join(os2.homedir(), ".overture", "attachments");
+      const safeFileName = path5.basename(fileName).replace(/[^\w.-]/g, "_");
+      const attachmentDir = path5.join(os2.homedir(), ".overture", "attachments");
       await fsp.mkdir(attachmentDir, { recursive: true });
       const timestamp = Date.now();
-      const absolutePath = path4.join(attachmentDir, `${timestamp}_${safeFileName}`);
+      const absolutePath = path5.join(attachmentDir, `${timestamp}_${safeFileName}`);
       const fileBuffer = Buffer.from(contentBase64, "base64");
       await fsp.writeFile(absolutePath, fileBuffer);
       res.json({
@@ -3073,7 +3989,7 @@ function startHttpServer(port) {
   });
   app.use(express.static(staticPath));
   app.get("*", (_req, res) => {
-    res.sendFile(path4.join(staticPath, "index.html"));
+    res.sendFile(path5.join(staticPath, "index.html"));
   });
   const server = createServer(app);
   server.on("error", (err) => {
@@ -3102,5 +4018,8 @@ export {
   handleRequestPlanUpdate,
   handleCreateNewPlan,
   handleGetUsageInstructions,
+  handleGetNodeInfo,
+  handleUpdateNodesDetail,
+  handleUpdateNodeDetail,
   startHttpServer
 };