code-graph-context 2.5.4 → 2.6.0

package/dist/mcp/tools/swarm-complete-task.tool.js

@@ -76,10 +76,11 @@ const FAIL_TASK_QUERY = `
 `;
 /**
  * Query to mark task as needs_review
+ * Accepts both in_progress and claimed states (agent may have done work without calling start)
  */
 const REVIEW_TASK_QUERY = `
   MATCH (t:SwarmTask {id: $taskId, projectId: $projectId})
-  WHERE t.status = 'in_progress' AND t.claimedBy = $agentId
+  WHERE t.status IN ['in_progress', 'claimed'] AND t.claimedBy = $agentId
 
   SET t.status = 'needs_review',
       t.reviewRequestedAt = timestamp(),
@@ -180,6 +181,63 @@ const RETRY_TASK_QUERY = `
          t.status as status,
          t.retryCount as retryCount
 `;
+/**
+ * Query to get current task state for better error messages
+ */
+const GET_TASK_STATE_QUERY = `
+  MATCH (t:SwarmTask {id: $taskId, projectId: $projectId})
+  RETURN t.id as id,
+         t.title as title,
+         t.status as status,
+         t.claimedBy as claimedBy,
+         t.claimedAt as claimedAt,
+         t.startedAt as startedAt,
+         t.completedAt as completedAt,
+         t.failedAt as failedAt,
+         t.retryable as retryable,
+         t.abandonCount as abandonCount
+`;
+/**
+ * Helper to get task state and format error message
+ */
+async function getTaskStateError(neo4jService, taskId, projectId, action, agentId) {
+    const stateResult = await neo4jService.run(GET_TASK_STATE_QUERY, {
+        taskId,
+        projectId,
+    });
+    if (stateResult.length === 0) {
+        return `Task ${taskId} not found.`;
+    }
+    const state = stateResult[0];
+    const claimedBy = state.claimedBy || 'none';
+    const isOwner = claimedBy === agentId;
+    let suggestion = '';
+    if (action === 'complete' || action === 'fail') {
+        if (state.status === 'available') {
+            suggestion = 'You must claim the task first using swarm_claim_task.';
+        }
+        else if (!isOwner) {
+            suggestion = `Task is claimed by "${claimedBy}", not you.`;
+        }
+        else if (state.status === 'completed') {
+            suggestion = 'Task is already completed.';
+        }
+        else if (state.status === 'failed') {
+            suggestion = 'Task has failed. Use action="retry" to make it available again.';
+        }
+    }
+    else if (action === 'request_review') {
+        if (!isOwner) {
+            suggestion = `Task is claimed by "${claimedBy}", not you.`;
+        }
+        else if (state.status === 'available') {
+            suggestion = 'You must claim and work on the task first.';
+        }
+    }
+    return (`Cannot ${action} task ${taskId}. ` +
+        `Current state: ${state.status}, claimedBy: ${claimedBy}. ` +
+        (suggestion || 'Check that you own the task and it is in a valid state.'));
+}
 export const createSwarmCompleteTaskTool = (server) => {
     server.registerTool(TOOL_NAMES.swarmCompleteTask, {
         title: TOOL_METADATA[TOOL_NAMES.swarmCompleteTask].title,
@@ -246,14 +304,7 @@ export const createSwarmCompleteTaskTool = (server) => {
         }
         const resolvedProjectId = projectResult.projectId;
         try {
-            await debugLog('Swarm complete task', {
-                action,
-                taskId,
-                projectId: resolvedProjectId,
-                agentId,
-            });
             let result;
-            let responseData = { success: true, action };
             switch (action) {
                 case 'complete':
                     if (!summary) {
@@ -270,23 +321,14 @@ export const createSwarmCompleteTaskTool = (server) => {
                         linesRemoved: linesRemoved || 0,
                     });
                     if (result.length === 0) {
-                        return createErrorResponse(`Cannot complete task ${taskId}. It may not exist, not be in_progress, or you don't own it.`);
+                        const errorMsg = await getTaskStateError(neo4jService, taskId, resolvedProjectId, 'complete', agentId);
+                        return createErrorResponse(errorMsg);
                     }
-                    responseData.task = {
-                        id: result[0].id,
-                        title: result[0].title,
-                        status: result[0].status,
-                        completedAt: typeof result[0].completedAt === 'object'
-                            ? result[0].completedAt.toNumber()
-                            : result[0].completedAt,
-                        summary: result[0].summary,
-                        claimedBy: result[0].claimedBy,
-                    };
-                    responseData.unblockedTasks = result[0].unblockedTaskIds || [];
-                    responseData.message = responseData.unblockedTasks.length > 0
-                        ? `Task completed. ${responseData.unblockedTasks.length} dependent task(s) are now available.`
-                        : 'Task completed successfully.';
-                    break;
+                    return createSuccessResponse(JSON.stringify({
+                        action: 'completed',
+                        taskId: result[0].id,
+                        ...(result[0].unblockedTaskIds?.length > 0 && { unblockedTasks: result[0].unblockedTaskIds }),
+                    }));
                 case 'fail':
                     if (!reason) {
                         return createErrorResponse('reason is required for fail action');
@@ -300,22 +342,10 @@ export const createSwarmCompleteTaskTool = (server) => {
                         retryable,
                     });
                     if (result.length === 0) {
-                        return createErrorResponse(`Cannot fail task ${taskId}. It may not exist, not be in_progress/claimed, or you don't own it.`);
+                        const errorMsg = await getTaskStateError(neo4jService, taskId, resolvedProjectId, 'fail', agentId);
+                        return createErrorResponse(errorMsg);
                     }
-                    responseData.task = {
-                        id: result[0].id,
-                        title: result[0].title,
-                        status: result[0].status,
-                        failedAt: typeof result[0].failedAt === 'object'
-                            ? result[0].failedAt.toNumber()
-                            : result[0].failedAt,
-                        failureReason: result[0].failureReason,
-                        retryable: result[0].retryable,
-                    };
-                    responseData.message = retryable
-                        ? 'Task marked as failed. Use action="retry" to make it available again.'
-                        : 'Task marked as failed (not retryable).';
-                    break;
+                    return createSuccessResponse(JSON.stringify({ action: 'failed', taskId: result[0].id, retryable: result[0].retryable }));
                 case 'request_review':
                     if (!summary) {
                         return createErrorResponse('summary is required for request_review action');
@@ -330,20 +360,10 @@ export const createSwarmCompleteTaskTool = (server) => {
                         reviewNotes: reviewNotes || null,
                     });
                     if (result.length === 0) {
-                        return createErrorResponse(`Cannot request review for task ${taskId}. It may not exist, not be in_progress, or you don't own it.`);
+                        const errorMsg = await getTaskStateError(neo4jService, taskId, resolvedProjectId, 'request_review', agentId);
+                        return createErrorResponse(errorMsg);
                     }
-                    responseData.task = {
-                        id: result[0].id,
-                        title: result[0].title,
-                        status: result[0].status,
-                        reviewRequestedAt: typeof result[0].reviewRequestedAt === 'object'
-                            ? result[0].reviewRequestedAt.toNumber()
-                            : result[0].reviewRequestedAt,
-                        summary: result[0].summary,
-                        claimedBy: result[0].claimedBy,
-                    };
-                    responseData.message = 'Task submitted for review.';
-                    break;
+                    return createSuccessResponse(JSON.stringify({ action: 'review_requested', taskId: result[0].id }));
                 case 'approve':
                     if (!reviewerId) {
                         return createErrorResponse('reviewerId is required for approve action');
@@ -357,20 +377,11 @@ export const createSwarmCompleteTaskTool = (server) => {
                     if (result.length === 0) {
                         return createErrorResponse(`Cannot approve task ${taskId}. It may not exist or not be in needs_review status.`);
                     }
-                    responseData.task = {
-                        id: result[0].id,
-                        title: result[0].title,
-                        status: result[0].status,
-                        completedAt: typeof result[0].completedAt === 'object'
-                            ? result[0].completedAt.toNumber()
-                            : result[0].completedAt,
-                        approvedBy: result[0].approvedBy,
-                    };
-                    responseData.unblockedTasks = result[0].unblockedTaskIds || [];
-                    responseData.message = responseData.unblockedTasks.length > 0
-                        ? `Task approved. ${responseData.unblockedTasks.length} dependent task(s) are now available.`
-                        : 'Task approved and completed.';
-                    break;
+                    return createSuccessResponse(JSON.stringify({
+                        action: 'approved',
+                        taskId: result[0].id,
+                        ...(result[0].unblockedTaskIds?.length > 0 && { unblockedTasks: result[0].unblockedTaskIds }),
+                    }));
                 case 'reject':
                     if (!reviewerId) {
                         return createErrorResponse('reviewerId is required for reject action');
@@ -385,17 +396,7 @@ export const createSwarmCompleteTaskTool = (server) => {
                     if (result.length === 0) {
                         return createErrorResponse(`Cannot reject task ${taskId}. It may not exist or not be in needs_review status.`);
                     }
-                    responseData.task = {
-                        id: result[0].id,
-                        title: result[0].title,
-                        status: result[0].status,
-                        claimedBy: result[0].claimedBy,
-                        rejectionNotes: result[0].rejectionNotes,
-                    };
-                    responseData.message = markAsFailed
-                        ? 'Task rejected and marked as failed.'
-                        : 'Task rejected and returned to in_progress for the original agent to fix.';
-                    break;
+                    return createSuccessResponse(JSON.stringify({ action: 'rejected', taskId: result[0].id, status: result[0].status }));
                 case 'retry':
                     result = await neo4jService.run(RETRY_TASK_QUERY, {
                         taskId,
@@ -404,20 +405,10 @@ export const createSwarmCompleteTaskTool = (server) => {
                     if (result.length === 0) {
                         return createErrorResponse(`Cannot retry task ${taskId}. It may not exist, not be failed, or not be retryable.`);
                     }
-                    responseData.task = {
-                        id: result[0].id,
-                        title: result[0].title,
-                        status: result[0].status,
-                        retryCount: typeof result[0].retryCount === 'object'
-                            ? result[0].retryCount.toNumber()
-                            : result[0].retryCount,
-                    };
-                    responseData.message = `Task is now available for retry (attempt #${responseData.task.retryCount + 1}).`;
-                    break;
+                    return createSuccessResponse(JSON.stringify({ action: 'retried', taskId: result[0].id, status: 'available' }));
                 default:
                     return createErrorResponse(`Unknown action: ${action}`);
             }
-            return createSuccessResponse(JSON.stringify(responseData));
         }
         catch (error) {
             await debugLog('Swarm complete task error', { error: String(error) });

package/dist/mcp/tools/swarm-get-tasks.tool.js

@@ -212,15 +212,6 @@ export const createSwarmGetTasksTool = (server) => {
         }
         const resolvedProjectId = projectResult.projectId;
         try {
-            await debugLog('Swarm get tasks', {
-                projectId: resolvedProjectId,
-                swarmId,
-                taskId,
-                statuses,
-                types,
-                claimedBy,
-                limit,
-            });
             // If taskId is provided, get single task with full details
             if (taskId) {
                 const result = await neo4jService.run(GET_TASK_BY_ID_QUERY, {

package/dist/mcp/tools/swarm-orchestrate.tool.js

@@ -86,6 +86,21 @@ const CREATE_PHEROMONE_QUERY = `
   MERGE (p)-[:MARKS]->(target)
   RETURN p.nodeId AS nodeId
 `;
+/**
+ * Query to get node IDs for a file path (fallback when decomposition has no nodeIds)
+ * Uses ENDS WITH for flexible matching (handles absolute vs relative paths)
+ */
+const GET_NODES_FOR_FILE_QUERY = `
+  MATCH (n)
+  WHERE (n.filePath = $filePath OR n.filePath ENDS WITH $filePath)
+    AND n.projectId = $projectId
+    AND n.id IS NOT NULL
+    AND NOT n:Pheromone
+    AND NOT n:SwarmTask
+  RETURN n.id AS id, n.name AS name, n.coreType AS coreType
+  ORDER BY n.startLine
+  LIMIT 20
+`;
 /**
  * Query to create a SwarmTask node
  */
@@ -183,15 +198,7 @@ export const createSwarmOrchestrateTool = (server) => {
                 return projectResult.error;
             }
             const resolvedProjectId = projectResult.projectId;
-            await debugLog('Swarm orchestration started', {
-                swarmId,
-                projectId: resolvedProjectId,
-                task,
-                maxAgents,
-                dryRun,
-            });
             // Step 2: Semantic search to find affected nodes
-            await debugLog('Searching for affected nodes', { task });
             let embedding;
             try {
                 embedding = await embeddingsService.embedText(task);
@@ -218,12 +225,7 @@ export const createSwarmOrchestrateTool = (server) => {
                 startLine: typeof r.startLine === 'object' ? r.startLine.toNumber() : r.startLine,
                 endLine: typeof r.endLine === 'object' ? r.endLine.toNumber() : r.endLine,
             }));
-            await debugLog('Found affected nodes', {
-                count: affectedNodes.length,
-                files: [...new Set(affectedNodes.map((n) => n.filePath))].length,
-            });
             // Step 3: Run impact analysis on each node
-            await debugLog('Running impact analysis', { nodeCount: affectedNodes.length });
             const impactMap = new Map();
             for (const node of affectedNodes) {
                 const impactResult = await neo4jService.run(IMPACT_QUERY, {
@@ -247,22 +249,27 @@ export const createSwarmOrchestrateTool = (server) => {
                 }
             }
             // Step 4: Decompose task into atomic tasks
-            await debugLog('Decomposing task', { nodeCount: affectedNodes.length });
             const decomposition = await taskDecomposer.decomposeTask(task, affectedNodes, impactMap, priority);
             if (decomposition.tasks.length === 0) {
                 return createErrorResponse('Task decomposition produced no actionable tasks');
             }
-            await debugLog('Task decomposition complete', {
-                totalTasks: decomposition.tasks.length,
-                parallelizable: decomposition.summary.parallelizable,
-            });
             // Step 5: Create SwarmTasks on the blackboard (unless dry run)
             if (!dryRun) {
-                await debugLog('Creating SwarmTasks', { count: decomposition.tasks.length });
                 for (const atomicTask of decomposition.tasks) {
                     // Determine initial status based on dependencies
                     const hasUnmetDeps = atomicTask.dependencies.length > 0;
                     const initialStatus = hasUnmetDeps ? 'blocked' : 'available';
+                    // Filter out null/undefined nodeIds, then fallback to file query if empty
+                    let targetNodeIds = (atomicTask.nodeIds || []).filter((id) => typeof id === 'string' && id.length > 0);
+                    if (targetNodeIds.length === 0 && atomicTask.filePath) {
+                        const fileNodes = await neo4jService.run(GET_NODES_FOR_FILE_QUERY, {
+                            filePath: atomicTask.filePath,
+                            projectId: resolvedProjectId,
+                        });
+                        if (fileNodes.length > 0) {
+                            targetNodeIds = fileNodes.map((n) => n.id).filter(Boolean);
+                        }
+                    }
                     await neo4jService.run(CREATE_TASK_QUERY, {
                         taskId: atomicTask.id,
                         projectId: resolvedProjectId,
@@ -273,14 +280,15 @@ export const createSwarmOrchestrateTool = (server) => {
                         priority: atomicTask.priority,
                         priorityScore: atomicTask.priorityScore,
                         status: initialStatus,
-                        targetNodeIds: atomicTask.nodeIds,
+                        targetNodeIds,
                         targetFilePaths: [atomicTask.filePath],
                         dependencies: atomicTask.dependencies,
                         createdBy: 'orchestrator',
                         metadata: JSON.stringify(atomicTask.metadata ?? {}),
                     });
+                    // Update the atomicTask.nodeIds for pheromone creation below
+                    atomicTask.nodeIds = targetNodeIds;
                 }
-                await debugLog('SwarmTasks created', { swarmId, count: decomposition.tasks.length });
                 // Step 5b: Leave "proposal" pheromones on all target nodes
                 // This signals to other agents that work is planned for these nodes
                 const uniqueNodeIds = new Set();
@@ -289,7 +297,6 @@ export const createSwarmOrchestrateTool = (server) => {
                         uniqueNodeIds.add(nodeId);
                     }
                 }
-                await debugLog('Creating proposal pheromones', { nodeCount: uniqueNodeIds.size });
                 for (const nodeId of uniqueNodeIds) {
                     await neo4jService.run(CREATE_PHEROMONE_QUERY, {
                         nodeId,
@@ -302,7 +309,6 @@ export const createSwarmOrchestrateTool = (server) => {
                         data: JSON.stringify({ task, swarmId }),
                     });
                 }
-                await debugLog('Proposal pheromones created', { swarmId, count: uniqueNodeIds.size });
             }
             // Step 6: Generate worker instructions
             const workerInstructions = generateWorkerInstructions(swarmId, resolvedProjectId, maxAgents, decomposition.tasks.length);
@@ -331,11 +337,6 @@ export const createSwarmOrchestrateTool = (server) => {
                     ? `Dry run complete. ${decomposition.tasks.length} tasks planned but not created.`
                     : `Swarm ready! ${decomposition.tasks.length} tasks created. ${decomposition.summary.parallelizable} can run in parallel.`,
             };
-            await debugLog('Swarm orchestration complete', {
-                swarmId,
-                status: result.status,
-                totalTasks: result.plan.totalTasks,
-            });
             return createSuccessResponse(JSON.stringify(result, null, 2));
         }
         catch (error) {
@@ -354,103 +355,65 @@ function generateWorkerInstructions(swarmId, projectId, maxAgents, taskCount) {
     const recommendedAgents = Math.min(maxAgents, Math.ceil(taskCount / 2), taskCount);
     // Generate unique agent IDs for each worker
     const agentIds = Array.from({ length: recommendedAgents }, (_, i) => `${swarmId}_worker_${i + 1}`);
-    const workerPrompt = `You are a swarm worker agent.
+    const workerPrompt = `You are a swarm worker agent with access to a code graph.
 - Agent ID: {AGENT_ID}
 - Swarm ID: ${swarmId}
 - Project: ${projectId}
 
-## CRITICAL RULES
-1. NEVER fabricate node IDs - get them from graph tool responses
-2. ALWAYS use the blackboard task queue (swarm_claim_task, swarm_complete_task)
-3. Use graph tools (traverse_from_node, search_codebase) to understand context
-4. Exit when swarm_claim_task returns "no_tasks"
+## RULES
+1. Use graph tools (traverse_from_node, search_codebase) for context
+2. Tasks provide: targets (best), targetNodeIds (good), targetFilePaths (fallback)
+3. Exit when swarm_claim_task returns "no_tasks"
 
-## WORKFLOW - Follow these steps exactly:
+## WORKFLOW
 
-### Step 1: Claim a task from the blackboard
+### Step 1: Claim a task
 swarm_claim_task({
   projectId: "${projectId}",
   swarmId: "${swarmId}",
   agentId: "{AGENT_ID}"
 })
-// If returns "no_tasks" → exit, swarm is complete
-// Otherwise you now own the returned task
+// Returns: { task: { id, targets: [{nodeId, name, filePath}], targetFilePaths, ... } }
+// If "no_tasks" → exit
 
-### Step 2: Start working and check for conflicts
-swarm_claim_task({
-  projectId: "${projectId}",
-  swarmId: "${swarmId}",
-  agentId: "{AGENT_ID}",
-  taskId: "<TASK_ID_FROM_STEP_1>",
-  action: "start"
-})
-
-// Check if another agent is working on related code
-swarm_sense({
-  projectId: "${projectId}",
-  swarmId: "${swarmId}",
-  types: ["modifying", "warning"],
-  excludeAgentId: "{AGENT_ID}"
-})
-
-### Step 3: Understand the code context (USE GRAPH TOOLS!)
-// Use traverse_from_node to see relationships and callers
+### Step 2: Understand context via graph (USE NODE IDs!)
+// Priority: task.targets[0].nodeId > task.targetNodeIds[0] > search
 traverse_from_node({
   projectId: "${projectId}",
-  filePath: "<TARGET_FILE_FROM_TASK>",
-  maxDepth: 2,
-  includeCode: true
+  nodeId: "<nodeId_FROM_task.targets>",
+  maxDepth: 2
 })
 
-// Or search for related code
-search_codebase({
-  projectId: "${projectId}",
-  query: "<WHAT_YOU_NEED_TO_UNDERSTAND>"
-})
+// Fallback if no nodeIds:
+search_codebase({ projectId: "${projectId}", query: "<TASK_DESCRIPTION>" })
 
-### Step 4: Do the work
-- Use Read tool for full source code of files to modify
-- Use Edit tool to make changes
-- Mark nodes you're modifying:
+### Step 3: Mark nodes you're analyzing/modifying
 swarm_pheromone({
   projectId: "${projectId}",
-  nodeId: "<NODE_ID_FROM_GRAPH>",
+  nodeId: "<nodeId>",
   type: "modifying",
   agentId: "{AGENT_ID}",
   swarmId: "${swarmId}"
 })
 
-### Step 5: Complete the task via blackboard
-swarm_pheromone({
-  projectId: "${projectId}",
-  nodeId: "<NODE_ID>",
-  type: "completed",
-  agentId: "{AGENT_ID}",
-  swarmId: "${swarmId}",
-  data: { summary: "<WHAT_YOU_DID>" }
-})
+### Step 4: Do the work
+- Read tool for full source
+- Edit tool for changes
 
+### Step 5: Complete the task
 swarm_complete_task({
   projectId: "${projectId}",
   taskId: "<TASK_ID>",
   agentId: "{AGENT_ID}",
   action: "complete",
-  summary: "<DESCRIBE_WHAT_YOU_DID>",
-  filesChanged: ["<LIST_OF_FILES_YOU_MODIFIED>"]
+  summary: "<WHAT_YOU_DID>",
+  filesChanged: ["<FILES>"]
 })
 
-### Step 6: Loop back to Step 1
-Claim the next available task. Continue until no tasks remain.
+### Step 6: Loop to Step 1
 
-## IF YOU GET STUCK
-swarm_complete_task({
-  projectId: "${projectId}",
-  taskId: "<TASK_ID>",
-  agentId: "{AGENT_ID}",
-  action: "fail",
-  reason: "<WHY_YOU_ARE_STUCK>",
-  retryable: true
-})
+## IF STUCK
+swarm_complete_task({ ..., action: "fail", reason: "<WHY>", retryable: true })
 Then claim another task.`;
     const taskCalls = agentIds.map(agentId => {
         const prompt = workerPrompt.replace(/\{AGENT_ID\}/g, agentId);

package/dist/mcp/tools/swarm-post-task.tool.js

@@ -7,6 +7,21 @@ import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
 import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
 import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog } from '../utils.js';
 import { TASK_PRIORITIES, TASK_TYPES, generateTaskId, } from './swarm-constants.js';
+/**
+ * Query to get node IDs for a file path (fallback when no nodeIds provided)
+ * Uses ENDS WITH for flexible matching (handles absolute vs relative paths)
+ */
+const GET_NODES_FOR_FILE_QUERY = `
+  MATCH (n)
+  WHERE (n.filePath = $filePath OR n.filePath ENDS WITH $filePath)
+    AND n.projectId = $projectId
+    AND n.id IS NOT NULL
+    AND NOT n:Pheromone
+    AND NOT n:SwarmTask
+  RETURN n.id AS id
+  ORDER BY n.startLine
+  LIMIT 20
+`;
 /**
  * Neo4j query to create a new SwarmTask node
  */
@@ -138,16 +153,22 @@ export const createSwarmPostTaskTool = (server) => {
             const taskId = generateTaskId();
             const priorityScore = TASK_PRIORITIES[priority];
             const metadataJson = metadata ? JSON.stringify(metadata) : null;
-            await debugLog('Creating swarm task', {
-                taskId,
-                projectId: resolvedProjectId,
-                swarmId,
-                title,
-                type,
-                priority,
-                targetNodeIds: targetNodeIds.length,
-                dependencies: dependencies.length,
-            });
+            // Filter out null/undefined, then fallback to file query if empty
+            let resolvedNodeIds = (targetNodeIds || []).filter((id) => typeof id === 'string' && id.length > 0);
+            if (resolvedNodeIds.length === 0 && targetFilePaths.length > 0) {
+                for (const filePath of targetFilePaths) {
+                    const fileNodes = await neo4jService.run(GET_NODES_FOR_FILE_QUERY, {
+                        filePath,
+                        projectId: resolvedProjectId,
+                    });
+                    if (fileNodes.length > 0) {
+                        resolvedNodeIds = [
+                            ...resolvedNodeIds,
+                            ...fileNodes.map((n) => n.id).filter(Boolean),
+                        ];
+                    }
+                }
+            }
             // Create the task
             const result = await neo4jService.run(CREATE_TASK_QUERY, {
                 taskId,
@@ -158,7 +179,7 @@ export const createSwarmPostTaskTool = (server) => {
                 type,
                 priority,
                 priorityScore,
-                targetNodeIds,
+                targetNodeIds: resolvedNodeIds,
                 targetFilePaths,
                 dependencies,
                 createdBy,

package/dist/mcp/tools/traverse-from-node.tool.js

@@ -109,21 +109,6 @@ export const createTraverseFromNodeTool = (server) => {
             }
             const sanitizedMaxDepth = sanitizeNumericInput(maxDepth, DEFAULTS.traversalDepth, MAX_TRAVERSAL_DEPTH);
             const sanitizedSkip = sanitizeNumericInput(skip, DEFAULTS.skipOffset);
-            await debugLog('Node traversal started', {
-                projectId: resolvedProjectId,
-                nodeId: resolvedNodeId,
-                filePath,
-                maxDepth: sanitizedMaxDepth,
-                skip: sanitizedSkip,
-                limit,
-                direction,
-                relationshipTypes,
-                includeCode,
-                maxNodesPerChain,
-                summaryOnly,
-                snippetLength,
-                maxTotalNodes,
-            });
             // Safety check - resolvedNodeId should be set at this point
             if (!resolvedNodeId) {
                 return createErrorResponse('Could not resolve node ID from provided parameters.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-context",
-  "version": "2.5.4",
+  "version": "2.6.0",
   "description": "MCP server that builds code graphs to provide rich context to LLMs",
   "type": "module",
   "homepage": "https://github.com/drewdrewH/code-graph-context#readme",