code-graph-context 2.6.2 → 2.8.0

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

@@ -6,7 +6,7 @@ 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_PRIORITIES, TASK_TYPES, generateTaskId, } from './swarm-constants.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)
@@ -135,10 +135,7 @@ export const createSwarmPostTaskTool = (server) => {
                 .default([])
                 .describe('Task IDs that must be completed before this task can start'),
             createdBy: z.string().describe('Agent ID or identifier of who created this task'),
-            metadata: z
-                .record(z.unknown())
-                .optional()
-                .describe('Additional metadata (context, acceptance criteria, etc.)'),
+            metadata: z.record(z.unknown()).optional().describe('Additional metadata (context, acceptance criteria, etc.)'),
         },
     }, async ({ projectId, swarmId, title, description, type = 'implement', priority = 'normal', targetNodeIds = [], targetFilePaths = [], dependencies = [], createdBy, metadata, }) => {
         const neo4jService = new Neo4jService();
@@ -162,10 +159,7 @@ export const createSwarmPostTaskTool = (server) => {
                         projectId: resolvedProjectId,
                     });
                     if (fileNodes.length > 0) {
-                        resolvedNodeIds = [
-                            ...resolvedNodeIds,
-                            ...fileNodes.map((n) => n.id).filter(Boolean),
-                        ];
+                        resolvedNodeIds = [...resolvedNodeIds, ...fileNodes.map((n) => n.id).filter(Boolean)];
                     }
                 }
             }
@@ -198,9 +192,7 @@ export const createSwarmPostTaskTool = (server) => {
                 });
                 if (depCheck.length > 0) {
                     dependencyStatus = {
-                        totalDeps: typeof depCheck[0].totalDeps === 'object'
-                            ? depCheck[0].totalDeps.toNumber()
-                            : depCheck[0].totalDeps,
+                        totalDeps: typeof depCheck[0].totalDeps === 'object' ? depCheck[0].totalDeps.toNumber() : depCheck[0].totalDeps,
                         incompleteDeps: typeof depCheck[0].incompleteDeps === 'object'
                             ? depCheck[0].incompleteDeps.toNumber()
                             : depCheck[0].incompleteDeps,
@@ -232,9 +224,7 @@ export const createSwarmPostTaskTool = (server) => {
                     targetFilePaths: task.targetFilePaths,
                     dependencies: task.dependencies,
                     createdBy: task.createdBy,
-                    createdAt: typeof task.createdAt === 'object'
-                        ? task.createdAt.toNumber()
-                        : task.createdAt,
+                    createdAt: typeof task.createdAt === 'object' ? task.createdAt.toNumber() : task.createdAt,
                 },
                 dependencyStatus: {
                     isBlocked,

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

@@ -21,6 +21,7 @@ const SENSE_PHEROMONES_QUERY = `
     AND ($agentIds IS NULL OR size($agentIds) = 0 OR p.agentId IN $agentIds)
     AND ($swarmId IS NULL OR p.swarmId = $swarmId)
     AND ($excludeAgentId IS NULL OR p.agentId <> $excludeAgentId)
+    AND ($sessionId IS NULL OR p.sessionId = $sessionId)
 
   // Calculate current intensity with exponential decay
   WITH p,
@@ -49,6 +50,7 @@ const SENSE_PHEROMONES_QUERY = `
     p.timestamp AS timestamp,
     p.data AS data,
     p.halfLife AS halfLifeMs,
+    p.sessionId AS sessionId,
     CASE WHEN target IS NOT NULL THEN labels(target)[0] ELSE null END AS targetType,
     CASE WHEN target IS NOT NULL THEN target.name ELSE null END AS targetName,
     CASE WHEN target IS NOT NULL THEN target.filePath ELSE null END AS targetFilePath
@@ -108,6 +110,10 @@ export const createSwarmSenseTool = (server) => {
                 .string()
                 .optional()
                 .describe('Exclude pheromones from this agent ID (useful for seeing what OTHER agents are doing)'),
+            sessionId: z
+                .string()
+                .optional()
+                .describe('Filter pheromones by session ID. Use to recover context after compaction or session restart.'),
             minIntensity: z
                 .number()
                 .min(0)
@@ -130,7 +136,7 @@ export const createSwarmSenseTool = (server) => {
                 .default(false)
                 .describe('Run cleanup of fully decayed pheromones (intensity < 0.01)'),
         },
-    }, async ({ projectId, types, nodeIds, agentIds, swarmId, excludeAgentId, minIntensity = 0.3, limit = 50, includeStats = false, cleanup = false, }) => {
+    }, async ({ projectId, types, nodeIds, agentIds, swarmId, excludeAgentId, sessionId, minIntensity = 0.3, limit = 50, includeStats = false, cleanup = false, }) => {
         const neo4jService = new Neo4jService();
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
@@ -162,6 +168,7 @@ export const createSwarmSenseTool = (server) => {
                 agentIds: agentIds ?? null,
                 swarmId: swarmId ?? null,
                 excludeAgentId: excludeAgentId ?? null,
+                sessionId: sessionId ?? null,
                 minIntensity,
                 limit: Math.floor(limit),
             });
@@ -177,6 +184,7 @@ export const createSwarmSenseTool = (server) => {
                     originalIntensity: p.originalIntensity,
                     agentId: p.agentId,
                     swarmId: p.swarmId,
+                    sessionId: p.sessionId ?? null,
                     timestamp: ts,
                     age: ts ? `${Math.round((Date.now() - ts) / 1000)}s ago` : null,
                     data: p.data ? JSON.parse(p.data) : null,

package/dist/storage/neo4j/neo4j.service.js

@@ -138,12 +138,24 @@ export const QUERIES = {
   `,
     CREATE_EMBEDDED_VECTOR_INDEX: `
   CREATE VECTOR INDEX embedded_nodes_idx IF NOT EXISTS
-  FOR (n:Embedded) ON (n.embedding) 
+  FOR (n:Embedded) ON (n.embedding)
   OPTIONS {indexConfig: {
     \`vector.dimensions\`: 3072,
     \`vector.similarity_function\`: 'cosine'
   }}
 `,
+    CREATE_SESSION_NOTES_VECTOR_INDEX: `
+  CREATE VECTOR INDEX session_notes_idx IF NOT EXISTS
+  FOR (n:SessionNote) ON (n.embedding)
+  OPTIONS {indexConfig: {
+    \`vector.dimensions\`: 3072,
+    \`vector.similarity_function\`: 'cosine'
+  }}
+`,
+    // Indexes for efficient SessionBookmark and SessionNote lookups
+    CREATE_SESSION_BOOKMARK_INDEX: 'CREATE INDEX session_bookmark_idx IF NOT EXISTS FOR (n:SessionBookmark) ON (n.projectId, n.sessionId)',
+    CREATE_SESSION_NOTE_INDEX: 'CREATE INDEX session_note_idx IF NOT EXISTS FOR (n:SessionNote) ON (n.projectId, n.sessionId)',
+    CREATE_SESSION_NOTE_CATEGORY_INDEX: 'CREATE INDEX session_note_category_idx IF NOT EXISTS FOR (n:SessionNote) ON (n.projectId, n.category)',
     // Vector search with configurable fetch multiplier for project filtering.
     // fetchMultiplier (default: 10) controls how many extra results to fetch before filtering by projectId.
     // minSimilarity (default: 0.3) filters out low-confidence matches for nonsense queries.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-context",
-  "version": "2.6.2",
+  "version": "2.8.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",

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

@@ -1,469 +0,0 @@
-/**
- * Swarm Orchestrate Tool
- * Orchestrates multiple agents to tackle complex, multi-file code tasks in parallel
- *
- * This is the main entry point for swarm-based task execution. It:
- * 1. Analyzes the task using semantic search and impact analysis
- * 2. Decomposes the task into atomic, dependency-ordered SwarmTasks
- * 3. Creates tasks on the blackboard for worker agents
- * 4. Returns execution plan for agents to claim and execute
- */
-import { z } from 'zod';
-import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
-import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
-import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
-import { TaskDecompositionHandler, } from '../handlers/task-decomposition.handler.js';
-import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog } from '../utils.js';
-import { TASK_PRIORITIES, generateSwarmId, ORCHESTRATOR_CONFIG, getHalfLife, } from './swarm-constants.js';
-/**
- * Query to search for nodes matching the task description
- */
-const SEMANTIC_SEARCH_QUERY = `
-  CALL db.index.vector.queryNodes('embedded_nodes_idx', toInteger($limit), $embedding)
-  YIELD node, score
-  WHERE node.projectId = $projectId
-    AND score >= $minSimilarity
-  RETURN node.id AS id,
-         node.name AS name,
-         node.coreType AS coreType,
-         node.semanticType AS semanticType,
-         node.filePath AS filePath,
-         substring(node.sourceCode, 0, 500) AS sourceCode,
-         node.startLine AS startLine,
-         node.endLine AS endLine,
-         score
-  ORDER BY score DESC
-  LIMIT toInteger($limit)
-`;
-/**
- * Query to get impact analysis for a node
- */
-const IMPACT_QUERY = `
-  MATCH (target)
-  WHERE target.id = $nodeId AND target.projectId = $projectId
-  OPTIONAL MATCH (dependent)-[r]->(target)
-  WHERE dependent.projectId = $projectId
-    AND NOT dependent:Pheromone
-    AND NOT dependent:SwarmTask
-  WITH target, collect(DISTINCT {
-    nodeId: dependent.id,
-    filePath: dependent.filePath,
-    relType: type(r)
-  }) AS dependents
-  RETURN target.id AS nodeId,
-         size(dependents) AS dependentCount,
-         [d IN dependents | d.filePath] AS affectedFiles,
-         CASE
-           WHEN size(dependents) >= 20 THEN 'CRITICAL'
-           WHEN size(dependents) >= 10 THEN 'HIGH'
-           WHEN size(dependents) >= 5 THEN 'MEDIUM'
-           ELSE 'LOW'
-         END AS riskLevel
-`;
-/**
- * Query to create a pheromone marker on a node
- */
-const CREATE_PHEROMONE_QUERY = `
-  MATCH (target)
-  WHERE target.id = $nodeId AND target.projectId = $projectId
-  MERGE (p:Pheromone {
-    nodeId: $nodeId,
-    agentId: $agentId,
-    type: $type,
-    projectId: $projectId
-  })
-  ON CREATE SET
-    p.id = randomUUID(),
-    p.swarmId = $swarmId,
-    p.intensity = $intensity,
-    p.timestamp = timestamp(),
-    p.halfLife = $halfLife,
-    p.data = $data
-  ON MATCH SET
-    p.intensity = $intensity,
-    p.timestamp = timestamp(),
-    p.data = $data
-  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
- */
-const CREATE_TASK_QUERY = `
-  CREATE (t:SwarmTask {
-    id: $taskId,
-    projectId: $projectId,
-    swarmId: $swarmId,
-    title: $title,
-    description: $description,
-    type: $type,
-    priority: $priority,
-    priorityScore: $priorityScore,
-    status: $status,
-    targetNodeIds: $targetNodeIds,
-    targetFilePaths: $targetFilePaths,
-    dependencies: $dependencies,
-    createdBy: $createdBy,
-    createdAt: timestamp(),
-    updatedAt: timestamp(),
-    metadata: $metadata
-  })
-
-  // Link to target code nodes if they exist
-  WITH t
-  OPTIONAL MATCH (target)
-  WHERE target.id IN $targetNodeIds
-    AND target.projectId = $projectId
-    AND NOT target:SwarmTask
-    AND NOT target:Pheromone
-  WITH t, collect(DISTINCT target) as targets
-  FOREACH (target IN targets | MERGE (t)-[:TARGETS]->(target))
-
-  // Link to dependency tasks if they exist
-  WITH t
-  OPTIONAL MATCH (dep:SwarmTask)
-  WHERE dep.id IN $dependencies
-    AND dep.projectId = $projectId
-  WITH t, collect(DISTINCT dep) as deps
-  FOREACH (dep IN deps | MERGE (t)-[:DEPENDS_ON]->(dep))
-
-  RETURN t.id AS id
-`;
-export const createSwarmOrchestrateTool = (server) => {
-    const embeddingsService = new EmbeddingsService();
-    const taskDecomposer = new TaskDecompositionHandler();
-    server.registerTool(TOOL_NAMES.swarmOrchestrate, {
-        title: TOOL_METADATA[TOOL_NAMES.swarmOrchestrate].title,
-        description: TOOL_METADATA[TOOL_NAMES.swarmOrchestrate].description,
-        inputSchema: {
-            projectId: z.string().describe('Project ID, name, or path'),
-            task: z.string().min(10).describe('Natural language description of the task to execute'),
-            maxAgents: z
-                .number()
-                .int()
-                .min(1)
-                .max(ORCHESTRATOR_CONFIG.maxAgentsLimit)
-                .optional()
-                .default(ORCHESTRATOR_CONFIG.defaultMaxAgents)
-                .describe(`Maximum concurrent worker agents (default: ${ORCHESTRATOR_CONFIG.defaultMaxAgents})`),
-            dryRun: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('If true, only plan without creating tasks (default: false)'),
-            priority: z
-                .enum(Object.keys(TASK_PRIORITIES))
-                .optional()
-                .default('normal')
-                .describe('Overall priority level for tasks'),
-            minSimilarity: z
-                .number()
-                .min(0.5)
-                .max(1.0)
-                .optional()
-                .default(0.65)
-                .describe('Minimum similarity score for semantic search (default: 0.65)'),
-            maxNodes: z
-                .number()
-                .int()
-                .min(1)
-                .max(100)
-                .optional()
-                .default(50)
-                .describe('Maximum nodes to consider from search (default: 50)'),
-        },
-    }, async ({ projectId, task, maxAgents = ORCHESTRATOR_CONFIG.defaultMaxAgents, dryRun = false, priority = 'normal', minSimilarity = 0.65, maxNodes = 50, }) => {
-        const neo4jService = new Neo4jService();
-        const swarmId = generateSwarmId();
-        try {
-            // Step 1: Resolve project ID
-            const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
-            if (!projectResult.success) {
-                await neo4jService.close();
-                return projectResult.error;
-            }
-            const resolvedProjectId = projectResult.projectId;
-            // Step 2: Semantic search to find affected nodes
-            let embedding;
-            try {
-                embedding = await embeddingsService.embedText(task);
-            }
-            catch (error) {
-                return createErrorResponse(`Failed to generate embedding for task description: ${error}`);
-            }
-            const searchResults = await neo4jService.run(SEMANTIC_SEARCH_QUERY, {
-                projectId: resolvedProjectId,
-                embedding,
-                minSimilarity,
-                limit: Math.floor(maxNodes),
-            });
-            if (searchResults.length === 0) {
-                return createErrorResponse(`No code found matching task: "${task}". Try rephrasing or use search_codebase to explore the codebase first.`);
-            }
-            const affectedNodes = searchResults.map((r) => ({
-                id: r.id,
-                name: r.name,
-                coreType: r.coreType,
-                semanticType: r.semanticType,
-                filePath: r.filePath,
-                sourceCode: r.sourceCode,
-                startLine: typeof r.startLine === 'object' ? r.startLine.toNumber() : r.startLine,
-                endLine: typeof r.endLine === 'object' ? r.endLine.toNumber() : r.endLine,
-            }));
-            // Step 3: Run impact analysis on each node
-            const impactMap = new Map();
-            for (const node of affectedNodes) {
-                const impactResult = await neo4jService.run(IMPACT_QUERY, {
-                    nodeId: node.id,
-                    projectId: resolvedProjectId,
-                });
-                if (impactResult.length > 0) {
-                    const impact = impactResult[0];
-                    impactMap.set(node.id, {
-                        nodeId: node.id,
-                        riskLevel: impact.riskLevel,
-                        directDependents: {
-                            count: typeof impact.dependentCount === 'object'
-                                ? impact.dependentCount.toNumber()
-                                : impact.dependentCount,
-                            byType: {},
-                        },
-                        transitiveDependents: { count: 0 },
-                        affectedFiles: impact.affectedFiles ?? [],
-                    });
-                }
-            }
-            // Step 4: Decompose task into atomic tasks
-            const decomposition = await taskDecomposer.decomposeTask(task, affectedNodes, impactMap, priority);
-            if (decomposition.tasks.length === 0) {
-                return createErrorResponse('Task decomposition produced no actionable tasks');
-            }
-            // Step 5: Create SwarmTasks on the blackboard (unless dry run)
-            if (!dryRun) {
-                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,
-                        swarmId,
-                        title: atomicTask.title,
-                        description: atomicTask.description,
-                        type: atomicTask.type,
-                        priority: atomicTask.priority,
-                        priorityScore: atomicTask.priorityScore,
-                        status: initialStatus,
-                        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;
-                }
-                // 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();
-                for (const atomicTask of decomposition.tasks) {
-                    for (const nodeId of atomicTask.nodeIds) {
-                        uniqueNodeIds.add(nodeId);
-                    }
-                }
-                for (const nodeId of uniqueNodeIds) {
-                    await neo4jService.run(CREATE_PHEROMONE_QUERY, {
-                        nodeId,
-                        projectId: resolvedProjectId,
-                        agentId: 'orchestrator',
-                        swarmId,
-                        type: 'proposal',
-                        intensity: 1.0,
-                        halfLife: getHalfLife('proposal'),
-                        data: JSON.stringify({ task, swarmId }),
-                    });
-                }
-            }
-            // Step 6: Generate worker instructions
-            const workerInstructions = generateWorkerInstructions(swarmId, resolvedProjectId, maxAgents, decomposition.tasks.length);
-            // Step 7: Build result
-            const result = {
-                swarmId,
-                status: dryRun ? 'planning' : 'ready',
-                plan: {
-                    totalTasks: decomposition.tasks.length,
-                    parallelizable: decomposition.summary.parallelizable,
-                    sequential: decomposition.summary.sequential,
-                    estimatedComplexity: decomposition.summary.estimatedComplexity,
-                    tasks: decomposition.tasks.map((t) => ({
-                        id: t.id,
-                        title: t.title,
-                        type: t.type,
-                        priority: t.priority,
-                        status: t.dependencies.length > 0 ? 'blocked' : 'available',
-                        dependencyCount: t.dependencies.length,
-                        targetFiles: [t.filePath],
-                    })),
-                    dependencyGraph: buildDependencyGraph(decomposition),
-                },
-                workerInstructions,
-                message: dryRun
-                    ? `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.`,
-            };
-            return createSuccessResponse(JSON.stringify(result, null, 2));
-        }
-        catch (error) {
-            await debugLog('Swarm orchestration error', { swarmId, error: String(error) });
-            return createErrorResponse(error instanceof Error ? error : String(error));
-        }
-        finally {
-            await neo4jService.close();
-        }
-    });
-};
-/**
- * Generate instructions for spawning worker agents
- */
-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 with access to a code graph.
-- Agent ID: {AGENT_ID}
-- Swarm ID: ${swarmId}
-- Project: ${projectId}
-
-## 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
-
-### Step 1: Claim a task
-swarm_claim_task({
-  projectId: "${projectId}",
-  swarmId: "${swarmId}",
-  agentId: "{AGENT_ID}"
-})
-// Returns: { task: { id, targets: [{nodeId, name, filePath}], targetFilePaths, ... } }
-// If "no_tasks" → exit
-
-### Step 2: Understand context via graph (USE NODE IDs!)
-// Priority: task.targets[0].nodeId > task.targetNodeIds[0] > search
-traverse_from_node({
-  projectId: "${projectId}",
-  nodeId: "<nodeId_FROM_task.targets>",
-  maxDepth: 2
-})
-
-// Fallback if no nodeIds:
-search_codebase({ projectId: "${projectId}", query: "<TASK_DESCRIPTION>" })
-
-### Step 3: Mark nodes you're analyzing/modifying
-swarm_pheromone({
-  projectId: "${projectId}",
-  nodeId: "<nodeId>",
-  type: "modifying",
-  agentId: "{AGENT_ID}",
-  swarmId: "${swarmId}"
-})
-
-### 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: "<WHAT_YOU_DID>",
-  filesChanged: ["<FILES>"]
-})
-
-### Step 6: Loop to Step 1
-
-## 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);
-        return `Task({
-  subagent_type: "general-purpose",
-  run_in_background: false,
-  prompt: \`${prompt}\`
-})`;
-    }).join('\n\n');
-    return `
-## Worker Agent Instructions
-
-Spawn ${recommendedAgents} worker agent(s) IN PARALLEL (all Task calls in ONE message):
-
-\`\`\`javascript
-${taskCalls}
-\`\`\`
-
-**CRITICAL:** Include ALL ${recommendedAgents} Task calls in a single message to run them in parallel.
-
-## Monitoring Progress
-
-Check swarm progress:
-\`\`\`javascript
-swarm_get_tasks({
-  projectId: "${projectId}",
-  swarmId: "${swarmId}",
-  includeStats: true
-})
-\`\`\`
-
-## Cleanup (after all workers complete)
-
-\`\`\`javascript
-swarm_cleanup({
-  projectId: "${projectId}",
-  swarmId: "${swarmId}"
-})
-\`\`\`
-`;
-}
-/**
- * Build dependency graph edges for visualization
- */
-function buildDependencyGraph(decomposition) {
-    const edges = [];
-    for (const task of decomposition.tasks) {
-        for (const depId of task.dependencies) {
-            edges.push({ from: depId, to: task.id });
-        }
-    }
-    return edges;
-}