code-graph-context 2.5.3 → 2.6.0

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

@@ -1,12 +1,21 @@
 /**
  * Swarm Claim Task Tool
  * Allow an agent to claim an available task from the blackboard
+ *
+ * Phase 1 improvements:
+ * - Atomic claim_and_start action (eliminates race window)
+ * - Retry logic on race loss
+ * - Recovery actions (abandon, force_start)
  */
 import { z } from 'zod';
 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_TYPES, TASK_PRIORITIES } from './swarm-constants.js';
+/** Maximum retries when racing for a task */
+const MAX_CLAIM_RETRIES = 3;
+/** Delay between retries (ms) */
+const RETRY_DELAY_BASE_MS = 50;
 /**
  * Query to claim a specific task by ID
  * Uses atomic update to prevent race conditions
@@ -30,9 +39,10 @@ const CLAIM_TASK_BY_ID_QUERY = `
   WITH t WHERE t.status IN ['available', 'blocked']
 
   // Atomic claim
-  SET t.status = 'claimed',
+  SET t.status = $targetStatus,
       t.claimedBy = $agentId,
       t.claimedAt = timestamp(),
+      t.startedAt = CASE WHEN $targetStatus = 'in_progress' THEN timestamp() ELSE null END,
       t.updatedAt = timestamp()
 
   // Return task details with target info
@@ -52,6 +62,7 @@ const CLAIM_TASK_BY_ID_QUERY = `
          t.dependencies as dependencies,
          t.claimedBy as claimedBy,
          t.claimedAt as claimedAt,
+         t.startedAt as startedAt,
          t.createdBy as createdBy,
          t.metadata as metadata,
          collect(DISTINCT {
@@ -64,6 +75,7 @@ const CLAIM_TASK_BY_ID_QUERY = `
 /**
  * Query to claim the highest priority available task matching criteria
  * Uses APOC locking to prevent race conditions between parallel workers
+ * Supports both 'claimed' and 'in_progress' target states for atomic claim_and_start
  */
 const CLAIM_NEXT_TASK_QUERY = `
   // Find available or blocked tasks (blocked tasks may have deps completed now)
@@ -78,7 +90,8 @@ const CLAIM_NEXT_TASK_QUERY = `
   WITH t, count(dep) as incompleteDeps
   WHERE incompleteDeps = 0
 
-  // Order by priority (highest first), then by creation time (oldest first)
+  // Re-establish context for ordering (required by Cypher syntax)
+  WITH t
   ORDER BY t.priorityScore DESC, t.createdAt ASC
   LIMIT 1
 
@@ -88,10 +101,11 @@ const CLAIM_NEXT_TASK_QUERY = `
   // Double-check status after acquiring lock (another worker may have claimed it)
   WITH t WHERE t.status IN ['available', 'blocked']
 
-  // Atomic claim
-  SET t.status = 'claimed',
+  // Atomic claim - supports both claim and claim_and_start via $targetStatus
+  SET t.status = $targetStatus,
       t.claimedBy = $agentId,
       t.claimedAt = timestamp(),
+      t.startedAt = CASE WHEN $targetStatus = 'in_progress' THEN timestamp() ELSE null END,
       t.updatedAt = timestamp()
 
   // Return task details with target info
@@ -111,6 +125,7 @@ const CLAIM_NEXT_TASK_QUERY = `
          t.dependencies as dependencies,
          t.claimedBy as claimedBy,
          t.claimedAt as claimedAt,
+         t.startedAt as startedAt,
          t.createdBy as createdBy,
          t.metadata as metadata,
          collect(DISTINCT {
@@ -154,6 +169,71 @@ const RELEASE_TASK_QUERY = `
          t.title as title,
          t.status as status
 `;
+/**
+ * Query to abandon a task - releases it with tracking for debugging
+ * More explicit than release, tracks abandon history
+ */
+const ABANDON_TASK_QUERY = `
+  MATCH (t:SwarmTask {id: $taskId, projectId: $projectId})
+  WHERE t.claimedBy = $agentId
+    AND t.status IN ['claimed', 'in_progress']
+
+  // Track abandon history
+  SET t.status = 'available',
+      t.previousClaimedBy = t.claimedBy,
+      t.claimedBy = null,
+      t.claimedAt = null,
+      t.startedAt = null,
+      t.updatedAt = timestamp(),
+      t.abandonedBy = $agentId,
+      t.abandonedAt = timestamp(),
+      t.abandonReason = $reason,
+      t.abandonCount = COALESCE(t.abandonCount, 0) + 1
+
+  RETURN t.id as id,
+         t.title as title,
+         t.status as status,
+         t.abandonCount as abandonCount,
+         t.abandonReason as abandonReason
+`;
+/**
+ * Query to force-start a task that's stuck in claimed state
+ * Allows recovery when the normal start action fails
+ */
+const FORCE_START_QUERY = `
+  MATCH (t:SwarmTask {id: $taskId, projectId: $projectId})
+  WHERE t.claimedBy = $agentId
+    AND t.status IN ['claimed', 'available']
+
+  SET t.status = 'in_progress',
+      t.claimedBy = $agentId,
+      t.claimedAt = COALESCE(t.claimedAt, timestamp()),
+      t.startedAt = timestamp(),
+      t.updatedAt = timestamp(),
+      t.forceStarted = true,
+      t.forceStartReason = $reason
+
+  RETURN t.id as id,
+         t.title as title,
+         t.status as status,
+         t.claimedBy as claimedBy,
+         t.startedAt as startedAt,
+         t.forceStarted as forceStarted
+`;
+/**
+ * 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.abandonCount as abandonCount,
+         t.previousClaimedBy as previousClaimedBy
+`;
 export const createSwarmClaimTaskTool = (server) => {
     server.registerTool(TOOL_NAMES.swarmClaimTask, {
         title: TOOL_METADATA[TOOL_NAMES.swarmClaimTask].title,
@@ -175,16 +255,18 @@ export const createSwarmClaimTaskTool = (server) => {
                 .optional()
                 .describe('Minimum priority level when auto-selecting'),
             action: z
-                .enum(['claim', 'start', 'release'])
+                .enum(['claim', 'claim_and_start', 'start', 'release', 'abandon', 'force_start'])
                 .optional()
-                .default('claim')
-                .describe('Action: claim (reserve task), start (begin work), release (give up task)'),
+                .default('claim_and_start')
+                .describe('Action: claim_and_start (RECOMMENDED: atomic claim+start), claim (reserve only), ' +
+                'start (begin work on claimed task), release (give up task), ' +
+                'abandon (release with tracking), force_start (recover from stuck claimed state)'),
             releaseReason: z
                 .string()
                 .optional()
-                .describe('Reason for releasing the task (required if action=release)'),
+                .describe('Reason for releasing/abandoning the task'),
         },
-    }, async ({ projectId, swarmId, agentId, taskId, types, minPriority, action = 'claim', releaseReason, }) => {
+    }, async ({ projectId, swarmId, agentId, taskId, types, minPriority, action = 'claim_and_start', releaseReason, }) => {
         const neo4jService = new Neo4jService();
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
@@ -194,15 +276,6 @@ export const createSwarmClaimTaskTool = (server) => {
         }
         const resolvedProjectId = projectResult.projectId;
         try {
-            await debugLog('Swarm claim task', {
-                action,
-                projectId: resolvedProjectId,
-                swarmId,
-                agentId,
-                taskId,
-                types,
-                minPriority,
-            });
             // Handle release action
             if (action === 'release') {
                 if (!taskId) {
@@ -215,18 +288,70 @@ export const createSwarmClaimTaskTool = (server) => {
                     reason: releaseReason || 'No reason provided',
                 });
                 if (result.length === 0) {
-                    return createErrorResponse(`Cannot release task ${taskId}. Either it doesn't exist, isn't claimed/in_progress, or you don't own it.`);
+                    // Get current state for better error message
+                    const stateResult = await neo4jService.run(GET_TASK_STATE_QUERY, {
+                        taskId,
+                        projectId: resolvedProjectId,
+                    });
+                    const currentState = stateResult[0];
+                    return createErrorResponse(`Cannot release task ${taskId}. ` +
+                        (currentState
+                            ? `Current state: ${currentState.status}, claimedBy: ${currentState.claimedBy || 'none'}`
+                            : 'Task not found.'));
+                }
+                return createSuccessResponse(JSON.stringify({ action: 'released', taskId: result[0].id }));
+            }
+            // Handle abandon action (release with tracking)
+            if (action === 'abandon') {
+                if (!taskId) {
+                    return createErrorResponse('taskId is required for abandon action');
+                }
+                const result = await neo4jService.run(ABANDON_TASK_QUERY, {
+                    taskId,
+                    projectId: resolvedProjectId,
+                    agentId,
+                    reason: releaseReason || 'No reason provided',
+                });
+                if (result.length === 0) {
+                    const stateResult = await neo4jService.run(GET_TASK_STATE_QUERY, {
+                        taskId,
+                        projectId: resolvedProjectId,
+                    });
+                    const currentState = stateResult[0];
+                    return createErrorResponse(`Cannot abandon task ${taskId}. ` +
+                        (currentState
+                            ? `Current state: ${currentState.status}, claimedBy: ${currentState.claimedBy || 'none'}`
+                            : 'Task not found.'));
+                }
+                const abandonCount = typeof result[0].abandonCount === 'object'
+                    ? result[0].abandonCount.toNumber()
+                    : result[0].abandonCount;
+                return createSuccessResponse(JSON.stringify({ action: 'abandoned', taskId: result[0].id, abandonCount }));
+            }
+            // Handle force_start action (recovery from stuck claimed state)
+            if (action === 'force_start') {
+                if (!taskId) {
+                    return createErrorResponse('taskId is required for force_start action');
+                }
+                const result = await neo4jService.run(FORCE_START_QUERY, {
+                    taskId,
+                    projectId: resolvedProjectId,
+                    agentId,
+                    reason: releaseReason || 'Recovering from stuck state',
+                });
+                if (result.length === 0) {
+                    const stateResult = await neo4jService.run(GET_TASK_STATE_QUERY, {
+                        taskId,
+                        projectId: resolvedProjectId,
+                    });
+                    const currentState = stateResult[0];
+                    return createErrorResponse(`Cannot force_start task ${taskId}. ` +
+                        (currentState
+                            ? `Current state: ${currentState.status}, claimedBy: ${currentState.claimedBy || 'none'}. ` +
+                                `force_start requires status=claimed|available and you must be the claimant.`
+                            : 'Task not found.'));
                 }
-                return createSuccessResponse(JSON.stringify({
-                    success: true,
-                    action: 'released',
-                    task: {
-                        id: result[0].id,
-                        title: result[0].title,
-                        status: result[0].status,
-                    },
-                    message: `Task released and now available for other agents`,
-                }));
+                return createSuccessResponse(JSON.stringify({ action: 'force_started', taskId: result[0].id, status: 'in_progress' }));
             }
             // Handle start action
             if (action === 'start') {
@@ -239,98 +364,100 @@ export const createSwarmClaimTaskTool = (server) => {
                     agentId,
                 });
                 if (result.length === 0) {
-                    return createErrorResponse(`Cannot start task ${taskId}. Either it doesn't exist, isn't claimed, or you don't own it.`);
+                    // Get current state for better error message
+                    const stateResult = await neo4jService.run(GET_TASK_STATE_QUERY, {
+                        taskId,
+                        projectId: resolvedProjectId,
+                    });
+                    const currentState = stateResult[0];
+                    return createErrorResponse(`Cannot start task ${taskId}. ` +
+                        (currentState
+                            ? `Current state: ${currentState.status}, claimedBy: ${currentState.claimedBy || 'none'}. ` +
+                                `Tip: Use action="force_start" to recover from stuck claimed state, ` +
+                                `or action="abandon" to release the task.`
+                            : 'Task not found.'));
                 }
-                return createSuccessResponse(JSON.stringify({
-                    success: true,
-                    action: 'started',
-                    task: {
-                        id: result[0].id,
-                        status: result[0].status,
-                        claimedBy: result[0].claimedBy,
-                        startedAt: typeof result[0].startedAt === 'object'
-                            ? result[0].startedAt.toNumber()
-                            : result[0].startedAt,
-                    },
-                    message: 'Task is now in progress',
-                }));
+                return createSuccessResponse(JSON.stringify({ action: 'started', taskId: result[0].id, status: 'in_progress' }));
             }
-            // Handle claim action
+            // Handle claim and claim_and_start actions
+            // Determine target status based on action
+            const targetStatus = action === 'claim_and_start' ? 'in_progress' : 'claimed';
             let result;
+            let retryCount = 0;
             if (taskId) {
                 // Claim specific task
                 result = await neo4jService.run(CLAIM_TASK_BY_ID_QUERY, {
                     taskId,
                     projectId: resolvedProjectId,
                     agentId,
+                    targetStatus,
                 });
                 if (result.length === 0) {
-                    return createErrorResponse(`Cannot claim task ${taskId}. It may not exist, already be claimed, or have incomplete dependencies.`);
+                    const stateResult = await neo4jService.run(GET_TASK_STATE_QUERY, {
+                        taskId,
+                        projectId: resolvedProjectId,
+                    });
+                    const currentState = stateResult[0];
+                    return createErrorResponse(`Cannot claim task ${taskId}. ` +
+                        (currentState
+                            ? `Current state: ${currentState.status}, claimedBy: ${currentState.claimedBy || 'none'}`
+                            : 'Task not found or has incomplete dependencies.'));
                 }
             }
             else {
-                // Auto-select highest priority available task
+                // Auto-select highest priority available task with retry logic
                 const minPriorityScore = minPriority
                     ? TASK_PRIORITIES[minPriority]
                     : null;
-                result = await neo4jService.run(CLAIM_NEXT_TASK_QUERY, {
-                    projectId: resolvedProjectId,
-                    swarmId,
-                    agentId,
-                    types: types || null,
-                    minPriority: minPriorityScore,
-                });
-                if (result.length === 0) {
-                    return createSuccessResponse(JSON.stringify({
-                        success: true,
-                        action: 'no_tasks',
-                        message: 'No available tasks matching criteria. All tasks may be claimed, blocked, or completed.',
-                        filters: {
-                            swarmId,
-                            types: types || 'any',
-                            minPriority: minPriority || 'any',
-                        },
-                    }));
-                }
-            }
-            const task = result[0];
-            // Parse metadata if present
-            let metadata = null;
-            if (task.metadata) {
-                try {
-                    metadata = JSON.parse(task.metadata);
+                // Retry loop to handle race conditions
+                while (retryCount < MAX_CLAIM_RETRIES) {
+                    result = await neo4jService.run(CLAIM_NEXT_TASK_QUERY, {
+                        projectId: resolvedProjectId,
+                        swarmId,
+                        agentId,
+                        types: types || null,
+                        minPriority: minPriorityScore,
+                        targetStatus,
+                    });
+                    if (result.length > 0) {
+                        break; // Successfully claimed a task
+                    }
+                    retryCount++;
+                    if (retryCount < MAX_CLAIM_RETRIES) {
+                        // Wait before retry with exponential backoff
+                        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_BASE_MS * Math.pow(2, retryCount - 1)));
+                    }
                 }
-                catch {
-                    metadata = task.metadata;
+                if (!result || result.length === 0) {
+                    return createSuccessResponse(JSON.stringify({ action: 'no_tasks', retryAttempts: retryCount }));
                 }
             }
-            // Filter out null targets
-            const targets = (task.targets || []).filter((t) => t.id !== null);
+            const task = result[0];
+            const actionLabel = action === 'claim_and_start' ? 'claimed_and_started' : 'claimed';
+            // Extract valid targets (resolved via :TARGETS relationship)
+            const resolvedTargets = (task.targets || [])
+                .filter((t) => t?.id)
+                .map((t) => ({
+                nodeId: t.id,
+                name: t.name,
+                filePath: t.filePath,
+            }));
+            // Slim response - only essential fields for agent to do work
             return createSuccessResponse(JSON.stringify({
-                success: true,
-                action: 'claimed',
+                action: actionLabel,
                 task: {
                     id: task.id,
-                    projectId: task.projectId,
-                    swarmId: task.swarmId,
                     title: task.title,
                     description: task.description,
-                    type: task.type,
-                    priority: task.priority,
-                    priorityScore: task.priorityScore,
                     status: task.status,
-                    targetNodeIds: task.targetNodeIds,
+                    type: task.type,
+                    // Prefer resolved targets over stored nodeIds (resolved targets are from graph relationships)
+                    targets: resolvedTargets.length > 0 ? resolvedTargets : undefined,
+                    targetNodeIds: task.targetNodeIds?.length > 0 ? task.targetNodeIds : undefined,
                     targetFilePaths: task.targetFilePaths,
-                    dependencies: task.dependencies,
-                    claimedBy: task.claimedBy,
-                    claimedAt: typeof task.claimedAt === 'object'
-                        ? task.claimedAt.toNumber()
-                        : task.claimedAt,
-                    createdBy: task.createdBy,
-                    metadata,
-                    targets,
+                    ...(task.dependencies?.length > 0 && { dependencies: task.dependencies }),
                 },
-                message: 'Task claimed successfully. Use action="start" when you begin working.',
+                ...(retryCount > 0 && { retryAttempts: retryCount }),
             }));
         }
         catch (error) {

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

@@ -9,7 +9,7 @@ import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, de
 /**
  * Neo4j query to delete pheromones by swarm ID
  */
-const CLEANUP_BY_SWARM_QUERY = `
+const CLEANUP_PHEROMONES_BY_SWARM_QUERY = `
   MATCH (p:Pheromone)
   WHERE p.projectId = $projectId
     AND p.swarmId = $swarmId
@@ -18,6 +18,17 @@ const CLEANUP_BY_SWARM_QUERY = `
   DETACH DELETE p
   RETURN count(p) as deleted, collect(DISTINCT agentId) as agents, collect(DISTINCT type) as types
 `;
+/**
+ * Neo4j query to delete SwarmTask nodes by swarm ID
+ */
+const CLEANUP_TASKS_BY_SWARM_QUERY = `
+  MATCH (t:SwarmTask)
+  WHERE t.projectId = $projectId
+    AND t.swarmId = $swarmId
+  WITH t, t.status as status
+  DETACH DELETE t
+  RETURN count(t) as deleted, collect(DISTINCT status) as statuses
+`;
 /**
  * Neo4j query to delete pheromones by agent ID
  */
@@ -44,11 +55,16 @@ const CLEANUP_ALL_QUERY = `
 /**
  * Count queries for dry run
  */
-const COUNT_BY_SWARM_QUERY = `
+const COUNT_PHEROMONES_BY_SWARM_QUERY = `
   MATCH (p:Pheromone)
   WHERE p.projectId = $projectId AND p.swarmId = $swarmId AND NOT p.type IN $keepTypes
   RETURN count(p) as count, collect(DISTINCT p.agentId) as agents, collect(DISTINCT p.type) as types
 `;
+const COUNT_TASKS_BY_SWARM_QUERY = `
+  MATCH (t:SwarmTask)
+  WHERE t.projectId = $projectId AND t.swarmId = $swarmId
+  RETURN count(t) as count, collect(DISTINCT t.status) as statuses
+`;
 const COUNT_BY_AGENT_QUERY = `
   MATCH (p:Pheromone)
   WHERE p.projectId = $projectId AND p.agentId = $agentId AND NOT p.type IN $keepTypes
@@ -65,9 +81,14 @@ export const createSwarmCleanupTool = (server) => {
         description: TOOL_METADATA[TOOL_NAMES.swarmCleanup].description,
         inputSchema: {
             projectId: z.string().describe('Project ID, name, or path'),
-            swarmId: z.string().optional().describe('Delete all pheromones from this swarm'),
+            swarmId: z.string().optional().describe('Delete all pheromones and tasks from this swarm'),
             agentId: z.string().optional().describe('Delete all pheromones from this agent'),
             all: z.boolean().optional().default(false).describe('Delete ALL pheromones in project (use with caution)'),
+            includeTasks: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('Also delete SwarmTask nodes (default: true, only applies when swarmId is provided)'),
             keepTypes: z
                 .array(z.string())
                 .optional()
@@ -75,7 +96,7 @@ export const createSwarmCleanupTool = (server) => {
                 .describe('Pheromone types to preserve (default: ["warning"])'),
             dryRun: z.boolean().optional().default(false).describe('Preview what would be deleted without deleting'),
         },
-    }, async ({ projectId, swarmId, agentId, all = false, keepTypes = ['warning'], dryRun = false }) => {
+    }, async ({ projectId, swarmId, agentId, all = false, includeTasks = true, keepTypes = ['warning'], dryRun = false }) => {
         const neo4jService = new Neo4jService();
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
@@ -89,61 +110,84 @@ export const createSwarmCleanupTool = (server) => {
             if (!swarmId && !agentId && !all) {
                 return createErrorResponse('Must specify one of: swarmId, agentId, or all=true. Use dryRun=true to preview.');
             }
-            await debugLog('Swarm cleanup operation', {
-                projectId: resolvedProjectId,
-                swarmId,
-                agentId,
-                all,
-                keepTypes,
-                dryRun,
-            });
             const params = { projectId: resolvedProjectId, keepTypes };
-            let deleteQuery;
-            let countQuery;
+            let pheromoneDeleteQuery;
+            let pheromoneCountQuery;
             let mode;
             if (swarmId) {
                 params.swarmId = swarmId;
-                deleteQuery = CLEANUP_BY_SWARM_QUERY;
-                countQuery = COUNT_BY_SWARM_QUERY;
+                pheromoneDeleteQuery = CLEANUP_PHEROMONES_BY_SWARM_QUERY;
+                pheromoneCountQuery = COUNT_PHEROMONES_BY_SWARM_QUERY;
                 mode = 'swarm';
             }
             else if (agentId) {
                 params.agentId = agentId;
-                deleteQuery = CLEANUP_BY_AGENT_QUERY;
-                countQuery = COUNT_BY_AGENT_QUERY;
+                pheromoneDeleteQuery = CLEANUP_BY_AGENT_QUERY;
+                pheromoneCountQuery = COUNT_BY_AGENT_QUERY;
                 mode = 'agent';
             }
             else {
-                deleteQuery = CLEANUP_ALL_QUERY;
-                countQuery = COUNT_ALL_QUERY;
+                pheromoneDeleteQuery = CLEANUP_ALL_QUERY;
+                pheromoneCountQuery = COUNT_ALL_QUERY;
                 mode = 'all';
             }
             if (dryRun) {
-                const result = await neo4jService.run(countQuery, params);
-                const count = result[0]?.count ?? 0;
+                const pheromoneResult = await neo4jService.run(pheromoneCountQuery, params);
+                const pheromoneCount = pheromoneResult[0]?.count ?? 0;
+                let taskCount = 0;
+                let taskStatuses = [];
+                if (swarmId && includeTasks) {
+                    const taskResult = await neo4jService.run(COUNT_TASKS_BY_SWARM_QUERY, params);
+                    taskCount = taskResult[0]?.count ?? 0;
+                    taskCount = typeof taskCount === 'object' && 'toNumber' in taskCount ? taskCount.toNumber() : taskCount;
+                    taskStatuses = taskResult[0]?.statuses ?? [];
+                }
                 return createSuccessResponse(JSON.stringify({
                     success: true,
                     dryRun: true,
                     mode,
-                    wouldDelete: typeof count === 'object' && 'toNumber' in count ? count.toNumber() : count,
-                    agents: result[0]?.agents ?? [],
-                    swarms: result[0]?.swarms ?? [],
-                    types: result[0]?.types ?? [],
+                    pheromones: {
+                        wouldDelete: typeof pheromoneCount === 'object' && 'toNumber' in pheromoneCount ? pheromoneCount.toNumber() : pheromoneCount,
+                        agents: pheromoneResult[0]?.agents ?? [],
+                        types: pheromoneResult[0]?.types ?? [],
+                    },
+                    tasks: swarmId && includeTasks ? {
+                        wouldDelete: taskCount,
+                        statuses: taskStatuses,
+                    } : null,
                     keepTypes,
                     projectId: resolvedProjectId,
                 }));
             }
-            const result = await neo4jService.run(deleteQuery, params);
-            const deleted = result[0]?.deleted ?? 0;
+            // Delete pheromones
+            const pheromoneResult = await neo4jService.run(pheromoneDeleteQuery, params);
+            const pheromonesDeleted = pheromoneResult[0]?.deleted ?? 0;
+            // Delete tasks if swarmId provided and includeTasks is true
+            let tasksDeleted = 0;
+            let taskStatuses = [];
+            if (swarmId && includeTasks) {
+                const taskResult = await neo4jService.run(CLEANUP_TASKS_BY_SWARM_QUERY, params);
+                tasksDeleted = taskResult[0]?.deleted ?? 0;
+                tasksDeleted = typeof tasksDeleted === 'object' && 'toNumber' in tasksDeleted ? tasksDeleted.toNumber() : tasksDeleted;
+                taskStatuses = taskResult[0]?.statuses ?? [];
+            }
             return createSuccessResponse(JSON.stringify({
                 success: true,
                 mode,
-                deleted: typeof deleted === 'object' && 'toNumber' in deleted ? deleted.toNumber() : deleted,
-                agents: result[0]?.agents ?? [],
-                swarms: result[0]?.swarms ?? [],
-                types: result[0]?.types ?? [],
+                pheromones: {
+                    deleted: typeof pheromonesDeleted === 'object' && 'toNumber' in pheromonesDeleted ? pheromonesDeleted.toNumber() : pheromonesDeleted,
+                    agents: pheromoneResult[0]?.agents ?? [],
+                    types: pheromoneResult[0]?.types ?? [],
+                },
+                tasks: swarmId && includeTasks ? {
+                    deleted: tasksDeleted,
+                    statuses: taskStatuses,
+                } : null,
                 keepTypes,
                 projectId: resolvedProjectId,
+                message: swarmId && includeTasks
+                    ? `Cleaned up ${pheromonesDeleted} pheromones and ${tasksDeleted} tasks`
+                    : `Cleaned up ${pheromonesDeleted} pheromones`,
             }));
         }
         catch (error) {