code-graph-context 2.2.0 → 2.4.0

package/dist/mcp/constants.js

@@ -31,6 +31,9 @@ export const TOOL_NAMES = {
     listWatchers: 'list_watchers',
     detectDeadCode: 'detect_dead_code',
     detectDuplicateCode: 'detect_duplicate_code',
+    swarmPheromone: 'swarm_pheromone',
+    swarmSense: 'swarm_sense',
+    swarmCleanup: 'swarm_cleanup',
 };
 // Tool Metadata
 export const TOOL_METADATA = {
@@ -354,6 +357,123 @@ Parameters:
 
 Use this to identify refactoring opportunities and reduce code duplication.`,
     },
+    [TOOL_NAMES.swarmPheromone]: {
+        title: 'Swarm Pheromone',
+        description: `Leave a pheromone marker on a code node for stigmergic coordination between agents.
+
+**What is Stigmergy?**
+Agents coordinate indirectly by leaving markers (pheromones) on code nodes. Other agents sense these markers and adapt their behavior. No direct messaging needed.
+
+**Pheromone Types:**
+- exploring: "I'm looking at this" (2 min half-life)
+- modifying: "I'm actively working on this" (10 min half-life)
+- claiming: "This is my territory" (1 hour half-life)
+- completed: "I finished work here" (24 hour half-life)
+- warning: "Danger - don't touch" (never decays)
+- blocked: "I'm stuck on this" (5 min half-life)
+- proposal: "Proposed artifact awaiting approval" (1 hour half-life)
+- needs_review: "Someone should check this" (30 min half-life)
+
+**Parameters:**
+- nodeId: The code node ID to mark
+- type: Type of pheromone (see above)
+- agentId: Your unique agent identifier
+- swarmId: Swarm ID from orchestrator (for bulk cleanup)
+- intensity: 0.0-1.0, how strong the signal (default: 1.0)
+- data: Optional metadata (summary, reason, etc.)
+- remove: Set true to remove the pheromone
+
+**Workflow states** (exploring, claiming, modifying, completed, blocked) are mutually exclusive per agent+node. Setting one automatically removes others.
+
+**Usage Pattern:**
+1. Before starting work: swarm_sense to check what's claimed
+2. Claim your target: swarm_pheromone({ nodeId, type: "claiming", agentId, swarmId })
+3. Refresh periodically if working long
+4. Mark complete: swarm_pheromone({ nodeId, type: "completed", agentId, swarmId, data: { summary: "..." } })
+
+**Decay:**
+Pheromones automatically fade over time. If an agent dies, its markers decay and work becomes available again.`,
+    },
+    [TOOL_NAMES.swarmSense]: {
+        title: 'Swarm Sense',
+        description: `Query pheromones in the code graph to sense what other agents are doing.
+
+**What This Does:**
+Returns active pheromones with their current intensity (after decay). Use this to:
+- See what nodes are being worked on
+- Avoid conflicts with other agents
+- Find unclaimed work
+- Check if your dependencies are being modified
+
+**Parameters:**
+- swarmId: Filter by swarm ID (see only this swarm's pheromones)
+- types: Filter by pheromone types (e.g., ["modifying", "claiming"])
+- nodeIds: Check specific nodes
+- agentIds: Filter by specific agents
+- excludeAgentId: Exclude your own pheromones (see what OTHERS are doing)
+- minIntensity: Minimum intensity after decay (default: 0.3)
+- limit: Max results (default: 50)
+- includeStats: Get summary statistics by type
+- cleanup: Remove fully decayed pheromones (intensity < 0.01)
+
+**Usage Pattern:**
+\`\`\`
+// Before starting work, check what's taken
+swarm_sense({
+  types: ["modifying", "claiming"],
+  minIntensity: 0.3
+})
+
+// Check a specific node before modifying
+swarm_sense({
+  nodeIds: ["proj_xxx:Service:UserService"],
+  types: ["modifying", "warning"]
+})
+
+// See what other agents are doing (exclude self)
+swarm_sense({
+  excludeAgentId: "my-agent-id",
+  types: ["exploring", "modifying"]
+})
+\`\`\`
+
+**Decay:**
+Intensity decreases over time (exponential decay). A pheromone with intensity 0.25 is almost gone. Below minIntensity threshold, it's not returned.`,
+    },
+    [TOOL_NAMES.swarmCleanup]: {
+        title: 'Swarm Cleanup',
+        description: `Bulk delete pheromones after a swarm completes.
+
+**When to use:**
+Call this when a swarm finishes to clean up all its pheromones. Prevents pollution for future swarms.
+
+**Parameters:**
+- projectId: Required - the project
+- swarmId: Delete all pheromones from this swarm
+- agentId: Delete all pheromones from this specific agent
+- all: Set true to delete ALL pheromones in project (use with caution)
+- keepTypes: Pheromone types to preserve (default: ["warning"])
+- dryRun: Preview what would be deleted without deleting
+
+**Must specify one of:** swarmId, agentId, or all=true
+
+**Examples:**
+\`\`\`
+// Clean up after a swarm completes
+swarm_cleanup({ projectId: "backend", swarmId: "swarm_abc123" })
+
+// Preview what would be deleted
+swarm_cleanup({ projectId: "backend", swarmId: "swarm_abc123", dryRun: true })
+
+// Clean up a specific agent's pheromones
+swarm_cleanup({ projectId: "backend", agentId: "swarm_abc123_auth" })
+
+// Nuclear option: delete all (except warnings)
+swarm_cleanup({ projectId: "backend", all: true })
+\`\`\`
+
+**Note:** \`warning\` pheromones are preserved by default. Pass \`keepTypes: []\` to delete everything.`,
+    },
 };
 // Default Values
 export const DEFAULTS = {

package/dist/mcp/handlers/incremental-parse.handler.js

@@ -37,6 +37,7 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
         });
         // If no changes, return early
         if (filesToReparse.length === 0 && filesToDelete.length === 0) {
+            await debugLog('Incremental parse: no changes, returning early', {});
             return {
                 nodesUpdated: 0,
                 edgesUpdated: 0,
@@ -44,24 +45,35 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
                 filesDeleted: filesToDelete.length,
             };
         }
+        await debugLog('Incremental parse: changes detected, continuing', { filesToReparse: filesToReparse.length });
         let savedCrossFileEdges = [];
         const filesToRemoveFromGraph = [...filesToDelete, ...filesToReparse];
         if (filesToRemoveFromGraph.length > 0) {
+            await debugLog('Incremental parse: getting cross-file edges', { count: filesToRemoveFromGraph.length });
             // Save cross-file edges before deletion
             savedCrossFileEdges = await getCrossFileEdges(neo4jService, filesToRemoveFromGraph, resolvedId);
+            await debugLog('Incremental parse: got cross-file edges', { savedCount: savedCrossFileEdges.length });
+            await debugLog('Incremental parse: deleting old subgraphs', {});
             // Delete old subgraphs
             await deleteSourceFileSubgraphs(neo4jService, filesToRemoveFromGraph, resolvedId);
+            await debugLog('Incremental parse: deleted old subgraphs', {});
         }
         let nodesImported = 0;
         let edgesImported = 0;
         if (filesToReparse.length > 0) {
+            await debugLog('Incremental parse: loading existing nodes', {});
             // Load existing nodes for edge detection
             const existingNodes = await loadExistingNodesForEdgeDetection(neo4jService, filesToRemoveFromGraph, resolvedId);
+            await debugLog('Incremental parse: loaded existing nodes', { count: existingNodes.length });
             parser.setExistingNodes(existingNodes);
+            await debugLog('Incremental parse: parsing workspace', { fileCount: filesToReparse.length });
             // Parse only changed files
             await parser.parseWorkspace(filesToReparse);
+            await debugLog('Incremental parse: parsed workspace', {});
             // Export graph data
+            await debugLog('Incremental parse: exporting to JSON', {});
             const { nodes, edges } = parser.exportToJson();
+            await debugLog('Incremental parse: exported to JSON', { nodeCount: nodes.length, edgeCount: edges.length });
             // Get framework schemas if available (use unknown as intermediate to access private property)
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const parserAny = parser;
@@ -80,26 +92,33 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
                 },
             };
             // Write to JSON file (required by GraphGeneratorHandler)
+            await debugLog('Incremental parse: writing JSON file', {});
             const outputPath = join(projectPath, FILE_PATHS.graphOutput);
             writeFileSync(outputPath, JSON.stringify(graphData, null, LOG_CONFIG.jsonIndentation));
+            await debugLog('Incremental parse: wrote JSON file', { outputPath });
             // Update Project node
+            await debugLog('Incremental parse: updating project node', {});
             await neo4jService.run(UPSERT_PROJECT_QUERY, {
                 projectId: resolvedId,
                 path: projectPath,
                 name: projectName,
                 status: 'complete',
             });
+            await debugLog('Incremental parse: updated project node', {});
             // Import nodes and edges (clearExisting = false for incremental)
+            await debugLog('Incremental parse: starting graph import', {});
             graphHandler.setProjectId(resolvedId);
             try {
                 const result = await graphHandler.generateGraph(outputPath, DEFAULTS.batchSize, false);
                 nodesImported = result.nodesImported;
                 edgesImported = result.edgesImported;
+                await debugLog('Incremental parse: graph import completed', { nodesImported, edgesImported });
             }
             finally {
                 // Clean up temporary graph.json file
                 try {
                     unlinkSync(outputPath);
+                    await debugLog('Incremental parse: cleaned up temp file', {});
                 }
                 catch {
                     // Ignore cleanup errors - file may not exist or be inaccessible

package/dist/mcp/mcp.server.js

@@ -22,11 +22,34 @@ import { initializeServices } from './service-init.js';
 import { watchManager } from './services/watch-manager.js';
 import { registerAllTools } from './tools/index.js';
 import { debugLog } from './utils.js';
+// Track server state for debugging
+let serverStartTime;
+let toolCallCount = 0;
+let lastToolCall = null;
+/**
+ * Log memory usage and server stats
+ */
+const logServerStats = async (context) => {
+    const mem = process.memoryUsage();
+    await debugLog(`Server stats [${context}]`, {
+        uptime: serverStartTime ? `${Math.round((Date.now() - serverStartTime.getTime()) / 1000)}s` : 'not started',
+        toolCallCount,
+        lastToolCall,
+        memory: {
+            heapUsed: `${Math.round(mem.heapUsed / 1024 / 1024)}MB`,
+            heapTotal: `${Math.round(mem.heapTotal / 1024 / 1024)}MB`,
+            rss: `${Math.round(mem.rss / 1024 / 1024)}MB`,
+        },
+        pid: process.pid,
+    });
+};
 /**
  * Main server initialization and startup
  */
 const startServer = async () => {
+    serverStartTime = new Date();
     console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.starting }));
+    await debugLog('Server starting', { pid: process.pid, startTime: serverStartTime.toISOString() });
     // Create MCP server instance
     const server = new McpServer({
         name: MCP_SERVER_CONFIG.name,
@@ -34,6 +57,7 @@ const startServer = async () => {
     });
     // Register all tools
     registerAllTools(server);
+    await debugLog('Tools registered', { toolCount: 15 });
     // Configure watch manager with incremental parse handler and MCP server
     watchManager.setIncrementalParseHandler(performIncrementalParse);
     watchManager.setMcpServer(server.server);
@@ -50,22 +74,46 @@ const startServer = async () => {
     });
     // Create and connect transport
     console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.creatingTransport }));
+    await debugLog('Creating stdio transport', {});
     const transport = new StdioServerTransport();
+    // Add transport event logging
+    process.stdin.on('close', async () => {
+        await debugLog('STDIN closed - client disconnected', {});
+        await logServerStats('stdin-close');
+    });
+    process.stdin.on('end', async () => {
+        await debugLog('STDIN ended', {});
+        await logServerStats('stdin-end');
+    });
+    process.stdin.on('error', async (err) => {
+        await debugLog('STDIN error', { error: err.message, stack: err.stack });
+    });
+    process.stdout.on('close', async () => {
+        await debugLog('STDOUT closed', {});
+    });
+    process.stdout.on('error', async (err) => {
+        await debugLog('STDOUT error', { error: err.message, stack: err.stack });
+    });
     console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.connectingTransport }));
+    await debugLog('Connecting transport', {});
     await server.connect(transport);
     console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.connected }));
+    await debugLog('Server connected and ready', { pid: process.pid });
+    await logServerStats('server-ready');
 };
 /**
  * Graceful shutdown handler
  */
 const shutdown = async (signal) => {
     console.error(JSON.stringify({ level: 'info', message: `Received ${signal}, shutting down...` }));
+    await logServerStats(`shutdown-${signal}`);
     try {
         await watchManager.stopAllWatchers();
         await debugLog('Shutdown complete', { signal });
     }
     catch (error) {
         console.error(JSON.stringify({ level: 'error', message: 'Error during shutdown', error: String(error) }));
+        await debugLog('Error during shutdown', { signal, error: String(error) });
     }
     process.exit(0);
 };
@@ -73,14 +121,41 @@ const shutdown = async (signal) => {
 process.on('uncaughtException', async (error) => {
     console.error(JSON.stringify({ level: 'error', message: 'Uncaught exception', error: String(error), stack: error.stack }));
     await debugLog('Uncaught exception', { error: String(error), stack: error.stack });
+    await logServerStats('uncaught-exception');
 });
 process.on('unhandledRejection', async (reason) => {
     console.error(JSON.stringify({ level: 'error', message: 'Unhandled rejection', reason: String(reason) }));
     await debugLog('Unhandled rejection', { reason: String(reason) });
+    await logServerStats('unhandled-rejection');
+});
+// Log other process events that might indicate issues
+process.on('warning', async (warning) => {
+    await debugLog('Process warning', { name: warning.name, message: warning.message, stack: warning.stack });
+});
+process.on('beforeExit', async (code) => {
+    await debugLog('Process beforeExit', { code });
+    await logServerStats('before-exit');
+});
+process.on('exit', (code) => {
+    // Note: Can't use async here, exit is synchronous
+    console.error(JSON.stringify({ level: 'info', message: `Process exiting with code ${code}` }));
 });
 // Register shutdown handlers
-process.on('SIGINT', () => shutdown('SIGINT'));
+// NOTE: Only handle SIGTERM for graceful shutdown. SIGINT is ignored because
+// Claude Code may propagate SIGINT to child processes when spawning agents,
+// which would incorrectly kill the MCP server. The MCP server lifecycle is
+// managed by Claude Code via stdio transport closure.
 process.on('SIGTERM', () => shutdown('SIGTERM'));
+// Log SIGINT but don't exit - Claude Code manages our lifecycle
+process.on('SIGINT', async () => {
+    await debugLog('SIGINT received but ignored - lifecycle managed by Claude Code', {});
+    await logServerStats('sigint-ignored');
+});
+// Also ignore SIGHUP which can be sent during terminal operations
+process.on('SIGHUP', async () => {
+    await debugLog('SIGHUP received but ignored', {});
+    await logServerStats('sighup-ignored');
+});
 // Start the server
 console.error(JSON.stringify({ level: 'info', message: MESSAGES.server.startingServer }));
 await startServer();

package/dist/mcp/service-init.js

@@ -4,14 +4,67 @@
  */
 import fs from 'fs/promises';
 import { join } from 'path';
+import { ensureNeo4jRunning, isDockerInstalled, isDockerRunning, } from '../cli/neo4j-docker.js';
 import { Neo4jService, QUERIES } from '../storage/neo4j/neo4j.service.js';
 import { FILE_PATHS, LOG_CONFIG } from './constants.js';
 import { initializeNaturalLanguageService } from './tools/natural-language-to-cypher.tool.js';
 import { debugLog } from './utils.js';
+/**
+ * Log startup warnings for missing configuration
+ */
+const checkConfiguration = async () => {
+    if (!process.env.OPENAI_API_KEY) {
+        console.error(JSON.stringify({
+            level: 'warn',
+            message: '[code-graph-context] OPENAI_API_KEY not set. Semantic search and NL queries unavailable.',
+        }));
+        await debugLog('Configuration warning', { warning: 'OPENAI_API_KEY not set' });
+    }
+};
+/**
+ * Ensure Neo4j is running - auto-start if Docker available, fail if not
+ */
+const ensureNeo4j = async () => {
+    // Check if Docker is available
+    if (!isDockerInstalled()) {
+        const msg = 'Docker not installed. Install Docker or run: code-graph-context init';
+        console.error(JSON.stringify({ level: 'error', message: `[code-graph-context] ${msg}` }));
+        throw new Error(msg);
+    }
+    if (!isDockerRunning()) {
+        const msg = 'Docker not running. Start Docker or run: code-graph-context init';
+        console.error(JSON.stringify({ level: 'error', message: `[code-graph-context] ${msg}` }));
+        throw new Error(msg);
+    }
+    const result = await ensureNeo4jRunning();
+    if (!result.success) {
+        const msg = `Neo4j failed to start: ${result.error}. Run: code-graph-context init`;
+        console.error(JSON.stringify({ level: 'error', message: `[code-graph-context] ${msg}` }));
+        throw new Error(msg);
+    }
+    if (result.action === 'created') {
+        console.error(JSON.stringify({
+            level: 'info',
+            message: '[code-graph-context] Neo4j container created and started',
+        }));
+    }
+    else if (result.action === 'started') {
+        console.error(JSON.stringify({
+            level: 'info',
+            message: '[code-graph-context] Neo4j container started',
+        }));
+    }
+    await debugLog('Neo4j ready', result);
+};
 /**
  * Initialize all external services required by the MCP server
  */
 export const initializeServices = async () => {
+    // Check for missing configuration (non-fatal warnings)
+    await checkConfiguration();
+    // Ensure Neo4j is running (fatal if not)
+    await ensureNeo4j();
+    // Initialize services
     await Promise.all([initializeNeo4jSchema(), initializeNaturalLanguageService()]);
 };
 /**

package/dist/mcp/services/watch-manager.js

@@ -26,9 +26,12 @@ class WatchManager {
      * Send a notification via MCP logging (if supported)
      */
     sendNotification(notification) {
+        debugLog('sendNotification called', { type: notification.type, projectId: notification.projectId });
         if (!this.mcpServer) {
+            debugLog('sendNotification: no MCP server, skipping', {});
             return;
         }
+        debugLog('sendNotification: sending to MCP', { type: notification.type });
         // sendLoggingMessage returns a Promise - use .catch() to handle rejection
         this.mcpServer
             .sendLoggingMessage({
@@ -36,9 +39,16 @@ class WatchManager {
             logger: 'file-watcher',
             data: notification,
         })
-            .catch(() => {
-            // MCP logging not supported - silently ignore
+            .then(() => {
+            debugLog('sendNotification: MCP message sent successfully', { type: notification.type });
+        })
+            .catch((error) => {
+            // MCP logging not supported - log but don't crash
             // This is expected if the client doesn't support logging capability
+            debugLog('sendNotification: MCP message failed (expected if client lacks logging)', {
+                type: notification.type,
+                error: String(error)
+            });
         });
     }
     /**
@@ -128,7 +138,7 @@ class WatchManager {
      * Handle a file system event
      */
     handleFileEvent(state, type, filePath) {
-        debugLog('File event received', { type, filePath, projectId: state.projectId, status: state.status });
+        debugLog('handleFileEvent START', { type, filePath, projectId: state.projectId, status: state.status, isStopping: state.isStopping });
         // Ignore events if watcher is stopping or not active
         if (state.isStopping || state.status !== 'active') {
             debugLog('Ignoring event - watcher not active or stopping', {
@@ -166,20 +176,35 @@ class WatchManager {
             timestamp: new Date().toISOString(),
         });
         // Set new debounce timer
+        debugLog('handleFileEvent: setting debounce timer', { debounceMs: state.config.debounceMs });
         state.debounceTimer = setTimeout(() => {
+            debugLog('handleFileEvent: debounce timer fired, calling processEvents', { projectId: state.projectId });
             this.processEvents(state).catch((error) => {
+                debugLog('handleFileEvent: processEvents error', { error: String(error) });
                 console.error('[WatchManager] Error in processEvents:', error);
             });
         }, state.config.debounceMs);
+        debugLog('handleFileEvent END', { pendingCount: state.pendingEvents.length });
     }
     /**
      * Process accumulated file events after debounce period
      */
     async processEvents(state) {
+        await debugLog('processEvents START', {
+            projectId: state.projectId,
+            isProcessing: state.isProcessing,
+            pendingCount: state.pendingEvents.length,
+            isStopping: state.isStopping
+        });
         // Don't process if already processing, no events, or watcher is stopping
-        if (state.isProcessing || state.pendingEvents.length === 0 || state.isStopping)
+        if (state.isProcessing || state.pendingEvents.length === 0 || state.isStopping) {
+            await debugLog('processEvents: early return', {
+                reason: state.isProcessing ? 'already processing' : state.pendingEvents.length === 0 ? 'no events' : 'stopping'
+            });
             return;
+        }
         state.isProcessing = true;
+        await debugLog('processEvents: set isProcessing=true', {});
         const events = [...state.pendingEvents];
         state.pendingEvents = [];
         state.debounceTimer = null;
@@ -199,7 +224,15 @@ class WatchManager {
             if (!this.incrementalParseHandler) {
                 throw new Error('Incremental parse handler not configured');
             }
+            await debugLog('processEvents: calling incrementalParseHandler', {
+                projectPath: state.projectPath,
+                projectId: state.projectId
+            });
             const result = await this.incrementalParseHandler(state.projectPath, state.projectId, state.tsconfigPath);
+            await debugLog('processEvents: incrementalParseHandler returned', {
+                nodesUpdated: result.nodesUpdated,
+                edgesUpdated: result.edgesUpdated
+            });
             state.lastUpdateTime = new Date();
             const elapsedMs = Date.now() - startTime;
             this.sendNotification({
@@ -221,6 +254,7 @@ class WatchManager {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
+            await debugLog('processEvents: error caught', { error: errorMessage });
             this.sendNotification({
                 type: 'incremental_parse_failed',
                 projectId: state.projectId,
@@ -235,6 +269,7 @@ class WatchManager {
         }
         finally {
             state.isProcessing = false;
+            await debugLog('processEvents END', { projectId: state.projectId, isProcessing: state.isProcessing });
         }
     }
     /**
@@ -243,9 +278,14 @@ class WatchManager {
     handleWatcherError(state, error) {
         state.status = 'error';
         state.errorMessage = error instanceof Error ? error.message : String(error);
-        debugLog('Watcher error', { projectId: state.projectId, error: state.errorMessage });
+        debugLog('handleWatcherError START', { projectId: state.projectId, error: state.errorMessage });
         // Clean up the failed watcher to prevent it from staying in error state indefinitely
-        this.stopWatching(state.projectId).catch((cleanupError) => {
+        this.stopWatching(state.projectId)
+            .then(() => {
+            debugLog('handleWatcherError: cleanup succeeded', { projectId: state.projectId });
+        })
+            .catch((cleanupError) => {
+            debugLog('handleWatcherError: cleanup failed', { projectId: state.projectId, cleanupError: String(cleanupError) });
             console.error(`[WatchManager] Failed to cleanup errored watcher ${state.projectId}:`, cleanupError);
         });
     }
@@ -255,23 +295,33 @@ class WatchManager {
      * Promise is tracked on state to allow cleanup during stop
      */
     syncMissedChanges(state) {
-        if (!this.incrementalParseHandler)
+        debugLog('syncMissedChanges START', { projectId: state.projectId });
+        if (!this.incrementalParseHandler) {
+            debugLog('syncMissedChanges: no handler, skipping', {});
             return;
+        }
         // Track the promise on state so stopWatching can wait for it
         state.syncPromise = this.incrementalParseHandler(state.projectPath, state.projectId, state.tsconfigPath)
             .then((result) => {
+            debugLog('syncMissedChanges: completed', {
+                projectId: state.projectId,
+                nodesUpdated: result.nodesUpdated,
+                edgesUpdated: result.edgesUpdated
+            });
             if (result.nodesUpdated > 0 || result.edgesUpdated > 0) {
                 console.log(`[WatchManager] Synced missed changes for ${state.projectId}: ` +
                     `${result.nodesUpdated} nodes, ${result.edgesUpdated} edges`);
             }
         })
             .catch((error) => {
+            debugLog('syncMissedChanges: error', { projectId: state.projectId, error: String(error), isStopping: state.isStopping });
             // Only log if watcher hasn't been stopped
             if (!state.isStopping) {
                 console.error(`[WatchManager] Failed to sync missed changes for ${state.projectId}:`, error);
             }
         })
             .finally(() => {
+            debugLog('syncMissedChanges END', { projectId: state.projectId });
             state.syncPromise = undefined;
         });
     }

package/dist/mcp/tools/hello.tool.js

@@ -3,11 +3,25 @@
  * Simple test tool to verify MCP connection
  */
 import { TOOL_NAMES, TOOL_METADATA, MESSAGES } from '../constants.js';
-import { createSuccessResponse } from '../utils.js';
+import { createSuccessResponse, debugLog } from '../utils.js';
+import { logToolCallStart, logToolCallEnd } from './index.js';
 export const createHelloTool = (server) => {
     server.registerTool(TOOL_NAMES.hello, {
         title: TOOL_METADATA[TOOL_NAMES.hello].title,
         description: TOOL_METADATA[TOOL_NAMES.hello].description,
         inputSchema: {},
-    }, async () => createSuccessResponse(MESSAGES.success.hello));
+    }, async () => {
+        const startTime = Date.now();
+        const callId = await logToolCallStart('hello');
+        try {
+            const result = createSuccessResponse(MESSAGES.success.hello);
+            await logToolCallEnd('hello', callId, true, Date.now() - startTime);
+            return result;
+        }
+        catch (error) {
+            await debugLog('Hello tool error', { error: String(error) });
+            await logToolCallEnd('hello', callId, false, Date.now() - startTime);
+            throw error;
+        }
+    });
 };

package/dist/mcp/tools/index.js

@@ -2,6 +2,7 @@
  * MCP Tool Factory
  * Centralized tool creation and registration
  */
+import { debugLog } from '../utils.js';
 import { createCheckParseStatusTool } from './check-parse-status.tool.js';
 import { createDetectDeadCodeTool } from './detect-dead-code.tool.js';
 import { createDetectDuplicateCodeTool } from './detect-duplicate-code.tool.js';
@@ -14,8 +15,36 @@ import { createParseTypescriptProjectTool } from './parse-typescript-project.too
 import { createSearchCodebaseTool } from './search-codebase.tool.js';
 import { createStartWatchProjectTool } from './start-watch-project.tool.js';
 import { createStopWatchProjectTool } from './stop-watch-project.tool.js';
+import { createSwarmCleanupTool } from './swarm-cleanup.tool.js';
+import { createSwarmPheromoneTool } from './swarm-pheromone.tool.js';
+import { createSwarmSenseTool } from './swarm-sense.tool.js';
 import { createTestNeo4jConnectionTool } from './test-neo4j-connection.tool.js';
 import { createTraverseFromNodeTool } from './traverse-from-node.tool.js';
+// Track tool calls for debugging
+let globalToolCallCount = 0;
+/**
+ * Log tool call start (exported for use by individual tools)
+ */
+export const logToolCallStart = async (toolName, params) => {
+    globalToolCallCount++;
+    const callId = globalToolCallCount;
+    await debugLog(`Tool call START: ${toolName}`, {
+        callId,
+        totalCalls: globalToolCallCount,
+        params: params ? JSON.stringify(params).substring(0, 500) : 'none',
+    });
+    return callId;
+};
+/**
+ * Log tool call end (exported for use by individual tools)
+ */
+export const logToolCallEnd = async (toolName, callId, success, duration) => {
+    await debugLog(`Tool call END: ${toolName}`, {
+        callId,
+        success,
+        duration: duration ? `${duration}ms` : 'unknown',
+    });
+};
 /**
  * Register all MCP tools with the server
  */
@@ -39,4 +68,8 @@ export const registerAllTools = (server) => {
     createStartWatchProjectTool(server);
     createStopWatchProjectTool(server);
     createListWatchersTool(server);
+    // Register swarm coordination tools
+    createSwarmPheromoneTool(server);
+    createSwarmSenseTool(server);
+    createSwarmCleanupTool(server);
 };