agent-planner-mcp 0.5.0 → 0.5.1

package/src/tools.js

@@ -10,7 +10,11 @@
  */
 
 const { ListToolsRequestSchema, CallToolRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
-const apiClient = require('./api-client');
+const defaultApiClient = require('./api-client');
+
+const APP_URL = (process.env.APP_URL || 'https://agentplanner.io').replace(/\/$/, '');
+function buildPlanUrl(planId) { return `${APP_URL}/app/plans/${planId}`; }
+function buildTaskUrl(planId, nodeId) { return `${APP_URL}/app/plans/${planId}?node=${nodeId}`; }
 
 /**
  * Format JSON data as text for Claude Desktop
@@ -43,8 +47,10 @@ function formatResponse(data) {
 /**
  * Setup tools for the MCP server
  * @param {Server} server - MCP server instance
+ * @param {Object} [apiClientOverride] - Per-session API client (HTTP mode). Falls back to default (stdio mode).
  */
-function setupTools(server) {
+function setupTools(server, apiClientOverride) {
+  const apiClient = apiClientOverride || defaultApiClient;
   // Suppress console logs when not in debug mode
   if (process.env.NODE_ENV !== 'development') {
     // Silent mode for production
@@ -62,7 +68,7 @@ function setupTools(server) {
         // ========================================
         {
           name: "quick_plan",
-          description: "Create a plan quickly from a title and list of tasks. Perfect for getting started fast - just provide a title and task names. Returns plan URL and task IDs for immediate use.",
+          description: "Create a plan quickly from a title and list of tasks. Perfect for getting started fast - just provide a title and task names. Returns plan URL and task IDs for immediate use. Tip: provide a goal_id to automatically link this plan to a goal.",
           inputSchema: {
             type: "object",
             properties: {
@@ -73,7 +79,7 @@ function setupTools(server) {
                 items: { type: "string" },
                 description: "List of task titles (simple strings). A phase will be created automatically."
               },
-              goal_id: { type: "string", description: "Optionally link to a goal" },
+              goal_id: { type: "string", description: "Optionally link this plan to a goal. Recommended: always link plans to goals for tracking." },
               organization_id: { type: "string", description: "Organization ID (uses default if not provided)" }
             },
             required: ["title", "tasks"]
@@ -104,7 +110,7 @@ function setupTools(server) {
               plan_id: { type: "string", description: "Plan ID (required for API)" },
               status: { 
                 type: "string", 
-                enum: ["not_started", "in_progress", "completed", "blocked"],
+                enum: ["not_started", "in_progress", "completed", "blocked", "plan_ready"],
                 description: "New status"
               },
               note: { type: "string", description: "Optional note explaining the status change (especially useful for 'blocked')" }
@@ -132,6 +138,46 @@ function setupTools(server) {
           }
         },
 
+        {
+          name: "check_goals_health",
+          description: "Check the health of all your goals. Returns per-goal health status (on_track/at_risk/stale), bottleneck summaries, knowledge gaps, and pending decisions. Call this FIRST in the autonomous loop to identify which goals need attention.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              status_filter: { type: "string", description: "Filter by health status (e.g. 'on_track', 'at_risk', 'stale')" }
+            }
+          }
+        },
+
+        // ========================================
+        // TASK CLAIMING - Prevent agent collisions
+        // ========================================
+        {
+          name: "claim_task",
+          description: "Claim exclusive ownership of a task before starting work. Prevents other agents from working on the same task. Claims expire after ttl_minutes (default 30). Always claim before starting work on a task.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              task_id: { type: "string", description: "Task ID to claim" },
+              plan_id: { type: "string", description: "Plan ID" },
+              ttl_minutes: { type: "integer", description: "Claim duration in minutes (default 30)", default: 30 }
+            },
+            required: ["task_id", "plan_id"]
+          }
+        },
+        {
+          name: "release_task",
+          description: "Release a previously claimed task. Called automatically when you complete a task, but use this if you need to abandon work early.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              task_id: { type: "string", description: "Task ID to release" },
+              plan_id: { type: "string", description: "Plan ID" }
+            },
+            required: ["task_id", "plan_id"]
+          }
+        },
+
         // ========================================
         // CONTEXT LOADING - Get everything you need
         // Use before starting work on a plan/goal
@@ -150,7 +196,7 @@ function setupTools(server) {
         },
         {
           name: "get_my_tasks",
-          description: "Get tasks that need attention - blocked tasks, in-progress tasks, and next tasks to start. Perfect for heartbeat check-ins.",
+          description: "Get tasks that need attention - blocked tasks, in-progress tasks, and next tasks to start. Perfect for status check-ins.",
           inputSchema: {
             type: "object",
             properties: {
@@ -165,31 +211,6 @@ function setupTools(server) {
           }
         },
 
-        // ========================================
-        // KNOWLEDGE - Build persistent memory
-        // ========================================
-        {
-          name: "add_learning",
-          description: "Capture something you learned for future reference. This persists beyond the current session - other agents and future-you will benefit.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              title: { type: "string", description: "Brief title summarizing the learning" },
-              content: { type: "string", description: "What you learned - be specific and include context" },
-              scope: { type: "string", enum: ["organization", "goal", "plan"], description: "Where to store this (defaults to organization)" },
-              scope_id: { type: "string", description: "ID of the organization/goal/plan" },
-              tags: { type: "array", items: { type: "string" }, description: "Tags for easier retrieval" },
-              entry_type: {
-                type: "string",
-                enum: ["learning", "decision", "context", "constraint"],
-                default: "learning",
-                description: "Type of knowledge"
-              }
-            },
-            required: ["title", "content"]
-          }
-        },
-
         // ========================================
         // MARKDOWN EXPORT/IMPORT - Filesystem pattern
         // ========================================
@@ -380,14 +401,20 @@ function setupTools(server) {
               status: { 
                 type: "string", 
                 description: "Node status",
-                enum: ["not_started", "in_progress", "completed", "blocked"],
+                enum: ["not_started", "in_progress", "completed", "blocked", "plan_ready"],
                 default: "not_started"
               },
               context: { type: "string", description: "Additional context for the node" },
               agent_instructions: { type: "string", description: "Instructions for AI agents working on this node" },
               acceptance_criteria: { type: "string", description: "Criteria for node completion" },
               due_date: { type: "string", description: "Due date (ISO format)" },
-              metadata: { type: "object", description: "Additional metadata" }
+              metadata: { type: "object", description: "Additional metadata" },
+              task_mode: {
+                type: "string",
+                description: "RPI workflow mode for the node",
+                enum: ["research", "plan", "implement", "free"],
+                default: "free"
+              }
             },
             required: ["plan_id", "node_type", "title"]
           }
@@ -405,13 +432,18 @@ function setupTools(server) {
               status: { 
                 type: "string", 
                 description: "New node status",
-                enum: ["not_started", "in_progress", "completed", "blocked"]
+                enum: ["not_started", "in_progress", "completed", "blocked", "plan_ready"]
               },
               context: { type: "string", description: "New context" },
               agent_instructions: { type: "string", description: "New agent instructions" },
               acceptance_criteria: { type: "string", description: "New acceptance criteria" },
               due_date: { type: "string", description: "New due date (ISO format)" },
-              metadata: { type: "object", description: "New metadata" }
+              metadata: { type: "object", description: "New metadata" },
+              task_mode: {
+                type: "string",
+                description: "RPI workflow mode for the node",
+                enum: ["research", "plan", "implement", "free"]
+              }
             },
             required: ["plan_id", "node_id"]
           }
@@ -467,6 +499,168 @@ function setupTools(server) {
           }
         },
         
+        // ===== DEPENDENCY TOOLS =====
+        {
+          name: "create_dependency",
+          description: "Create a dependency edge between two nodes in a plan. Source 'blocks' target by default.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              plan_id: { type: "string", description: "Plan ID" },
+              source_node_id: { type: "string", description: "Source node ID (the blocker)" },
+              target_node_id: { type: "string", description: "Target node ID (the blocked)" },
+              dependency_type: {
+                type: "string",
+                description: "Type of dependency",
+                enum: ["blocks", "requires", "relates_to"],
+                default: "blocks"
+              },
+              weight: { type: "integer", description: "Edge weight (default 1)", default: 1 },
+              metadata: { type: "object", description: "Additional metadata" }
+            },
+            required: ["plan_id", "source_node_id", "target_node_id"]
+          }
+        },
+        {
+          name: "delete_dependency",
+          description: "Delete a dependency edge",
+          inputSchema: {
+            type: "object",
+            properties: {
+              plan_id: { type: "string", description: "Plan ID" },
+              dependency_id: { type: "string", description: "Dependency edge ID" }
+            },
+            required: ["plan_id", "dependency_id"]
+          }
+        },
+        {
+          name: "list_dependencies",
+          description: "List all dependency edges in a plan",
+          inputSchema: {
+            type: "object",
+            properties: {
+              plan_id: { type: "string", description: "Plan ID" }
+            },
+            required: ["plan_id"]
+          }
+        },
+        {
+          name: "get_node_dependencies",
+          description: "Get upstream and downstream dependencies for a node",
+          inputSchema: {
+            type: "object",
+            properties: {
+              plan_id: { type: "string", description: "Plan ID" },
+              node_id: { type: "string", description: "Node ID" },
+              direction: {
+                type: "string",
+                description: "Direction to query",
+                enum: ["upstream", "downstream", "both"],
+                default: "both"
+              }
+            },
+            required: ["plan_id", "node_id"]
+          }
+        },
+
+        // ===== RPI WORKFLOW =====
+        {
+          name: "create_rpi_chain",
+          description: "Create a Research→Plan→Implement task chain with automatic dependency edges. The three tasks are linked: Research blocks Plan, Plan blocks Implement.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              plan_id: { type: "string", description: "Plan ID" },
+              title: { type: "string", description: "Base title for the chain (e.g. 'Auth refactor')" },
+              description: { type: "string", description: "Description for the research task" },
+              parent_id: { type: "string", description: "Parent node ID (optional, defaults to root)" }
+            },
+            required: ["plan_id", "title"]
+          }
+        },
+
+        // ===== ANALYSIS TOOLS =====
+        {
+          name: "analyze_impact",
+          description: "Analyze what happens if a node is delayed, blocked, or removed. Shows directly and transitively affected nodes.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              plan_id: { type: "string", description: "Plan ID" },
+              node_id: { type: "string", description: "Node ID to analyze" },
+              scenario: {
+                type: "string",
+                description: "Impact scenario",
+                enum: ["delay", "block", "remove"],
+                default: "block"
+              }
+            },
+            required: ["plan_id", "node_id"]
+          }
+        },
+        {
+          name: "get_critical_path",
+          description: "Find the critical path (longest dependency chain) through incomplete tasks in a plan",
+          inputSchema: {
+            type: "object",
+            properties: {
+              plan_id: { type: "string", description: "Plan ID" }
+            },
+            required: ["plan_id"]
+          }
+        },
+
+        // ===== PROGRESSIVE CONTEXT TOOLS =====
+        {
+          name: "get_task_context",
+          description: "Get progressive context for a task at adjustable depth. This is the PRIMARY way to load context before starting work on a task.\n\nDepth levels:\n- 1: Task focus — node details + recent logs\n- 2: Local neighborhood — adds parent, siblings, direct dependencies\n- 3: Knowledge — adds plan-scoped knowledge entries\n- 4: Extended — adds plan overview, ancestry, goals, transitive dependencies\n\nFor RPI implement tasks, automatically includes research/plan outputs from the chain.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              node_id: { type: "string", description: "Task/node ID to get context for" },
+              depth: {
+                type: "integer",
+                description: "Context depth 1-4 (default 2). Start with 2, go deeper if needed.",
+                minimum: 1,
+                maximum: 4,
+                default: 2
+              },
+              token_budget: {
+                type: "integer",
+                description: "Max estimated tokens (0 = unlimited). Use to stay within context window limits.",
+                default: 0
+              },
+              log_limit: {
+                type: "integer",
+                description: "Max recent logs to include per node",
+                default: 10
+              },
+              include_research: {
+                type: "boolean",
+                description: "Include research outputs from RPI chain siblings (for implement tasks)",
+                default: true
+              }
+            },
+            required: ["node_id"]
+          }
+        },
+        {
+          name: "suggest_next_tasks",
+          description: "Suggest the next actionable tasks for a plan based on dependency analysis. Returns tasks where all upstream blockers are completed, prioritized by: RPI research tasks first, then by how many downstream tasks each unblocks.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              plan_id: { type: "string", description: "Plan ID" },
+              limit: {
+                type: "integer",
+                description: "Maximum suggestions to return",
+                default: 5
+              }
+            },
+            required: ["plan_id"]
+          }
+        },
+
         // ===== LOGGING TOOLS (Replaces Comments) =====
         {
           name: "add_log",
@@ -532,7 +726,7 @@ function setupTools(server) {
                     node_id: { type: "string", description: "Node ID" },
                     status: { 
                       type: "string",
-                      enum: ["not_started", "in_progress", "completed", "blocked"]
+                      enum: ["not_started", "in_progress", "completed", "blocked", "plan_ready"]
                     },
                     title: { type: "string" },
                     description: { type: "string" }
@@ -766,102 +960,174 @@ function setupTools(server) {
           }
         },
         
-        // ===== KNOWLEDGE TOOLS =====
+        // ===== CROSS-PLAN & EXTERNAL DEPENDENCY TOOLS =====
         {
-          name: "add_knowledge_entry",
-          description: "Add a knowledge entry (decision, context, constraint, learning, reference, note) to a scope",
+          name: "create_cross_plan_dependency",
+          description: "Create a dependency edge between nodes in different plans. Use when a task in one plan blocks or requires a task in another plan.",
           inputSchema: {
             type: "object",
             properties: {
-              scope: { 
-                type: "string", 
-                description: "Scope type",
-                enum: ["organization", "goal", "plan"]
-              },
-              scope_id: { type: "string", description: "ID of the org, goal, or plan" },
-              entry_type: { 
-                type: "string", 
-                description: "Type of knowledge entry",
-                enum: ["decision", "context", "constraint", "learning", "reference", "note"]
-              },
-              title: { type: "string", description: "Entry title" },
-              content: { type: "string", description: "Entry content" },
-              source_url: { type: "string", description: "Source URL (optional)" },
-              tags: { type: "array", description: "Tags for categorization", items: { type: "string" } }
+              source_node_id: { type: "string", description: "Source node ID (the blocker/prerequisite)" },
+              target_node_id: { type: "string", description: "Target node ID (the blocked/dependent task)" },
+              dependency_type: { type: "string", enum: ["blocks", "requires", "relates_to"], default: "blocks", description: "Edge type (default: blocks)" },
+              weight: { type: "number", description: "Edge weight (default 1)" }
             },
-            required: ["scope", "scope_id", "entry_type", "title", "content"]
+            required: ["source_node_id", "target_node_id"]
           }
         },
         {
-          name: "list_knowledge_entries",
-          description: "List knowledge entries for a scope",
+          name: "list_cross_plan_dependencies",
+          description: "List all dependency edges that cross plan boundaries between specified plans.",
           inputSchema: {
             type: "object",
             properties: {
-              scope: { 
-                type: "string", 
-                description: "Scope type",
-                enum: ["organization", "goal", "plan"]
-              },
-              scope_id: { type: "string", description: "ID of the org, goal, or plan" },
-              entry_type: { 
-                type: "string", 
-                description: "Filter by entry type",
-                enum: ["decision", "context", "constraint", "learning", "reference", "note"]
-              },
-              tags: { type: "string", description: "Filter by tags (comma-separated)" },
-              limit: { type: "integer", description: "Max entries to return", default: 50 }
+              plan_ids: {
+                type: "array",
+                items: { type: "string" },
+                description: "Plan IDs to check for cross-plan edges (at least 2)"
+              }
             },
-            required: ["scope", "scope_id"]
+            required: ["plan_ids"]
           }
         },
         {
-          name: "search_knowledge",
-          description: "Search knowledge entries across scopes using text search",
+          name: "create_external_dependency",
+          description: "Create an external dependency node representing a blocker outside the system (vendor API, legal approval, etc.). Optionally blocks a target task.",
           inputSchema: {
             type: "object",
             properties: {
-              query: { type: "string", description: "Search query" },
-              scope: { 
-                type: "string", 
-                description: "Limit to scope type",
-                enum: ["organization", "goal", "plan"]
-              },
-              scope_id: { type: "string", description: "Limit to specific scope" },
-              entry_types: { 
-                type: "array", 
-                description: "Filter by entry types",
-                items: { type: "string" }
-              },
-              limit: { type: "integer", description: "Max results", default: 10 }
+              plan_id: { type: "string", description: "Plan to add the external dependency to" },
+              title: { type: "string", description: "External dependency title (e.g., 'Waiting for vendor API access')" },
+              description: { type: "string", description: "Details about the external dependency" },
+              url: { type: "string", description: "URL reference (ticket, docs, etc.)" },
+              blocks_node_id: { type: "string", description: "Node ID that this external dep blocks" }
+            },
+            required: ["plan_id", "title"]
+          }
+        },
+
+        // ===== GOAL-DEPENDENCY TOOLS =====
+        {
+          name: "goal_path",
+          description: "Get the full dependency path to a goal — all tasks that contribute to achieving it (direct achievers + their upstream blockers). Shows completion stats and which tasks are blocking progress.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              goal_id: { type: "string", description: "Goal ID" },
+              max_depth: { type: "number", description: "Max traversal depth (default 20)" }
+            },
+            required: ["goal_id"]
+          }
+        },
+        {
+          name: "goal_progress",
+          description: "Get goal progress calculated from its dependency graph. Returns overall completion percentage and direct achiever progress.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              goal_id: { type: "string", description: "Goal ID" }
+            },
+            required: ["goal_id"]
+          }
+        },
+        {
+          name: "add_achiever",
+          description: "Link a task to a goal via an 'achieves' dependency edge. This declares that completing this task contributes to achieving the goal.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              goal_id: { type: "string", description: "Goal ID" },
+              node_id: { type: "string", description: "Task/node ID that achieves this goal" },
+              weight: { type: "number", description: "Edge weight for critical path (default 1)" }
+            },
+            required: ["goal_id", "node_id"]
+          }
+        },
+        {
+          name: "remove_achiever",
+          description: "Remove an achieves edge between a task and a goal",
+          inputSchema: {
+            type: "object",
+            properties: {
+              goal_id: { type: "string", description: "Goal ID" },
+              dependency_id: { type: "string", description: "Dependency edge ID to remove" }
+            },
+            required: ["goal_id", "dependency_id"]
+          }
+        },
+        {
+          name: "goal_knowledge_gaps",
+          description: "Detect knowledge gaps for a goal — checks which tasks on the goal's dependency path lack relevant knowledge in the temporal knowledge graph. Useful for identifying where research is needed before implementation.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              goal_id: { type: "string", description: "Goal ID" }
+            },
+            required: ["goal_id"]
+          }
+        },
+
+        // ===== GRAPHITI KNOWLEDGE GRAPH TOOLS =====
+        {
+          name: "add_learning",
+          description: "Record a knowledge episode to the temporal knowledge graph. Use this after research, when making decisions, or discovering important context. Graphiti automatically extracts entities and relationships. The knowledge persists across plans and sessions.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              content: { type: "string", description: "The knowledge content — be detailed. Include context, reasoning, and conclusions." },
+              title: { type: "string", description: "Short title/name for the episode" },
+              entry_type: { type: "string", enum: ["decision", "learning", "context", "constraint"], description: "Type of knowledge" },
+              plan_id: { type: "string", description: "Plan ID this knowledge relates to (optional)" },
+              node_id: { type: "string", description: "Node/task ID this knowledge relates to (optional)" }
+            },
+            required: ["content"]
+          }
+        },
+        {
+          name: "recall_knowledge",
+          description: "Search the temporal knowledge graph for relevant facts, decisions, and learnings. Searches across ALL plans in the organization. Use before starting work or making decisions.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "What to search for — be specific" },
+              max_results: { type: "number", description: "Maximum results (default 10)", default: 10 }
             },
             required: ["query"]
           }
         },
         {
-          name: "update_knowledge_entry",
-          description: "Update a knowledge entry",
+          name: "find_entities",
+          description: "Search for entities (technologies, people, patterns, constraints) in the knowledge graph. Returns entity nodes with their relationships.",
           inputSchema: {
             type: "object",
             properties: {
-              entry_id: { type: "string", description: "Entry ID" },
-              title: { type: "string", description: "New title" },
-              content: { type: "string", description: "New content" },
-              entry_type: { type: "string", description: "New type" },
-              tags: { type: "array", description: "New tags", items: { type: "string" } }
+              query: { type: "string", description: "Entity search query" },
+              max_results: { type: "number", description: "Maximum results (default 10)", default: 10 }
             },
-            required: ["entry_id"]
+            required: ["query"]
           }
         },
+
         {
-          name: "delete_knowledge_entry",
-          description: "Delete a knowledge entry",
+          name: "check_contradictions",
+          description: "Check if knowledge about a topic has changed over time. Returns current facts and any superseded (outdated) facts. Useful before making decisions based on past knowledge — ensures you're working with the latest information.",
           inputSchema: {
             type: "object",
             properties: {
-              entry_id: { type: "string", description: "Entry ID to delete" }
+              query: { type: "string", description: "Topic to check for contradictions" },
+              max_results: { type: "number", description: "Maximum results (default 10)", default: 10 }
             },
-            required: ["entry_id"]
+            required: ["query"]
+          }
+        },
+        {
+          name: "get_recent_episodes",
+          description: "Get recent knowledge episodes from the temporal graph. Returns the latest episodes (learnings, decisions, context) across all plans. Useful to understand what has been learned recently or to review your own work session history.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              max_episodes: { type: "number", description: "Maximum episodes to return (default 20)", default: 20 }
+            }
           }
         },
 
@@ -967,7 +1233,7 @@ function setupTools(server) {
           success: true,
           message: `Plan "${title}" created with ${tasks.length} tasks`,
           plan_id: plan.id,
-          plan_url: `https://www.agentplanner.io/app/plans/${plan.id}`,
+          plan_url: buildPlanUrl(plan.id),
           phase_id: phase.id,
           task_ids: createdTasks.map(t => t.id),
           tasks: createdTasks,
@@ -1029,7 +1295,7 @@ function setupTools(server) {
           task_id: task.id,
           plan_id: plan_id,
           phase_id: targetPhaseId,
-          task_url: `https://www.agentplanner.io/app/plans/${plan_id}?node=${task.id}`,
+          task_url: buildTaskUrl(plan_id, task.id),
           next_steps: [
             "Use quick_status to mark as in_progress when you start",
             "Use quick_log to document progress"
@@ -1132,12 +1398,8 @@ function setupTools(server) {
             context.goal = await apiClient.goals.get(goal_id);
             if (include_knowledge) {
               try {
-                const knowledge = await apiClient.knowledge.getEntries({ 
-                  scope: 'goal',
-                  scope_id: goal_id,
-                  limit: 10 
-                });
-                context.goal_knowledge = knowledge.entries || [];
+                const graphResult = await apiClient.graphiti.graphSearch({ query: context.goal?.title || '', max_results: 10 });
+                context.goal_knowledge = graphResult?.results?.facts || [];
               } catch (e) {}
             }
           } catch (e) {
@@ -1149,7 +1411,7 @@ function setupTools(server) {
         if (plan_id) {
           try {
             context.plan = await apiClient.plans.getPlan(plan_id);
-            context.plan_url = `https://www.agentplanner.io/app/plans/${plan_id}`;
+            context.plan_url = buildPlanUrl(plan_id);
             
             const nodes = await apiClient.nodes.getNodes(plan_id);
             context.statistics = calculatePlanStatistics(nodes);
@@ -1178,12 +1440,8 @@ function setupTools(server) {
             
             if (include_knowledge) {
               try {
-                const knowledge = await apiClient.knowledge.getEntries({ 
-                  scope: 'plan',
-                  scope_id: plan_id,
-                  limit: 10 
-                });
-                context.plan_knowledge = knowledge.entries || [];
+                const graphResult = await apiClient.graphiti.graphSearch({ query: context.plan?.title || '', max_results: 10 });
+                context.plan_knowledge = graphResult?.results?.facts || [];
               } catch (e) {}
             }
           } catch (e) {
@@ -1260,34 +1518,8 @@ function setupTools(server) {
         return formatResponse(tasks);
       }
       
-      // ========================================
-      // KNOWLEDGE SHORTCUTS
-      // ========================================
-      
-      if (name === "add_learning") {
-        const { title, content, scope = 'organization', scope_id, tags, entry_type = 'learning' } = args;
-        
-        const entryData = {
-          entry_type,
-          title,
-          content
-        };
-        if (scope) entryData.scope = scope;
-        if (scope_id) entryData.scope_id = scope_id;
-        if (tags) entryData.tags = tags;
-        
-        const entry = await apiClient.knowledge.createEntry(entryData);
-        
-        return formatResponse({
-          success: true,
-          message: "Knowledge captured for future reference",
-          entry_id: entry.id,
-          entry_type,
-          title,
-          tip: "This will be searchable via search_knowledge. Good practice!"
-        });
-      }
-      
+      // add_learning handled in GRAPHITI KNOWLEDGE GRAPH HANDLERS section below
+
       // ========================================
       // MARKDOWN EXPORT
       // ========================================
@@ -1475,7 +1707,7 @@ function setupTools(server) {
           success: true,
           message: `Plan "${planTitle}" created from markdown with ${phases.length} phases and ${createdTasks.length} tasks`,
           plan_id: plan.id,
-          plan_url: `https://www.agentplanner.io/app/plans/${plan.id}`,
+          plan_url: buildPlanUrl(plan.id),
           phases: createdPhases,
           tasks: createdTasks,
           next_steps: [
@@ -1600,7 +1832,7 @@ function setupTools(server) {
         const result = await apiClient.plans.updateVisibility(plan_id, visibilityData);
         
         const shareUrl = visibility === "public" 
-          ? `https://www.agentplanner.io/app/plans/${plan_id}`
+          ? buildPlanUrl(plan_id)
           : null;
         
         return formatResponse({
@@ -1641,27 +1873,29 @@ function setupTools(server) {
       
       if (name === "move_node") {
         const { plan_id, node_id, parent_id, order_index } = args;
-        
+
         try {
+          // Build request body with only provided fields - don't send nulls
+          const body = {};
+          if (parent_id) body.parent_id = parent_id;
+          if (order_index !== undefined) body.order_index = order_index;
+
           // Call the move endpoint - using POST as per API definition
           const response = await apiClient.axiosInstance.post(
             `/plans/${plan_id}/nodes/${node_id}/move`,
-            { 
-              parent_id: parent_id || null,
-              order_index: order_index !== undefined ? order_index : null
-            }
+            body
           );
-          
+
           return formatResponse(response.data);
         } catch (error) {
           // If endpoint still doesn't work, try updating the node directly
           if (error.response && error.response.status === 404) {
             console.error('Move endpoint not found, trying direct update');
             // Fallback to updating the node's parent_id via regular update
-            const updateResponse = await apiClient.nodes.updateNode(plan_id, node_id, {
-              parent_id: parent_id || null,
-              order_index: order_index !== undefined ? order_index : null
-            });
+            const updateData = {};
+            if (parent_id) updateData.parent_id = parent_id;
+            if (order_index !== undefined) updateData.order_index = order_index;
+            const updateResponse = await apiClient.nodes.updateNode(plan_id, node_id, updateData);
             return formatResponse(updateResponse);
           }
           throw error;
@@ -1690,6 +1924,90 @@ function setupTools(server) {
         return formatResponse(response.data);
       }
       
+      // ===== DEPENDENCIES =====
+      if (name === "create_dependency") {
+        const { plan_id, source_node_id, target_node_id, dependency_type, weight, metadata } = args;
+        const response = await apiClient.axiosInstance.post(
+          `/plans/${plan_id}/dependencies`,
+          { source_node_id, target_node_id, dependency_type, weight, metadata }
+        );
+        return formatResponse(response.data);
+      }
+
+      if (name === "delete_dependency") {
+        const { plan_id, dependency_id } = args;
+        const response = await apiClient.axiosInstance.delete(
+          `/plans/${plan_id}/dependencies/${dependency_id}`
+        );
+        return formatResponse(response.data);
+      }
+
+      if (name === "list_dependencies") {
+        const { plan_id } = args;
+        const response = await apiClient.axiosInstance.get(
+          `/plans/${plan_id}/dependencies`
+        );
+        return formatResponse(response.data);
+      }
+
+      if (name === "get_node_dependencies") {
+        const { plan_id, node_id, direction = 'both' } = args;
+        const response = await apiClient.axiosInstance.get(
+          `/plans/${plan_id}/nodes/${node_id}/dependencies`,
+          { params: { direction } }
+        );
+        return formatResponse(response.data);
+      }
+
+      // ===== RPI WORKFLOW =====
+      if (name === "create_rpi_chain") {
+        const { plan_id, title, description, parent_id } = args;
+        const response = await apiClient.axiosInstance.post(
+          `/plans/${plan_id}/nodes/rpi-chain`,
+          { title, description, parent_id }
+        );
+        return formatResponse(response.data);
+      }
+
+      // ===== ANALYSIS =====
+      if (name === "analyze_impact") {
+        const { plan_id, node_id, scenario = 'block' } = args;
+        const response = await apiClient.axiosInstance.get(
+          `/plans/${plan_id}/nodes/${node_id}/impact`,
+          { params: { scenario } }
+        );
+        return formatResponse(response.data);
+      }
+
+      if (name === "get_critical_path") {
+        const { plan_id } = args;
+        const response = await apiClient.axiosInstance.get(
+          `/plans/${plan_id}/critical-path`
+        );
+        return formatResponse(response.data);
+      }
+
+      // ===== PROGRESSIVE CONTEXT =====
+      if (name === "get_task_context") {
+        const { node_id, depth = 2, token_budget = 0, log_limit = 10, include_research = true } = args;
+        const params = new URLSearchParams({
+          node_id,
+          depth: String(depth),
+          token_budget: String(token_budget),
+          log_limit: String(log_limit),
+          include_research: String(include_research),
+        });
+        const response = await apiClient.axiosInstance.get(`/context/progressive?${params.toString()}`);
+        return formatResponse(response.data);
+      }
+
+      if (name === "suggest_next_tasks") {
+        const { plan_id, limit = 5 } = args;
+        const params = new URLSearchParams({ plan_id, limit: String(limit) });
+        const response = await apiClient.axiosInstance.get(`/context/suggest?${params.toString()}`);
+        return formatResponse(response.data);
+      }
+
       // ===== LOGGING =====
       if (name === "add_log") {
         const { plan_id, node_id, content, log_type = "comment", tags } = args;
@@ -1901,60 +2219,154 @@ function setupTools(server) {
         });
       }
       
-      // ===== KNOWLEDGE TOOLS =====
-      if (name === "add_knowledge_entry") {
-        const { scope, scope_id, entry_type, title, content, source_url, tags } = args;
-        const result = await apiClient.knowledge.createEntry({
-          scope,
-          scope_id,
-          entry_type,
-          title,
-          content,
-          source_url,
-          tags
+      // ===== CROSS-PLAN & EXTERNAL DEPENDENCY HANDLERS =====
+      if (name === "create_cross_plan_dependency") {
+        const { source_node_id, target_node_id, dependency_type, weight } = args;
+        const result = await apiClient.dependencies.createCrossPlan({
+          source_node_id, target_node_id, dependency_type, weight
         });
         return formatResponse(result);
       }
-      
-      if (name === "list_knowledge_entries") {
-        const { scope, scope_id, entry_type, tags, limit = 50 } = args;
 
-        const result = await apiClient.knowledge.listEntries({ scope, scope_id, entry_type, tags, limit });
+      if (name === "list_cross_plan_dependencies") {
+        const { plan_ids } = args;
+        const result = await apiClient.dependencies.listCrossPlan(plan_ids);
         return formatResponse(result);
       }
-      
-      if (name === "search_knowledge") {
-        const { query, scope, scope_id, entry_types, limit = 10 } = args;
-        
-        // Build search request
-        const searchData = { query, limit };
-        if (scope && scope_id) {
-          searchData.scope = scope;
-          searchData.scope_id = scope_id;
-        }
-        if (entry_types) {
-          searchData.entry_types = entry_types;
-        }
-        
-        const result = await apiClient.knowledge.search(searchData);
+
+      if (name === "create_external_dependency") {
+        const { plan_id, title, description, url, blocks_node_id } = args;
+        const result = await apiClient.dependencies.createExternal({
+          plan_id, title, description, url, blocks_node_id
+        });
         return formatResponse(result);
       }
-      
-      if (name === "update_knowledge_entry") {
-        const { entry_id, ...updateData } = args;
-        const result = await apiClient.knowledge.updateEntry(entry_id, updateData);
+
+      // ===== GOAL-DEPENDENCY HANDLERS =====
+      if (name === "goal_path") {
+        const { goal_id, max_depth } = args;
+        const result = await apiClient.goals.getPath(goal_id, max_depth);
         return formatResponse(result);
       }
-      
-      if (name === "delete_knowledge_entry") {
-        const { entry_id } = args;
-        await apiClient.knowledge.deleteEntry(entry_id);
+
+      if (name === "goal_progress") {
+        const { goal_id } = args;
+        const result = await apiClient.goals.getProgress(goal_id);
+        return formatResponse(result);
+      }
+
+      if (name === "add_achiever") {
+        const { goal_id, node_id, weight } = args;
+        const result = await apiClient.goals.addAchiever(goal_id, node_id, weight);
         return formatResponse({
-          success: true,
-          message: `Knowledge entry ${entry_id} deleted`
+          ...result,
+          message: `Task ${node_id} now achieves goal ${goal_id}`,
+        });
+      }
+
+      if (name === "remove_achiever") {
+        const { goal_id, dependency_id } = args;
+        const result = await apiClient.goals.removeAchiever(goal_id, dependency_id);
+        return formatResponse(result);
+      }
+
+      if (name === "goal_knowledge_gaps") {
+        const { goal_id } = args;
+        const result = await apiClient.goals.getKnowledgeGaps(goal_id);
+        return formatResponse(result);
+      }
+
+      // ===== GRAPHITI KNOWLEDGE GRAPH HANDLERS =====
+      if (name === "add_learning") {
+        const { content, title, entry_type, plan_id, node_id } = args;
+
+        // Add to Graphiti temporal knowledge graph
+        const result = await apiClient.graphiti.addEpisode({
+          content,
+          name: title,
+          plan_id,
+          node_id,
+          metadata: { entry_type: entry_type || 'learning' },
+        });
+        return formatResponse({
+          ...result,
+          message: 'Knowledge recorded in temporal graph',
+          tip: 'This is now searchable via recall_knowledge across all plans'
         });
       }
 
+      if (name === "recall_knowledge") {
+        const { query, max_results = 10 } = args;
+
+        // Try Graphiti first (temporal, cross-plan)
+        try {
+          const graphResult = await apiClient.graphiti.graphSearch({ query, max_results });
+          if (graphResult?.results) {
+            return formatResponse({
+              ...graphResult,
+              source: 'graphiti_temporal_graph'
+            });
+          }
+        } catch (err) {
+          return formatResponse({
+            results: [],
+            source: 'graphiti_temporal_graph',
+            error: 'Knowledge graph not available: ' + err.message,
+          });
+        }
+      }
+
+      if (name === "find_entities") {
+        const { query, max_results = 10 } = args;
+
+        try {
+          const result = await apiClient.graphiti.searchEntities({ query, max_results });
+          return formatResponse(result);
+        } catch (err) {
+          return formatResponse({
+            error: 'Entity search requires the temporal knowledge graph (Graphiti)',
+            detail: err.message
+          });
+        }
+      }
+
+      if (name === "check_contradictions") {
+        const { query, max_results = 10 } = args;
+
+        try {
+          const result = await apiClient.graphiti.detectContradictions({ query, max_results });
+          if (result.contradictions_found) {
+            return formatResponse({
+              ...result,
+              warning: 'Some knowledge has been superseded. Review the "superseded" facts before proceeding.',
+            });
+          }
+          return formatResponse({
+            ...result,
+            message: 'No contradictions found — all facts are current.',
+          });
+        } catch (err) {
+          return formatResponse({
+            error: 'Contradiction detection requires the temporal knowledge graph (Graphiti)',
+            detail: err.message,
+          });
+        }
+      }
+
+      if (name === "get_recent_episodes") {
+        const { max_episodes = 20 } = args || {};
+
+        try {
+          const result = await apiClient.graphiti.getEpisodes({ max_episodes });
+          return formatResponse(result);
+        } catch (err) {
+          return formatResponse({
+            error: 'Episodic memory requires the temporal knowledge graph (Graphiti)',
+            detail: err.message
+          });
+        }
+      }
+
       // ===== HELPER TOOLS =====
       if (name === "get_started") {
         const { topic = "overview" } = args || {};
@@ -1975,8 +2387,8 @@ function setupTools(server) {
               "2. Use list_plans to see existing plans",
               "3. Before working on a plan, use understand_context to get the full picture",
               "4. Update task statuses as you work (update_node with status)",
-              "5. Store important decisions and learnings using add_knowledge_entry",
-              "6. Check search_knowledge before making decisions to see past context"
+              "5. Store important decisions and learnings using add_learning",
+              "6. Check recall_knowledge before making decisions to see past context"
             ],
             quick_tips: [
               "Always capture WHY decisions were made, not just WHAT",
@@ -2008,7 +2420,7 @@ function setupTools(server) {
             workflow: [
               "1. Use get_plan_structure to see the full plan",
               "2. Find tasks with status 'not_started' or 'in_progress'",
-              "3. Before starting a task, check search_knowledge for relevant context",
+              "3. Before starting a task, check recall_knowledge for relevant context",
               "4. Update task status to 'in_progress' when you begin",
               "5. Add logs to document what you're doing",
               "6. Mark 'completed' when done, or 'blocked' if stuck"
@@ -2025,7 +2437,7 @@ function setupTools(server) {
               "When blocked, clearly document what's blocking you",
               "Store learnings as you go - don't wait until the end"
             ],
-            tools_to_use: ["get_plan_structure", "update_node", "add_log", "search_knowledge"]
+            tools_to_use: ["get_plan_structure", "update_node", "add_log", "recall_knowledge"]
           },
           knowledge: {
             title: "Knowledge Management",
@@ -2051,7 +2463,7 @@ function setupTools(server) {
               "When you discover a constraint or rule",
               "When you find a useful resource or reference"
             ],
-            tools_to_use: ["add_knowledge_entry", "search_knowledge", "list_knowledge_entries"]
+            tools_to_use: ["add_learning", "recall_knowledge", "find_entities", "check_contradictions"]
           },
           collaboration: {
             title: "Collaboration",
@@ -2095,12 +2507,8 @@ function setupTools(server) {
             // Get related knowledge if available
             if (include_knowledge) {
               try {
-                const knowledge = await apiClient.knowledge.getEntries({ 
-                  scope: 'goal',
-                  scope_id: goal_id,
-                  limit: 10 
-                });
-                context.goal_knowledge = knowledge.entries || [];
+                const graphResult = await apiClient.graphiti.graphSearch({ query: context.goal?.title || '', max_results: 10 });
+                context.goal_knowledge = graphResult?.results?.facts || [];
               } catch (e) {
                 // Knowledge fetch failed, continue without it
               }
@@ -2147,12 +2555,8 @@ function setupTools(server) {
             // Get related knowledge if available
             if (include_knowledge) {
               try {
-                const knowledge = await apiClient.knowledge.getEntries({ 
-                  scope: 'plan',
-                  scope_id: plan_id,
-                  limit: 10 
-                });
-                context.plan_knowledge = knowledge.entries || [];
+                const graphResult = await apiClient.graphiti.graphSearch({ query: context.plan?.title || '', max_results: 10 });
+                context.plan_knowledge = graphResult?.results?.facts || [];
               } catch (e) {
                 // Knowledge fetch failed, continue without it
               }
@@ -2166,6 +2570,45 @@ function setupTools(server) {
         return formatResponse(context);
       }
       
+      // ===== GOALS HEALTH DASHBOARD =====
+      if (name === "check_goals_health") {
+        const { status_filter } = args || {};
+        const result = await apiClient.goals.getDashboard();
+
+        let goals = result.goals || result;
+        if (status_filter && Array.isArray(goals)) {
+          goals = goals.filter(g => g.health_status === status_filter || g.status === status_filter);
+        }
+
+        return formatResponse({
+          ...result,
+          goals,
+          tip: "Prioritize: stale goals first, then at_risk, then on_track."
+        });
+      }
+
+      // ===== TASK CLAIMING =====
+      if (name === "claim_task") {
+        const { task_id, plan_id, ttl_minutes = 30 } = args;
+        const result = await apiClient.nodes.claimTask(plan_id, task_id, 'mcp-agent', ttl_minutes);
+        return formatResponse({
+          success: true,
+          message: `Task ${task_id} claimed for ${ttl_minutes} minutes`,
+          ...result,
+          tip: "Remember to release the task when done, or it will auto-expire."
+        });
+      }
+
+      if (name === "release_task") {
+        const { task_id, plan_id } = args;
+        const result = await apiClient.nodes.releaseTask(plan_id, task_id, 'mcp-agent');
+        return formatResponse({
+          success: true,
+          message: `Task ${task_id} released`,
+          ...result
+        });
+      }
+
       // Tool not found
       throw new Error(`Unknown tool: ${name}`);
     } catch (error) {