agent-planner-mcp 0.5.0 → 0.6.0

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,61 +138,64 @@ 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')" }
+            }
+          }
+        },
+
         // ========================================
-        // CONTEXT LOADING - Get everything you need
-        // Use before starting work on a plan/goal
+        // TASK CLAIMING - Prevent agent collisions
         // ========================================
         {
-          name: "get_context",
-          description: "Load EVERYTHING you need to work on a plan or goal: structure, status, progress, blocked tasks, recent activity, and relevant knowledge. Call this FIRST before starting work.",
+          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: {
-              plan_id: { type: "string", description: "Plan to get context for" },
-              goal_id: { type: "string", description: "Goal to get context for" },
-              include_knowledge: { type: "boolean", default: true, description: "Include relevant knowledge entries" }
-            }
+              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: "get_my_tasks",
-          description: "Get tasks that need attention - blocked tasks, in-progress tasks, and next tasks to start. Perfect for heartbeat check-ins.",
+          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: {
-              plan_id: { type: "string", description: "Specific plan to check (optional - checks all if not provided)" },
-              status: { 
-                type: "array", 
-                items: { type: "string" },
-                default: ["blocked", "in_progress"],
-                description: "Task statuses to include"
-              }
-            }
+              task_id: { type: "string", description: "Task ID to release" },
+              plan_id: { type: "string", description: "Plan ID" }
+            },
+            required: ["task_id", "plan_id"]
           }
         },
 
         // ========================================
-        // KNOWLEDGE - Build persistent memory
+        // CONTEXT LOADING - Get everything you need
+        // Use before starting work on a plan/goal
         // ========================================
         {
-          name: "add_learning",
-          description: "Capture something you learned for future reference. This persists beyond the current session - other agents and future-you will benefit.",
+          name: "get_my_tasks",
+          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: {
-              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"
+              plan_id: { type: "string", description: "Specific plan to check (optional - checks all if not provided)" },
+              status: { 
+                type: "array", 
+                items: { type: "string" },
+                default: ["blocked", "in_progress"],
+                description: "Task statuses to include"
               }
-            },
-            required: ["title", "content"]
+            }
           }
         },
 
@@ -380,14 +389,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 +420,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"]
           }
@@ -443,8 +463,8 @@ function setupTools(server) {
           }
         },
         {
-          name: "get_node_context",
-          description: "Get comprehensive context for a node including children and logs",
+          name: "get_node_ancestry",
+          description: "Get the path from root to a specific node",
           inputSchema: {
             type: "object",
             properties: {
@@ -454,19 +474,169 @@ function setupTools(server) {
             required: ["plan_id", "node_id"]
           }
         },
+        
+        // ===== 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: "get_node_ancestry",
-          description: "Get the path from root to a specific node",
+          name: "delete_dependency",
+          description: "Delete a dependency edge",
           inputSchema: {
             type: "object",
             properties: {
               plan_id: { type: "string", description: "Plan ID" },
-              node_id: { type: "string", description: "Node 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 +702,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" }
@@ -548,7 +718,7 @@ function setupTools(server) {
         // ===== PLAN STRUCTURE & SUMMARY =====
         {
           name: "get_plan_structure",
-          description: "Get the hierarchical structure of a plan with minimal fields (id, parent_id, node_type, title, status, order_index). Use get_node_context for detailed information about specific nodes.",
+          description: "Get the hierarchical structure of a plan with minimal fields (id, parent_id, node_type, title, status, order_index). Use get_task_context for detailed information about specific nodes.",
           inputSchema: {
             type: "object",
             properties: {
@@ -575,33 +745,9 @@ function setupTools(server) {
         },
         
         // ===== AGENT CONTEXT TOOLS (Leaf-up context loading) =====
-        {
-          name: "get_agent_context",
-          description: "Get focused context for a specific task/node. Uses leaf-up traversal - returns only the relevant path from the node to root, not the entire plan tree. Best for agents starting work on a specific task.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              node_id: { 
-                type: "string", 
-                description: "Task or phase node ID to get context for" 
-              },
-              include_knowledge: { 
-                type: "boolean", 
-                description: "Include knowledge entries from relevant scopes (plan, goals, org)",
-                default: true
-              },
-              include_siblings: { 
-                type: "boolean", 
-                description: "Include sibling tasks in the same phase",
-                default: false
-              }
-            },
-            required: ["node_id"]
-          }
-        },
         {
           name: "get_plan_context",
-          description: "Get plan-level context overview. Returns plan details, phase summaries (not full tree), linked goals, and organization. Use get_agent_context for task-focused work.",
+          description: "Get plan-level context overview. Returns plan details, phase summaries (not full tree), linked goals, and organization. Use get_task_context for task-focused work.",
           inputSchema: {
             type: "object",
             properties: {
@@ -766,102 +912,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 }
+            }
           }
         },
 
@@ -881,18 +1099,6 @@ function setupTools(server) {
             }
           }
         },
-        {
-          name: "understand_context",
-          description: "Get comprehensive context about a plan or goal - its purpose, current state, recent activity, blocked tasks, and relevant knowledge. Use this BEFORE starting work to understand the full situation.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              plan_id: { type: "string", description: "Plan ID to understand" },
-              goal_id: { type: "string", description: "Goal ID to understand" },
-              include_knowledge: { type: "boolean", description: "Include relevant knowledge entries", default: true }
-            }
-          }
-        }
       ]
     };
   });
@@ -967,14 +1173,14 @@ 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,
           next_steps: [
             "Use quick_status to update task progress",
             "Use quick_log to document your work",
-            "Use get_context to load full plan details"
+            "Use get_plan_context to load full plan details"
           ]
         });
       }
@@ -1029,7 +1235,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"
@@ -1110,96 +1316,7 @@ function setupTools(server) {
       // ========================================
       // CONTEXT LOADING IMPLEMENTATIONS
       // ========================================
-      
-      if (name === "get_context") {
-        // Redirect to understand_context implementation (same functionality)
-        const { plan_id, goal_id, include_knowledge = true } = args;
-        
-        if (!plan_id && !goal_id) {
-          return formatResponse({
-            error: "Provide either plan_id or goal_id to get context",
-            suggestion: "Use list_plans or list_goals to find IDs"
-          });
-        }
-        
-        const context = {
-          retrieved_at: new Date().toISOString()
-        };
-        
-        // Get goal context
-        if (goal_id) {
-          try {
-            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 || [];
-              } catch (e) {}
-            }
-          } catch (e) {
-            context.goal_error = e.message;
-          }
-        }
-        
-        // Get plan context
-        if (plan_id) {
-          try {
-            context.plan = await apiClient.plans.getPlan(plan_id);
-            context.plan_url = `https://www.agentplanner.io/app/plans/${plan_id}`;
-            
-            const nodes = await apiClient.nodes.getNodes(plan_id);
-            context.statistics = calculatePlanStatistics(nodes);
-            context.progress_percentage = context.statistics.total > 0 
-              ? ((context.statistics.status_counts.completed / context.statistics.total) * 100).toFixed(1) + '%'
-              : '0%';
-            
-            const flatNodes = flattenNodes(nodes);
-            context.needs_attention = {
-              blocked: flatNodes.filter(n => n.status === 'blocked').map(n => ({ 
-                id: n.id, title: n.title, type: n.node_type
-              })),
-              in_progress: flatNodes.filter(n => n.status === 'in_progress').map(n => ({ 
-                id: n.id, title: n.title, type: n.node_type
-              })),
-              ready_to_start: flatNodes
-                .filter(n => n.node_type === 'task' && n.status === 'not_started')
-                .slice(0, 5)
-                .map(n => ({ id: n.id, title: n.title }))
-            };
-            
-            try {
-              const activity = await apiClient.activity.getPlanActivity(plan_id);
-              context.recent_activity = (activity || []).slice(0, 5);
-            } catch (e) {}
-            
-            if (include_knowledge) {
-              try {
-                const knowledge = await apiClient.knowledge.getEntries({ 
-                  scope: 'plan',
-                  scope_id: plan_id,
-                  limit: 10 
-                });
-                context.plan_knowledge = knowledge.entries || [];
-              } catch (e) {}
-            }
-          } catch (e) {
-            context.plan_error = e.message;
-          }
-        }
-        
-        context.recommendation = context.needs_attention?.blocked?.length > 0 
-          ? "⚠️ There are blocked tasks that need attention first"
-          : context.needs_attention?.in_progress?.length > 0
-            ? "Continue working on the in-progress tasks"
-            : "Pick a task from ready_to_start to begin";
-            
-        return formatResponse(context);
-      }
-      
+
       if (name === "get_my_tasks") {
         const { plan_id, status = ["blocked", "in_progress"] } = args;
         
@@ -1260,34 +1377,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,11 +1566,11 @@ 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: [
-            "Use get_context to review the imported plan",
+            "Use get_plan_context to review the imported plan",
             "Use quick_status to update task progress"
           ]
         });
@@ -1600,7 +1691,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,55 +1732,130 @@ 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;
         }
       }
       
-      if (name === "get_node_context") {
+      if (name === "get_node_ancestry") {
         const { plan_id, node_id } = args;
         
-        // Get node with context
+        // Get node ancestry
         const response = await apiClient.axiosInstance.get(
-          `/plans/${plan_id}/nodes/${node_id}/context`
+          `/plans/${plan_id}/nodes/${node_id}/ancestry`
         );
         
         return formatResponse(response.data);
       }
       
-      if (name === "get_node_ancestry") {
-        const { plan_id, node_id } = args;
-        
-        // Get node ancestry
+      // ===== 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}/nodes/${node_id}/ancestry`
+          `/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;
@@ -1804,17 +1970,6 @@ function setupTools(server) {
       }
       
       // ===== AGENT CONTEXT TOOLS =====
-      if (name === "get_agent_context") {
-        const { node_id, include_knowledge = true, include_siblings = false } = args;
-        
-        const result = await apiClient.context.getNodeContext(node_id, {
-          include_knowledge,
-          include_siblings
-        });
-        
-        return formatResponse(result);
-      }
-      
       if (name === "get_plan_context") {
         const { plan_id, include_knowledge = true } = args;
         
@@ -1901,60 +2056,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 || {};
@@ -1973,10 +2222,10 @@ function setupTools(server) {
             recommended_workflow: [
               "1. Check list_goals to understand current objectives",
               "2. Use list_plans to see existing plans",
-              "3. Before working on a plan, use understand_context to get the full picture",
+              "3. Before working on a plan, use get_plan_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 +2257,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 +2274,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 +2300,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",
@@ -2074,98 +2323,45 @@ function setupTools(server) {
         return formatResponse(guides[topic] || guides.overview);
       }
 
-      if (name === "understand_context") {
-        const { plan_id, goal_id, include_knowledge = true } = args;
-        
-        if (!plan_id && !goal_id) {
-          return formatResponse({
-            error: "Provide either plan_id or goal_id to get context"
-          });
-        }
-        
-        const context = {
-          retrieved_at: new Date().toISOString()
-        };
-        
-        // Get goal context
-        if (goal_id) {
-          try {
-            context.goal = await apiClient.goals.get(goal_id);
-            
-            // 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 || [];
-              } catch (e) {
-                // Knowledge fetch failed, continue without it
-              }
-            }
-          } catch (e) {
-            context.goal_error = e.message;
-          }
-        }
-        
-        // Get plan context
-        if (plan_id) {
-          try {
-            context.plan = await apiClient.plans.getPlan(plan_id);
-            
-            const nodes = await apiClient.nodes.getNodes(plan_id);
-            context.statistics = calculatePlanStatistics(nodes);
-            context.progress_percentage = context.statistics.total > 0 
-              ? ((context.statistics.status_counts.completed / context.statistics.total) * 100).toFixed(1) + '%'
-              : '0%';
-            
-            // Get blocked and in-progress tasks for attention
-            const flatNodes = flattenNodes(nodes);
-            context.needs_attention = {
-              blocked: flatNodes.filter(n => n.status === 'blocked').map(n => ({ 
-                id: n.id, 
-                title: n.title,
-                type: n.node_type
-              })),
-              in_progress: flatNodes.filter(n => n.status === 'in_progress').map(n => ({ 
-                id: n.id, 
-                title: n.title,
-                type: n.node_type
-              }))
-            };
-            
-            // Get recent activity
-            try {
-              const activity = await apiClient.activity.getPlanActivity(plan_id);
-              context.recent_activity = (activity || []).slice(0, 5);
-            } catch (e) {
-              // Activity fetch failed, continue without it
-            }
-            
-            // 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 || [];
-              } catch (e) {
-                // Knowledge fetch failed, continue without it
-              }
-            }
-          } catch (e) {
-            context.plan_error = e.message;
-          }
+      // ===== 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);
         }
-        
-        context.recommendation = "Review the statistics, needs_attention, and knowledge entries before starting work.";
-        return formatResponse(context);
+
+        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) {