code-graph-context 2.0.1 → 2.3.0

package/dist/mcp/handlers/streaming-import.handler.js

@@ -33,36 +33,33 @@ export class StreamingImportHandler {
         if (config.onProgress) {
             this.progressReporter.setCallback(config.onProgress);
         }
-        // Set project ID on graph generator
-        this.graphGeneratorHandler.setProjectId(config.projectId);
-        // Phase 1: Get discovered files (already discovered by worker, this returns cached result)
         const allFilePaths = await parser.discoverSourceFiles();
-        console.log(`📁 Found ${allFilePaths.length} files to parse`);
         await debugLog('Streaming import started', {
             totalFiles: allFilePaths.length,
             chunkSize: config.chunkSize,
         });
-        // Create chunks
+        this.progressReporter.report({
+            phase: 'parsing',
+            current: 0,
+            total: allFilePaths.length,
+            message: `Starting streaming import of ${allFilePaths.length} files in chunks of ~${config.chunkSize}`,
+        });
         const chunks = [];
         for (let i = 0; i < allFilePaths.length; i += config.chunkSize) {
             chunks.push(allFilePaths.slice(i, i + config.chunkSize));
         }
-        console.log(`📦 Split into ${chunks.length} chunks of ~${config.chunkSize} files each`);
         let totalNodesImported = 0;
         let totalEdgesImported = 0;
-        // Phase 2: Parse and import chunks
         for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
             const chunk = chunks[chunkIndex];
             const filesProcessed = chunkIndex * config.chunkSize + chunk.length;
-            console.log(`\n🔄 Processing chunk ${chunkIndex + 1}/${chunks.length} (${chunk.length} files)`);
             try {
-                // Parse the chunk (skip edge resolution for streaming)
+                // Skip edge resolution during chunk parsing - resolve after all chunks complete
                 const { nodes, edges } = await parser.parseChunk(chunk, true);
-                // Add parsed nodes to existing nodes for cross-chunk edge resolution
+                // Accumulate nodes for cross-chunk edge resolution
                 parser.addExistingNodesFromChunk(nodes);
-                // Import to Neo4j if we have data
                 if (nodes.length > 0 || edges.length > 0) {
-                    await debugLog('Importing chunk - generating embeddings', {
+                    await debugLog('Importing chunk', {
                         chunkIndex: chunkIndex + 1,
                         totalChunks: chunks.length,
                         nodeCount: nodes.length,
@@ -72,14 +69,12 @@ export class StreamingImportHandler {
                     totalEdgesImported += edges.length;
                 }
                 else {
-                    console.warn(`⚠️ Chunk ${chunkIndex + 1} produced 0 nodes/edges from ${chunk.length} files`);
                     await debugLog('Empty chunk result', {
                         chunkIndex: chunkIndex + 1,
                         fileCount: chunk.length,
                         sampleFiles: chunk.slice(0, 3),
                     });
                 }
-                // Report progress with all relevant data
                 await this.progressReporter.report({
                     phase: 'importing',
                     current: filesProcessed,
@@ -94,10 +89,8 @@ export class StreamingImportHandler {
                         totalChunks: chunks.length,
                     },
                 });
-                console.log(`✅ Chunk ${chunkIndex + 1}: ${nodes.length} nodes, ${edges.length} edges imported`);
             }
             catch (chunkError) {
-                console.error(`❌ Error processing chunk ${chunkIndex + 1}:`, chunkError);
                 await debugLog('Chunk processing error', {
                     chunkIndex: chunkIndex + 1,
                     fileCount: chunk.length,
@@ -105,40 +98,24 @@ export class StreamingImportHandler {
                     error: chunkError instanceof Error ? chunkError.message : String(chunkError),
                     stack: chunkError instanceof Error ? chunkError.stack : undefined,
                 });
-                // Re-throw to fail the entire import - don't silently continue
                 throw chunkError;
             }
-            // Note: Don't clear parsed data during streaming - we need accumulated nodes for cross-chunk edge resolution
-            // Memory usage is bounded because we only keep Neo4jNode references (not full AST)
         }
-        // Phase 3: Resolve cross-chunk deferred edges
         await this.progressReporter.reportResolving(0, totalEdgesImported);
-        console.log('\n🔗 Resolving cross-chunk edges...');
-        const resolvedEdges = await parser.resolveDeferredEdgesManually();
+        const resolvedEdges = await parser.resolveDeferredEdges();
         if (resolvedEdges.length > 0) {
             await this.importEdgesToNeo4j(resolvedEdges);
             totalEdgesImported += resolvedEdges.length;
-            console.log(`✅ Resolved ${resolvedEdges.length} cross-chunk edges`);
-        }
-        else {
-            console.log('ℹ️ No cross-chunk edges to resolve');
+            await debugLog(`Resolved ${resolvedEdges.length} cross-chunk edges`);
         }
-        // Phase 3b: Apply edge enhancements on all accumulated nodes
-        // This catches context-dependent edges (like INTERNAL_API_CALL) that span chunks
-        console.log('\n🔗 Applying edge enhancements on all nodes...');
         const enhancedEdges = await parser.applyEdgeEnhancementsManually();
         if (enhancedEdges.length > 0) {
             await this.importEdgesToNeo4j(enhancedEdges);
             totalEdgesImported += enhancedEdges.length;
-            console.log(`✅ Created ${enhancedEdges.length} edges from edge enhancements`);
+            await debugLog(`Created ${enhancedEdges.length} edges from edge enhancements`);
         }
-        else {
-            console.log('ℹ️ No edges from edge enhancements');
-        }
-        // Clear accumulated data now that edge resolution is complete
         parser.clearParsedData();
         await this.progressReporter.reportResolving(resolvedEdges.length, resolvedEdges.length);
-        // Phase 4: Complete
         const elapsedMs = Date.now() - startTime;
         await this.progressReporter.reportComplete(totalNodesImported, totalEdgesImported);
         const result = {
@@ -148,32 +125,17 @@ export class StreamingImportHandler {
             chunksProcessed: chunks.length,
             elapsedMs,
         };
-        console.log(`\n🎉 Streaming import complete!`);
-        console.log(`   Files: ${allFilePaths.length}`);
-        console.log(`   Nodes: ${totalNodesImported}`);
-        console.log(`   Edges: ${totalEdgesImported}`);
-        console.log(`   Time: ${(elapsedMs / 1000).toFixed(2)}s`);
         await debugLog('Streaming import completed', result);
         return result;
     }
-    /**
-     * Import a chunk of nodes and edges to Neo4j using the graph generator handler
-     */
     async importChunkToNeo4j(nodes, edges) {
-        // Write to temporary JSON and use existing import mechanism
-        // This reuses the batched embedding and import logic
         const tempPath = generateTempPath('chunk');
         const fs = await import('fs/promises');
         try {
-            await fs.writeFile(tempPath, JSON.stringify({
-                nodes,
-                edges,
-                metadata: { chunked: true },
-            }));
+            await fs.writeFile(tempPath, JSON.stringify({ nodes, edges, metadata: { chunked: true } }));
             await this.graphGeneratorHandler.generateGraph(tempPath, DEFAULTS.batchSize, false);
         }
         finally {
-            // Clean up temp file
             try {
                 await fs.unlink(tempPath);
             }
@@ -182,20 +144,13 @@ export class StreamingImportHandler {
             }
         }
     }
-    /**
-     * Import resolved edges to Neo4j
-     */
     async importEdgesToNeo4j(edges) {
         if (edges.length === 0)
             return;
         const tempPath = generateTempPath('edges');
         const fs = await import('fs/promises');
         try {
-            await fs.writeFile(tempPath, JSON.stringify({
-                nodes: [],
-                edges,
-                metadata: { edgesOnly: true },
-            }));
+            await fs.writeFile(tempPath, JSON.stringify({ nodes: [], edges, metadata: { edgesOnly: true } }));
             await this.graphGeneratorHandler.generateGraph(tempPath, DEFAULTS.batchSize, false);
         }
         finally {

package/dist/mcp/mcp.server.js

@@ -18,15 +18,38 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { MCP_SERVER_CONFIG, MESSAGES } from './constants.js';
 import { performIncrementalParse } from './handlers/incremental-parse.handler.js';
-import { watchManager } from './services/watch-manager.js';
 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/services/job-manager.js

@@ -3,6 +3,7 @@
  * Tracks background parsing jobs for async mode
  */
 import { randomBytes } from 'crypto';
+import { JOBS } from '../constants.js';
 const generateJobId = () => {
     return `job_${randomBytes(8).toString('hex')}`;
 };
@@ -15,10 +16,6 @@ const createInitialProgress = () => ({
     currentChunk: 0,
     totalChunks: 0,
 });
-// Cleanup interval: 5 minutes
-const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
-// Maximum concurrent jobs to prevent memory exhaustion
-const MAX_JOBS = 100;
 class JobManager {
     jobs = new Map();
     cleanupInterval = null;
@@ -38,7 +35,7 @@ class JobManager {
             if (cleaned > 0) {
                 console.log(`[JobManager] Cleaned up ${cleaned} old jobs`);
             }
-        }, CLEANUP_INTERVAL_MS);
+        }, JOBS.cleanupIntervalMs);
         // Don't prevent Node.js from exiting if this is the only timer
         this.cleanupInterval.unref();
     }
@@ -57,11 +54,11 @@ class JobManager {
      */
     createJob(projectPath, projectId) {
         // SECURITY: Enforce maximum job limit to prevent memory exhaustion
-        if (this.jobs.size >= MAX_JOBS) {
+        if (this.jobs.size >= JOBS.maxJobs) {
             // Try to cleanup old jobs first
             const cleaned = this.cleanupOldJobs(0); // Remove all completed/failed jobs
-            if (this.jobs.size >= MAX_JOBS) {
-                throw new Error(`Maximum job limit (${MAX_JOBS}) reached. ` +
+            if (this.jobs.size >= JOBS.maxJobs) {
+                throw new Error(`Maximum job limit (${JOBS.maxJobs}) reached. ` +
                     `${this.listJobs('running').length} jobs are currently running. ` +
                     `Please wait for jobs to complete or cancel existing jobs.`);
             }

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

@@ -4,19 +4,8 @@
  * Uses @parcel/watcher for high-performance file watching
  */
 import * as watcher from '@parcel/watcher';
+import { WATCH } from '../constants.js';
 import { debugLog } from '../utils.js';
-const DEFAULT_EXCLUDE_PATTERNS = [
-    '**/node_modules/**',
-    '**/dist/**',
-    '**/build/**',
-    '**/.git/**',
-    '**/*.d.ts',
-    '**/*.js.map',
-    '**/*.js',
-];
-const DEFAULT_DEBOUNCE_MS = 1000;
-const MAX_WATCHERS = 10;
-const MAX_PENDING_EVENTS = 1000;
 class WatchManager {
     watchers = new Map();
     mcpServer = null;
@@ -37,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({
@@ -47,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)
+            });
         });
     }
     /**
@@ -62,15 +61,15 @@ class WatchManager {
             return this.getWatcherInfoFromState(existing);
         }
         // Enforce maximum watcher limit
-        if (this.watchers.size >= MAX_WATCHERS) {
-            throw new Error(`Maximum watcher limit (${MAX_WATCHERS}) reached. ` + `Stop an existing watcher before starting a new one.`);
+        if (this.watchers.size >= WATCH.maxWatchers) {
+            throw new Error(`Maximum watcher limit (${WATCH.maxWatchers}) reached. ` + `Stop an existing watcher before starting a new one.`);
         }
         const fullConfig = {
             projectPath: config.projectPath,
             projectId: config.projectId,
             tsconfigPath: config.tsconfigPath,
-            debounceMs: config.debounceMs ?? DEFAULT_DEBOUNCE_MS,
-            excludePatterns: config.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS,
+            debounceMs: config.debounceMs ?? WATCH.defaultDebounceMs,
+            excludePatterns: config.excludePatterns ?? [...WATCH.excludePatterns],
         };
         await debugLog('Creating @parcel/watcher subscription', {
             watchPath: fullConfig.projectPath,
@@ -139,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', {
@@ -154,9 +153,9 @@ class WatchManager {
             timestamp: Date.now(),
         };
         // Prevent unbounded event accumulation - drop oldest events if buffer is full
-        if (state.pendingEvents.length >= MAX_PENDING_EVENTS) {
+        if (state.pendingEvents.length >= WATCH.maxPendingEvents) {
             debugLog('Event buffer full, dropping oldest events', { projectId: state.projectId });
-            state.pendingEvents = state.pendingEvents.slice(-Math.floor(MAX_PENDING_EVENTS / 2));
+            state.pendingEvents = state.pendingEvents.slice(-Math.floor(WATCH.maxPendingEvents / 2));
         }
         state.pendingEvents.push(event);
         debugLog('Event added to pending', { pendingCount: state.pendingEvents.length });
@@ -177,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;
@@ -210,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({
@@ -232,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,
@@ -246,6 +269,7 @@ class WatchManager {
         }
         finally {
             state.isProcessing = false;
+            await debugLog('processEvents END', { projectId: state.projectId, isProcessing: state.isProcessing });
         }
     }
     /**
@@ -254,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);
         });
     }
@@ -266,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;
         });
     }