roadmap-skill 0.2.10 → 0.3.0

package/dist/index.js

@@ -1,31 +1,40 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 
-// node_modules/tsup/assets/esm_shims.js
-import path from "path";
-import { fileURLToPath } from "url";
-var init_esm_shims = __esm({
-  "node_modules/tsup/assets/esm_shims.js"() {
-    "use strict";
-  }
-});
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/tools/project-tools.ts
+import { z } from "zod";
+
+// src/storage/index.ts
+import * as path3 from "path";
+
+// src/utils/path-helpers.ts
+import * as os from "os";
+import * as path from "path";
+function getStorageDir() {
+  const homeDir = os.homedir();
+  return path.join(homeDir, ".roadmap-skill", "projects");
+}
 
 // src/utils/file-helpers.ts
-var file_helpers_exports = {};
-__export(file_helpers_exports, {
-  ensureDir: () => ensureDir,
-  readJsonFile: () => readJsonFile,
-  writeJsonFile: () => writeJsonFile
-});
 import * as fs from "fs/promises";
+import * as path2 from "path";
+function buildTempFilePath(filePath) {
+  const fileName = path2.basename(filePath);
+  const tempSuffix = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return path2.join(path2.dirname(filePath), `.${fileName}.${tempSuffix}.tmp`);
+}
 async function readJsonFile(filePath) {
   try {
     const content = await fs.readFile(filePath, "utf-8");
@@ -38,10 +47,16 @@ async function readJsonFile(filePath) {
   }
 }
 async function writeJsonFile(filePath, data) {
+  const tempPath = buildTempFilePath(filePath);
   try {
     const content = JSON.stringify(data, null, 2);
-    await fs.writeFile(filePath, content, "utf-8");
+    await fs.writeFile(tempPath, content, "utf-8");
+    await fs.rename(tempPath, filePath);
   } catch (error) {
+    try {
+      await fs.unlink(tempPath);
+    } catch {
+    }
     if (error instanceof Error) {
       throw new Error(`Failed to write JSON file ${filePath}: ${error.message}`);
     }
@@ -58,56 +73,44 @@ async function ensureDir(dirPath) {
     throw error;
   }
 }
-var init_file_helpers = __esm({
-  "src/utils/file-helpers.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
-// src/index.ts
-init_esm_shims();
-
-// src/server.ts
-init_esm_shims();
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-
-// src/tools/index.ts
-init_esm_shims();
-
-// src/tools/project-tools.ts
-init_esm_shims();
-import { z } from "zod";
-
-// src/storage/index.ts
-init_esm_shims();
-import * as path3 from "path";
-
-// src/utils/path-helpers.ts
-init_esm_shims();
-import * as os from "os";
-import * as path2 from "path";
-function getStorageDir() {
-  const homeDir = os.homedir();
-  return path2.join(homeDir, ".roadmap-skill", "projects");
-}
 
 // src/storage/index.ts
-init_file_helpers();
 var ProjectStorage = class {
   storageDir;
+  projectMutationQueues;
   constructor() {
     this.storageDir = getStorageDir();
+    this.projectMutationQueues = /* @__PURE__ */ new Map();
+  }
+  async runProjectMutation(projectId, operation) {
+    const previous = this.projectMutationQueues.get(projectId) ?? Promise.resolve();
+    let releaseQueue;
+    const current = new Promise((resolve) => {
+      releaseQueue = resolve;
+    });
+    this.projectMutationQueues.set(projectId, current);
+    try {
+      await previous;
+      return await operation();
+    } finally {
+      releaseQueue();
+      if (this.projectMutationQueues.get(projectId) === current) {
+        this.projectMutationQueues.delete(projectId);
+      }
+    }
+  }
+  async mutateProject(projectId, updater) {
+    return this.runProjectMutation(projectId, async () => {
+      const projectData = await this.readProject(projectId);
+      if (!projectData) {
+        return null;
+      }
+      const updateResult = await updater(projectData);
+      if (updateResult.shouldSave) {
+        await writeJsonFile(this.getFilePath(projectId), projectData);
+      }
+      return updateResult.result;
+    });
   }
   /**
    * Ensure the storage directory exists
@@ -148,7 +151,8 @@ var ProjectStorage = class {
       project,
       milestones: [],
       tasks: [],
-      tags: []
+      tags: [],
+      dependencyViews: []
     };
     const filePath = this.getFilePath(projectId);
     await writeJsonFile(filePath, projectData);
@@ -162,7 +166,11 @@ var ProjectStorage = class {
   async readProject(projectId) {
     try {
       const filePath = this.getFilePath(projectId);
-      return await readJsonFile(filePath);
+      const projectData = await readJsonFile(filePath);
+      return {
+        ...projectData,
+        dependencyViews: projectData.dependencyViews ?? []
+      };
     } catch (error) {
       if (error instanceof Error && error.message.includes("ENOENT")) {
         return null;
@@ -177,19 +185,18 @@ var ProjectStorage = class {
    * @returns The updated project data or null if not found
    */
   async updateProject(projectId, input) {
-    const projectData = await this.readProject(projectId);
-    if (!projectData) {
-      return null;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    projectData.project = {
-      ...projectData.project,
-      ...input,
-      updatedAt: now
-    };
-    const filePath = this.getFilePath(projectId);
-    await writeJsonFile(filePath, projectData);
-    return projectData;
+    return this.mutateProject(projectId, async (projectData) => {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      projectData.project = {
+        ...projectData.project,
+        ...input,
+        updatedAt: now
+      };
+      return {
+        result: projectData,
+        shouldSave: true
+      };
+    });
   }
   /**
    * Delete a project by ID
@@ -197,17 +204,19 @@ var ProjectStorage = class {
    * @returns True if deleted, false if not found
    */
   async deleteProject(projectId) {
-    try {
-      const filePath = this.getFilePath(projectId);
-      const fs3 = await import("fs/promises");
-      await fs3.unlink(filePath);
-      return true;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("ENOENT")) {
-        return false;
+    return this.runProjectMutation(projectId, async () => {
+      try {
+        const filePath = this.getFilePath(projectId);
+        const fs3 = await import("fs/promises");
+        await fs3.unlink(filePath);
+        return true;
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("ENOENT")) {
+          return false;
+        }
+        throw error;
       }
-      throw error;
-    }
+    });
   }
   /**
    * List all projects sorted by updatedAt (descending)
@@ -324,7 +333,9 @@ var ProjectStorage = class {
           continue;
         }
         const filePath = this.getFilePath(projectData.project.id);
-        await writeJsonFile(filePath, projectData);
+        await this.runProjectMutation(projectData.project.id, async () => {
+          await writeJsonFile(filePath, projectData);
+        });
         imported++;
       } catch (error) {
         errors++;
@@ -345,7 +356,7 @@ var storage = new ProjectStorage();
 // src/tools/project-tools.ts
 var ProjectTypeEnum = z.enum(["roadmap", "skill-tree", "kanban"]);
 var ProjectStatusEnum = z.enum(["active", "completed", "archived"]);
-function toProjectSummary(project, taskCount, tags) {
+function toProjectSummary(project, taskCount, dependencyViewCount, tags) {
   return {
     id: project.id,
     name: project.name,
@@ -353,6 +364,7 @@ function toProjectSummary(project, taskCount, tags) {
     status: project.status,
     targetDate: project.targetDate,
     taskCount,
+    dependencyViewCount,
     ...tags ? { tags } : {}
   };
 }
@@ -390,7 +402,7 @@ var createProjectTool = {
       const projectData = await storage.createProject(projectInput);
       return {
         success: true,
-        data: input.verbose ? projectData : toProjectSummary(projectData.project, 0)
+        data: input.verbose ? projectData : toProjectSummary(projectData.project, 0, 0)
       };
     } catch (error) {
       return {
@@ -423,7 +435,12 @@ var listProjectsTool = {
             name: tag.name,
             color: tag.color
           }));
-          return toProjectSummary(projectSummary.project, projectSummary.taskCount, tags);
+          return toProjectSummary(
+            projectSummary.project,
+            projectSummary.taskCount,
+            projectData?.dependencyViews?.length ?? 0,
+            tags
+          );
         })
       );
       return {
@@ -501,7 +518,11 @@ var updateProjectTool = {
       }
       return {
         success: true,
-        data: verbose ? projectData : toProjectSummary(projectData.project, projectData.tasks.length)
+        data: verbose ? projectData : toProjectSummary(
+          projectData.project,
+          projectData.tasks.length,
+          projectData.dependencyViews.length
+        )
       };
     } catch (error) {
       return {
@@ -540,14 +561,9 @@ var deleteProjectTool = {
 };
 
 // src/tools/task-tools.ts
-init_esm_shims();
 import { z as z2 } from "zod";
 
-// src/services/index.ts
-init_esm_shims();
-
 // src/services/tag-service.ts
-init_esm_shims();
 function generateTagId() {
   return `tag_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
@@ -597,47 +613,57 @@ var TagService = class {
    */
   async create(projectId, data) {
     try {
-      const projectData = await this.storage.readProject(projectId);
-      if (!projectData) {
-        return {
-          success: false,
-          error: `Project with ID '${projectId}' not found`,
-          code: "NOT_FOUND"
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const existingTag = projectData.tags.find(
+          (t) => t.name.toLowerCase() === data.name.toLowerCase()
+        );
+        if (existingTag) {
+          return {
+            result: {
+              success: false,
+              error: `Tag with name '${data.name}' already exists in this project`,
+              code: "DUPLICATE_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const resolvedColor = resolveTagColor(data.name, data.color);
+        if (!HEX_COLOR_PATTERN.test(resolvedColor)) {
+          return {
+            result: {
+              success: false,
+              error: `Color must be a valid hex code (e.g., #FF5733), received '${resolvedColor}'`,
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const tag = {
+          id: generateTagId(),
+          name: data.name,
+          color: resolvedColor,
+          description: data.description || "",
+          createdAt: now
         };
-      }
-      const existingTag = projectData.tags.find(
-        (t) => t.name.toLowerCase() === data.name.toLowerCase()
-      );
-      if (existingTag) {
+        projectData.tags.push(tag);
+        projectData.project.updatedAt = now;
         return {
-          success: false,
-          error: `Tag with name '${data.name}' already exists in this project`,
-          code: "DUPLICATE_ERROR"
+          result: {
+            success: true,
+            data: tag
+          },
+          shouldSave: true
         };
-      }
-      const resolvedColor = resolveTagColor(data.name, data.color);
-      if (!HEX_COLOR_PATTERN.test(resolvedColor)) {
+      });
+      if (result === null) {
         return {
           success: false,
-          error: `Color must be a valid hex code (e.g., #FF5733), received '${resolvedColor}'`,
-          code: "VALIDATION_ERROR"
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
         };
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const tag = {
-        id: generateTagId(),
-        name: data.name,
-        color: resolvedColor,
-        description: data.description || "",
-        createdAt: now
-      };
-      projectData.tags.push(tag);
-      projectData.project.updatedAt = now;
-      await this.saveProjectData(projectId, projectData);
-      return {
-        success: true,
-        data: tag
-      };
+      return result;
     } catch (error) {
       return {
         success: false,
@@ -691,63 +717,78 @@ var TagService = class {
    */
   async update(projectId, tagId, data) {
     try {
-      const projectData = await this.storage.readProject(projectId);
-      if (!projectData) {
-        return {
-          success: false,
-          error: `Project with ID '${projectId}' not found`,
-          code: "NOT_FOUND"
-        };
-      }
-      const tagIndex = projectData.tags.findIndex((t) => t.id === tagId);
-      if (tagIndex === -1) {
-        return {
-          success: false,
-          error: `Tag with ID '${tagId}' not found in project '${projectId}'`,
-          code: "NOT_FOUND"
-        };
-      }
-      if (Object.keys(data).length === 0) {
-        return {
-          success: false,
-          error: "At least one field to update is required",
-          code: "VALIDATION_ERROR"
-        };
-      }
-      if (data.name) {
-        const existingTag2 = projectData.tags.find(
-          (t) => t.name.toLowerCase() === data.name.toLowerCase() && t.id !== tagId
-        );
-        if (existingTag2) {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const tagIndex = projectData.tags.findIndex((t) => t.id === tagId);
+        if (tagIndex === -1) {
           return {
-            success: false,
-            error: `Tag with name '${data.name}' already exists in this project`,
-            code: "DUPLICATE_ERROR"
+            result: {
+              success: false,
+              error: `Tag with ID '${tagId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
           };
         }
-      }
-      if (data.color && !HEX_COLOR_PATTERN.test(data.color)) {
+        if (Object.keys(data).length === 0) {
+          return {
+            result: {
+              success: false,
+              error: "At least one field to update is required",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        if (data.name) {
+          const existingTag2 = projectData.tags.find(
+            (t) => t.name.toLowerCase() === data.name.toLowerCase() && t.id !== tagId
+          );
+          if (existingTag2) {
+            return {
+              result: {
+                success: false,
+                error: `Tag with name '${data.name}' already exists in this project`,
+                code: "DUPLICATE_ERROR"
+              },
+              shouldSave: false
+            };
+          }
+        }
+        if (data.color && !HEX_COLOR_PATTERN.test(data.color)) {
+          return {
+            result: {
+              success: false,
+              error: `Color must be a valid hex code (e.g., #FF5733), received '${data.color}'`,
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const existingTag = projectData.tags[tagIndex];
+        const updatedTag = {
+          ...existingTag,
+          ...data,
+          id: existingTag.id,
+          createdAt: existingTag.createdAt
+        };
+        projectData.tags[tagIndex] = updatedTag;
+        projectData.project.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return {
+          result: {
+            success: true,
+            data: updatedTag
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
         return {
           success: false,
-          error: `Color must be a valid hex code (e.g., #FF5733), received '${data.color}'`,
-          code: "VALIDATION_ERROR"
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
         };
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const existingTag = projectData.tags[tagIndex];
-      const updatedTag = {
-        ...existingTag,
-        ...data,
-        id: existingTag.id,
-        createdAt: existingTag.createdAt
-      };
-      projectData.tags[tagIndex] = updatedTag;
-      projectData.project.updatedAt = now;
-      await this.saveProjectData(projectId, projectData);
-      return {
-        success: true,
-        data: updatedTag
-      };
+      return result;
     } catch (error) {
       return {
         success: false,
@@ -765,44 +806,51 @@ var TagService = class {
    */
   async delete(projectId, tagId) {
     try {
-      const projectData = await this.storage.readProject(projectId);
-      if (!projectData) {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const tagIndex = projectData.tags.findIndex((t) => t.id === tagId);
+        if (tagIndex === -1) {
+          return {
+            result: {
+              success: false,
+              error: `Tag with ID '${tagId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        const tag = projectData.tags[tagIndex];
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        let tasksUpdated = 0;
+        for (const task of projectData.tasks) {
+          const tagIndexInTask = task.tags.indexOf(tagId);
+          if (tagIndexInTask !== -1) {
+            task.tags.splice(tagIndexInTask, 1);
+            task.updatedAt = now;
+            tasksUpdated++;
+          }
+        }
+        projectData.tags.splice(tagIndex, 1);
+        projectData.project.updatedAt = now;
         return {
-          success: false,
-          error: `Project with ID '${projectId}' not found`,
-          code: "NOT_FOUND"
+          result: {
+            success: true,
+            data: {
+              deleted: true,
+              tag,
+              tasksUpdated
+            }
+          },
+          shouldSave: true
         };
-      }
-      const tagIndex = projectData.tags.findIndex((t) => t.id === tagId);
-      if (tagIndex === -1) {
+      });
+      if (result === null) {
         return {
           success: false,
-          error: `Tag with ID '${tagId}' not found in project '${projectId}'`,
+          error: `Project with ID '${projectId}' not found`,
           code: "NOT_FOUND"
         };
       }
-      const tag = projectData.tags[tagIndex];
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      let tasksUpdated = 0;
-      for (const task of projectData.tasks) {
-        const tagIndexInTask = task.tags.indexOf(tagId);
-        if (tagIndexInTask !== -1) {
-          task.tags.splice(tagIndexInTask, 1);
-          task.updatedAt = now;
-          tasksUpdated++;
-        }
-      }
-      projectData.tags.splice(tagIndex, 1);
-      projectData.project.updatedAt = now;
-      await this.saveProjectData(projectId, projectData);
-      return {
-        success: true,
-        data: {
-          deleted: true,
-          tag,
-          tasksUpdated
-        }
-      };
+      return result;
     } catch (error) {
       return {
         success: false,
@@ -854,21 +902,9 @@ var TagService = class {
       };
     }
   }
-  /**
-   * Helper method to save project data
-   * @param projectId - The project ID
-   * @param projectData - The project data to save
-   */
-  async saveProjectData(projectId, projectData) {
-    const filePath = this.storage.getFilePath(projectId);
-    const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-    await writeJsonFile2(filePath, projectData);
-  }
 };
 
 // src/services/task-service.ts
-init_esm_shims();
-init_file_helpers();
 function generateTaskId() {
   return `task_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
@@ -897,46 +933,52 @@ var TaskService = {
    */
   async create(projectId, data) {
     try {
-      const projectData = await storage.readProject(projectId);
-      if (!projectData) {
+      const result = await storage.mutateProject(projectId, async (projectData) => {
+        const incomingTagIds = data.tags ?? [];
+        const invalidTagIds = findInvalidTagIds(projectData, incomingTagIds);
+        if (invalidTagIds.length > 0) {
+          return {
+            result: {
+              success: false,
+              error: `Invalid tag IDs for project '${projectId}': ${invalidTagIds.join(", ")}`,
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const task = {
+          id: generateTaskId(),
+          projectId,
+          title: data.title,
+          description: data.description,
+          status: "todo",
+          priority: data.priority ?? "medium",
+          tags: incomingTagIds,
+          dueDate: data.dueDate ?? null,
+          assignee: data.assignee ?? null,
+          createdAt: now,
+          updatedAt: now,
+          completedAt: null
+        };
+        projectData.tasks.push(task);
+        projectData.project.updatedAt = now;
         return {
-          success: false,
-          error: `Project with ID '${projectId}' not found`,
-          code: "NOT_FOUND"
+          result: {
+            success: true,
+            data: task
+          },
+          shouldSave: true
         };
-      }
-      const incomingTagIds = data.tags ?? [];
-      const invalidTagIds = findInvalidTagIds(projectData, incomingTagIds);
-      if (invalidTagIds.length > 0) {
+      });
+      if (result === null) {
         return {
           success: false,
-          error: `Invalid tag IDs for project '${projectId}': ${invalidTagIds.join(", ")}`,
-          code: "VALIDATION_ERROR"
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
         };
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const task = {
-        id: generateTaskId(),
-        projectId,
-        title: data.title,
-        description: data.description,
-        status: "todo",
-        priority: data.priority ?? "medium",
-        tags: incomingTagIds,
-        dueDate: data.dueDate ?? null,
-        assignee: data.assignee ?? null,
-        createdAt: now,
-        updatedAt: now,
-        completedAt: null
-      };
-      projectData.tasks.push(task);
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(projectId);
-      await writeJsonFile(filePath, projectData);
-      return {
-        success: true,
-        data: task
-      };
+      return result;
     } catch (error) {
       return {
         success: false,
@@ -991,65 +1033,77 @@ var TaskService = {
    */
   async update(projectId, taskId, data) {
     try {
-      const projectData = await storage.readProject(projectId);
-      if (!projectData) {
-        return {
-          success: false,
-          error: `Project with ID '${projectId}' not found`,
-          code: "NOT_FOUND"
-        };
-      }
-      const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
-      if (taskIndex === -1) {
-        return {
-          success: false,
-          error: `Task with ID '${taskId}' not found in project '${projectId}'`,
-          code: "NOT_FOUND"
-        };
-      }
-      const updateKeys = Object.keys(data);
-      if (updateKeys.length === 0) {
-        return {
-          success: false,
-          error: "At least one field to update is required",
-          code: "VALIDATION_ERROR"
-        };
-      }
-      if (data.tags) {
-        const invalidTagIds = findInvalidTagIds(projectData, data.tags);
-        if (invalidTagIds.length > 0) {
+      const result = await storage.mutateProject(projectId, async (projectData) => {
+        const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
+        if (taskIndex === -1) {
           return {
-            success: false,
-            error: `Invalid tag IDs for project '${projectId}': ${invalidTagIds.join(", ")}`,
-            code: "VALIDATION_ERROR"
+            result: {
+              success: false,
+              error: `Task with ID '${taskId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
           };
         }
+        const updateKeys = Object.keys(data);
+        if (updateKeys.length === 0) {
+          return {
+            result: {
+              success: false,
+              error: "At least one field to update is required",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        if (data.tags) {
+          const invalidTagIds = findInvalidTagIds(projectData, data.tags);
+          if (invalidTagIds.length > 0) {
+            return {
+              result: {
+                success: false,
+                error: `Invalid tag IDs for project '${projectId}': ${invalidTagIds.join(", ")}`,
+                code: "VALIDATION_ERROR"
+              },
+              shouldSave: false
+            };
+          }
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const existingTask = projectData.tasks[taskIndex];
+        const completedAt = calculateCompletedAt(
+          existingTask.status,
+          data.status,
+          existingTask.completedAt,
+          now
+        );
+        const updatedTask = {
+          ...existingTask,
+          ...data,
+          id: existingTask.id,
+          projectId: existingTask.projectId,
+          createdAt: existingTask.createdAt,
+          updatedAt: now,
+          completedAt
+        };
+        projectData.tasks[taskIndex] = updatedTask;
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: updatedTask
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const existingTask = projectData.tasks[taskIndex];
-      const completedAt = calculateCompletedAt(
-        existingTask.status,
-        data.status,
-        existingTask.completedAt,
-        now
-      );
-      const updatedTask = {
-        ...existingTask,
-        ...data,
-        id: existingTask.id,
-        projectId: existingTask.projectId,
-        createdAt: existingTask.createdAt,
-        updatedAt: now,
-        completedAt
-      };
-      projectData.tasks[taskIndex] = updatedTask;
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(projectId);
-      await writeJsonFile(filePath, projectData);
-      return {
-        success: true,
-        data: updatedTask
-      };
+      return result;
     } catch (error) {
       return {
         success: false,
@@ -1066,31 +1120,37 @@ var TaskService = {
    */
   async delete(projectId, taskId) {
     try {
-      const projectData = await storage.readProject(projectId);
-      if (!projectData) {
+      const result = await storage.mutateProject(projectId, async (projectData) => {
+        const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
+        if (taskIndex === -1) {
+          return {
+            result: {
+              success: false,
+              error: `Task with ID '${taskId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        projectData.tasks.splice(taskIndex, 1);
+        projectData.project.updatedAt = now;
         return {
-          success: false,
-          error: `Project with ID '${projectId}' not found`,
-          code: "NOT_FOUND"
+          result: {
+            success: true,
+            data: void 0
+          },
+          shouldSave: true
         };
-      }
-      const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
-      if (taskIndex === -1) {
+      });
+      if (result === null) {
         return {
           success: false,
-          error: `Task with ID '${taskId}' not found in project '${projectId}'`,
+          error: `Project with ID '${projectId}' not found`,
           code: "NOT_FOUND"
         };
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      projectData.tasks.splice(taskIndex, 1);
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(projectId);
-      await writeJsonFile(filePath, projectData);
-      return {
-        success: true,
-        data: void 0
-      };
+      return result;
     } catch (error) {
       return {
         success: false,
@@ -1138,7 +1198,996 @@ var TaskService = {
    */
   async batchUpdate(projectId, taskIds, data) {
     try {
-      const projectData = await storage.readProject(projectId);
+      const result = await storage.mutateProject(projectId, async (projectData) => {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const updatedTasks = [];
+        const notFoundIds = [];
+        for (const taskId of taskIds) {
+          const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
+          if (taskIndex === -1) {
+            notFoundIds.push(taskId);
+            continue;
+          }
+          const existingTask = projectData.tasks[taskIndex];
+          let updatedTags = existingTask.tags ?? [];
+          if (data.tags) {
+            const invalidTagIds = findInvalidTagIds(projectData, data.tags);
+            if (invalidTagIds.length > 0) {
+              return {
+                result: {
+                  success: false,
+                  error: `Invalid tag IDs for project '${projectId}': ${invalidTagIds.join(", ")}`,
+                  code: "VALIDATION_ERROR"
+                },
+                shouldSave: false
+              };
+            }
+          }
+          if (data.tags) {
+            const existingTags = existingTask.tags ?? [];
+            switch (data.tagOperation) {
+              case "add":
+                updatedTags = [.../* @__PURE__ */ new Set([...existingTags, ...data.tags])];
+                break;
+              case "remove":
+                updatedTags = existingTags.filter((tag) => !data.tags.includes(tag));
+                break;
+              case "replace":
+              default:
+                updatedTags = data.tags;
+                break;
+            }
+          }
+          const completedAt = calculateCompletedAt(
+            existingTask.status,
+            data.status,
+            existingTask.completedAt,
+            now
+          );
+          const updatedTask = {
+            ...existingTask,
+            ...data.status && { status: data.status },
+            ...data.priority && { priority: data.priority },
+            tags: updatedTags,
+            updatedAt: now,
+            completedAt
+          };
+          projectData.tasks[taskIndex] = updatedTask;
+          updatedTasks.push(updatedTask);
+        }
+        if (updatedTasks.length === 0) {
+          return {
+            result: {
+              success: false,
+              error: "No tasks were found to update",
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: {
+              updatedTasks,
+              updatedCount: updatedTasks.length,
+              notFoundIds: notFoundIds.length > 0 ? notFoundIds : void 0
+            }
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to batch update tasks",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+};
+
+// src/services/dependency-view-service.ts
+function generateDependencyViewId() {
+  return `depview_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function generateDependencyViewEdgeId() {
+  return `depedge_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function getDependencyViews(projectData) {
+  if (!projectData.dependencyViews) {
+    projectData.dependencyViews = [];
+  }
+  return projectData.dependencyViews;
+}
+function findView(projectData, viewId) {
+  return getDependencyViews(projectData).find((view) => view.id === viewId);
+}
+function cloneView(view) {
+  return {
+    ...view,
+    nodes: view.nodes.map((node) => ({ ...node })),
+    edges: view.edges.map((edge) => ({ ...edge }))
+  };
+}
+function applyNodeUpdate(node, data) {
+  if (data.x !== void 0) {
+    node.x = data.x;
+  }
+  if (data.y !== void 0) {
+    node.y = data.y;
+  }
+  if (data.collapsed !== void 0) {
+    node.collapsed = data.collapsed;
+  }
+  if (data.note !== void 0) {
+    node.note = data.note;
+  }
+}
+function createMutationChanges(partial) {
+  return {
+    addedNodeIds: partial?.addedNodeIds ?? [],
+    updatedNodeIds: partial?.updatedNodeIds ?? [],
+    removedNodeIds: partial?.removedNodeIds ?? [],
+    addedEdgeIds: partial?.addedEdgeIds ?? [],
+    updatedEdgeIds: partial?.updatedEdgeIds ?? [],
+    removedEdgeIds: partial?.removedEdgeIds ?? []
+  };
+}
+function buildAdjacency(view) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of view.nodes) {
+    adjacency.set(node.taskId, []);
+  }
+  for (const edge of view.edges) {
+    const neighbors = adjacency.get(edge.fromTaskId);
+    if (neighbors) {
+      neighbors.push(edge.toTaskId);
+    }
+  }
+  return adjacency;
+}
+function canReach(adjacency, startId, targetId) {
+  if (startId === targetId) {
+    return true;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [startId];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const neighbors = adjacency.get(current) ?? [];
+    for (const neighbor of neighbors) {
+      if (neighbor === targetId) {
+        return true;
+      }
+      if (!visited.has(neighbor)) {
+        stack.push(neighbor);
+      }
+    }
+  }
+  return false;
+}
+function analyzeDependencyView(view) {
+  const nodeIds = view.nodes.map((node) => node.taskId);
+  const adjacency = buildAdjacency(view);
+  const indegree = new Map(nodeIds.map((nodeId) => [nodeId, 0]));
+  const outgoing = new Map(nodeIds.map((nodeId) => [nodeId, 0]));
+  for (const edge of view.edges) {
+    indegree.set(edge.toTaskId, (indegree.get(edge.toTaskId) ?? 0) + 1);
+    outgoing.set(edge.fromTaskId, (outgoing.get(edge.fromTaskId) ?? 0) + 1);
+  }
+  const queue = nodeIds.filter((nodeId) => (indegree.get(nodeId) ?? 0) === 0);
+  const indegreeCopy = new Map(indegree);
+  const topologicalOrder = [];
+  const layerByTask = /* @__PURE__ */ new Map();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+    topologicalOrder.push(current);
+    const currentLayer = layerByTask.get(current) ?? 0;
+    const neighbors = adjacency.get(current) ?? [];
+    for (const neighbor of neighbors) {
+      layerByTask.set(neighbor, Math.max(layerByTask.get(neighbor) ?? 0, currentLayer + 1));
+      const nextIndegree = (indegreeCopy.get(neighbor) ?? 0) - 1;
+      indegreeCopy.set(neighbor, nextIndegree);
+      if (nextIndegree === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+  const layers = [];
+  for (const nodeId of topologicalOrder) {
+    const layerIndex = layerByTask.get(nodeId) ?? 0;
+    if (!layers[layerIndex]) {
+      layers[layerIndex] = [];
+    }
+    layers[layerIndex].push(nodeId);
+  }
+  return {
+    viewId: view.id,
+    revision: view.revision,
+    topologicalOrder,
+    layers,
+    readyTaskIds: nodeIds.filter((nodeId) => (indegree.get(nodeId) ?? 0) === 0),
+    blockedTaskIds: nodeIds.filter((nodeId) => (indegree.get(nodeId) ?? 0) > 0),
+    roots: nodeIds.filter((nodeId) => (indegree.get(nodeId) ?? 0) === 0),
+    leaves: nodeIds.filter((nodeId) => (outgoing.get(nodeId) ?? 0) === 0),
+    isolatedTaskIds: nodeIds.filter(
+      (nodeId) => (indegree.get(nodeId) ?? 0) === 0 && (outgoing.get(nodeId) ?? 0) === 0
+    )
+  };
+}
+var DependencyViewService = class {
+  storage;
+  constructor(storage2) {
+    this.storage = storage2;
+  }
+  async create(projectId, data) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const views = getDependencyViews(projectData);
+        const name = data.name.trim();
+        if (!name) {
+          return {
+            result: {
+              success: false,
+              error: "Dependency view name is required",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const view = {
+          id: generateDependencyViewId(),
+          projectId,
+          name,
+          description: data.description,
+          dimension: data.dimension ?? null,
+          createdAt: now,
+          updatedAt: now,
+          revision: 1,
+          nodes: [],
+          edges: []
+        };
+        views.push(view);
+        projectData.project.updatedAt = now;
+        return {
+          result: { success: true, data: view },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create dependency view",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async list(projectId) {
+    try {
+      const projectData = await this.storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return { success: true, data: getDependencyViews(projectData).map(cloneView) };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list dependency views",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async get(projectId, viewId) {
+    try {
+      const projectData = await this.storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      const view = findView(projectData, viewId);
+      if (!view) {
+        return {
+          success: false,
+          error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+          code: "NOT_FOUND"
+        };
+      }
+      return { success: true, data: cloneView(view) };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get dependency view",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async update(projectId, viewId, data) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        if (Object.keys(data).length === 0) {
+          return {
+            result: {
+              success: false,
+              error: "At least one field to update is required",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const view = findView(projectData, viewId);
+        if (!view) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        if (data.name !== void 0 && !data.name.trim()) {
+          return {
+            result: {
+              success: false,
+              error: "Dependency view name cannot be empty",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        view.name = data.name?.trim() ?? view.name;
+        if (data.description !== void 0) {
+          view.description = data.description;
+        }
+        if (data.dimension !== void 0) {
+          view.dimension = data.dimension;
+        }
+        view.updatedAt = now;
+        view.revision += 1;
+        projectData.project.updatedAt = now;
+        return {
+          result: { success: true, data: cloneView(view) },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update dependency view",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async delete(projectId, viewId) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const views = getDependencyViews(projectData);
+        const viewIndex = views.findIndex((view) => view.id === viewId);
+        if (viewIndex === -1) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        views.splice(viewIndex, 1);
+        projectData.project.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return {
+          result: { success: true, data: void 0 },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to delete dependency view",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async addNode(projectId, viewId, data) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const view = findView(projectData, viewId);
+        if (!view) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        const task = projectData.tasks.find((item) => item.id === data.taskId);
+        if (!task) {
+          return {
+            result: {
+              success: false,
+              error: `Task with ID '${data.taskId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        if (view.nodes.some((node2) => node2.taskId === data.taskId)) {
+          return {
+            result: {
+              success: false,
+              error: `Task '${data.taskId}' is already in dependency view '${viewId}'`,
+              code: "DUPLICATE_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const node = {
+          taskId: data.taskId,
+          x: data.x ?? 0,
+          y: data.y ?? 0,
+          collapsed: data.collapsed ?? false,
+          note: data.note ?? null
+        };
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        view.nodes.push(node);
+        view.updatedAt = now;
+        view.revision += 1;
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: {
+              view: cloneView(view),
+              changes: createMutationChanges({ addedNodeIds: [data.taskId] })
+            }
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to add task to dependency view",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async updateNode(projectId, viewId, taskId, data) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        if (Object.keys(data).length === 0) {
+          return {
+            result: {
+              success: false,
+              error: "At least one node field to update is required",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const view = findView(projectData, viewId);
+        if (!view) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        const node = view.nodes.find((item) => item.taskId === taskId);
+        if (!node) {
+          return {
+            result: {
+              success: false,
+              error: `Task '${taskId}' is not present in dependency view '${viewId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        applyNodeUpdate(node, data);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        view.updatedAt = now;
+        view.revision += 1;
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: {
+              view: cloneView(view),
+              changes: createMutationChanges({ updatedNodeIds: [taskId] })
+            }
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update dependency view node",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async batchUpdateNodes(projectId, viewId, data) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        if (data.nodes.length === 0) {
+          return {
+            result: {
+              success: false,
+              error: "At least one node update is required",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const view = findView(projectData, viewId);
+        if (!view) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        for (const nodeUpdate of data.nodes) {
+          const node = view.nodes.find((item) => item.taskId === nodeUpdate.taskId);
+          if (!node) {
+            return {
+              result: {
+                success: false,
+                error: `Task '${nodeUpdate.taskId}' is not present in dependency view '${viewId}'`,
+                code: "NOT_FOUND"
+              },
+              shouldSave: false
+            };
+          }
+          applyNodeUpdate(node, nodeUpdate);
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        view.updatedAt = now;
+        view.revision += 1;
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: {
+              view: cloneView(view),
+              changes: createMutationChanges({
+                updatedNodeIds: [...new Set(data.nodes.map((node) => node.taskId))]
+              })
+            }
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to batch update dependency view nodes",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async removeNode(projectId, viewId, taskId) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const view = findView(projectData, viewId);
+        if (!view) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        const nodeIndex = view.nodes.findIndex((node) => node.taskId === taskId);
+        if (nodeIndex === -1) {
+          return {
+            result: {
+              success: false,
+              error: `Task '${taskId}' is not present in dependency view '${viewId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        view.nodes.splice(nodeIndex, 1);
+        const removedEdgeIds = view.edges.filter((edge) => edge.fromTaskId === taskId || edge.toTaskId === taskId).map((edge) => edge.id);
+        view.edges = view.edges.filter((edge) => edge.fromTaskId !== taskId && edge.toTaskId !== taskId);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        view.updatedAt = now;
+        view.revision += 1;
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: {
+              view: cloneView(view),
+              changes: createMutationChanges({
+                removedNodeIds: [taskId],
+                removedEdgeIds
+              })
+            }
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to remove task from dependency view",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async addEdge(projectId, viewId, data) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const view = findView(projectData, viewId);
+        if (!view) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        if (data.fromTaskId === data.toTaskId) {
+          return {
+            result: {
+              success: false,
+              error: "A task cannot depend on itself",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const nodeIds = new Set(view.nodes.map((node) => node.taskId));
+        if (!nodeIds.has(data.fromTaskId) || !nodeIds.has(data.toTaskId)) {
+          return {
+            result: {
+              success: false,
+              error: "Both tasks must be present in the dependency view before connecting them",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const duplicateEdge = view.edges.find(
+          (edge2) => edge2.fromTaskId === data.fromTaskId && edge2.toTaskId === data.toTaskId
+        );
+        if (duplicateEdge) {
+          return {
+            result: {
+              success: false,
+              error: "That dependency already exists in the view",
+              code: "DUPLICATE_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const adjacency = buildAdjacency(view);
+        if (canReach(adjacency, data.toTaskId, data.fromTaskId)) {
+          return {
+            result: {
+              success: false,
+              error: "Adding this dependency would create a cycle",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const edge = {
+          id: generateDependencyViewEdgeId(),
+          fromTaskId: data.fromTaskId,
+          toTaskId: data.toTaskId,
+          kind: "hard",
+          createdAt: now
+        };
+        view.edges.push(edge);
+        view.updatedAt = now;
+        view.revision += 1;
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: {
+              view: cloneView(view),
+              changes: createMutationChanges({ addedEdgeIds: [edge.id] })
+            }
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to add dependency edge",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async updateEdge(projectId, viewId, edgeId, data) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        if (Object.keys(data).length === 0) {
+          return {
+            result: {
+              success: false,
+              error: "At least one edge field to update is required",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const view = findView(projectData, viewId);
+        if (!view) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        const edge = view.edges.find((item) => item.id === edgeId);
+        if (!edge) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency edge with ID '${edgeId}' not found in view '${viewId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        const nextFromTaskId = data.fromTaskId ?? edge.fromTaskId;
+        const nextToTaskId = data.toTaskId ?? edge.toTaskId;
+        if (nextFromTaskId === nextToTaskId) {
+          return {
+            result: {
+              success: false,
+              error: "A task cannot depend on itself",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const nodeIds = new Set(view.nodes.map((node) => node.taskId));
+        if (!nodeIds.has(nextFromTaskId) || !nodeIds.has(nextToTaskId)) {
+          return {
+            result: {
+              success: false,
+              error: "Both tasks must be present in the dependency view before updating an edge",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const duplicateEdge = view.edges.find(
+          (item) => item.id !== edgeId && item.fromTaskId === nextFromTaskId && item.toTaskId === nextToTaskId
+        );
+        if (duplicateEdge) {
+          return {
+            result: {
+              success: false,
+              error: "That dependency already exists in the view",
+              code: "DUPLICATE_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        const adjacency = buildAdjacency({
+          ...view,
+          edges: view.edges.filter((item) => item.id !== edgeId).map((item) => ({ ...item }))
+        });
+        if (canReach(adjacency, nextToTaskId, nextFromTaskId)) {
+          return {
+            result: {
+              success: false,
+              error: "Updating this dependency would create a cycle",
+              code: "VALIDATION_ERROR"
+            },
+            shouldSave: false
+          };
+        }
+        edge.fromTaskId = nextFromTaskId;
+        edge.toTaskId = nextToTaskId;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        view.updatedAt = now;
+        view.revision += 1;
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: {
+              view: cloneView(view),
+              changes: createMutationChanges({ updatedEdgeIds: [edgeId] })
+            }
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update dependency edge",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async removeEdge(projectId, viewId, edgeId) {
+    try {
+      const result = await this.storage.mutateProject(projectId, async (projectData) => {
+        const view = findView(projectData, viewId);
+        if (!view) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        const edgeIndex = view.edges.findIndex((edge) => edge.id === edgeId);
+        if (edgeIndex === -1) {
+          return {
+            result: {
+              success: false,
+              error: `Dependency edge with ID '${edgeId}' not found in view '${viewId}'`,
+              code: "NOT_FOUND"
+            },
+            shouldSave: false
+          };
+        }
+        view.edges.splice(edgeIndex, 1);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        view.updatedAt = now;
+        view.revision += 1;
+        projectData.project.updatedAt = now;
+        return {
+          result: {
+            success: true,
+            data: {
+              view: cloneView(view),
+              changes: createMutationChanges({ removedEdgeIds: [edgeId] })
+            }
+          },
+          shouldSave: true
+        };
+      });
+      if (result === null) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to remove dependency edge",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  async analyze(projectId, viewId) {
+    try {
+      const projectData = await this.storage.readProject(projectId);
       if (!projectData) {
         return {
           success: false,
@@ -1146,90 +2195,28 @@ var TaskService = {
           code: "NOT_FOUND"
         };
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const updatedTasks = [];
-      const notFoundIds = [];
-      for (const taskId of taskIds) {
-        const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
-        if (taskIndex === -1) {
-          notFoundIds.push(taskId);
-          continue;
-        }
-        const existingTask = projectData.tasks[taskIndex];
-        let updatedTags = existingTask.tags ?? [];
-        if (data.tags) {
-          const invalidTagIds = findInvalidTagIds(projectData, data.tags);
-          if (invalidTagIds.length > 0) {
-            return {
-              success: false,
-              error: `Invalid tag IDs for project '${projectId}': ${invalidTagIds.join(", ")}`,
-              code: "VALIDATION_ERROR"
-            };
-          }
-        }
-        if (data.tags) {
-          const existingTags = existingTask.tags ?? [];
-          switch (data.tagOperation) {
-            case "add":
-              updatedTags = [.../* @__PURE__ */ new Set([...existingTags, ...data.tags])];
-              break;
-            case "remove":
-              updatedTags = existingTags.filter((tag) => !data.tags.includes(tag));
-              break;
-            case "replace":
-            default:
-              updatedTags = data.tags;
-              break;
-          }
-        }
-        const completedAt = calculateCompletedAt(
-          existingTask.status,
-          data.status,
-          existingTask.completedAt,
-          now
-        );
-        const updatedTask = {
-          ...existingTask,
-          ...data.status && { status: data.status },
-          ...data.priority && { priority: data.priority },
-          tags: updatedTags,
-          updatedAt: now,
-          completedAt
-        };
-        projectData.tasks[taskIndex] = updatedTask;
-        updatedTasks.push(updatedTask);
-      }
-      if (updatedTasks.length === 0) {
+      const view = findView(projectData, viewId);
+      if (!view) {
         return {
           success: false,
-          error: "No tasks were found to update",
+          error: `Dependency view with ID '${viewId}' not found in project '${projectId}'`,
           code: "NOT_FOUND"
         };
       }
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(projectId);
-      await writeJsonFile(filePath, projectData);
       return {
         success: true,
-        data: {
-          updatedTasks,
-          updatedCount: updatedTasks.length,
-          notFoundIds: notFoundIds.length > 0 ? notFoundIds : void 0
-        }
+        data: analyzeDependencyView(view)
       };
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Failed to batch update tasks",
+        error: error instanceof Error ? error.message : "Failed to analyze dependency view",
         code: "INTERNAL_ERROR"
       };
     }
   }
 };
 
-// src/services/types.ts
-init_esm_shims();
-
 // src/tools/task-tools.ts
 var TaskStatusEnum = z2.enum(["todo", "in-progress", "review", "done"]);
 var TaskPriorityEnum = z2.enum(["low", "medium", "high", "critical"]);
@@ -1396,104 +2383,461 @@ var batchUpdateTasksTool = {
     };
   }
 };
-
-// src/tools/tag-tools.ts
-init_esm_shims();
-import { z as z3 } from "zod";
-var tagService = new TagService(storage);
-var createTagTool = {
-  name: "create_tag",
-  description: "Create a new tag in a project. If color is omitted, it is generated deterministically from tag name.",
-  inputSchema: z3.object({
-    projectId: z3.string().min(1, "Project ID is required"),
-    name: z3.string().min(1, "Tag name is required"),
-    color: z3.string().regex(/^#[0-9A-Fa-f]{6}$/, "Color must be a valid hex code (e.g., #FF5733)").optional(),
-    description: z3.string().default("")
+
+// src/tools/tag-tools.ts
+import { z as z3 } from "zod";
+var tagService = new TagService(storage);
+var createTagTool = {
+  name: "create_tag",
+  description: "Create a new tag in a project. If color is omitted, it is generated deterministically from tag name.",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required"),
+    name: z3.string().min(1, "Tag name is required"),
+    color: z3.string().regex(/^#[0-9A-Fa-f]{6}$/, "Color must be a valid hex code (e.g., #FF5733)").optional(),
+    description: z3.string().default("")
+  }),
+  async execute(input) {
+    const { projectId, ...data } = input;
+    const result = await tagService.create(projectId, data);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    return { success: true, data: result.data };
+  }
+};
+var listTagsTool = {
+  name: "list_tags",
+  description: "List all tags in a project",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required")
+  }),
+  async execute(input) {
+    const result = await tagService.list(input.projectId);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    return { success: true, data: result.data };
+  }
+};
+var updateTagTool = {
+  name: "update_tag",
+  description: "Update an existing tag",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required"),
+    tagId: z3.string().min(1, "Tag ID is required"),
+    name: z3.string().min(1).optional(),
+    color: z3.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+    description: z3.string().optional()
+  }),
+  async execute(input) {
+    const { projectId, tagId, ...data } = input;
+    const result = await tagService.update(projectId, tagId, data);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    return { success: true, data: result.data };
+  }
+};
+var deleteTagTool = {
+  name: "delete_tag",
+  description: "Delete a tag by project ID and tag ID",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required"),
+    tagId: z3.string().min(1, "Tag ID is required")
+  }),
+  async execute(input) {
+    const result = await tagService.delete(input.projectId, input.tagId);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    return { success: true, data: result.data };
+  }
+};
+var getTasksByTagTool = {
+  name: "get_tasks_by_tag",
+  description: "Get all tasks that have a specific tag",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required"),
+    tagName: z3.string().min(1, "Tag name is required")
+  }),
+  async execute(input) {
+    const result = await tagService.getTasksByTag(input.projectId, input.tagName);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    return { success: true, data: result.data };
+  }
+};
+
+// src/tools/dependency-view-tools.ts
+import { z as z4 } from "zod";
+var dependencyViewService = new DependencyViewService(storage);
+function toDependencyViewSummary(view) {
+  return {
+    id: view.id,
+    projectId: view.projectId,
+    name: view.name,
+    description: view.description,
+    dimension: view.dimension,
+    revision: view.revision,
+    nodeCount: view.nodes.length,
+    edgeCount: view.edges.length
+  };
+}
+function toTaskSummary3(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    priority: task.priority,
+    dueDate: task.dueDate,
+    assignee: task.assignee,
+    tags: [...task.tags]
+  };
+}
+function toAgentDependencyView(view, tasks) {
+  const tasksById = new Map(tasks.map((task) => [task.id, task]));
+  return {
+    ...toDependencyViewSummary(view),
+    nodes: view.nodes.flatMap((node) => {
+      const task = tasksById.get(node.taskId);
+      if (!task) {
+        return [];
+      }
+      return [{
+        taskId: node.taskId,
+        task: toTaskSummary3(task)
+      }];
+    }),
+    edges: view.edges.map((edge) => ({
+      id: edge.id,
+      fromTaskId: edge.fromTaskId,
+      toTaskId: edge.toTaskId
+    }))
+  };
+}
+function toDependencyViewMutationResult(mutation) {
+  return {
+    ...toDependencyViewSummary(mutation.view),
+    changes: mutation.changes
+  };
+}
+var NullableString = z4.string().nullable();
+var createDependencyViewTool = {
+  name: "create_dependency_view",
+  description: "Create a dependency planning view inside a project. Returns summary by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    name: z4.string().min(1, "View name is required"),
+    description: z4.string().default(""),
+    dimension: NullableString.optional(),
+    verbose: z4.boolean().optional()
+  }),
+  async execute(input) {
+    const result = await dependencyViewService.create(input.projectId, input);
+    if (!result.success) {
+      return result;
+    }
+    return {
+      success: true,
+      data: input.verbose ? result.data : toDependencyViewSummary(result.data)
+    };
+  }
+};
+var listDependencyViewsTool = {
+  name: "list_dependency_views",
+  description: "List dependency planning views in a project. Returns summaries by default; set includeTasks=true for Agent-friendly task snapshots or verbose=true for raw node and edge data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    includeTasks: z4.boolean().optional(),
+    verbose: z4.boolean().optional()
+  }),
+  async execute(input) {
+    const result = await dependencyViewService.list(input.projectId);
+    if (!result.success) {
+      return result;
+    }
+    if (input.verbose) {
+      return {
+        success: true,
+        data: result.data
+      };
+    }
+    if (input.includeTasks) {
+      const projectData = await storage.readProject(input.projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${input.projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      return {
+        success: true,
+        data: result.data.map((view) => toAgentDependencyView(view, projectData.tasks))
+      };
+    }
+    return {
+      success: true,
+      data: result.data.map(toDependencyViewSummary)
+    };
+  }
+};
+var getDependencyViewTool = {
+  name: "get_dependency_view",
+  description: "Get a dependency planning view by project ID and view ID. Returns Agent-friendly task snapshots by default; set verbose=true for raw node and edge data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    verbose: z4.boolean().optional()
+  }),
+  async execute(input) {
+    const result = await dependencyViewService.get(input.projectId, input.viewId);
+    if (!result.success) {
+      return result;
+    }
+    if (input.verbose) {
+      return {
+        success: true,
+        data: result.data
+      };
+    }
+    const projectData = await storage.readProject(input.projectId);
+    if (!projectData) {
+      return {
+        success: false,
+        error: `Project with ID '${input.projectId}' not found`,
+        code: "NOT_FOUND"
+      };
+    }
+    return {
+      success: true,
+      data: toAgentDependencyView(result.data, projectData.tasks)
+    };
+  }
+};
+var updateDependencyViewTool = {
+  name: "update_dependency_view",
+  description: "Update dependency planning view metadata. Returns summary by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    name: z4.string().min(1).optional(),
+    description: z4.string().optional(),
+    dimension: NullableString.optional(),
+    verbose: z4.boolean().optional()
+  }),
+  async execute(input) {
+    const { projectId, viewId, verbose, ...updateData } = input;
+    const result = await dependencyViewService.update(projectId, viewId, updateData);
+    if (!result.success) {
+      return result;
+    }
+    return {
+      success: true,
+      data: verbose ? result.data : toDependencyViewSummary(result.data)
+    };
+  }
+};
+var deleteDependencyViewTool = {
+  name: "delete_dependency_view",
+  description: "Delete a dependency planning view by project ID and view ID",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required")
+  }),
+  async execute(input) {
+    const result = await dependencyViewService.delete(input.projectId, input.viewId);
+    if (!result.success) {
+      return result;
+    }
+    return {
+      success: true,
+      data: { deleted: true }
+    };
+  }
+};
+var addTaskToDependencyViewTool = {
+  name: "add_task_to_dependency_view",
+  description: "Add an existing task into a dependency planning view. Returns summary plus changed ids by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    taskId: z4.string().min(1, "Task ID is required"),
+    x: z4.number().optional(),
+    y: z4.number().optional(),
+    collapsed: z4.boolean().optional(),
+    note: NullableString.optional(),
+    verbose: z4.boolean().optional()
+  }),
+  async execute(input) {
+    const { projectId, viewId, verbose, ...nodeData } = input;
+    const result = await dependencyViewService.addNode(projectId, viewId, nodeData);
+    if (!result.success) {
+      return result;
+    }
+    return {
+      success: true,
+      data: verbose ? result.data.view : toDependencyViewMutationResult(result.data)
+    };
+  }
+};
+var updateDependencyViewNodeTool = {
+  name: "update_dependency_view_node",
+  description: "Update a task node layout or note inside a dependency planning view. Returns summary plus changed ids by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    taskId: z4.string().min(1, "Task ID is required"),
+    x: z4.number().optional(),
+    y: z4.number().optional(),
+    collapsed: z4.boolean().optional(),
+    note: NullableString.optional(),
+    verbose: z4.boolean().optional()
+  }),
+  async execute(input) {
+    const { projectId, viewId, taskId, verbose, ...nodeData } = input;
+    const result = await dependencyViewService.updateNode(projectId, viewId, taskId, nodeData);
+    if (!result.success) {
+      return result;
+    }
+    return {
+      success: true,
+      data: verbose ? result.data.view : toDependencyViewMutationResult(result.data)
+    };
+  }
+};
+var batchUpdateDependencyViewNodesTool = {
+  name: "batch_update_dependency_view_nodes",
+  description: "Update multiple task node layouts or notes inside a dependency planning view. Returns summary plus changed ids by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    nodes: z4.array(z4.object({
+      taskId: z4.string().min(1, "Task ID is required"),
+      x: z4.number().optional(),
+      y: z4.number().optional(),
+      collapsed: z4.boolean().optional(),
+      note: NullableString.optional()
+    })).min(1, "At least one node update is required"),
+    verbose: z4.boolean().optional()
+  }),
+  async execute(input) {
+    const { projectId, viewId, verbose, ...nodeData } = input;
+    const result = await dependencyViewService.batchUpdateNodes(projectId, viewId, nodeData);
+    if (!result.success) {
+      return result;
+    }
+    return {
+      success: true,
+      data: verbose ? result.data.view : toDependencyViewMutationResult(result.data)
+    };
+  }
+};
+var removeTaskFromDependencyViewTool = {
+  name: "remove_task_from_dependency_view",
+  description: "Remove a task node from a dependency planning view. Connected edges are removed too. Returns summary plus changed ids by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    taskId: z4.string().min(1, "Task ID is required"),
+    verbose: z4.boolean().optional()
   }),
   async execute(input) {
-    const { projectId, ...data } = input;
-    const result = await tagService.create(projectId, data);
+    const result = await dependencyViewService.removeNode(input.projectId, input.viewId, input.taskId);
     if (!result.success) {
-      return { success: false, error: result.error };
+      return result;
     }
-    return { success: true, data: result.data };
+    return {
+      success: true,
+      data: input.verbose ? result.data.view : toDependencyViewMutationResult(result.data)
+    };
   }
 };
-var listTagsTool = {
-  name: "list_tags",
-  description: "List all tags in a project",
-  inputSchema: z3.object({
-    projectId: z3.string().min(1, "Project ID is required")
+var addDependencyViewEdgeTool = {
+  name: "add_dependency_view_edge",
+  description: "Create a dependency edge between two tasks already present in a dependency planning view. Returns summary plus changed ids by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    fromTaskId: z4.string().min(1, "Source task ID is required"),
+    toTaskId: z4.string().min(1, "Target task ID is required"),
+    verbose: z4.boolean().optional()
   }),
   async execute(input) {
-    const result = await tagService.list(input.projectId);
+    const { projectId, viewId, verbose, ...edgeData } = input;
+    const result = await dependencyViewService.addEdge(projectId, viewId, edgeData);
     if (!result.success) {
-      return { success: false, error: result.error };
+      return result;
     }
-    return { success: true, data: result.data };
+    return {
+      success: true,
+      data: verbose ? result.data.view : toDependencyViewMutationResult(result.data)
+    };
   }
 };
-var updateTagTool = {
-  name: "update_tag",
-  description: "Update an existing tag",
-  inputSchema: z3.object({
-    projectId: z3.string().min(1, "Project ID is required"),
-    tagId: z3.string().min(1, "Tag ID is required"),
-    name: z3.string().min(1).optional(),
-    color: z3.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
-    description: z3.string().optional()
+var removeDependencyViewEdgeTool = {
+  name: "remove_dependency_view_edge",
+  description: "Remove a dependency edge from a dependency planning view. Returns summary plus changed ids by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    edgeId: z4.string().min(1, "Edge ID is required"),
+    verbose: z4.boolean().optional()
   }),
   async execute(input) {
-    const { projectId, tagId, ...data } = input;
-    const result = await tagService.update(projectId, tagId, data);
+    const result = await dependencyViewService.removeEdge(input.projectId, input.viewId, input.edgeId);
     if (!result.success) {
-      return { success: false, error: result.error };
+      return result;
     }
-    return { success: true, data: result.data };
+    return {
+      success: true,
+      data: input.verbose ? result.data.view : toDependencyViewMutationResult(result.data)
+    };
   }
 };
-var deleteTagTool = {
-  name: "delete_tag",
-  description: "Delete a tag by project ID and tag ID",
-  inputSchema: z3.object({
-    projectId: z3.string().min(1, "Project ID is required"),
-    tagId: z3.string().min(1, "Tag ID is required")
+var updateDependencyViewEdgeTool = {
+  name: "update_dependency_view_edge",
+  description: "Update the direction of a dependency edge inside a dependency planning view. Returns summary plus changed ids by default; set verbose=true for full data.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required"),
+    edgeId: z4.string().min(1, "Edge ID is required"),
+    fromTaskId: z4.string().min(1).optional(),
+    toTaskId: z4.string().min(1).optional(),
+    verbose: z4.boolean().optional()
   }),
   async execute(input) {
-    const result = await tagService.delete(input.projectId, input.tagId);
+    const { projectId, viewId, edgeId, verbose, ...edgeData } = input;
+    const result = await dependencyViewService.updateEdge(projectId, viewId, edgeId, edgeData);
     if (!result.success) {
-      return { success: false, error: result.error };
+      return result;
     }
-    return { success: true, data: result.data };
+    return {
+      success: true,
+      data: verbose ? result.data.view : toDependencyViewMutationResult(result.data)
+    };
   }
 };
-var getTasksByTagTool = {
-  name: "get_tasks_by_tag",
-  description: "Get all tasks that have a specific tag",
-  inputSchema: z3.object({
-    projectId: z3.string().min(1, "Project ID is required"),
-    tagName: z3.string().min(1, "Tag name is required")
+var analyzeDependencyViewTool = {
+  name: "analyze_dependency_view",
+  description: "Analyze a dependency planning view and return topological layers, ready tasks, blocked tasks, roots, leaves, and isolated tasks.",
+  inputSchema: z4.object({
+    projectId: z4.string().min(1, "Project ID is required"),
+    viewId: z4.string().min(1, "View ID is required")
   }),
   async execute(input) {
-    const result = await tagService.getTasksByTag(input.projectId, input.tagName);
-    if (!result.success) {
-      return { success: false, error: result.error };
-    }
-    return { success: true, data: result.data };
+    return await dependencyViewService.analyze(input.projectId, input.viewId);
   }
 };
 
-// src/tools/web-tools.ts
-init_esm_shims();
-
 // src/web/server.ts
-init_esm_shims();
 import express from "express";
 import * as path4 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath } from "url";
 import { createRequire } from "module";
 import { existsSync } from "fs";
-var __filename2 = fileURLToPath2(import.meta.url);
+var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = path4.dirname(__filename2);
 function resolveAppPath() {
   const candidates = [];
@@ -1525,10 +2869,61 @@ Ensure the package is installed correctly and web assets exist.`
   );
 }
 var tagService2 = new TagService(storage);
+var dependencyViewService2 = new DependencyViewService(storage);
+function unwrapDependencyViewMutation(data) {
+  if (typeof data !== "object" || data === null || !("view" in data)) {
+    return data;
+  }
+  return data.view;
+}
+function normalizeRepositoryUrl(repository) {
+  if (!repository) {
+    return null;
+  }
+  if (repository.startsWith("git@github.com:")) {
+    return `https://github.com/${repository.slice("git@github.com:".length).replace(/\.git$/, "")}`;
+  }
+  return repository.replace(/^git\+/, "").replace(/\.git$/, "");
+}
+function resolveAppMetadata() {
+  const fallback = {
+    version: "0.0.0",
+    repositoryUrl: "https://github.com/shiquda/roadmap-skill"
+  };
+  const candidates = [];
+  try {
+    const require2 = createRequire(import.meta.url);
+    try {
+      const pkgRoot = path4.dirname(require2.resolve("../../package.json"));
+      candidates.push(path4.join(pkgRoot, "package.json"));
+    } catch {
+    }
+    candidates.push(path4.join(process.cwd(), "package.json"));
+    candidates.push(path4.join(__dirname2, "../../package.json"));
+    candidates.push(path4.join(__dirname2, "../package.json"));
+    for (const candidate of candidates) {
+      if (!existsSync(candidate)) {
+        continue;
+      }
+      const pkg = require2(candidate);
+      const repository = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
+      return {
+        version: pkg.version ?? fallback.version,
+        repositoryUrl: normalizeRepositoryUrl(repository) ?? pkg.homepage ?? fallback.repositoryUrl
+      };
+    }
+  } catch {
+  }
+  return fallback;
+}
+var appMetadata = resolveAppMetadata();
 function createServer(port = 7860) {
   return new Promise((resolve, reject) => {
     const app = express();
     app.use(express.json());
+    app.get("/api/meta", (_req, res) => {
+      res.json(appMetadata);
+    });
     app.get("/api/projects", async (_req, res) => {
       try {
         const projects = await storage.listProjects();
@@ -1549,6 +2944,189 @@ function createServer(port = 7860) {
         res.status(500).json({ error: error.message });
       }
     });
+    app.get("/api/projects/:projectId/dependency-views", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.list(req.params.projectId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.post("/api/projects/:projectId/dependency-views", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.create(req.params.projectId, req.body);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.get("/api/projects/:projectId/dependency-views/:viewId", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.get(req.params.projectId, req.params.viewId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.put("/api/projects/:projectId/dependency-views/:viewId", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.update(req.params.projectId, req.params.viewId, req.body);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.delete("/api/projects/:projectId/dependency-views/:viewId", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.delete(req.params.projectId, req.params.viewId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.post("/api/projects/:projectId/dependency-views/:viewId/nodes", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.addNode(req.params.projectId, req.params.viewId, req.body);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.put("/api/projects/:projectId/dependency-views/:viewId/nodes/:taskId", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.updateNode(
+          req.params.projectId,
+          req.params.viewId,
+          req.params.taskId,
+          req.body
+        );
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.put("/api/projects/:projectId/dependency-views/:viewId/nodes", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.batchUpdateNodes(
+          req.params.projectId,
+          req.params.viewId,
+          req.body
+        );
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.delete("/api/projects/:projectId/dependency-views/:viewId/nodes/:taskId", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.removeNode(req.params.projectId, req.params.viewId, req.params.taskId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.post("/api/projects/:projectId/dependency-views/:viewId/edges", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.addEdge(req.params.projectId, req.params.viewId, req.body);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.put("/api/projects/:projectId/dependency-views/:viewId/edges/:edgeId", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.updateEdge(
+          req.params.projectId,
+          req.params.viewId,
+          req.params.edgeId,
+          req.body
+        );
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.delete("/api/projects/:projectId/dependency-views/:viewId/edges/:edgeId", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.removeEdge(req.params.projectId, req.params.viewId, req.params.edgeId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: unwrapDependencyViewMutation(result.data) });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.get("/api/projects/:projectId/dependency-views/:viewId/analyze", async (req, res) => {
+      try {
+        const result = await dependencyViewService2.analyze(req.params.projectId, req.params.viewId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: result.data });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
     app.get("/api/tasks", async (req, res) => {
       try {
         const filters = { ...req.query };
@@ -1837,8 +3415,7 @@ var closeWebInterfaceTool = {
 };
 
 // src/tools/template-tools.ts
-init_esm_shims();
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 import * as path5 from "path";
 import * as fs2 from "fs/promises";
 var TEMPLATES_DIR = path5.join(process.cwd(), "templates");
@@ -1866,7 +3443,7 @@ function generateId(prefix) {
 var listTemplatesTool = {
   name: "list_templates",
   description: "List all available project templates",
-  inputSchema: z4.object({}),
+  inputSchema: z5.object({}),
   async execute() {
     try {
       const templateFiles = await getTemplateFiles();
@@ -1899,8 +3476,8 @@ var listTemplatesTool = {
 var getTemplateTool = {
   name: "get_template",
   description: "Get detailed information about a specific template",
-  inputSchema: z4.object({
-    templateName: z4.string().min(1, "Template name is required")
+  inputSchema: z5.object({
+    templateName: z5.string().min(1, "Template name is required")
   }),
   async execute(input) {
     try {
@@ -1938,12 +3515,12 @@ var getTemplateTool = {
 var applyTemplateTool = {
   name: "apply_template",
   description: "Create a new project from a template",
-  inputSchema: z4.object({
-    templateName: z4.string().min(1, "Template name is required"),
-    projectName: z4.string().min(1, "Project name is required"),
-    description: z4.string().default(""),
-    startDate: z4.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional(),
-    targetDate: z4.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional()
+  inputSchema: z5.object({
+    templateName: z5.string().min(1, "Template name is required"),
+    projectName: z5.string().min(1, "Project name is required"),
+    description: z5.string().default(""),
+    startDate: z5.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional(),
+    targetDate: z5.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional()
   }),
   async execute(input) {
     try {
@@ -1996,16 +3573,25 @@ var applyTemplateTool = {
         };
         tasks.push(task);
       }
-      projectData.tags = tags;
-      projectData.tasks = tasks;
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(projectId);
-      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-      await writeJsonFile2(filePath, projectData);
+      const updatedProjectData = await storage.mutateProject(projectId, async (storedProjectData) => {
+        storedProjectData.tags = tags;
+        storedProjectData.tasks = tasks;
+        storedProjectData.project.updatedAt = now;
+        return {
+          result: storedProjectData,
+          shouldSave: true
+        };
+      });
+      if (!updatedProjectData) {
+        return {
+          success: false,
+          error: `Project '${projectId}' not found after creation`
+        };
+      }
       return {
         success: true,
         data: {
-          project: projectData.project,
+          project: updatedProjectData.project,
           taskCount: tasks.length,
           tagCount: tags.length,
           tasksCreated: tasks.map((t) => ({
@@ -2029,11 +3615,7 @@ var applyTemplateTool = {
   }
 };
 
-// src/resources/index.ts
-init_esm_shims();
-
 // src/resources/project-resources.ts
-init_esm_shims();
 var projectResources = [
   {
     uri: "roadmap://projects",
@@ -2238,11 +3820,7 @@ function getAllResources() {
   return projectResources;
 }
 
-// src/prompts/index.ts
-init_esm_shims();
-
 // src/prompts/project-prompts.ts
-init_esm_shims();
 var projectPrompts = [
   {
     name: "suggest-tasks",
@@ -2310,9 +3888,12 @@ var projectPrompts = [
     ]
   }
 ];
+function formatOptionalArgument(value) {
+  return value && value.trim() ? value.trim() : "[not provided]";
+}
 function getRecommendNextTasksPrompt(projectId, limit) {
-  const projectHint = projectId ? `User specified project: ${projectId}. Use this project if it exists, or inform user if not found.` : "User did not specify a project. Based on the current working directory and conversation context, try to identify the most relevant project. If a clear match exists, focus on that project; otherwise, analyze all active projects";
-  const taskLimit = limit ? parseInt(limit, 10) : 3;
+  const requestedProjectId = formatOptionalArgument(projectId);
+  const requestedLimit = formatOptionalArgument(limit);
   return {
     description: "Intelligent Task Recommendation Assistant",
     messages: [
@@ -2320,7 +3901,17 @@ function getRecommendNextTasksPrompt(projectId, limit) {
         role: "user",
         content: {
           type: "text",
-          text: `${projectHint}, please recommend the ${taskLimit} tasks I should prioritize next.
+          text: `Please recommend the next tasks I should prioritize.
+
+## Provided Arguments
+- projectId: ${requestedProjectId}
+- limit: ${requestedLimit}
+
+## Argument Handling Rules
+- If projectId is provided, use that project if it exists; if it does not exist, tell the user clearly.
+- If projectId is not provided, infer the most relevant project from the current working directory and conversation context; if no clear match exists, analyze all active projects.
+- If limit is provided and valid, return that many recommendations.
+- If limit is not provided or invalid, default to 3 recommendations.
 
 ## Recommendation Logic (sorted by priority):
 
@@ -2346,7 +3937,7 @@ function getRecommendNextTasksPrompt(projectId, limit) {
 2. **Filter high-priority tasks**: critical and high
 3. **Check due dates**: Identify tasks due soon or overdue
 4. **Analyze blocking relationships**: Identify tasks blocking others
-5. **Generate recommendation list**: Provide ${taskLimit} tasks to prioritize with reasons
+5. **Generate recommendation list**: Provide the requested number of tasks to prioritize with reasons
 
 ## Output Format:
 
@@ -2380,7 +3971,7 @@ Keep task status synchronized with actual progress!`
   };
 }
 function getAutoPrioritizePrompt(projectId) {
-  const projectHint = projectId ? `User specified project: ${projectId}. Use this project if it exists, or inform user if not found.` : "User did not specify a project. Based on the current working directory and conversation context, try to identify the most relevant project. If a clear match exists, focus on that project; otherwise, analyze all active projects";
+  const requestedProjectId = formatOptionalArgument(projectId);
   return {
     description: "Intelligent Priority Optimization Assistant",
     messages: [
@@ -2388,7 +3979,14 @@ function getAutoPrioritizePrompt(projectId) {
         role: "user",
         content: {
           type: "text",
-          text: `${projectHint}, please automatically analyze and adjust priorities.
+          text: `Please automatically analyze and adjust priorities.
+
+## Provided Arguments
+- projectId: ${requestedProjectId}
+
+## Argument Handling Rules
+- If projectId is provided, use that project if it exists; if it does not exist, tell the user clearly.
+- If projectId is not provided, infer the most relevant project from the current working directory and conversation context; if no clear match exists, analyze all active projects.
 
 ## Priority Adjustment Rules:
 
@@ -2529,7 +4127,7 @@ Please fetch task info and immediately use update_task to apply the enhanced det
   };
 }
 function getQuickCapturePrompt(idea, projectId) {
-  const projectContext = projectId ? `User specified project: ${projectId}. Use this project if it exists, or inform user if not found.` : "User did not specify a project. Based on the current working directory and conversation context, try to identify the most relevant project. If a clear match exists, use that project; otherwise, analyze all active projects and select the best match";
+  const requestedProjectId = formatOptionalArgument(projectId);
   return {
     description: "Quick Capture Assistant",
     messages: [
@@ -2539,7 +4137,14 @@ function getQuickCapturePrompt(idea, projectId) {
           type: "text",
           text: `I want to quickly capture an idea/task: "${idea}"
 
-${projectContext}
+## Provided Arguments
+- projectId: ${requestedProjectId}
+
+## Argument Handling Rules
+- If projectId is provided, use that project if it exists; if it does not exist, tell the user clearly.
+- If projectId is not provided, infer the most relevant project from the current working directory and conversation context; if no clear match exists, analyze all active projects and choose the best fit.
+
+## [Non-intrusive task] Pause your current work briefly to complete this quick capture, then let the user know it's done and resume what you were doing.
 
 ## Please complete the following steps immediately:
 
@@ -2601,7 +4206,7 @@ Analyze the idea, select the best matching project, and immediately execute crea
   };
 }
 function getOpenWebUIPrompt(port) {
-  const portNum = port ? parseInt(port, 10) : 7860;
+  const requestedPort = formatOptionalArgument(port);
   return {
     description: "Open Web Visualization Interface",
     messages: [
@@ -2609,7 +4214,16 @@ function getOpenWebUIPrompt(port) {
         role: "user",
         content: {
           type: "text",
-          text: `Please open the roadmap-skill web interface by calling the open_web_interface tool with port ${portNum}. Do it immediately without asking for confirmation.`
+          text: `**[Non-intrusive task]** Pause your current work briefly to complete this quick action, then let the user know it's done and resume what you were doing.
+
+## Provided Arguments
+- port: ${requestedPort}
+
+## Argument Handling Rules
+- If port is provided and valid, call the open_web_interface tool with that port.
+- If port is not provided or invalid, call the open_web_interface tool with its default behavior.
+
+Launch the roadmap-skill web visualization interface now.`
         }
       }
     ]
@@ -2653,6 +4267,19 @@ var allTools = [
   updateTagTool,
   deleteTagTool,
   getTasksByTagTool,
+  createDependencyViewTool,
+  listDependencyViewsTool,
+  getDependencyViewTool,
+  updateDependencyViewTool,
+  deleteDependencyViewTool,
+  addTaskToDependencyViewTool,
+  updateDependencyViewNodeTool,
+  batchUpdateDependencyViewNodesTool,
+  removeTaskFromDependencyViewTool,
+  addDependencyViewEdgeTool,
+  updateDependencyViewEdgeTool,
+  removeDependencyViewEdgeTool,
+  analyzeDependencyViewTool,
   openWebInterfaceTool,
   closeWebInterfaceTool
 ];