codeseeker 1.8.2 → 1.9.0

package/dist/mcp/mcp-server.js

@@ -1,11 +1,16 @@
 "use strict";
 /**
- * CodeSeeker MCP Server
+ * CodeSeeker MCP Server (Consolidated)
  *
  * Exposes CodeSeeker's semantic search and code analysis capabilities
  * as an MCP (Model Context Protocol) server for use with Claude Desktop
  * and Claude Code.
  *
+ * OPTIMIZED: 12 tools consolidated to 3 to minimize token usage:
+ *   1. search  - Code discovery (search, search+read, read-with-context)
+ *   2. analyze - Code analysis (dependencies, dead_code, duplicates, standards)
+ *   3. index   - Index management (init, sync, status, parsers, exclude)
+ *
  * Usage:
  *   codeseeker serve --mcp
  *
@@ -67,12 +72,15 @@ const indexing_service_1 = require("./indexing-service");
 const coding_standards_generator_1 = require("../cli/services/analysis/coding-standards-generator");
 const language_support_service_1 = require("../cli/services/project/language-support-service");
 const query_cache_service_1 = require("./query-cache-service");
-// DuplicateCodeDetector no longer used - find_duplicates now uses indexed embeddings directly
-// SemanticKnowledgeGraph no longer used - find_dead_code now uses indexed graph from storage manager
 // Version from package.json
 const VERSION = '2.0.0';
 /**
- * MCP Server for CodeSeeker
+ * MCP Server for CodeSeeker - Consolidated 3-tool architecture
+ *
+ * Tools:
+ *   1. search  - Semantic code search with optional file reading
+ *   2. analyze - Code analysis (dependencies, dead_code, duplicates, standards)
+ *   3. index   - Index management (init, sync, status, parsers, exclude)
  */
 class CodeSeekerMcpServer {
     server;
@@ -82,20 +90,15 @@ class CodeSeekerMcpServer {
     queryCache;
     // Background indexing state
     indexingJobs = new Map();
-    // Mutex for concurrent indexing protection
     indexingMutex = new Set();
-    // Cancellation tokens for running indexing jobs
     cancellationTokens = new Map();
     // Job cleanup interval (clean completed/failed jobs after 1 hour)
-    JOB_TTL_MS = 60 * 60 * 1000; // 1 hour
+    JOB_TTL_MS = 60 * 60 * 1000;
     cleanupTimer = null;
     // Dangerous paths that should never be indexed (security)
     DANGEROUS_PATHS = [
-        // System directories
         '/etc', '/var', '/usr', '/bin', '/sbin', '/lib', '/boot', '/root', '/proc', '/sys', '/dev',
-        // Windows system directories
         'C:\\Windows', 'C:\\Program Files', 'C:\\Program Files (x86)', 'C:\\ProgramData',
-        // User sensitive directories
         '.ssh', '.gnupg', '.aws', '.azure', '.config',
     ];
     constructor() {
@@ -108,33 +111,25 @@ class CodeSeekerMcpServer {
         this.languageSupportService = new language_support_service_1.LanguageSupportService();
         this.queryCache = (0, query_cache_service_1.getQueryCacheService)();
         this.registerTools();
-        // Start cleanup timer for old indexing jobs
         this.startJobCleanupTimer();
     }
-    /**
-     * Start periodic cleanup of completed/failed indexing jobs
-     */
+    // ============================================================
+    // LIFECYCLE & UTILITY METHODS
+    // ============================================================
     startJobCleanupTimer() {
-        // Clean up every 10 minutes
         this.cleanupTimer = setInterval(() => {
             this.cleanupOldJobs();
         }, 10 * 60 * 1000);
-        // Ensure timer doesn't prevent process exit
         if (this.cleanupTimer.unref) {
             this.cleanupTimer.unref();
         }
     }
-    /**
-     * Clean up completed/failed jobs older than TTL
-     */
     cleanupOldJobs() {
         const now = Date.now();
         const jobsToDelete = [];
         for (const [projectId, job] of this.indexingJobs) {
-            // Only clean up non-running jobs
             if (job.status !== 'running' && job.completedAt) {
-                const age = now - job.completedAt.getTime();
-                if (age > this.JOB_TTL_MS) {
+                if (now - job.completedAt.getTime() > this.JOB_TTL_MS) {
                     jobsToDelete.push(projectId);
                 }
             }
@@ -143,17 +138,11 @@ class CodeSeekerMcpServer {
             this.indexingJobs.delete(projectId);
         }
     }
-    /**
-     * Validate that a path is safe to index (security)
-     * Returns error message if unsafe, null if safe
-     */
     validateProjectPath(projectPath) {
         const normalizedPath = path.normalize(projectPath);
-        // Check for path traversal attempts
         if (normalizedPath.includes('..')) {
             return 'Path traversal detected: paths with ".." are not allowed';
         }
-        // Check for dangerous system directories
         const lowerPath = normalizedPath.toLowerCase();
         for (const dangerous of this.DANGEROUS_PATHS) {
             const lowerDangerous = dangerous.toLowerCase();
@@ -161,7 +150,6 @@ class CodeSeekerMcpServer {
                 return `Security: cannot index system directory "${dangerous}"`;
             }
         }
-        // Check path components for sensitive directories
         const pathParts = normalizedPath.split(path.sep);
         for (const part of pathParts) {
             const lowerPart = part.toLowerCase();
@@ -169,17 +157,11 @@ class CodeSeekerMcpServer {
                 return `Security: cannot index sensitive directory "${part}"`;
             }
         }
-        return null; // Path is safe
+        return null;
     }
-    /**
-     * Start background indexing for a project
-     * Returns immediately, indexing happens asynchronously
-     */
     startBackgroundIndexing(projectId, projectName, projectPath, clearExisting = true) {
-        // Create cancellation token
         const cancellationToken = { cancelled: false };
         this.cancellationTokens.set(projectId, cancellationToken);
-        // Create job entry
         const job = {
             projectId,
             projectName,
@@ -194,9 +176,7 @@ class CodeSeekerMcpServer {
             },
         };
         this.indexingJobs.set(projectId, job);
-        // Release mutex once job is registered (actual indexing is tracked by job status)
         this.indexingMutex.delete(projectId);
-        // Start indexing in background (don't await)
         this.runBackgroundIndexing(job, clearExisting, cancellationToken).catch((error) => {
             job.status = 'failed';
             job.error = error instanceof Error ? error.message : String(error);
@@ -204,9 +184,6 @@ class CodeSeekerMcpServer {
             this.cancellationTokens.delete(projectId);
         });
     }
-    /**
-     * Cancel a running indexing job
-     */
     cancelIndexing(projectId) {
         const token = this.cancellationTokens.get(projectId);
         if (token) {
@@ -215,20 +192,15 @@ class CodeSeekerMcpServer {
         }
         return false;
     }
-    /**
-     * Run the actual indexing (called asynchronously)
-     */
     async runBackgroundIndexing(job, clearExisting, cancellationToken) {
         try {
             const storageManager = await (0, storage_1.getStorageManager)();
             const vectorStore = storageManager.getVectorStore();
             const graphStore = storageManager.getGraphStore();
-            // Clear existing data if requested
             if (clearExisting) {
                 await vectorStore.deleteByProject(job.projectId);
                 await graphStore.deleteByProject(job.projectId);
             }
-            // Check for cancellation before starting
             if (cancellationToken.cancelled) {
                 job.status = 'failed';
                 job.error = 'Indexing cancelled by user';
@@ -236,9 +208,7 @@ class CodeSeekerMcpServer {
                 this.cancellationTokens.delete(job.projectId);
                 return;
             }
-            // Run indexing with progress tracking
             const result = await this.indexingService.indexProject(job.projectPath, job.projectId, (progress) => {
-                // Check for cancellation during indexing
                 if (cancellationToken.cancelled) {
                     throw new Error('Indexing cancelled by user');
                 }
@@ -249,7 +219,6 @@ class CodeSeekerMcpServer {
                     chunksCreated: progress.chunksCreated,
                 };
             });
-            // Update job with results
             job.status = 'completed';
             job.completedAt = new Date();
             job.result = {
@@ -259,24 +228,17 @@ class CodeSeekerMcpServer {
                 edgesCreated: result.edgesCreated,
                 durationMs: result.durationMs,
             };
-            // Generate coding standards after indexing (if not cancelled)
             if (!cancellationToken.cancelled) {
                 try {
                     const generator = new coding_standards_generator_1.CodingStandardsGenerator(vectorStore);
                     await generator.generateStandards(job.projectId, job.projectPath);
                 }
-                catch {
-                    // Non-fatal - standards generation is optional
-                }
+                catch { /* Non-fatal */ }
             }
-            // Invalidate query cache for this project (full reindex)
             try {
                 await this.queryCache.invalidateProject(job.projectId);
             }
-            catch {
-                // Non-fatal - cache invalidation is optional
-            }
-            // Clean up cancellation token
+            catch { /* Non-fatal */ }
             this.cancellationTokens.delete(job.projectId);
         }
         catch (error) {
@@ -286,16 +248,9 @@ class CodeSeekerMcpServer {
             this.cancellationTokens.delete(job.projectId);
         }
     }
-    /**
-     * Get indexing status for a project
-     */
     getIndexingStatus(projectId) {
         return this.indexingJobs.get(projectId);
     }
-    /**
-     * Find CodeSeeker project by walking up directory tree from startPath
-     * looking for .codeseeker/project.json
-     */
     async findProjectPath(startPath) {
         let currentPath = path.resolve(startPath);
         const root = path.parse(currentPath).root;
@@ -306,2171 +261,1281 @@ class CodeSeekerMcpServer {
             }
             currentPath = path.dirname(currentPath);
         }
-        // No project found, return original path
         return startPath;
     }
+    generateProjectId(projectPath) {
+        return crypto.createHash('md5').update(projectPath).digest('hex');
+    }
+    async getAllProjectDocuments(vectorStore, projectId) {
+        const randomEmbedding = Array.from({ length: 384 }, () => Math.random() - 0.5);
+        const results = await vectorStore.searchByVector(randomEmbedding, projectId, 10000);
+        return results.map(r => r.document);
+    }
+    formatErrorMessage(operation, error, context) {
+        const message = error instanceof Error ? error.message : String(error);
+        const lowerMessage = message.toLowerCase();
+        if (lowerMessage.includes('enoent') || lowerMessage.includes('not found') || lowerMessage.includes('no such file')) {
+            return `${operation} failed: File or directory not found. Verify: ${context?.projectPath || 'the specified path'}`;
+        }
+        if (lowerMessage.includes('eacces') || lowerMessage.includes('permission denied')) {
+            return `${operation} failed: Permission denied.`;
+        }
+        if (lowerMessage.includes('timeout') || lowerMessage.includes('timed out')) {
+            return `${operation} failed: Timed out. Check status with index({action: "status"}).`;
+        }
+        if (lowerMessage.includes('connection') || lowerMessage.includes('econnrefused') || lowerMessage.includes('network')) {
+            return `${operation} failed: Connection error. Check storage services.`;
+        }
+        if (lowerMessage.includes('not indexed') || lowerMessage.includes('no project')) {
+            const pathHint = context?.projectPath ? `index({action: "init", path: "${context.projectPath}"})` : 'index({action: "init", path: "/path/to/project"})';
+            return `${operation} failed: Project not indexed. Run: ${pathHint}`;
+        }
+        if (lowerMessage.includes('out of memory') || lowerMessage.includes('heap')) {
+            return `${operation} failed: Out of memory. Use index({action: "exclude"}) to skip large directories.`;
+        }
+        return `${operation} failed: ${message}`;
+    }
+    matchesExclusionPattern(filePath, pattern) {
+        const normalizedPath = filePath.replace(/\\/g, '/').toLowerCase();
+        const normalizedPattern = pattern.replace(/\\/g, '/').toLowerCase();
+        if (normalizedPath === normalizedPattern)
+            return true;
+        let regexPattern = normalizedPattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '<<GLOBSTAR>>')
+            .replace(/\*/g, '[^/]*')
+            .replace(/<<GLOBSTAR>>/g, '.*')
+            .replace(/\?/g, '.');
+        if (!regexPattern.startsWith('.*')) {
+            regexPattern = `(^|/)${regexPattern}`;
+        }
+        regexPattern = `${regexPattern}(/.*)?$`;
+        try {
+            return new RegExp(regexPattern).test(normalizedPath);
+        }
+        catch {
+            return normalizedPath.includes(normalizedPattern.replace(/\*/g, ''));
+        }
+    }
+    _getIndexingStatusForProject(projectId) {
+        const job = this.indexingJobs.get(projectId);
+        if (!job)
+            return null;
+        return {
+            indexing_status: job.status,
+            indexing_progress: job.progress,
+            indexing_result: job.result,
+            indexing_error: job.error,
+            indexing_started: job.startedAt.toISOString(),
+            indexing_completed: job.completedAt?.toISOString(),
+        };
+    }
+    /**
+     * Resolve project from name/path, returning project record and path.
+     * Shared helper for search and analyze tools.
+     */
+    async resolveProject(project) {
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        const projects = await projectStore.list();
+        if (project) {
+            const found = projects.find(p => p.name === project ||
+                p.path === project ||
+                path.basename(p.path) === project ||
+                path.resolve(project) === p.path);
+            if (found) {
+                return { projectPath: found.path, projectRecord: found };
+            }
+            return { projectPath: await this.findProjectPath(path.resolve(project)) };
+        }
+        if (projects.length === 0) {
+            return {
+                projectPath: '',
+                error: {
+                    content: [{ type: 'text', text: 'No indexed projects. Use index({action: "init", path: "/path/to/project"}) first.' }],
+                    isError: true,
+                },
+            };
+        }
+        if (projects.length === 1) {
+            return { projectPath: projects[0].path, projectRecord: projects[0] };
+        }
+        const projectList = projects.map(p => `  - "${p.name}" (${p.path})`).join('\n');
+        return {
+            projectPath: '',
+            error: {
+                content: [{ type: 'text', text: `Multiple projects indexed. Specify project parameter:\n\n${projectList}` }],
+                isError: true,
+            },
+        };
+    }
     /**
-     * Register all MCP tools
+     * Verify project has embeddings (is actually indexed).
      */
+    async verifyIndexed(projectPath, projectRecord) {
+        if (!projectRecord)
+            return {};
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const vectorStore = storageManager.getVectorStore();
+        try {
+            const testResults = await vectorStore.searchByText('test', projectRecord.id, 1);
+            if (!testResults || testResults.length === 0) {
+                return {
+                    error: {
+                        content: [{ type: 'text', text: `Project "${path.basename(projectPath)}" not indexed. Run index({action: "init", path: "${projectPath}"}) first.` }],
+                        isError: true,
+                    },
+                };
+            }
+        }
+        catch {
+            return {
+                error: {
+                    content: [{ type: 'text', text: `Project "${path.basename(projectPath)}" needs indexing. Run index({action: "init", path: "${projectPath}"}) first.` }],
+                    isError: true,
+                },
+            };
+        }
+        return {};
+    }
+    // ============================================================
+    // TOOL REGISTRATION - 3 CONSOLIDATED TOOLS
+    // ============================================================
     registerTools() {
         this.registerSearchTool();
-        this.registerSearchAndReadTool();
-        this.registerReadWithContextTool();
-        this.registerShowDependenciesTool();
-        this.registerProjectsTool();
+        this.registerAnalyzeTool();
         this.registerIndexTool();
-        this.registerSyncTool();
-        this.registerInstallParsersTool();
-        this.registerExcludeTool();
-        this.registerFindDuplicatesTool();
-        this.registerFindDeadCodeTool();
     }
-    /**
-     * Tool 1: Semantic search across indexed projects
-     */
+    // ============================================================
+    // TOOL 1: search
+    //   Combines: search, search_and_read, read_with_context
+    // ============================================================
     registerSearchTool() {
         this.server.registerTool('search', {
-            description: '**DEFAULT TOOL FOR CODE DISCOVERY** - Use this BEFORE grep/glob for any code search. ' +
-                'This semantic search finds code by meaning, not just text patterns. ' +
-                'ALWAYS use for: "Where is X handled?", "Find the auth logic", "How does Y work?", "What calls Z?" ' +
-                'Only fall back to grep when: you need exact literal strings, regex patterns, or already know the exact file. ' +
-                'Why better than grep: finds "user authentication" even if code says "login", "session", "credentials". ' +
-                'Examples: ❌ grep -r "damage.*ship" → ✅ search("how ships take damage"). ' +
-                'Returns absolute file paths ready for the Read tool. If not indexed, call index first. ' +
-                '**IMPORTANT**: Always pass the project parameter with the current working directory to ensure correct index is searched.',
+            description: 'Semantic code search. Finds code by meaning, not just text. ' +
+                'Pass query to search, add read=true to include file contents, or pass filepath instead to read a file with related context.',
             inputSchema: {
-                query: zod_1.z.string().describe('Natural language query or code snippet (e.g., "validation logic", "error handling")'),
-                project: zod_1.z.string().optional().describe('Project path - RECOMMENDED: pass cwd/workspace root to ensure correct index. Auto-detects if omitted but may select wrong project.'),
-                limit: zod_1.z.number().optional().default(10).describe('Maximum results (default: 10)'),
+                query: zod_1.z.string().optional().describe('Natural language search query'),
+                filepath: zod_1.z.string().optional().describe('File path to read with semantic context (alternative to query)'),
+                project: zod_1.z.string().optional().describe('Project path or name'),
+                read: zod_1.z.boolean().optional().default(false).describe('Include file contents in results'),
+                limit: zod_1.z.number().optional().default(10).describe('Max results'),
+                max_lines: zod_1.z.number().optional().default(500).describe('Max lines per file when read=true'),
                 search_type: zod_1.z.enum(['hybrid', 'fts', 'vector', 'graph']).optional().default('hybrid')
-                    .describe('Search method: hybrid (default), fts, vector, or graph'),
+                    .describe('Search method'),
                 mode: zod_1.z.enum(['full', 'exists']).optional().default('full')
-                    .describe('Mode: "full" returns detailed results, "exists" returns quick summary (faster)'),
+                    .describe('"exists" returns quick yes/no'),
             },
-        }, async ({ query, project, limit = 10, search_type = 'hybrid', mode = 'full' }) => {
+        }, async ({ query, filepath, project, read = false, limit = 10, max_lines = 500, search_type = 'hybrid', mode = 'full' }) => {
             try {
-                // Get storage manager
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const projects = await projectStore.list();
-                // Resolve project path - auto-detect if not provided
-                let projectPath;
-                let projectRecord;
-                if (project) {
-                    // Try to find by name/path
-                    projectRecord = projects.find(p => p.name === project ||
-                        p.path === project ||
-                        path.basename(p.path) === project ||
-                        path.resolve(project) === p.path);
-                    if (projectRecord) {
-                        projectPath = projectRecord.path;
-                    }
-                    else {
-                        // Use provided path directly and try to find CodeSeeker project
-                        projectPath = await this.findProjectPath(path.resolve(project));
-                    }
-                }
-                else {
-                    // No project specified - this is unreliable! MCP servers don't receive client's cwd.
-                    // We'll try to auto-detect but require explicit parameter when ambiguous.
-                    if (projects.length === 0) {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `No indexed projects found. Use index to index a project first.`,
-                                }],
-                            isError: true,
-                        };
-                    }
-                    else if (projects.length === 1) {
-                        // Only one project indexed - safe to use it
-                        projectRecord = projects[0];
-                        projectPath = projectRecord.path;
-                    }
-                    else {
-                        // Multiple projects - we can't reliably detect which one
-                        // Return an error asking for explicit project parameter
-                        const projectList = projects.map(p => `  - "${p.name}" (${p.path})`).join('\n');
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `⚠️ Multiple projects indexed. Please specify which project to search:\n\n` +
-                                        `${projectList}\n\n` +
-                                        `Example: search({query: "${query}", project: "/path/to/project"})\n\n` +
-                                        `TIP: Always pass the 'project' parameter with your workspace root path.`,
-                                }],
-                            isError: true,
-                        };
-                    }
-                }
-                // Check if project is indexed by checking for embeddings
-                const vectorStore = storageManager.getVectorStore();
-                if (!projectRecord) {
-                    projectRecord = await projectStore.findByPath(projectPath);
-                }
-                if (projectRecord) {
-                    // Quick check: does this project have any embeddings?
-                    try {
-                        const testResults = await vectorStore.searchByText('test', projectRecord.id, 1);
-                        if (!testResults || testResults.length === 0) {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `⚠️  Project "${path.basename(projectPath)}" found but not indexed.\n\n` +
-                                            `ACTION REQUIRED: Call index({path: "${projectPath}"}) then retry this search.`,
-                                    }],
-                                isError: true,
-                            };
-                        }
-                    }
-                    catch (err) {
-                        // If search fails, project likely not indexed
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `⚠️  Project "${path.basename(projectPath)}" needs indexing.\n\n` +
-                                        `ACTION REQUIRED: Call index({path: "${projectPath}"}) then retry this search.`,
-                                }],
-                            isError: true,
-                        };
-                    }
+                // Dispatch: filepath → read-with-context, read → search-and-read, else → search
+                if (filepath) {
+                    return await this.handleReadWithContext(filepath, project, !read ? true : read);
                 }
-                // Check cache first (only for 'full' mode - exists mode is fast enough)
-                let results;
-                let fromCache = false;
-                const cacheProjectId = projectRecord?.id || this.generateProjectId(projectPath);
-                if (mode === 'full') {
-                    const cached = await this.queryCache.get(query, cacheProjectId, search_type);
-                    if (cached) {
-                        results = cached.results;
-                        fromCache = true;
-                    }
-                    else {
-                        // Perform actual search
-                        results = await this.searchOrchestrator.performSemanticSearch(query, projectPath);
-                        // Cache results for future queries
-                        if (results.length > 0) {
-                            await this.queryCache.set(query, cacheProjectId, results, search_type);
-                        }
-                    }
-                }
-                else {
-                    // exists mode - always search fresh (it's fast)
-                    results = await this.searchOrchestrator.performSemanticSearch(query, projectPath);
-                }
-                const limitedResults = results.slice(0, mode === 'exists' ? 5 : limit);
-                if (limitedResults.length === 0) {
-                    // For exists mode, return structured response
-                    if (mode === 'exists') {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({
-                                        exists: false,
-                                        query,
-                                        project: projectPath,
-                                        message: 'No matching code found',
-                                    }, null, 2),
-                                }],
-                        };
-                    }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `No results found for query: "${query}"\n\n` +
-                                    `This could mean:\n` +
-                                    `1. No matching code exists for this query\n` +
-                                    `2. Try different search terms or broader queries\n` +
-                                    `3. The project may need reindexing if code was recently added`,
-                            }],
-                    };
-                }
-                // For exists mode, return quick summary
-                if (mode === 'exists') {
-                    const topResult = limitedResults[0];
-                    const absolutePath = path.isAbsolute(topResult.file)
-                        ? topResult.file
-                        : path.join(projectPath, topResult.file);
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    exists: true,
-                                    query,
-                                    project: projectPath,
-                                    total_matches: results.length,
-                                    top_file: absolutePath,
-                                    top_score: Math.round(topResult.similarity * 100) / 100,
-                                    hint: `Use Read tool with "${absolutePath}" to view the file`,
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Format full results with absolute paths and match type info
-                const formattedResults = limitedResults.map((r, i) => {
-                    const absolutePath = path.isAbsolute(r.file)
-                        ? r.file
-                        : path.join(projectPath, r.file);
+                if (!query) {
                     return {
-                        rank: i + 1,
-                        file: absolutePath,
-                        relative_path: r.file,
-                        score: Math.round(r.similarity * 100) / 100,
-                        type: r.type,
-                        // Include match source for better understanding of why file matched
-                        match_source: r.debug?.matchSource || 'hybrid',
-                        chunk: r.content.substring(0, 500) + (r.content.length > 500 ? '...' : ''),
-                        lines: r.lineStart && r.lineEnd ? `${r.lineStart}-${r.lineEnd}` : undefined,
+                        content: [{ type: 'text', text: 'Provide either query or filepath parameter.' }],
+                        isError: true,
                     };
-                });
-                // Build response with truncation warning if applicable
-                const wasLimited = results.length > limit;
-                const response = {
-                    query,
-                    project: projectPath,
-                    total_results: limitedResults.length,
-                    search_type,
-                    results: formattedResults,
-                };
-                // Add cache indicator
-                if (fromCache) {
-                    response.cached = true;
                 }
-                // Add truncation warning when results were limited
-                if (wasLimited) {
-                    response.truncated = true;
-                    response.total_available = results.length;
-                    response.hint = `Showing ${limit} of ${results.length} results. Use limit parameter to see more.`;
+                if (read) {
+                    return await this.handleSearchAndRead(query, project, Math.min(limit, 3), Math.min(max_lines, 1000));
                 }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify(response, null, 2),
-                        }],
-                };
+                return await this.handleSearch(query, project, limit, search_type, mode);
             }
             catch (error) {
                 return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Search', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
+                    content: [{ type: 'text', text: this.formatErrorMessage('Search', error instanceof Error ? error : String(error), { projectPath: project }) }],
                     isError: true,
                 };
             }
         });
     }
-    /**
-     * Tool 2: Find and read - combined search + read in one call
-     */
-    registerSearchAndReadTool() {
-        this.server.registerTool('search_and_read', {
-            description: '**SEARCH + READ IN ONE STEP** - Use when you need to see actual code, not just file paths. ' +
-                'Combines search + Read into a single call. Saves a round-trip when you know you\'ll need to read results. ' +
-                'Use this instead of search when: implementing something similar, understanding HOW code works, ' +
-                'user asks "show me the X code", or you need full context to make changes. ' +
-                'Examples: "Show me how damage is calculated" → search_and_read("damage calculation"). ' +
-                '"I need to add validation like login" → search_and_read("login form validation"). ' +
-                'Use search instead when: you only need file paths, checking if something exists (mode="exists"), ' +
-                'or want to see many results before picking one. Returns full file content with line numbers. ' +
-                '**IMPORTANT**: Always pass the project parameter with the current working directory to ensure correct index is searched.',
-            inputSchema: {
-                query: zod_1.z.string().describe('Natural language query or code snippet (e.g., "validation logic", "error handling")'),
-                project: zod_1.z.string().optional().describe('Project path - RECOMMENDED: pass cwd/workspace root to ensure correct index. Auto-detects if omitted but may select wrong project.'),
-                max_files: zod_1.z.number().optional().default(1).describe('Maximum files to read (default: 1, max: 3)'),
-                max_lines: zod_1.z.number().optional().default(500).describe('Maximum lines per file (default: 500, max: 1000)'),
-            },
-        }, async ({ query, project, max_files = 1, max_lines = 500 }) => {
-            try {
-                // Cap the limits
-                const fileLimit = Math.min(max_files, 3);
-                const lineLimit = Math.min(max_lines, 1000);
-                // Get storage manager
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const projects = await projectStore.list();
-                // Resolve project path - auto-detect if not provided
-                let projectPath;
-                let projectRecord;
-                if (project) {
-                    // Try to find by name/path
-                    projectRecord = projects.find(p => p.name === project ||
-                        p.path === project ||
-                        path.basename(p.path) === project ||
-                        path.resolve(project) === p.path);
-                    if (projectRecord) {
-                        projectPath = projectRecord.path;
-                    }
-                    else {
-                        projectPath = await this.findProjectPath(path.resolve(project));
-                    }
-                }
-                else {
-                    // No project specified - require explicit parameter when ambiguous
-                    if (projects.length === 0) {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `No indexed projects found. Use index to index a project first.`,
-                                }],
-                            isError: true,
-                        };
-                    }
-                    else if (projects.length === 1) {
-                        // Only one project indexed - safe to use it
-                        projectRecord = projects[0];
-                        projectPath = projectRecord.path;
-                    }
-                    else {
-                        // Multiple projects - require explicit project parameter
-                        const projectList = projects.map(p => `  - "${p.name}" (${p.path})`).join('\n');
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `⚠️ Multiple projects indexed. Please specify which project to search:\n\n` +
-                                        `${projectList}\n\n` +
-                                        `Example: search_and_read({query: "${query}", project: "/path/to/project"})\n\n` +
-                                        `TIP: Always pass the 'project' parameter with your workspace root path.`,
-                                }],
-                            isError: true,
-                        };
-                    }
-                }
-                // Check if project is indexed
-                const vectorStore = storageManager.getVectorStore();
-                if (!projectRecord) {
-                    projectRecord = await projectStore.findByPath(projectPath);
-                }
-                if (projectRecord) {
-                    try {
-                        const testResults = await vectorStore.searchByText('test', projectRecord.id, 1);
-                        if (!testResults || testResults.length === 0) {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `⚠️  Project "${path.basename(projectPath)}" found but not indexed.\n\n` +
-                                            `ACTION REQUIRED: Call index({path: "${projectPath}"}) then retry.`,
-                                    }],
-                                isError: true,
-                            };
-                        }
-                    }
-                    catch {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `⚠️  Project "${path.basename(projectPath)}" needs indexing.\n\n` +
-                                        `ACTION REQUIRED: Call index({path: "${projectPath}"}) then retry.`,
-                                }],
-                            isError: true,
-                        };
-                    }
-                }
-                // Perform search
-                const results = await this.searchOrchestrator.performSemanticSearch(query, projectPath);
-                if (results.length === 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    query,
-                                    project: projectPath,
-                                    found: false,
-                                    message: 'No matching code found. Try different search terms.',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Get unique files (a search may return multiple chunks from the same file)
-                const seenFiles = new Set();
-                const uniqueResults = [];
-                for (const r of results) {
-                    const normalizedPath = r.file.replace(/\\/g, '/');
-                    if (!seenFiles.has(normalizedPath)) {
-                        seenFiles.add(normalizedPath);
-                        uniqueResults.push(r);
-                        if (uniqueResults.length >= fileLimit)
-                            break;
-                    }
-                }
-                // Read each file
-                const files = [];
-                for (const result of uniqueResults) {
-                    const absolutePath = path.isAbsolute(result.file)
-                        ? result.file
-                        : path.join(projectPath, result.file);
-                    try {
-                        if (!fs.existsSync(absolutePath)) {
-                            continue;
-                        }
-                        const content = fs.readFileSync(absolutePath, 'utf-8');
-                        const lines = content.split('\n');
-                        const truncated = lines.length > lineLimit;
-                        const displayLines = truncated ? lines.slice(0, lineLimit) : lines;
-                        // Add line numbers
-                        const numberedContent = displayLines
-                            .map((line, i) => `${String(i + 1).padStart(4)}│ ${line}`)
-                            .join('\n');
-                        files.push({
-                            file: absolutePath,
-                            relative_path: result.file,
-                            score: Math.round(result.similarity * 100) / 100,
-                            file_type: result.type,
-                            match_source: result.debug?.matchSource || 'hybrid',
-                            line_count: lines.length,
-                            content: numberedContent + (truncated ? `\n... (truncated at ${lineLimit} lines)` : ''),
-                            truncated,
-                        });
-                    }
-                    catch (err) {
-                        // Skip files we can't read
-                        continue;
-                    }
-                }
-                if (files.length === 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    query,
-                                    project: projectPath,
-                                    found: true,
-                                    readable: false,
-                                    message: 'Found matching files but could not read them.',
-                                }, null, 2),
-                            }],
-                    };
+    async handleSearch(query, project, limit, search_type, mode) {
+        const { projectPath, projectRecord, error } = await this.resolveProject(project);
+        if (error)
+            return error;
+        const indexCheck = await this.verifyIndexed(projectPath, projectRecord);
+        if (indexCheck.error)
+            return indexCheck.error;
+        // Check cache (only for 'full' mode)
+        let results;
+        let fromCache = false;
+        const cacheProjectId = projectRecord?.id || this.generateProjectId(projectPath);
+        if (mode === 'full') {
+            const cached = await this.queryCache.get(query, cacheProjectId, search_type);
+            if (cached) {
+                results = cached.results;
+                fromCache = true;
+            }
+            else {
+                results = await this.searchOrchestrator.performSemanticSearch(query, projectPath);
+                if (results.length > 0) {
+                    await this.queryCache.set(query, cacheProjectId, results, search_type);
                 }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                query,
-                                project: projectPath,
-                                files_found: results.length,
-                                files_returned: files.length,
-                                results: files,
-                            }, null, 2),
-                        }],
-                };
             }
-            catch (error) {
+        }
+        else {
+            results = await this.searchOrchestrator.performSemanticSearch(query, projectPath);
+        }
+        const limitedResults = results.slice(0, mode === 'exists' ? 5 : limit);
+        if (limitedResults.length === 0) {
+            if (mode === 'exists') {
                 return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Find and read', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
-                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify({ exists: false, query, project: projectPath, message: 'No matching code found' }, null, 2) }],
                 };
             }
+            return {
+                content: [{ type: 'text', text: `No results for: "${query}". Try different terms or reindex.` }],
+            };
+        }
+        if (mode === 'exists') {
+            const topResult = limitedResults[0];
+            const absolutePath = path.isAbsolute(topResult.file) ? topResult.file : path.join(projectPath, topResult.file);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            exists: true, query, project: projectPath,
+                            total_matches: results.length, top_file: absolutePath,
+                            top_score: Math.round(topResult.similarity * 100) / 100,
+                        }, null, 2) }],
+            };
+        }
+        const formattedResults = limitedResults.map((r, i) => {
+            const absolutePath = path.isAbsolute(r.file) ? r.file : path.join(projectPath, r.file);
+            return {
+                rank: i + 1,
+                file: absolutePath,
+                relative_path: r.file,
+                score: Math.round(r.similarity * 100) / 100,
+                type: r.type,
+                match_source: r.debug?.matchSource || 'hybrid',
+                chunk: r.content.substring(0, 500) + (r.content.length > 500 ? '...' : ''),
+                lines: r.lineStart && r.lineEnd ? `${r.lineStart}-${r.lineEnd}` : undefined,
+            };
         });
+        const wasLimited = results.length > limit;
+        const response = {
+            query, project: projectPath,
+            total_results: limitedResults.length,
+            search_type, results: formattedResults,
+        };
+        if (fromCache)
+            response.cached = true;
+        if (wasLimited) {
+            response.truncated = true;
+            response.total_available = results.length;
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
     }
-    /**
-     * Tool 3: Get file with semantic context
-     */
-    registerReadWithContextTool() {
-        this.server.registerTool('read_with_context', {
-            description: '**READ FILE WITH RELATED CODE** - Enhanced Read that includes semantically similar code. ' +
-                'Use instead of basic Read when: reading a file for the first time, the file references other modules, ' +
-                'or you want to discover patterns used elsewhere in the codebase. ' +
-                'Examples: Understanding a component → read_with_context("src/Button.tsx") returns Button + similar patterns. ' +
-                'Reading a service → read_with_context("src/api.ts") returns api.ts + related implementations. ' +
-                'Use basic Read instead when: you just need file contents, already understand the codebase, or making quick edits. ' +
-                'Set include_related=false to get just the file without related chunks.',
+    async handleSearchAndRead(query, project, max_files, max_lines) {
+        const fileLimit = Math.min(max_files, 3);
+        const lineLimit = Math.min(max_lines, 1000);
+        const { projectPath, projectRecord, error } = await this.resolveProject(project);
+        if (error)
+            return error;
+        const indexCheck = await this.verifyIndexed(projectPath, projectRecord);
+        if (indexCheck.error)
+            return indexCheck.error;
+        const results = await this.searchOrchestrator.performSemanticSearch(query, projectPath);
+        if (results.length === 0) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ query, project: projectPath, found: false, message: 'No matching code found.' }, null, 2) }],
+            };
+        }
+        // Get unique files
+        const seenFiles = new Set();
+        const uniqueResults = [];
+        for (const r of results) {
+            const normalizedPath = r.file.replace(/\\/g, '/');
+            if (!seenFiles.has(normalizedPath)) {
+                seenFiles.add(normalizedPath);
+                uniqueResults.push(r);
+                if (uniqueResults.length >= fileLimit)
+                    break;
+            }
+        }
+        const files = [];
+        for (const result of uniqueResults) {
+            const absolutePath = path.isAbsolute(result.file) ? result.file : path.join(projectPath, result.file);
+            try {
+                if (!fs.existsSync(absolutePath))
+                    continue;
+                const content = fs.readFileSync(absolutePath, 'utf-8');
+                const lines = content.split('\n');
+                const truncated = lines.length > lineLimit;
+                const displayLines = truncated ? lines.slice(0, lineLimit) : lines;
+                const numberedContent = displayLines.map((line, i) => `${String(i + 1).padStart(4)}│ ${line}`).join('\n');
+                files.push({
+                    file: absolutePath,
+                    relative_path: result.file,
+                    score: Math.round(result.similarity * 100) / 100,
+                    file_type: result.type,
+                    match_source: result.debug?.matchSource || 'hybrid',
+                    line_count: lines.length,
+                    content: numberedContent + (truncated ? `\n... (truncated at ${lineLimit} lines)` : ''),
+                    truncated,
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+        if (files.length === 0) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ query, project: projectPath, found: true, readable: false, message: 'Found matching files but could not read them.' }, null, 2) }],
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        query, project: projectPath,
+                        files_found: results.length, files_returned: files.length,
+                        results: files,
+                    }, null, 2) }],
+        };
+    }
+    async handleReadWithContext(filepath, project, include_related) {
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        let projectPath;
+        if (project) {
+            const projects = await projectStore.list();
+            const found = projects.find(p => p.name === project || p.path === project || path.basename(p.path) === project);
+            projectPath = found?.path || process.cwd();
+        }
+        else {
+            projectPath = process.cwd();
+        }
+        const absolutePath = path.isAbsolute(filepath) ? filepath : path.join(projectPath, filepath);
+        if (!fs.existsSync(absolutePath)) {
+            return { content: [{ type: 'text', text: `File not found: ${absolutePath}` }], isError: true };
+        }
+        const content = fs.readFileSync(absolutePath, 'utf-8');
+        let relatedChunks = [];
+        if (include_related) {
+            const lines = content.split('\n');
+            const meaningfulLines = [];
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*'))
+                    continue;
+                if (trimmed.startsWith('import ') || trimmed.startsWith('from ') || trimmed.startsWith('require('))
+                    continue;
+                if (trimmed.startsWith('#') && !trimmed.startsWith('##'))
+                    continue;
+                if (trimmed.startsWith('using ') || trimmed.startsWith('namespace '))
+                    continue;
+                meaningfulLines.push(trimmed);
+                if (meaningfulLines.length >= 5)
+                    break;
+            }
+            const fileName = path.basename(filepath);
+            const fileNameQuery = fileName.replace(/\.[^.]+$/, '').replace(/[-_]/g, ' ');
+            const contentQuery = meaningfulLines.join(' ').substring(0, 200);
+            const searchQuery = `${fileNameQuery} ${contentQuery}`.trim();
+            const results = await this.searchOrchestrator.performSemanticSearch(searchQuery || fileNameQuery, projectPath);
+            relatedChunks = results
+                .filter(r => !r.file.endsWith(path.basename(filepath)))
+                .slice(0, 5)
+                .map(r => ({
+                file: r.file,
+                chunk: r.content.substring(0, 300) + (r.content.length > 300 ? '...' : ''),
+                score: Math.round(r.similarity * 100) / 100,
+            }));
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        filepath: path.relative(projectPath, absolutePath),
+                        content: content.length > 10000 ? content.substring(0, 10000) + '\n... (truncated)' : content,
+                        line_count: content.split('\n').length,
+                        related_chunks: include_related ? relatedChunks : undefined,
+                    }, null, 2) }],
+        };
+    }
+    // ============================================================
+    // TOOL 2: analyze
+    //   Combines: show_dependencies, find_duplicates, find_dead_code, standards
+    // ============================================================
+    registerAnalyzeTool() {
+        this.server.registerTool('analyze', {
+            description: 'Code analysis. Actions: "dependencies" (imports/calls/extends graph), ' +
+                '"dead_code" (unused code, anti-patterns), "duplicates" (similar code), ' +
+                '"standards" (auto-detected coding patterns).',
             inputSchema: {
-                filepath: zod_1.z.string().describe('Path to the file (absolute or relative to project)'),
-                include_related: zod_1.z.boolean().optional().default(true)
-                    .describe('If true, also return semantically similar chunks from other files'),
-                project: zod_1.z.string().optional().describe('Project name or path (optional, defaults to current directory)'),
+                action: zod_1.z.enum(['dependencies', 'dead_code', 'duplicates', 'standards']).describe('Analysis type'),
+                project: zod_1.z.string().describe('Project path or name'),
+                // dependencies params
+                filepath: zod_1.z.string().optional().describe('File for dependency analysis'),
+                filepaths: zod_1.z.array(zod_1.z.string()).optional().describe('Multiple files for dependency analysis'),
+                query: zod_1.z.string().optional().describe('Search query to find seed files for dependencies'),
+                depth: zod_1.z.number().optional().default(1).describe('Relationship hops (1-3)'),
+                relationship_types: zod_1.z.array(zod_1.z.enum([
+                    'imports', 'exports', 'calls', 'extends', 'implements', 'contains', 'uses', 'depends_on'
+                ])).optional().describe('Filter relationship types'),
+                direction: zod_1.z.enum(['in', 'out', 'both']).optional().default('both').describe('Relationship direction'),
+                max_nodes: zod_1.z.number().optional().default(50).describe('Max nodes'),
+                // duplicates params
+                similarity_threshold: zod_1.z.number().optional().default(0.80).describe('Min similarity for duplicates (0-1)'),
+                min_lines: zod_1.z.number().optional().default(5).describe('Min lines for duplicate analysis'),
+                // dead_code params
+                include_patterns: zod_1.z.array(zod_1.z.enum(['dead_code', 'god_class', 'circular_deps', 'feature_envy', 'coupling'])).optional()
+                    .describe('Anti-patterns to detect'),
+                // standards params
+                category: zod_1.z.enum(['validation', 'error-handling', 'logging', 'testing', 'all']).optional().default('all')
+                    .describe('Standards category'),
             },
-        }, async ({ filepath, include_related = true, project }) => {
+        }, async (params) => {
             try {
-                // Resolve project path
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                let projectPath;
-                if (project) {
-                    const projects = await projectStore.list();
-                    const found = projects.find(p => p.name === project ||
-                        p.path === project ||
-                        path.basename(p.path) === project);
-                    projectPath = found?.path || process.cwd();
-                }
-                else {
-                    projectPath = process.cwd();
+                switch (params.action) {
+                    case 'dependencies':
+                        return await this.handleShowDependencies(params);
+                    case 'dead_code':
+                        return await this.handleFindDeadCode(params);
+                    case 'duplicates':
+                        return await this.handleFindDuplicates(params);
+                    case 'standards':
+                        return await this.handleStandards(params);
+                    default:
+                        return { content: [{ type: 'text', text: `Unknown action: ${params.action}` }], isError: true };
                 }
-                // Resolve file path
-                const absolutePath = path.isAbsolute(filepath)
-                    ? filepath
-                    : path.join(projectPath, filepath);
-                // Read file content
-                if (!fs.existsSync(absolutePath)) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `File not found: ${absolutePath}`,
-                            }],
-                        isError: true,
-                    };
-                }
-                const content = fs.readFileSync(absolutePath, 'utf-8');
-                // Get related chunks if requested
-                let relatedChunks = [];
-                if (include_related) {
-                    // Build a semantic search query from the file content
-                    // Use the first meaningful lines of code (skip comments, imports, empty lines)
-                    const lines = content.split('\n');
-                    const meaningfulLines = [];
-                    for (const line of lines) {
-                        const trimmed = line.trim();
-                        // Skip empty, comments, and import lines
-                        if (!trimmed)
-                            continue;
-                        if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*'))
-                            continue;
-                        if (trimmed.startsWith('import ') || trimmed.startsWith('from ') || trimmed.startsWith('require('))
-                            continue;
-                        if (trimmed.startsWith('#') && !trimmed.startsWith('##'))
-                            continue; // Skip Python comments but not markdown headers
-                        if (trimmed.startsWith('using ') || trimmed.startsWith('namespace '))
-                            continue; // C#
-                        meaningfulLines.push(trimmed);
-                        if (meaningfulLines.length >= 5)
-                            break; // Use first 5 meaningful lines
-                    }
-                    // Create search query from file name + meaningful content
-                    const fileName = path.basename(filepath);
-                    const fileNameQuery = fileName.replace(/\.[^.]+$/, '').replace(/[-_]/g, ' ');
-                    const contentQuery = meaningfulLines.join(' ').substring(0, 200);
-                    const searchQuery = `${fileNameQuery} ${contentQuery}`.trim();
-                    const results = await this.searchOrchestrator.performSemanticSearch(searchQuery || fileNameQuery, // Fallback to filename if no content
-                    projectPath);
-                    // Filter out the current file and limit results
-                    relatedChunks = results
-                        .filter(r => !r.file.endsWith(path.basename(filepath)))
-                        .slice(0, 5)
-                        .map(r => ({
-                        file: r.file,
-                        chunk: r.content.substring(0, 300) + (r.content.length > 300 ? '...' : ''),
-                        score: Math.round(r.similarity * 100) / 100,
-                    }));
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                filepath: path.relative(projectPath, absolutePath),
-                                content: content.length > 10000 ? content.substring(0, 10000) + '\n... (truncated)' : content,
-                                line_count: content.split('\n').length,
-                                related_chunks: include_related ? relatedChunks : undefined,
-                            }, null, 2),
-                        }],
-                };
             }
             catch (error) {
                 return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Get file context', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
+                    content: [{ type: 'text', text: this.formatErrorMessage('Analyze', error instanceof Error ? error : String(error), { projectPath: params.project }) }],
                     isError: true,
                 };
             }
         });
     }
-    /**
-     * Tool 3: Get code relationships from the knowledge graph
-     * Uses "Seed + Expand" strategy like the CLI's GraphAnalysisService
-     */
-    registerShowDependenciesTool() {
-        this.server.registerTool('show_dependencies', {
-            description: '**UNDERSTAND CODE CONNECTIONS** - Use after search to explore how files relate. ' +
-                'Maps imports, class hierarchies, function calls, dependencies. Essential for understanding impact of changes. ' +
-                'Use when: planning refactors ("what breaks if I change this?"), understanding architecture ("what depends on this?"), ' +
-                'tracing data flow ("where does this come from?"), before changing shared code. ' +
-                'WORKFLOW: 1) search to find files, 2) pass those paths here via filepaths parameter. ' +
-                'Filter with relationship_types: ["imports"], ["calls"], ["extends"] to reduce noise. ' +
-                'Use direction="in" to find what USES this file, direction="out" for what this file USES.',
-            inputSchema: {
-                filepath: zod_1.z.string().optional().describe('Single file path to explore (prefer filepaths for multiple)'),
-                filepaths: zod_1.z.array(zod_1.z.string()).optional().describe('PREFERRED: Array of file paths from search results'),
-                query: zod_1.z.string().optional().describe('Fallback: semantic search to find seed files (prefer using filepaths from search)'),
-                depth: zod_1.z.number().optional().default(1).describe('How many relationship hops to traverse (1-3, default: 1). Use 1 for focused results, 2+ can return many nodes.'),
-                relationship_types: zod_1.z.array(zod_1.z.enum([
-                    'imports', 'exports', 'calls', 'extends', 'implements', 'contains', 'uses', 'depends_on'
-                ])).optional().describe('Filter to specific relationship types (default: all). Recommended: use ["imports"] or ["imports", "calls"] to reduce output.'),
-                direction: zod_1.z.enum(['in', 'out', 'both']).optional().default('both')
-                    .describe('Direction of relationships: in (what points to this), out (what this points to), both'),
-                max_nodes: zod_1.z.number().optional().default(50).describe('Maximum nodes to return (default: 50). Increase for comprehensive analysis.'),
-                project: zod_1.z.string().optional().describe('Project name or path'),
-            },
-        }, async ({ filepath, filepaths, query, depth = 1, relationship_types, direction = 'both', max_nodes = 50, project }) => {
-            try {
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const graphStore = storageManager.getGraphStore();
-                // Resolve project
-                let projectId;
-                let projectPath;
-                if (project) {
-                    const projects = await projectStore.list();
-                    const found = projects.find(p => p.name === project ||
-                        p.path === project ||
-                        path.basename(p.path) === project);
-                    if (found) {
-                        projectId = found.id;
-                        projectPath = found.path;
-                    }
-                    else {
-                        projectPath = process.cwd();
-                    }
-                }
-                else {
-                    projectPath = process.cwd();
-                    const projects = await projectStore.list();
-                    const found = projects.find(p => p.path === projectPath ||
-                        path.basename(p.path) === path.basename(projectPath));
-                    if (found) {
-                        projectId = found.id;
-                        projectPath = found.path;
-                    }
+    async handleShowDependencies(params) {
+        const { filepath, filepaths, query, depth = 1, relationship_types, direction = 'both', max_nodes = 50, project } = params;
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        const graphStore = storageManager.getGraphStore();
+        let projectId;
+        let projectPath;
+        if (project) {
+            const projects = await projectStore.list();
+            const found = projects.find(p => p.name === project || p.path === project || path.basename(p.path) === project);
+            if (found) {
+                projectId = found.id;
+                projectPath = found.path;
+            }
+            else {
+                projectPath = process.cwd();
+            }
+        }
+        else {
+            projectPath = process.cwd();
+            const projects = await projectStore.list();
+            const found = projects.find(p => p.path === projectPath || path.basename(p.path) === path.basename(projectPath));
+            if (found) {
+                projectId = found.id;
+                projectPath = found.path;
+            }
+        }
+        if (!projectId) {
+            return { content: [{ type: 'text', text: 'Project not indexed. Use index({action: "init"}) first.' }], isError: true };
+        }
+        // Determine seed file paths
+        let seedFilePaths = [];
+        if (query) {
+            const searchResults = await this.searchOrchestrator.performSemanticSearch(query, projectPath);
+            seedFilePaths = searchResults.slice(0, 5).map(r => r.file.replace(/\\/g, '/'));
+        }
+        else if (filepaths && filepaths.length > 0) {
+            seedFilePaths = filepaths.map(fp => fp.replace(/\\/g, '/'));
+        }
+        else if (filepath) {
+            seedFilePaths = [filepath.replace(/\\/g, '/')];
+        }
+        else {
+            return {
+                content: [{ type: 'text', text: 'Provide filepath, filepaths, or query for dependency analysis.' }],
+                isError: true,
+            };
+        }
+        const allNodes = await graphStore.findNodes(projectId);
+        const graphStats = {
+            total_nodes: allNodes.length,
+            file_nodes: allNodes.filter(n => n.type === 'file').length,
+            class_nodes: allNodes.filter(n => n.type === 'class').length,
+            function_nodes: allNodes.filter(n => n.type === 'function' || n.type === 'method').length,
+        };
+        // Find starting nodes using flexible path matching
+        const startNodes = allNodes.filter(n => {
+            const normalizedNodePath = n.filePath.replace(/\\/g, '/');
+            const nodeRelativePath = n.properties?.relativePath?.replace(/\\/g, '/');
+            return seedFilePaths.some(seedPath => {
+                const normalizedSeedPath = seedPath.replace(/\\/g, '/');
+                return (normalizedNodePath === normalizedSeedPath ||
+                    nodeRelativePath === normalizedSeedPath ||
+                    normalizedNodePath.endsWith(normalizedSeedPath) ||
+                    normalizedNodePath.endsWith('/' + normalizedSeedPath) ||
+                    normalizedNodePath.includes('/' + normalizedSeedPath) ||
+                    n.name === path.basename(normalizedSeedPath).replace(/\.[^.]+$/, ''));
+            });
+        });
+        if (startNodes.length === 0) {
+            const fileNodes = allNodes.filter(n => n.type === 'file').slice(0, 15);
+            const availableFiles = fileNodes.map(n => {
+                const relPath = n.properties?.relativePath;
+                return relPath || path.relative(projectPath, n.filePath);
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: `No graph nodes found for: ${seedFilePaths.join(', ')}`,
+                            available_files: availableFiles,
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        // Traverse relationships
+        const visitedNodes = new Map();
+        const collectedEdges = [];
+        let truncated = false;
+        const traverse = async (nodeId, currentDepth) => {
+            if (visitedNodes.size >= max_nodes) {
+                truncated = true;
+                return;
+            }
+            if (currentDepth > Math.min(depth, 3) || visitedNodes.has(nodeId))
+                return;
+            const node = await graphStore.getNode(nodeId);
+            if (!node)
+                return;
+            const relPath = node.properties?.relativePath;
+            visitedNodes.set(nodeId, {
+                id: node.id, type: node.type, name: node.name,
+                file: relPath || path.relative(projectPath, node.filePath),
+            });
+            const edges = await graphStore.getEdges(nodeId, direction);
+            for (const edge of edges) {
+                if (visitedNodes.size >= max_nodes) {
+                    truncated = true;
+                    return;
+                }
+                if (relationship_types && relationship_types.length > 0) {
+                    if (!relationship_types.includes(edge.type))
+                        continue;
                 }
-                if (!projectId) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: 'Project not indexed. Use index first.',
-                            }],
-                        isError: true,
-                    };
-                }
-                // Determine seed file paths
-                let seedFilePaths = [];
-                if (query) {
-                    // Use semantic search to find seed files
-                    const searchResults = await this.searchOrchestrator.performSemanticSearch(query, projectPath);
-                    seedFilePaths = searchResults.slice(0, 5).map(r => r.file.replace(/\\/g, '/'));
-                }
-                else if (filepaths && filepaths.length > 0) {
-                    seedFilePaths = filepaths.map(fp => fp.replace(/\\/g, '/'));
-                }
-                else if (filepath) {
-                    seedFilePaths = [filepath.replace(/\\/g, '/')];
-                }
-                else {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: 'Please provide filepath, filepaths, or query to explore relationships.',
-                            }],
-                        isError: true,
-                    };
-                }
-                // Find all nodes for this project and get graph stats
-                const allNodes = await graphStore.findNodes(projectId);
-                const graphStats = {
-                    total_nodes: allNodes.length,
-                    file_nodes: allNodes.filter(n => n.type === 'file').length,
-                    class_nodes: allNodes.filter(n => n.type === 'class').length,
-                    function_nodes: allNodes.filter(n => n.type === 'function' || n.type === 'method').length,
+                collectedEdges.push({ from: edge.source, to: edge.target, type: edge.type });
+                const nextNodeId = edge.source === nodeId ? edge.target : edge.source;
+                await traverse(nextNodeId, currentDepth + 1);
+            }
+        };
+        for (const startNode of startNodes) {
+            if (visitedNodes.size >= max_nodes) {
+                truncated = true;
+                break;
+            }
+            await traverse(startNode.id, 1);
+        }
+        const nodes = Array.from(visitedNodes.values());
+        const uniqueEdges = collectedEdges.filter((e, i, arr) => arr.findIndex(x => x.from === e.from && x.to === e.to && x.type === e.type) === i);
+        const summary = {
+            graph_stats: graphStats,
+            seed_files: startNodes.map(n => ({
+                name: n.name, type: n.type,
+                file: n.properties?.relativePath || path.relative(projectPath, n.filePath),
+            })),
+            traversal: { depth_requested: depth, direction, relationship_filters: relationship_types || 'all', max_nodes },
+            results: { seed_nodes: startNodes.length, nodes_found: nodes.length, relationships_found: uniqueEdges.length, truncated },
+            nodes: nodes.map(n => ({ name: n.name, type: n.type, file: n.file })),
+            relationships: uniqueEdges.map(e => {
+                const fromNode = visitedNodes.get(e.from);
+                const toNode = visitedNodes.get(e.to);
+                return { type: e.type, from: fromNode?.name || e.from, to: toNode?.name || e.to };
+            }),
+        };
+        if (truncated) {
+            summary.truncated_warning = {
+                message: `Results truncated at ${max_nodes} nodes.`,
+                recommendations: [
+                    relationship_types ? null : 'Add relationship_types filter',
+                    depth > 1 ? 'Reduce depth to 1' : null,
+                    `Increase max_nodes (current: ${max_nodes})`,
+                ].filter(Boolean),
+            };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] };
+    }
+    async handleFindDuplicates(params) {
+        const { project, similarity_threshold = 0.80, min_lines = 5 } = params;
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        const vectorStore = storageManager.getVectorStore();
+        const projects = await projectStore.list();
+        const projectRecord = projects.find(p => p.name === project || p.path === project ||
+            path.basename(p.path) === project || path.resolve(project) === p.path);
+        if (!projectRecord) {
+            return {
+                content: [{ type: 'text', text: `Project not found: ${project}. Use index({action: "init"}) first.` }],
+                isError: true,
+            };
+        }
+        const allDocs = await this.getAllProjectDocuments(vectorStore, projectRecord.id);
+        if (allDocs.length === 0) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            project: projectRecord.name,
+                            summary: { total_chunks_analyzed: 0, exact_duplicates: 0, semantic_duplicates: 0, total_lines_affected: 0, potential_lines_saved: 0 },
+                            duplicate_groups: [],
+                        }, null, 2) }],
+            };
+        }
+        const filteredDocs = allDocs.filter(doc => doc.content.split('\n').length >= min_lines);
+        const duplicateGroups = [];
+        const processed = new Set();
+        const EXACT_THRESHOLD = 0.98;
+        for (let i = 0; i < filteredDocs.length && duplicateGroups.length < 50; i++) {
+            const doc = filteredDocs[i];
+            if (processed.has(doc.id))
+                continue;
+            const similarDocs = await vectorStore.searchByVector(doc.embedding, projectRecord.id, 20);
+            const matches = similarDocs.filter(match => match.document.id !== doc.id && match.score >= similarity_threshold && !processed.has(match.document.id));
+            if (matches.length > 0) {
+                const maxScore = Math.max(...matches.map(m => m.score));
+                const type = maxScore >= EXACT_THRESHOLD ? 'exact' : 'semantic';
+                const getLines = (d) => {
+                    const meta = d.metadata;
+                    return { startLine: meta?.startLine, endLine: meta?.endLine };
                 };
-                // Find starting nodes using flexible path matching (like CLI's GraphAnalysisService)
-                const startNodes = allNodes.filter(n => {
-                    const normalizedNodePath = n.filePath.replace(/\\/g, '/');
-                    const nodeRelativePath = n.properties?.relativePath?.replace(/\\/g, '/');
-                    return seedFilePaths.some(seedPath => {
-                        const normalizedSeedPath = seedPath.replace(/\\/g, '/');
-                        return (
-                        // Exact matches
-                        normalizedNodePath === normalizedSeedPath ||
-                            nodeRelativePath === normalizedSeedPath ||
-                            // Ends with (for relative paths)
-                            normalizedNodePath.endsWith(normalizedSeedPath) ||
-                            normalizedNodePath.endsWith('/' + normalizedSeedPath) ||
-                            // Contains match (for partial paths)
-                            normalizedNodePath.includes('/' + normalizedSeedPath) ||
-                            // Name match (for class/function names)
-                            n.name === path.basename(normalizedSeedPath).replace(/\.[^.]+$/, ''));
-                    });
+                duplicateGroups.push({
+                    type, similarity: maxScore,
+                    chunks: [
+                        { id: doc.id, filePath: doc.filePath, content: doc.content.substring(0, 200) + (doc.content.length > 200 ? '...' : ''), ...getLines(doc) },
+                        ...matches.map(m => ({
+                            id: m.document.id, filePath: m.document.filePath,
+                            content: m.document.content.substring(0, 200) + (m.document.content.length > 200 ? '...' : ''),
+                            ...getLines(m.document),
+                        })),
+                    ],
                 });
-                if (startNodes.length === 0) {
-                    // List available files in graph with relative paths
-                    const fileNodes = allNodes.filter(n => n.type === 'file').slice(0, 15);
-                    const availableFiles = fileNodes.map(n => {
-                        const relPath = n.properties?.relativePath;
-                        return relPath || path.relative(projectPath, n.filePath);
+                processed.add(doc.id);
+                matches.forEach(m => processed.add(m.document.id));
+            }
+        }
+        const exactDuplicates = duplicateGroups.filter(g => g.type === 'exact').length;
+        const semanticDuplicates = duplicateGroups.filter(g => g.type === 'semantic').length;
+        const totalLinesAffected = duplicateGroups.reduce((sum, g) => sum + g.chunks.reduce((chunkSum, c) => chunkSum + (c.endLine && c.startLine ? c.endLine - c.startLine + 1 : c.content.split('\n').length), 0), 0);
+        const formattedGroups = duplicateGroups.slice(0, 20).map(group => ({
+            type: group.type,
+            similarity: `${(group.similarity * 100).toFixed(1)}%`,
+            files_affected: new Set(group.chunks.map(c => c.filePath)).size,
+            locations: group.chunks.map(c => ({
+                file: path.relative(projectRecord.path, c.filePath),
+                lines: c.startLine && c.endLine ? `${c.startLine}-${c.endLine}` : 'N/A',
+                preview: c.content.substring(0, 100).replace(/\n/g, ' '),
+            })),
+        }));
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        project: projectRecord.name,
+                        summary: {
+                            total_chunks_analyzed: filteredDocs.length,
+                            exact_duplicates: exactDuplicates,
+                            semantic_duplicates: semanticDuplicates,
+                            total_lines_affected: totalLinesAffected,
+                            potential_lines_saved: Math.floor(totalLinesAffected * 0.6),
+                        },
+                        duplicate_groups: formattedGroups,
+                        recommendations: exactDuplicates > 0
+                            ? [`Found ${exactDuplicates} exact duplicate groups - prioritize consolidation`]
+                            : semanticDuplicates > 0
+                                ? [`Found ${semanticDuplicates} semantic duplicates - review for potential abstraction`]
+                                : ['No significant duplicates found above threshold'],
+                    }, null, 2) }],
+        };
+    }
+    async handleFindDeadCode(params) {
+        const { project, include_patterns } = params;
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        const graphStore = storageManager.getGraphStore();
+        const projects = await projectStore.list();
+        const projectRecord = projects.find(p => p.name === project || p.path === project ||
+            path.basename(p.path) === project || path.resolve(project) === p.path);
+        if (!projectRecord) {
+            return {
+                content: [{ type: 'text', text: `Project not found: ${project}. Use index({action: "init"}) first.` }],
+                isError: true,
+            };
+        }
+        const allNodes = await graphStore.findNodes(projectRecord.id);
+        if (allNodes.length === 0) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            project: projectRecord.name,
+                            summary: { total_issues: 0, dead_code_count: 0, anti_patterns_count: 0, coupling_issues_count: 0 },
+                            dead_code: [], anti_patterns: [], coupling_issues: [],
+                            note: 'No graph data. Project may need reindexing.',
+                        }, null, 2) }],
+            };
+        }
+        const patterns = include_patterns || ['dead_code', 'god_class', 'circular_deps', 'feature_envy', 'coupling'];
+        const deadCodeItems = [];
+        const antiPatternItems = [];
+        const couplingItems = [];
+        for (const node of allNodes) {
+            const inEdges = await graphStore.getEdges(node.id, 'in');
+            const outEdges = await graphStore.getEdges(node.id, 'out');
+            if (patterns.includes('dead_code')) {
+                const isEntryPoint = node.type === 'file' ||
+                    node.name.toLowerCase().includes('main') ||
+                    node.name.toLowerCase().includes('index') ||
+                    node.name.toLowerCase().includes('app');
+                if (!isEntryPoint && (node.type === 'class' || node.type === 'function') && inEdges.length === 0) {
+                    deadCodeItems.push({
+                        type: 'Dead Code', name: node.name,
+                        file: path.relative(projectRecord.path, node.filePath),
+                        description: `Unused ${node.type}: ${node.name} - no incoming references`,
+                        confidence: '70%', impact: 'medium',
+                        recommendation: 'Review if needed. Remove if unused or add to exports.',
                     });
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    error: `No graph nodes found for: ${seedFilePaths.join(', ')}`,
-                                    suggestion: query
-                                        ? 'The semantic search found files but they are not in the knowledge graph. Try re-indexing.'
-                                        : 'The file(s) may not be indexed in the knowledge graph.',
-                                    available_files: availableFiles,
-                                    tip: 'Use relative paths like "src/mcp/mcp-server.ts" or a query like "authentication middleware"',
-                                }, null, 2),
-                            }],
-                        isError: true,
-                    };
                 }
-                // Traverse relationships from all start nodes (Seed + Expand)
-                const visitedNodes = new Map();
-                const collectedEdges = [];
-                let truncated = false;
-                const traverse = async (nodeId, currentDepth) => {
-                    // Stop if we've reached max_nodes limit
-                    if (visitedNodes.size >= max_nodes) {
-                        truncated = true;
-                        return;
-                    }
-                    if (currentDepth > Math.min(depth, 3) || visitedNodes.has(nodeId))
-                        return;
-                    const node = await graphStore.getNode(nodeId);
-                    if (!node)
-                        return;
-                    const relPath = node.properties?.relativePath;
-                    visitedNodes.set(nodeId, {
-                        id: node.id,
-                        type: node.type,
-                        name: node.name,
-                        file: relPath || path.relative(projectPath, node.filePath),
+            }
+            if (patterns.includes('god_class') && node.type === 'class') {
+                const containsEdges = outEdges.filter(e => e.type === 'contains');
+                const dependsOnEdges = outEdges.filter(e => e.type === 'imports' || e.type === 'depends_on');
+                if (containsEdges.length > 15 || dependsOnEdges.length > 10) {
+                    antiPatternItems.push({
+                        type: 'God Class', name: node.name,
+                        file: path.relative(projectRecord.path, node.filePath),
+                        description: `${node.name} has ${containsEdges.length} members, ${dependsOnEdges.length} dependencies`,
+                        confidence: '80%', impact: 'high',
+                        recommendation: 'Break down following Single Responsibility Principle',
                     });
-                    // Get edges based on direction
-                    const edges = await graphStore.getEdges(nodeId, direction);
-                    for (const edge of edges) {
-                        // Stop if we've reached max_nodes limit
-                        if (visitedNodes.size >= max_nodes) {
-                            truncated = true;
-                            return;
-                        }
-                        // Filter by relationship type if specified
-                        if (relationship_types && relationship_types.length > 0) {
-                            if (!relationship_types.includes(edge.type))
-                                continue;
-                        }
-                        collectedEdges.push({
-                            from: edge.source,
-                            to: edge.target,
-                            type: edge.type,
-                        });
-                        // Continue traversal
-                        const nextNodeId = edge.source === nodeId ? edge.target : edge.source;
-                        await traverse(nextNodeId, currentDepth + 1);
-                    }
-                };
-                // Traverse from ALL start nodes (multiple seeds)
-                for (const startNode of startNodes) {
-                    if (visitedNodes.size >= max_nodes) {
-                        truncated = true;
-                        break;
-                    }
-                    await traverse(startNode.id, 1);
                 }
-                // Format output
-                const nodes = Array.from(visitedNodes.values());
-                const uniqueEdges = collectedEdges.filter((e, i, arr) => arr.findIndex(x => x.from === e.from && x.to === e.to && x.type === e.type) === i);
-                // Create a summary
-                const summary = {
-                    graph_stats: graphStats,
-                    seed_files: startNodes.map(n => ({
-                        name: n.name,
-                        type: n.type,
-                        file: n.properties?.relativePath || path.relative(projectPath, n.filePath),
-                    })),
-                    traversal: {
-                        depth_requested: depth,
-                        direction,
-                        relationship_filters: relationship_types || 'all',
-                        seed_method: query ? 'semantic_search' : (filepaths ? 'multiple_files' : 'single_file'),
-                        max_nodes,
-                    },
-                    results: {
-                        seed_nodes: startNodes.length,
-                        nodes_found: nodes.length,
-                        relationships_found: uniqueEdges.length,
-                        truncated,
-                    },
-                    nodes: nodes.map(n => ({
-                        name: n.name,
-                        type: n.type,
-                        file: n.file,
-                    })),
-                    relationships: uniqueEdges.map(e => {
-                        const fromNode = visitedNodes.get(e.from);
-                        const toNode = visitedNodes.get(e.to);
-                        return {
-                            type: e.type,
-                            from: fromNode?.name || e.from,
-                            to: toNode?.name || e.to,
-                        };
-                    }),
-                };
-                // Add truncation warning and recommendations if results were limited
-                if (truncated) {
-                    summary.truncated_warning = {
-                        message: `Results truncated at ${max_nodes} nodes.`,
-                        recommendations: [
-                            relationship_types ? null : 'Add relationship_types filter (e.g., ["imports"])',
-                            depth > 1 ? 'Reduce depth to 1' : null,
-                            `Increase max_nodes (current: ${max_nodes})`,
-                        ].filter(Boolean),
-                    };
+            }
+            if (patterns.includes('coupling') && (node.type === 'class' || node.type === 'file')) {
+                const dependencies = outEdges.filter(e => e.type === 'imports' || e.type === 'depends_on');
+                if (dependencies.length > 8) {
+                    couplingItems.push({
+                        type: 'High Coupling', name: node.name,
+                        file: path.relative(projectRecord.path, node.filePath),
+                        description: `${node.type} ${node.name} has ${dependencies.length} dependencies`,
+                        confidence: '75%', impact: 'high',
+                        recommendation: 'Reduce via interfaces or dependency injection',
+                    });
                 }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify(summary, null, 2),
-                        }],
-                };
             }
-            catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Get code relationships', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
-                    isError: true,
-                };
+        }
+        // Circular dependency detection
+        if (patterns.includes('circular_deps')) {
+            const fileNodes = allNodes.filter(n => n.type === 'file');
+            const importMap = new Map();
+            for (const fileNode of fileNodes) {
+                const imports = await graphStore.getEdges(fileNode.id, 'out');
+                importMap.set(fileNode.id, new Set(imports.filter(e => e.type === 'imports').map(e => e.target)));
             }
-        });
+            for (const [fileId, imports] of importMap.entries()) {
+                for (const targetId of imports) {
+                    const targetImports = importMap.get(targetId);
+                    if (targetImports?.has(fileId)) {
+                        const sourceNode = allNodes.find(n => n.id === fileId);
+                        const targetNode = allNodes.find(n => n.id === targetId);
+                        if (sourceNode && targetNode) {
+                            antiPatternItems.push({
+                                type: 'Circular Dependency',
+                                name: `${sourceNode.name} <-> ${targetNode.name}`,
+                                file: path.relative(projectRecord.path, sourceNode.filePath),
+                                description: `Bidirectional import between ${sourceNode.name} and ${targetNode.name}`,
+                                confidence: '90%', impact: 'high',
+                                recommendation: 'Break cycle using dependency inversion or extract shared code',
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        project: projectRecord.name,
+                        graph_stats: {
+                            total_nodes: allNodes.length,
+                            files: allNodes.filter(n => n.type === 'file').length,
+                            classes: allNodes.filter(n => n.type === 'class').length,
+                            functions: allNodes.filter(n => n.type === 'function').length,
+                        },
+                        summary: {
+                            total_issues: deadCodeItems.length + antiPatternItems.length + couplingItems.length,
+                            dead_code_count: deadCodeItems.length,
+                            anti_patterns_count: antiPatternItems.length,
+                            coupling_issues_count: couplingItems.length,
+                        },
+                        dead_code: deadCodeItems.slice(0, 20),
+                        anti_patterns: antiPatternItems.slice(0, 10),
+                        coupling_issues: couplingItems.slice(0, 10),
+                    }, null, 2) }],
+        };
     }
-    /**
-     * Tool 4: List indexed projects
-     */
-    registerProjectsTool() {
-        this.server.registerTool('projects', {
-            description: 'List all indexed projects with their metadata. ' +
-                'Returns project names, paths, indexed file counts, and last index timestamps. ' +
-                'Use to discover available projects before running search or show_dependencies. ' +
-                'Example: projects() shows all projects ready for semantic search.',
-        }, async () => {
+    async handleStandards(params) {
+        const { project, category = 'all' } = params;
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        const vectorStore = storageManager.getVectorStore();
+        const projects = await projectStore.list();
+        const found = projects.find(p => p.name === project || p.path === project || path.basename(p.path) === project);
+        if (!found) {
+            return {
+                content: [{ type: 'text', text: `Project not found: ${project}. Use index({action: "status"}) to list projects.` }],
+                isError: true,
+            };
+        }
+        const standardsPath = path.join(found.path, '.codeseeker', 'coding-standards.json');
+        let standardsContent;
+        try {
+            standardsContent = fs.readFileSync(standardsPath, 'utf-8');
+        }
+        catch {
+            const generator = new coding_standards_generator_1.CodingStandardsGenerator(vectorStore);
+            await generator.generateStandards(found.id, found.path);
             try {
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const vectorStore = storageManager.getVectorStore();
-                const projects = await projectStore.list();
-                if (projects.length === 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: 'No projects indexed. Use index to add a project.',
-                            }],
-                    };
-                }
-                // Get file and chunk counts for each project, plus indexing status
-                const projectsWithCounts = await Promise.all(projects.map(async (p) => {
-                    const fileCount = await vectorStore.countFiles(p.id);
-                    const chunkCount = await vectorStore.count(p.id);
-                    // Check for background indexing status
-                    const indexingStatus = this._getIndexingStatusForProject(p.id);
-                    const projectInfo = {
-                        name: p.name,
-                        path: p.path,
-                        files: fileCount,
-                        chunks: chunkCount,
-                        last_indexed: p.updatedAt.toISOString(),
-                    };
-                    // Add indexing status if job exists
-                    if (indexingStatus) {
-                        Object.assign(projectInfo, indexingStatus);
-                    }
-                    return projectInfo;
-                }));
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                storage_mode: storageManager.getMode(),
-                                total_projects: projects.length,
-                                projects: projectsWithCounts,
-                            }, null, 2),
-                        }],
-                };
+                standardsContent = fs.readFileSync(standardsPath, 'utf-8');
             }
-            catch (error) {
+            catch {
                 return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('List projects', error instanceof Error ? error : String(error)),
-                        }],
+                    content: [{ type: 'text', text: 'No coding standards detected. Index the project first.' }],
                     isError: true,
                 };
             }
-        });
+        }
+        const standards = JSON.parse(standardsContent);
+        let result = standards;
+        if (category !== 'all') {
+            result = { ...standards, standards: { [category]: standards.standards[category] || {} } };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     }
-    /**
-     * Tool 5: Index a project (with proper embeddings and knowledge graph)
-     * NOW RUNS IN BACKGROUND to prevent MCP timeouts
-     */
+    // ============================================================
+    // TOOL 3: index
+    //   Combines: index (init), sync, projects (status), install_parsers, exclude
+    // ============================================================
     registerIndexTool() {
         this.server.registerTool('index', {
-            description: 'Index a project directory for semantic search and knowledge graph. ' +
-                'Scans code, documentation, configs, and other text files. Generates vector embeddings and extracts code relationships. ' +
-                'Run once per project, then use sync for incremental updates. ' +
-                'Example: index({path: "/home/user/my-app"}) indexes all files in my-app.' +
-                '\n\nNOTE: Indexing runs in BACKGROUND to prevent timeouts. Use projects() to check indexing status.',
+            description: 'Index management. Actions: "init" (index project), "sync" (update changed files), ' +
+                '"status" (list projects), "parsers" (install language parsers), "exclude" (manage exclusions).',
             inputSchema: {
-                path: zod_1.z.string().describe('Absolute path to the project directory'),
-                name: zod_1.z.string().optional().describe('Project name (defaults to directory name)'),
+                action: zod_1.z.enum(['init', 'sync', 'status', 'parsers', 'exclude']).describe('Action'),
+                path: zod_1.z.string().optional().describe('Project directory (for init)'),
+                project: zod_1.z.string().optional().describe('Project name or path'),
+                name: zod_1.z.string().optional().describe('Project name (for init)'),
+                // sync params
+                changes: zod_1.z.array(zod_1.z.object({
+                    type: zod_1.z.enum(['created', 'modified', 'deleted']),
+                    path: zod_1.z.string(),
+                })).optional().describe('File changes for sync'),
+                full_reindex: zod_1.z.boolean().optional().default(false).describe('Full reindex'),
+                // parsers params
+                languages: zod_1.z.array(zod_1.z.string()).optional().describe('Languages to install parsers for'),
+                list_available: zod_1.z.boolean().optional().default(false).describe('List available parsers'),
+                // exclude params
+                exclude_action: zod_1.z.enum(['exclude', 'include', 'list']).optional().describe('Exclusion sub-action'),
+                paths: zod_1.z.array(zod_1.z.string()).optional().describe('Paths/patterns to exclude/include'),
+                reason: zod_1.z.string().optional().describe('Exclusion reason'),
             },
-        }, async (args) => {
+        }, async (params) => {
             try {
-                const { path: projectPath, name } = args;
-                // Validate path
-                const absolutePath = path.isAbsolute(projectPath)
-                    ? projectPath
-                    : path.resolve(projectPath);
-                // Security: validate path is safe to index
-                const pathError = this.validateProjectPath(absolutePath);
-                if (pathError) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: pathError,
-                            }],
-                        isError: true,
-                    };
-                }
-                if (!fs.existsSync(absolutePath)) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `Directory not found: ${absolutePath}`,
-                            }],
-                        isError: true,
-                    };
-                }
-                if (!fs.statSync(absolutePath).isDirectory()) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `Not a directory: ${absolutePath}`,
-                            }],
-                        isError: true,
-                    };
+                switch (params.action) {
+                    case 'init':
+                        return await this.handleIndexInit(params);
+                    case 'sync':
+                        return await this.handleSync(params);
+                    case 'status':
+                        return await this.handleProjects();
+                    case 'parsers':
+                        return await this.handleInstallParsers(params);
+                    case 'exclude':
+                        return await this.handleExclude(params);
+                    default:
+                        return { content: [{ type: 'text', text: `Unknown action: ${params.action}` }], isError: true };
                 }
-                const projectName = name || path.basename(absolutePath);
-                const projectId = this.generateProjectId(absolutePath);
-                // Mutex: prevent concurrent indexing of same project (race condition protection)
-                if (this.indexingMutex.has(projectId)) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    status: 'already_indexing',
-                                    project_name: projectName,
-                                    project_path: absolutePath,
-                                    message: 'Indexing request already being processed. Please wait.',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Check if already indexing (from job status)
-                const existingJob = this.getIndexingStatus(projectId);
-                if (existingJob?.status === 'running') {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    status: 'already_indexing',
-                                    project_name: projectName,
-                                    project_path: absolutePath,
-                                    progress: existingJob.progress,
-                                    message: 'Indexing already in progress. Use projects() to check status.',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Acquire mutex before starting
-                this.indexingMutex.add(projectId);
-                // Get storage and create project entry
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                // Create or update project
-                await projectStore.upsert({
-                    id: projectId,
-                    name: projectName,
-                    path: absolutePath,
-                    metadata: { indexedAt: new Date().toISOString(), indexing: true },
-                });
-                // Delete coding standards file (will be regenerated)
-                const codingStandardsPath = path.join(absolutePath, '.codeseeker', 'coding-standards.json');
-                if (fs.existsSync(codingStandardsPath)) {
-                    try {
-                        fs.unlinkSync(codingStandardsPath);
-                    }
-                    catch { /* ignore */ }
-                }
-                // Start background indexing (returns immediately)
-                this.startBackgroundIndexing(projectId, projectName, absolutePath, true);
-                // Return immediately with "started" status
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'indexing_started',
-                                project_name: projectName,
-                                project_path: absolutePath,
-                                message: 'Indexing started in background. Search will work with partial results. Use projects() to check progress.',
-                            }, null, 2),
-                        }],
-                };
-                // OLD SYNCHRONOUS CODE REMOVED - was causing MCP timeouts
-                // Now handled by startBackgroundIndexing()
             }
             catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
                 return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({ error: message }, null, 2),
-                        }],
+                    content: [{ type: 'text', text: this.formatErrorMessage('Index', error instanceof Error ? error : String(error), { projectPath: params.path || params.project }) }],
                     isError: true,
                 };
             }
         });
     }
-    // Remove the old synchronous indexing response builder (now in background)
-    _unusedOldIndexingResponse() {
-        // This is a placeholder to mark where old code was removed
-        // The synchronous indexing logic is now in runBackgroundIndexing()
-    }
-    /**
-     * Tool 5b: Check indexing status (part of projects output now)
-     */
-    _getIndexingStatusForProject(projectId) {
-        const job = this.indexingJobs.get(projectId);
-        if (!job)
-            return null;
+    async handleIndexInit(params) {
+        const projectPath = params.path;
+        if (!projectPath) {
+            return {
+                content: [{ type: 'text', text: 'path parameter required for init action.' }],
+                isError: true,
+            };
+        }
+        const absolutePath = path.isAbsolute(projectPath) ? projectPath : path.resolve(projectPath);
+        const pathError = this.validateProjectPath(absolutePath);
+        if (pathError) {
+            return { content: [{ type: 'text', text: pathError }], isError: true };
+        }
+        if (!fs.existsSync(absolutePath)) {
+            return { content: [{ type: 'text', text: `Directory not found: ${absolutePath}` }], isError: true };
+        }
+        if (!fs.statSync(absolutePath).isDirectory()) {
+            return { content: [{ type: 'text', text: `Not a directory: ${absolutePath}` }], isError: true };
+        }
+        const projectName = params.name || path.basename(absolutePath);
+        const projectId = this.generateProjectId(absolutePath);
+        if (this.indexingMutex.has(projectId)) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            status: 'already_indexing', project_name: projectName,
+                            message: 'Indexing request already being processed.',
+                        }, null, 2) }],
+            };
+        }
+        const existingJob = this.getIndexingStatus(projectId);
+        if (existingJob?.status === 'running') {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            status: 'already_indexing', project_name: projectName,
+                            progress: existingJob.progress,
+                            message: 'Indexing in progress. Check with index({action: "status"}).',
+                        }, null, 2) }],
+            };
+        }
+        this.indexingMutex.add(projectId);
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        await projectStore.upsert({
+            id: projectId, name: projectName, path: absolutePath,
+            metadata: { indexedAt: new Date().toISOString(), indexing: true },
+        });
+        const codingStandardsPath = path.join(absolutePath, '.codeseeker', 'coding-standards.json');
+        if (fs.existsSync(codingStandardsPath)) {
+            try {
+                fs.unlinkSync(codingStandardsPath);
+            }
+            catch { /* ignore */ }
+        }
+        this.startBackgroundIndexing(projectId, projectName, absolutePath, true);
         return {
-            indexing_status: job.status,
-            indexing_progress: job.progress,
-            indexing_result: job.result,
-            indexing_error: job.error,
-            indexing_started: job.startedAt.toISOString(),
-            indexing_completed: job.completedAt?.toISOString(),
+            content: [{ type: 'text', text: JSON.stringify({
+                        status: 'indexing_started', project_name: projectName, project_path: absolutePath,
+                        message: 'Indexing started in background. Use index({action: "status"}) to check progress.',
+                    }, null, 2) }],
         };
     }
-    /**
-     * Tool 6: Notify file changes for incremental updates
-     */
-    registerSyncTool() {
-        this.server.registerTool('sync', {
-            description: '**KEEP INDEX IN SYNC** - Call this after creating, editing, or deleting files. ' +
-                'IMPORTANT: If search returns stale results or grep finds content not in search results, ' +
-                'call this tool immediately to sync. Fast incremental updates (~100-500ms per file). ' +
-                'Use after: Edit/Write tool, file deletions, or when search results seem outdated. ' +
-                'For large changes (git pull, branch switch, many files), use full_reindex: true instead.',
-            inputSchema: {
-                project: zod_1.z.string().optional().describe('Project name or path (optional - auto-detects from indexed projects)'),
-                changes: zod_1.z.array(zod_1.z.object({
-                    type: zod_1.z.enum(['created', 'modified', 'deleted']),
-                    path: zod_1.z.string().describe('Path to the changed file'),
-                })).optional().describe('Array of file changes (not needed if full_reindex is true)'),
-                full_reindex: zod_1.z.boolean().optional().default(false)
-                    .describe('Trigger a complete re-index of the project. Use after git pull, branch switch, or major changes.'),
-            },
-        }, async ({ project, changes, full_reindex = false }) => {
-            try {
-                const startTime = Date.now();
-                // Resolve project
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const vectorStore = storageManager.getVectorStore();
-                const graphStore = storageManager.getGraphStore();
-                const projects = await projectStore.list();
-                // Auto-detect project if not provided
-                let found;
-                if (project) {
-                    found = projects.find(p => p.name === project ||
-                        p.path === project ||
-                        path.basename(p.path) === project ||
-                        path.resolve(project) === p.path);
-                }
-                else {
-                    // Try to find project from file paths in changes
-                    if (changes && changes.length > 0) {
-                        const firstPath = changes[0].path;
-                        if (path.isAbsolute(firstPath)) {
-                            found = projects.find(p => firstPath.startsWith(p.path));
-                        }
-                    }
-                    // If still not found, use single project if only one exists
-                    if (!found && projects.length === 1) {
-                        found = projects[0];
-                    }
-                }
-                if (!found) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: project
-                                    ? `Project not found: ${project}. Use projects to see available projects.`
-                                    : `Could not auto-detect project. Specify project name or use absolute paths in changes. Available: ${projects.map(p => p.name).join(', ')}`,
-                            }],
-                        isError: true,
-                    };
-                }
-                // Full reindex mode - NOW RUNS IN BACKGROUND
-                if (full_reindex) {
-                    // Check if already indexing
-                    const existingJob = this.getIndexingStatus(found.id);
-                    if (existingJob?.status === 'running') {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({
-                                        status: 'already_indexing',
-                                        project: found.name,
-                                        progress: existingJob.progress,
-                                        message: 'Full reindex already in progress. Use projects() to check status.',
-                                    }, null, 2),
-                                }],
-                        };
-                    }
-                    // Delete coding standards file (will be regenerated)
-                    const codingStandardsPath = path.join(found.path, '.codeseeker', 'coding-standards.json');
-                    if (fs.existsSync(codingStandardsPath)) {
-                        try {
-                            fs.unlinkSync(codingStandardsPath);
-                        }
-                        catch { /* ignore */ }
-                    }
-                    // Start background indexing (returns immediately)
-                    this.startBackgroundIndexing(found.id, found.name, found.path, true);
-                    // Return immediately with "started" status
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    status: 'reindex_started',
-                                    mode: 'full_reindex',
-                                    project: found.name,
-                                    message: 'Full reindex started in background. Search will work with partial results. Use projects() to check progress.',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Incremental update mode - use IndexingService
-                if (!changes || changes.length === 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: 'No changes provided. Either pass file changes or set full_reindex: true.',
-                            }],
-                        isError: true,
-                    };
-                }
-                let chunksCreated = 0;
-                let chunksDeleted = 0;
-                let filesProcessed = 0;
-                let filesSkipped = 0;
-                const errors = [];
-                for (const change of changes) {
-                    const relativePath = path.isAbsolute(change.path)
-                        ? path.relative(found.path, change.path)
-                        : change.path;
-                    try {
-                        if (change.type === 'deleted') {
-                            // Remove chunks for deleted file using IndexingService
-                            const result = await this.indexingService.deleteFile(found.id, relativePath);
-                            if (result.success) {
-                                chunksDeleted += result.deleted;
-                                filesProcessed++;
-                            }
-                        }
-                        else {
-                            // created or modified: re-index the file using IndexingService
-                            // Uses two-stage change detection: mtime (~0.1ms) then hash (~1-5ms)
-                            const result = await this.indexingService.indexSingleFile(found.path, relativePath, found.id);
-                            if (result.success) {
-                                if (result.skipped) {
-                                    filesSkipped++;
-                                }
-                                else {
-                                    chunksCreated += result.chunksCreated;
-                                    filesProcessed++;
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        const msg = error instanceof Error ? error.message : String(error);
-                        errors.push(`${change.path}: ${msg}`);
-                    }
-                }
-                // Update coding standards if pattern-related files changed
-                try {
-                    const changedPaths = changes.map(c => c.path);
-                    const generator = new coding_standards_generator_1.CodingStandardsGenerator(vectorStore);
-                    await generator.updateStandards(found.id, found.path, changedPaths);
-                }
-                catch (error) {
-                    // Don't fail the whole operation if standards update fails
-                    console.error('Failed to update coding standards:', error);
-                }
-                // Invalidate query cache for this project (files changed)
-                let cacheInvalidated = 0;
-                try {
-                    cacheInvalidated = await this.queryCache.invalidateProject(found.id);
-                }
-                catch (error) {
-                    // Don't fail if cache invalidation fails
-                    console.error('Failed to invalidate query cache:', error);
-                }
-                const duration = Date.now() - startTime;
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: errors.length === 0,
-                                mode: 'incremental',
-                                project: found.name,
-                                changes_processed: changes.length,
-                                files_reindexed: filesProcessed,
-                                files_skipped: filesSkipped > 0 ? filesSkipped : undefined,
-                                chunks_created: chunksCreated,
-                                chunks_deleted: chunksDeleted,
-                                cache_invalidated: cacheInvalidated > 0 ? cacheInvalidated : undefined,
-                                duration_ms: duration,
-                                note: filesSkipped > 0 ? `${filesSkipped} file(s) unchanged (skipped via mtime/hash check)` : undefined,
-                                errors: errors.length > 0 ? errors.slice(0, 5) : undefined,
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Process file changes', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
-                    isError: true,
-                };
+    async handleSync(params) {
+        const { project, changes, full_reindex = false } = params;
+        const startTime = Date.now();
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        const vectorStore = storageManager.getVectorStore();
+        const projects = await projectStore.list();
+        let found;
+        if (project) {
+            found = projects.find(p => p.name === project || p.path === project ||
+                path.basename(p.path) === project || path.resolve(project) === p.path);
+        }
+        else {
+            if (changes && changes.length > 0 && path.isAbsolute(changes[0].path)) {
+                found = projects.find(p => changes[0].path.startsWith(p.path));
             }
-        });
-        // standards - Get auto-detected coding standards
-        this.server.registerTool('standards', {
-            description: 'Get auto-detected coding patterns and standards for a project. ' +
-                'Returns validation patterns, error handling patterns, logging patterns, and testing patterns ' +
-                'discovered from the codebase. Use this to write code that follows project conventions. ' +
-                'Example: standards({project: "my-app", category: "validation"})',
-            inputSchema: {
-                project: zod_1.z.string().describe('Project name or path'),
-                category: zod_1.z.enum(['validation', 'error-handling', 'logging', 'testing', 'all']).optional().default('all')
-                    .describe('Category of standards to retrieve (default: all)'),
-            },
-        }, async ({ project, category = 'all' }) => {
-            try {
-                // Resolve project
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const vectorStore = storageManager.getVectorStore();
-                const projects = await projectStore.list();
-                const found = projects.find(p => p.name === project ||
-                    p.path === project ||
-                    path.basename(p.path) === project);
-                if (!found) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `Project not found: ${project}. Use projects to see available projects.`,
-                            }],
-                        isError: true,
-                    };
-                }
-                // Try to load standards file
-                const standardsPath = path.join(found.path, '.codeseeker', 'coding-standards.json');
-                let standardsContent;
-                try {
-                    standardsContent = fs.readFileSync(standardsPath, 'utf-8');
-                }
-                catch (error) {
-                    // Standards file doesn't exist - generate it now
-                    const generator = new coding_standards_generator_1.CodingStandardsGenerator(vectorStore);
-                    await generator.generateStandards(found.id, found.path);
-                    // Try reading again
-                    try {
-                        standardsContent = fs.readFileSync(standardsPath, 'utf-8');
-                    }
-                    catch {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: 'No coding standards detected yet. The project may need to be indexed first using index.',
-                                }],
-                            isError: true,
-                        };
-                    }
-                }
-                const standards = JSON.parse(standardsContent);
-                // Filter by category if requested
-                let result = standards;
-                if (category !== 'all') {
-                    result = {
-                        ...standards,
-                        standards: {
-                            [category]: standards.standards[category] || {}
-                        }
-                    };
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        }],
-                };
+            if (!found && projects.length === 1) {
+                found = projects[0];
             }
-            catch (error) {
+        }
+        if (!found) {
+            return {
+                content: [{ type: 'text', text: project
+                            ? `Project not found: ${project}. Use index({action: "status"}) to see projects.`
+                            : `Could not auto-detect project. Specify project. Available: ${projects.map(p => p.name).join(', ')}` }],
+                isError: true,
+            };
+        }
+        if (full_reindex) {
+            const existingJob = this.getIndexingStatus(found.id);
+            if (existingJob?.status === 'running') {
                 return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Get coding standards', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
-                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify({
+                                status: 'already_indexing', project: found.name,
+                                progress: existingJob.progress,
+                            }, null, 2) }],
                 };
             }
-        });
-    }
-    /**
-     * Tool 7: Install language support (Tree-sitter parsers)
-     */
-    registerInstallParsersTool() {
-        this.server.registerTool('install_parsers', {
-            description: 'Analyze project languages and install Tree-sitter parsers for better code understanding. ' +
-                'Detects which programming languages are used in a project and installs enhanced parsers. ' +
-                'Enhanced parsers provide better AST extraction for imports, classes, functions, and relationships. ' +
-                'Example: install_parsers({project: "/path/to/project"}) to auto-detect and install. ' +
-                'Example: install_parsers({languages: ["python", "java"]}) to install specific parsers.',
-            inputSchema: {
-                project: zod_1.z.string().optional().describe('Project path to analyze for languages (auto-detects needed parsers)'),
-                languages: zod_1.z.array(zod_1.z.string()).optional().describe('Specific languages to install parsers for (e.g., ["python", "java", "csharp"])'),
-                list_available: zod_1.z.boolean().optional().default(false).describe('List all available language parsers and their status'),
-            },
-        }, async ({ project, languages, list_available = false }) => {
-            try {
-                // List mode - show available parsers
-                if (list_available) {
-                    const parsers = await this.languageSupportService.checkInstalledParsers();
-                    const installed = parsers.filter(p => p.installed);
-                    const available = parsers.filter(p => !p.installed);
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    installed_parsers: installed.map(p => ({
-                                        language: p.language,
-                                        extensions: p.extensions,
-                                        quality: p.quality,
-                                        description: p.description,
-                                    })),
-                                    available_parsers: available.map(p => ({
-                                        language: p.language,
-                                        extensions: p.extensions,
-                                        npm_package: p.npmPackage,
-                                        quality: p.quality,
-                                        description: p.description,
-                                    })),
-                                    install_command: available.length > 0
-                                        ? `Use install_parsers({languages: [${available.slice(0, 3).map(p => `"${p.language.toLowerCase()}"`).join(', ')}]})`
-                                        : 'All parsers are already installed!',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Install specific languages
-                if (languages && languages.length > 0) {
-                    const result = await this.languageSupportService.installLanguageParsers(languages);
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: result.success,
-                                    installed: result.installed,
-                                    failed: result.failed.length > 0 ? result.failed : undefined,
-                                    message: result.message,
-                                    next_step: result.success
-                                        ? 'Reindex your project to use the new parsers: sync({project: "...", full_reindex: true})'
-                                        : 'Check the errors above and try again.',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Analyze project and suggest parsers
-                if (project) {
-                    const projectPath = path.isAbsolute(project)
-                        ? project
-                        : path.resolve(project);
-                    if (!fs.existsSync(projectPath)) {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `Directory not found: ${projectPath}`,
-                                }],
-                            isError: true,
-                        };
-                    }
-                    const analysis = await this.languageSupportService.analyzeProjectLanguages(projectPath);
-                    // If there are missing parsers, offer to install them
-                    const missingLanguages = analysis.missingParsers.map(p => p.language.toLowerCase());
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    project: projectPath,
-                                    detected_languages: analysis.detectedLanguages,
-                                    installed_parsers: analysis.installedParsers,
-                                    missing_parsers: analysis.missingParsers.map(p => ({
-                                        language: p.language,
-                                        npm_package: p.npmPackage,
-                                        quality: p.quality,
-                                        description: p.description,
-                                    })),
-                                    recommendations: analysis.recommendations,
-                                    install_command: missingLanguages.length > 0
-                                        ? `Use install_parsers({languages: [${missingLanguages.map(l => `"${l}"`).join(', ')}]}) to install enhanced parsers`
-                                        : 'All detected languages have parsers installed!',
-                                }, null, 2),
-                            }],
-                    };
+            const codingStandardsPath = path.join(found.path, '.codeseeker', 'coding-standards.json');
+            if (fs.existsSync(codingStandardsPath)) {
+                try {
+                    fs.unlinkSync(codingStandardsPath);
                 }
-                // No arguments - show usage
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                usage: {
-                                    analyze_project: 'install_parsers({project: "/path/to/project"}) - Detect languages and suggest parsers',
-                                    install_specific: 'install_parsers({languages: ["python", "java"]}) - Install parsers for specific languages',
-                                    list_available: 'install_parsers({list_available: true}) - Show all available parsers',
-                                },
-                                supported_languages: [
-                                    'TypeScript (bundled)', 'JavaScript (bundled)',
-                                    'Python', 'Java', 'C#', 'Go', 'Rust',
-                                    'C', 'C++', 'Ruby', 'PHP', 'Swift', 'Kotlin'
-                                ],
-                            }, null, 2),
-                        }],
-                };
+                catch { /* ignore */ }
             }
-            catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Manage language support', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
-                    isError: true,
-                };
-            }
-        });
-    }
-    /**
-     * Tool 8: Manage index exclusions/inclusions dynamically
-     * Allows Claude to exclude files that shouldn't be indexed (like Unity's Library folder)
-     * and include files that were wrongly excluded
-     */
-    registerExcludeTool() {
-        this.server.registerTool('exclude', {
-            description: 'Dynamically manage which files are included or excluded from the index. ' +
-                'Use this to exclude files that shouldn\'t be searched (e.g., Library/, build outputs, generated files) ' +
-                'or include files that were incorrectly excluded. Exclusions persist in .codeseeker/exclusions.json. ' +
-                'Example: exclude({action: "exclude", project: "my-app", paths: ["Library/**", "Temp/**"]}) ' +
-                'to exclude Unity folders. Changes take effect immediately - excluded files are removed from the index.',
-            inputSchema: {
-                action: zod_1.z.enum(['exclude', 'include', 'list']).describe('Action: "exclude" adds paths to exclusion list and removes from index, ' +
-                    '"include" removes paths from exclusion list (they will be indexed on next reindex), ' +
-                    '"list" shows current exclusions'),
-                project: zod_1.z.string().describe('Project name or path'),
-                paths: zod_1.z.array(zod_1.z.string()).optional().describe('File paths or glob patterns to exclude/include (e.g., ["Library/**", "Temp/**", "*.generated.cs"]). ' +
-                    'Required for exclude/include actions.'),
-                reason: zod_1.z.string().optional().describe('Optional reason for the exclusion (for documentation)'),
-            },
-        }, async ({ action, project, paths, reason }) => {
+            this.startBackgroundIndexing(found.id, found.name, found.path, true);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            status: 'reindex_started', project: found.name,
+                            message: 'Full reindex started. Use index({action: "status"}) to check.',
+                        }, null, 2) }],
+            };
+        }
+        if (!changes || changes.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'No changes provided. Either pass changes or set full_reindex: true.' }],
+                isError: true,
+            };
+        }
+        let chunksCreated = 0, chunksDeleted = 0, filesProcessed = 0, filesSkipped = 0;
+        const errors = [];
+        for (const change of changes) {
+            const relativePath = path.isAbsolute(change.path) ? path.relative(found.path, change.path) : change.path;
             try {
-                // Resolve project
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const vectorStore = storageManager.getVectorStore();
-                const graphStore = storageManager.getGraphStore();
-                const projects = await projectStore.list();
-                const found = projects.find(p => p.name === project ||
-                    p.path === project ||
-                    path.basename(p.path) === project);
-                if (!found) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `Project not found: ${project}. Use projects to see available projects.`,
-                            }],
-                        isError: true,
-                    };
-                }
-                // Load or create exclusions file
-                const exclusionsPath = path.join(found.path, '.codeseeker', 'exclusions.json');
-                let exclusions = {
-                    patterns: [],
-                    lastModified: new Date().toISOString()
-                };
-                // Ensure .codeseeker directory exists
-                const codeseekerDir = path.join(found.path, '.codeseeker');
-                if (!fs.existsSync(codeseekerDir)) {
-                    fs.mkdirSync(codeseekerDir, { recursive: true });
-                }
-                // Load existing exclusions
-                if (fs.existsSync(exclusionsPath)) {
-                    try {
-                        exclusions = JSON.parse(fs.readFileSync(exclusionsPath, 'utf-8'));
-                    }
-                    catch {
-                        // Invalid JSON, start fresh
-                    }
-                }
-                // Handle list action
-                if (action === 'list') {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    project: found.name,
-                                    project_path: found.path,
-                                    exclusions_file: exclusionsPath,
-                                    total_exclusions: exclusions.patterns.length,
-                                    patterns: exclusions.patterns,
-                                    last_modified: exclusions.lastModified,
-                                    usage: {
-                                        exclude: 'exclude({action: "exclude", project: "...", paths: ["pattern/**"]})',
-                                        include: 'exclude({action: "include", project: "...", paths: ["pattern/**"]})',
-                                    }
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Validate paths for exclude/include
-                if (!paths || paths.length === 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: 'No paths provided. Please specify paths or patterns to exclude/include.',
-                            }],
-                        isError: true,
-                    };
-                }
-                // Handle exclude action
-                if (action === 'exclude') {
-                    const addedPatterns = [];
-                    const alreadyExcluded = [];
-                    let filesRemoved = 0;
-                    for (const pattern of paths) {
-                        // Normalize pattern (use forward slashes)
-                        const normalizedPattern = pattern.replace(/\\/g, '/');
-                        // Check if already excluded
-                        if (exclusions.patterns.some(p => p.pattern === normalizedPattern)) {
-                            alreadyExcluded.push(normalizedPattern);
-                            continue;
-                        }
-                        // Add to exclusions
-                        exclusions.patterns.push({
-                            pattern: normalizedPattern,
-                            reason: reason,
-                            addedAt: new Date().toISOString()
-                        });
-                        addedPatterns.push(normalizedPattern);
-                        // Remove matching files from the vector store and graph
-                        // Search for files matching this pattern
-                        const results = await vectorStore.searchByText(normalizedPattern, found.id, 1000);
-                        for (const result of results) {
-                            const filePath = result.document.filePath.replace(/\\/g, '/');
-                            // Check if file matches the exclusion pattern
-                            if (this.matchesExclusionPattern(filePath, normalizedPattern)) {
-                                // Delete from vector store
-                                await vectorStore.delete(result.document.id);
-                                filesRemoved++;
-                            }
-                        }
+                if (change.type === 'deleted') {
+                    const result = await this.indexingService.deleteFile(found.id, relativePath);
+                    if (result.success) {
+                        chunksDeleted += result.deleted;
+                        filesProcessed++;
                     }
-                    // Save exclusions
-                    exclusions.lastModified = new Date().toISOString();
-                    fs.writeFileSync(exclusionsPath, JSON.stringify(exclusions, null, 2));
-                    // Flush to persist deletions
-                    await vectorStore.flush();
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    action: 'exclude',
-                                    project: found.name,
-                                    patterns_added: addedPatterns,
-                                    already_excluded: alreadyExcluded.length > 0 ? alreadyExcluded : undefined,
-                                    files_removed_from_index: filesRemoved,
-                                    total_exclusions: exclusions.patterns.length,
-                                    message: addedPatterns.length > 0
-                                        ? `Added ${addedPatterns.length} exclusion pattern(s). ${filesRemoved} file chunk(s) removed from index.`
-                                        : 'No new patterns added (all were already excluded).',
-                                    note: 'Excluded files will not appear in search results. Use action: "include" to re-enable indexing.'
-                                }, null, 2),
-                            }],
-                    };
                 }
-                // Handle include action (remove from exclusions)
-                if (action === 'include') {
-                    const removedPatterns = [];
-                    const notFound = [];
-                    for (const pattern of paths) {
-                        const normalizedPattern = pattern.replace(/\\/g, '/');
-                        const index = exclusions.patterns.findIndex(p => p.pattern === normalizedPattern);
-                        if (index >= 0) {
-                            exclusions.patterns.splice(index, 1);
-                            removedPatterns.push(normalizedPattern);
+                else {
+                    const result = await this.indexingService.indexSingleFile(found.path, relativePath, found.id);
+                    if (result.success) {
+                        if (result.skipped) {
+                            filesSkipped++;
                         }
                         else {
-                            notFound.push(normalizedPattern);
+                            chunksCreated += result.chunksCreated;
+                            filesProcessed++;
                         }
                     }
-                    // Save exclusions
-                    exclusions.lastModified = new Date().toISOString();
-                    fs.writeFileSync(exclusionsPath, JSON.stringify(exclusions, null, 2));
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    action: 'include',
-                                    project: found.name,
-                                    patterns_removed: removedPatterns,
-                                    not_found: notFound.length > 0 ? notFound : undefined,
-                                    total_exclusions: exclusions.patterns.length,
-                                    message: removedPatterns.length > 0
-                                        ? `Removed ${removedPatterns.length} exclusion pattern(s). ` +
-                                            `Files matching these patterns will be indexed on next reindex.`
-                                        : 'No patterns were removed (none matched).',
-                                    next_step: removedPatterns.length > 0
-                                        ? 'Run sync({project: "...", full_reindex: true}) to index the previously excluded files.'
-                                        : undefined
-                                }, null, 2),
-                            }],
-                    };
                 }
-                // Should not reach here
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Unknown action: ${action}`,
-                        }],
-                    isError: true,
-                };
             }
             catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Manage index exclusions', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
-                    isError: true,
-                };
+                errors.push(`${change.path}: ${error instanceof Error ? error.message : String(error)}`);
             }
-        });
-    }
-    /**
-     * Check if a file path matches an exclusion pattern
-     * Supports glob-like patterns: ** for any path, * for any segment
-     */
-    matchesExclusionPattern(filePath, pattern) {
-        // Normalize paths
-        const normalizedPath = filePath.replace(/\\/g, '/').toLowerCase();
-        const normalizedPattern = pattern.replace(/\\/g, '/').toLowerCase();
-        // Direct match
-        if (normalizedPath === normalizedPattern) {
-            return true;
         }
-        // Convert glob pattern to regex
-        // ** matches any path including slashes
-        // * matches any characters except slashes
-        let regexPattern = normalizedPattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars except * and ?
-            .replace(/\*\*/g, '<<GLOBSTAR>>') // Temporarily replace **
-            .replace(/\*/g, '[^/]*') // * matches anything except /
-            .replace(/<<GLOBSTAR>>/g, '.*') // ** matches anything including /
-            .replace(/\?/g, '.'); // ? matches any single char
-        // Check if pattern should match at start
-        if (!regexPattern.startsWith('.*')) {
-            // Pattern like "Library/**" should match "Library/foo" but not "src/Library/foo"
-            // Unless it's a more specific path pattern
-            if (normalizedPattern.includes('/')) {
-                regexPattern = `(^|/)${regexPattern}`;
-            }
-            else {
-                regexPattern = `(^|/)${regexPattern}`;
-            }
-        }
-        // Allow matching at end without trailing slash
-        regexPattern = `${regexPattern}(/.*)?$`;
+        // Update coding standards
         try {
-            const regex = new RegExp(regexPattern);
-            return regex.test(normalizedPath);
+            const changedPaths = changes.map(c => c.path);
+            const generator = new coding_standards_generator_1.CodingStandardsGenerator(vectorStore);
+            await generator.updateStandards(found.id, found.path, changedPaths);
         }
-        catch {
-            // If regex fails, try simple includes check
-            return normalizedPath.includes(normalizedPattern.replace(/\*/g, ''));
+        catch { /* Non-fatal */ }
+        // Invalidate cache
+        let cacheInvalidated = 0;
+        try {
+            cacheInvalidated = await this.queryCache.invalidateProject(found.id);
         }
+        catch { /* Non-fatal */ }
+        const duration = Date.now() - startTime;
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        success: errors.length === 0,
+                        mode: 'incremental', project: found.name,
+                        changes_processed: changes.length,
+                        files_reindexed: filesProcessed,
+                        files_skipped: filesSkipped > 0 ? filesSkipped : undefined,
+                        chunks_created: chunksCreated,
+                        chunks_deleted: chunksDeleted,
+                        cache_invalidated: cacheInvalidated > 0 ? cacheInvalidated : undefined,
+                        duration_ms: duration,
+                        errors: errors.length > 0 ? errors.slice(0, 5) : undefined,
+                    }, null, 2) }],
+        };
     }
-    /**
-     * Generate a deterministic project ID from path
-     */
-    generateProjectId(projectPath) {
-        return crypto.createHash('md5').update(projectPath).digest('hex');
-    }
-    /**
-     * Get all documents for a project from vector store
-     * Used by find_duplicates to analyze indexed embeddings
-     */
-    async getAllProjectDocuments(vectorStore, projectId) {
-        // Use a random embedding to get diverse results from vector search
-        // This leverages the existing searchByVector which returns all docs sorted by similarity
-        const randomEmbedding = Array.from({ length: 384 }, () => Math.random() - 0.5);
-        // Get a large sample of documents (up to 10000)
-        const results = await vectorStore.searchByVector(randomEmbedding, projectId, 10000);
-        return results.map(r => r.document);
+    async handleProjects() {
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        const vectorStore = storageManager.getVectorStore();
+        const projects = await projectStore.list();
+        if (projects.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'No projects indexed. Use index({action: "init", path: "/path/to/project"}).' }],
+            };
+        }
+        const projectsWithCounts = await Promise.all(projects.map(async (p) => {
+            const fileCount = await vectorStore.countFiles(p.id);
+            const chunkCount = await vectorStore.count(p.id);
+            const indexingStatus = this._getIndexingStatusForProject(p.id);
+            const projectInfo = {
+                name: p.name, path: p.path, files: fileCount, chunks: chunkCount,
+                last_indexed: p.updatedAt.toISOString(),
+            };
+            if (indexingStatus)
+                Object.assign(projectInfo, indexingStatus);
+            return projectInfo;
+        }));
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        storage_mode: storageManager.getMode(),
+                        total_projects: projects.length,
+                        projects: projectsWithCounts,
+                    }, null, 2) }],
+        };
     }
-    /**
-     * Generate actionable error message based on error type
-     */
-    formatErrorMessage(operation, error, context) {
-        const message = error instanceof Error ? error.message : String(error);
-        const lowerMessage = message.toLowerCase();
-        // Common error patterns with actionable guidance
-        if (lowerMessage.includes('enoent') || lowerMessage.includes('not found') || lowerMessage.includes('no such file')) {
-            return `${operation} failed: File or directory not found.\n\n` +
-                `TROUBLESHOOTING:\n` +
-                `• Verify the path exists: ${context?.projectPath || 'the specified path'}\n` +
-                `• Check for typos in the path\n` +
-                `• Ensure you have read permissions`;
+    async handleInstallParsers(params) {
+        const { project, languages, list_available = false } = params;
+        if (list_available) {
+            const parsers = await this.languageSupportService.checkInstalledParsers();
+            const installed = parsers.filter(p => p.installed);
+            const available = parsers.filter(p => !p.installed);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            installed_parsers: installed.map(p => ({ language: p.language, extensions: p.extensions, quality: p.quality })),
+                            available_parsers: available.map(p => ({ language: p.language, extensions: p.extensions, npm_package: p.npmPackage, quality: p.quality })),
+                        }, null, 2) }],
+            };
         }
-        if (lowerMessage.includes('eacces') || lowerMessage.includes('permission denied')) {
-            return `${operation} failed: Permission denied.\n\n` +
-                `TROUBLESHOOTING:\n` +
-                `• Check file/folder permissions\n` +
-                `• Run with appropriate access rights\n` +
-                `• Avoid system-protected directories`;
+        if (languages && languages.length > 0) {
+            const result = await this.languageSupportService.installLanguageParsers(languages);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            success: result.success, installed: result.installed,
+                            failed: result.failed.length > 0 ? result.failed : undefined,
+                            message: result.message,
+                            next_step: result.success ? 'Reindex: index({action: "sync", project: "...", full_reindex: true})' : undefined,
+                        }, null, 2) }],
+            };
         }
-        if (lowerMessage.includes('timeout') || lowerMessage.includes('timed out')) {
-            return `${operation} failed: Operation timed out.\n\n` +
-                `TROUBLESHOOTING:\n` +
-                `• Try again - the operation may complete on retry\n` +
-                `• For large projects, indexing runs in background - check status with projects()\n` +
-                `• Check network connectivity if using server storage mode`;
+        if (project) {
+            const projectPath = path.isAbsolute(project) ? project : path.resolve(project);
+            if (!fs.existsSync(projectPath)) {
+                return { content: [{ type: 'text', text: `Directory not found: ${projectPath}` }], isError: true };
+            }
+            const analysis = await this.languageSupportService.analyzeProjectLanguages(projectPath);
+            const missingLanguages = analysis.missingParsers.map(p => p.language.toLowerCase());
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            project: projectPath,
+                            detected_languages: analysis.detectedLanguages,
+                            installed_parsers: analysis.installedParsers,
+                            missing_parsers: analysis.missingParsers.map(p => ({ language: p.language, npm_package: p.npmPackage })),
+                            install_command: missingLanguages.length > 0
+                                ? `index({action: "parsers", languages: [${missingLanguages.map(l => `"${l}"`).join(', ')}]})`
+                                : 'All parsers installed!',
+                        }, null, 2) }],
+            };
         }
-        if (lowerMessage.includes('connection') || lowerMessage.includes('econnrefused') || lowerMessage.includes('network')) {
-            return `${operation} failed: Connection error.\n\n` +
-                `TROUBLESHOOTING:\n` +
-                `• Check if storage services are running (if using server mode)\n` +
-                `• Verify network connectivity\n` +
-                `• Consider switching to embedded mode for local development`;
+        return {
+            content: [{ type: 'text', text: 'Provide project path or languages, or set list_available: true.' }],
+            isError: true,
+        };
+    }
+    async handleExclude(params) {
+        const { project, exclude_action, paths: excludePaths, reason } = params;
+        if (!project) {
+            return { content: [{ type: 'text', text: 'project parameter required for exclude action.' }], isError: true };
         }
-        if (lowerMessage.includes('not indexed') || lowerMessage.includes('no project')) {
-            const pathHint = context?.projectPath ? `index({path: "${context.projectPath}"})` : 'index({path: "/path/to/project"})';
-            return `${operation} failed: Project not indexed.\n\n` +
-                `ACTION REQUIRED:\n` +
-                `• First run: ${pathHint}\n` +
-                `• Then retry your search\n` +
-                `• Use projects() to see indexed projects`;
+        if (!exclude_action) {
+            return { content: [{ type: 'text', text: 'exclude_action required (exclude, include, or list).' }], isError: true };
         }
-        if (lowerMessage.includes('out of memory') || lowerMessage.includes('heap')) {
-            return `${operation} failed: Out of memory.\n\n` +
-                `TROUBLESHOOTING:\n` +
-                `• Try indexing fewer files at once\n` +
-                `• Use exclude() to skip large directories (e.g., node_modules, dist)\n` +
-                `• Increase Node.js memory: NODE_OPTIONS=--max-old-space-size=4096`;
-        }
-        // Default: include original message with generic guidance
-        return `${operation} failed: ${message}\n\n` +
-            `TROUBLESHOOTING:\n` +
-            `• Check the error message above for details\n` +
-            `• Use projects() to verify project status\n` +
-            `• Try sync({project: "...", full_reindex: true}) if index seems corrupted`;
-    }
-    /**
-     * Tool 10: Find duplicate code patterns
-     */
-    registerFindDuplicatesTool() {
-        this.server.registerTool('find_duplicates', {
-            description: '**FIND DUPLICATE CODE** - Detects duplicate and similar code patterns using semantic analysis. ' +
-                'Finds: exact copies, semantically similar code (same logic, different names), and structurally similar patterns. ' +
-                'Use when: cleaning up codebase, finding copy-paste code, reducing maintenance burden. ' +
-                'Returns groups of duplicates with consolidation suggestions and estimated savings. ' +
-                '**IMPORTANT**: Always pass the project parameter with your workspace root path.',
-            inputSchema: {
-                project: zod_1.z.string().describe('Project path - REQUIRED: the workspace root path to analyze'),
-                similarity_threshold: zod_1.z.number().optional().default(0.80)
-                    .describe('Minimum similarity score (0.0-1.0) to consider as duplicate. Default: 0.80'),
-                min_lines: zod_1.z.number().optional().default(5)
-                    .describe('Minimum lines in a code block to analyze. Default: 5'),
-                include_types: zod_1.z.array(zod_1.z.enum(['function', 'class', 'method', 'block'])).optional()
-                    .describe('Types of code to analyze. Default: all types'),
-            },
-        }, async ({ project, similarity_threshold = 0.80, min_lines = 5, include_types: _include_types }) => {
+        const storageManager = await (0, storage_1.getStorageManager)();
+        const projectStore = storageManager.getProjectStore();
+        const vectorStore = storageManager.getVectorStore();
+        const projects = await projectStore.list();
+        const found = projects.find(p => p.name === project || p.path === project || path.basename(p.path) === project);
+        if (!found) {
+            return { content: [{ type: 'text', text: `Project not found: ${project}.` }], isError: true };
+        }
+        // Load exclusions
+        const exclusionsPath = path.join(found.path, '.codeseeker', 'exclusions.json');
+        let exclusions = { patterns: [], lastModified: new Date().toISOString() };
+        const codeseekerDir = path.join(found.path, '.codeseeker');
+        if (!fs.existsSync(codeseekerDir)) {
+            fs.mkdirSync(codeseekerDir, { recursive: true });
+        }
+        if (fs.existsSync(exclusionsPath)) {
             try {
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const vectorStore = storageManager.getVectorStore();
-                const projects = await projectStore.list();
-                // Find the project
-                const projectRecord = projects.find(p => p.name === project ||
-                    p.path === project ||
-                    path.basename(p.path) === project ||
-                    path.resolve(project) === p.path);
-                if (!projectRecord) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `Project not found or not indexed: ${project}\n\n` +
-                                    `Use index({path: "${project}"}) to index the project first.`,
-                            }],
-                        isError: true,
-                    };
-                }
-                // Use indexed embeddings from vector store for duplicate detection
-                // This leverages the existing indexed data instead of re-analyzing from scratch
-                // Get all documents for this project from the vector store
-                // We'll use the vector search to find similar chunks efficiently
-                const allDocs = await this.getAllProjectDocuments(vectorStore, projectRecord.id);
-                if (allDocs.length === 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    project: projectRecord.name,
-                                    summary: {
-                                        total_chunks_analyzed: 0,
-                                        exact_duplicates: 0,
-                                        semantic_duplicates: 0,
-                                        structural_duplicates: 0,
-                                        total_lines_affected: 0,
-                                        potential_lines_saved: 0,
-                                    },
-                                    duplicate_groups: [],
-                                    recommendations: ['No indexed chunks found. Run index() first.'],
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Filter by min_lines if metadata contains line info
-                const filteredDocs = allDocs.filter(doc => {
-                    const lineCount = doc.content.split('\n').length;
-                    return lineCount >= min_lines;
-                });
-                // Find duplicate groups using indexed embeddings
-                const duplicateGroups = [];
-                const processed = new Set();
-                const EXACT_THRESHOLD = 0.98;
-                // For each chunk, find similar chunks using cosine similarity
-                for (let i = 0; i < filteredDocs.length && duplicateGroups.length < 50; i++) {
-                    const doc = filteredDocs[i];
-                    if (processed.has(doc.id))
-                        continue;
-                    // Find similar documents using vector search
-                    const similarDocs = await vectorStore.searchByVector(doc.embedding, projectRecord.id, 20 // Get top 20 similar
-                    );
-                    // Filter by threshold and exclude self
-                    const matches = similarDocs.filter(match => match.document.id !== doc.id &&
-                        match.score >= similarity_threshold &&
-                        !processed.has(match.document.id));
-                    if (matches.length > 0) {
-                        // Determine type (exact vs semantic)
-                        const maxScore = Math.max(...matches.map(m => m.score));
-                        const type = maxScore >= EXACT_THRESHOLD ? 'exact' : 'semantic';
-                        // Extract line info from metadata if available
-                        const getLines = (d) => {
-                            const meta = d.metadata;
-                            return {
-                                startLine: meta?.startLine,
-                                endLine: meta?.endLine,
-                            };
-                        };
-                        duplicateGroups.push({
-                            type,
-                            similarity: maxScore,
-                            chunks: [
-                                {
-                                    id: doc.id,
-                                    filePath: doc.filePath,
-                                    content: doc.content.substring(0, 200) + (doc.content.length > 200 ? '...' : ''),
-                                    ...getLines(doc),
-                                },
-                                ...matches.map(m => ({
-                                    id: m.document.id,
-                                    filePath: m.document.filePath,
-                                    content: m.document.content.substring(0, 200) + (m.document.content.length > 200 ? '...' : ''),
-                                    ...getLines(m.document),
-                                })),
-                            ],
-                        });
-                        // Mark all as processed
-                        processed.add(doc.id);
-                        matches.forEach(m => processed.add(m.document.id));
+                exclusions = JSON.parse(fs.readFileSync(exclusionsPath, 'utf-8'));
+            }
+            catch { /* start fresh */ }
+        }
+        if (exclude_action === 'list') {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            project: found.name,
+                            total_exclusions: exclusions.patterns.length,
+                            patterns: exclusions.patterns,
+                        }, null, 2) }],
+            };
+        }
+        if (!excludePaths || excludePaths.length === 0) {
+            return { content: [{ type: 'text', text: 'No paths provided for exclude/include.' }], isError: true };
+        }
+        if (exclude_action === 'exclude') {
+            const addedPatterns = [];
+            const alreadyExcluded = [];
+            let filesRemoved = 0;
+            for (const pattern of excludePaths) {
+                const normalizedPattern = pattern.replace(/\\/g, '/');
+                if (exclusions.patterns.some(p => p.pattern === normalizedPattern)) {
+                    alreadyExcluded.push(normalizedPattern);
+                    continue;
+                }
+                exclusions.patterns.push({ pattern: normalizedPattern, reason, addedAt: new Date().toISOString() });
+                addedPatterns.push(normalizedPattern);
+                const results = await vectorStore.searchByText(normalizedPattern, found.id, 1000);
+                for (const result of results) {
+                    if (this.matchesExclusionPattern(result.document.filePath.replace(/\\/g, '/'), normalizedPattern)) {
+                        await vectorStore.delete(result.document.id);
+                        filesRemoved++;
                     }
                 }
-                // Calculate summary
-                const exactDuplicates = duplicateGroups.filter(g => g.type === 'exact').length;
-                const semanticDuplicates = duplicateGroups.filter(g => g.type === 'semantic').length;
-                const totalLinesAffected = duplicateGroups.reduce((sum, g) => sum + g.chunks.reduce((chunkSum, c) => chunkSum + (c.endLine && c.startLine ? c.endLine - c.startLine + 1 : c.content.split('\n').length), 0), 0);
-                // Format results
-                const formattedGroups = duplicateGroups.slice(0, 20).map(group => ({
-                    type: group.type,
-                    similarity: `${(group.similarity * 100).toFixed(1)}%`,
-                    files_affected: new Set(group.chunks.map(c => c.filePath)).size,
-                    locations: group.chunks.map(c => ({
-                        file: path.relative(projectRecord.path, c.filePath),
-                        lines: c.startLine && c.endLine ? `${c.startLine}-${c.endLine}` : 'N/A',
-                        preview: c.content.substring(0, 100).replace(/\n/g, ' '),
-                    })),
-                }));
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                project: projectRecord.name,
-                                summary: {
-                                    total_chunks_analyzed: filteredDocs.length,
-                                    exact_duplicates: exactDuplicates,
-                                    semantic_duplicates: semanticDuplicates,
-                                    structural_duplicates: 0, // Not computed in this approach
-                                    total_lines_affected: totalLinesAffected,
-                                    potential_lines_saved: Math.floor(totalLinesAffected * 0.6), // Estimate
-                                },
-                                duplicate_groups: formattedGroups,
-                                recommendations: exactDuplicates > 0
-                                    ? [`Found ${exactDuplicates} exact duplicate groups - prioritize consolidation`]
-                                    : semanticDuplicates > 0
-                                        ? [`Found ${semanticDuplicates} semantic duplicates - review for potential abstraction`]
-                                        : ['No significant duplicates found above threshold'],
-                            }, null, 2),
-                        }],
-                };
             }
-            catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Find duplicates', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
-                    isError: true,
-                };
-            }
-        });
-    }
-    /**
-     * Tool 11: Find dead/unused code
-     */
-    registerFindDeadCodeTool() {
-        this.server.registerTool('find_dead_code', {
-            description: '**FIND DEAD/UNUSED CODE** - Detects code that is never used or referenced. ' +
-                'Uses the knowledge graph to find: unused classes, unused functions, isolated code components. ' +
-                'Also detects: God classes (too many responsibilities), circular dependencies, feature envy. ' +
-                'Use when: cleaning up codebase, finding code to remove, improving architecture. ' +
-                '**IMPORTANT**: Always pass the project parameter. Project must be indexed first.',
-            inputSchema: {
-                project: zod_1.z.string().describe('Project path - REQUIRED: the workspace root path to analyze'),
-                include_patterns: zod_1.z.array(zod_1.z.enum(['dead_code', 'god_class', 'circular_deps', 'feature_envy', 'coupling'])).optional()
-                    .describe('Anti-patterns to detect. Default: all patterns'),
-            },
-        }, async ({ project, include_patterns }) => {
-            try {
-                const storageManager = await (0, storage_1.getStorageManager)();
-                const projectStore = storageManager.getProjectStore();
-                const graphStore = storageManager.getGraphStore();
-                const projects = await projectStore.list();
-                // Find the project
-                const projectRecord = projects.find(p => p.name === project ||
-                    p.path === project ||
-                    path.basename(p.path) === project ||
-                    path.resolve(project) === p.path);
-                if (!projectRecord) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `Project not found or not indexed: ${project}\n\n` +
-                                    `Use index({path: "${project}"}) to index the project first.`,
-                            }],
-                        isError: true,
-                    };
-                }
-                // Use the indexed graph data from storage manager (same as show_dependencies)
-                const allNodes = await graphStore.findNodes(projectRecord.id);
-                if (allNodes.length === 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    project: projectRecord.name,
-                                    summary: {
-                                        total_issues: 0,
-                                        dead_code_count: 0,
-                                        anti_patterns_count: 0,
-                                        coupling_issues_count: 0,
-                                    },
-                                    dead_code: [],
-                                    anti_patterns: [],
-                                    coupling_issues: [],
-                                    note: 'No graph data found. The project may need reindexing with graph building enabled.',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                // Analyze the indexed graph for dead code and anti-patterns
-                const patterns = include_patterns || ['dead_code', 'god_class', 'circular_deps', 'feature_envy', 'coupling'];
-                // Build analysis results from indexed graph
-                const deadCodeItems = [];
-                const antiPatternItems = [];
-                const couplingItems = [];
-                // Analyze each node for issues
-                for (const node of allNodes) {
-                    // Get edges for this node
-                    const inEdges = await graphStore.getEdges(node.id, 'in');
-                    const outEdges = await graphStore.getEdges(node.id, 'out');
-                    // Dead code detection: nodes with no incoming references (except entry points)
-                    if (patterns.includes('dead_code')) {
-                        const isEntryPoint = node.type === 'file' ||
-                            node.name.toLowerCase().includes('main') ||
-                            node.name.toLowerCase().includes('index') ||
-                            node.name.toLowerCase().includes('app');
-                        // A class/function with no incoming calls/imports is potentially dead
-                        if (!isEntryPoint && (node.type === 'class' || node.type === 'function') && inEdges.length === 0) {
-                            deadCodeItems.push({
-                                type: 'Dead Code',
-                                name: node.name,
-                                file: path.relative(projectRecord.path, node.filePath),
-                                description: `Unused ${node.type}: ${node.name} - no incoming references found`,
-                                confidence: '70%',
-                                impact: 'medium',
-                                recommendation: 'Review if this code is needed. Remove if unused or add to exports if it should be public.',
-                            });
-                        }
-                    }
-                    // God class detection: classes with too many methods/dependencies
-                    if (patterns.includes('god_class') && node.type === 'class') {
-                        const containsEdges = outEdges.filter(e => e.type === 'contains');
-                        const dependsOnEdges = outEdges.filter(e => e.type === 'imports' || e.type === 'depends_on');
-                        if (containsEdges.length > 15 || dependsOnEdges.length > 10) {
-                            antiPatternItems.push({
-                                type: 'God Class',
-                                name: node.name,
-                                file: path.relative(projectRecord.path, node.filePath),
-                                description: `Class ${node.name} has ${containsEdges.length} members and ${dependsOnEdges.length} dependencies`,
-                                confidence: '80%',
-                                impact: 'high',
-                                recommendation: 'Break down into smaller, focused classes following Single Responsibility Principle',
-                            });
-                        }
-                    }
-                    // High coupling detection
-                    if (patterns.includes('coupling') && (node.type === 'class' || node.type === 'file')) {
-                        const dependencies = outEdges.filter(e => e.type === 'imports' || e.type === 'depends_on');
-                        if (dependencies.length > 8) {
-                            couplingItems.push({
-                                type: 'High Coupling',
-                                name: node.name,
-                                file: path.relative(projectRecord.path, node.filePath),
-                                description: `${node.type} ${node.name} has ${dependencies.length} dependencies`,
-                                confidence: '75%',
-                                impact: 'high',
-                                recommendation: 'Reduce dependencies using interfaces, dependency injection, or service locator pattern',
-                            });
-                        }
-                    }
+            exclusions.lastModified = new Date().toISOString();
+            fs.writeFileSync(exclusionsPath, JSON.stringify(exclusions, null, 2));
+            await vectorStore.flush();
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            success: true, action: 'exclude', project: found.name,
+                            patterns_added: addedPatterns,
+                            already_excluded: alreadyExcluded.length > 0 ? alreadyExcluded : undefined,
+                            files_removed_from_index: filesRemoved,
+                            total_exclusions: exclusions.patterns.length,
+                        }, null, 2) }],
+            };
+        }
+        if (exclude_action === 'include') {
+            const removedPatterns = [];
+            const notFound = [];
+            for (const pattern of excludePaths) {
+                const normalizedPattern = pattern.replace(/\\/g, '/');
+                const index = exclusions.patterns.findIndex(p => p.pattern === normalizedPattern);
+                if (index >= 0) {
+                    exclusions.patterns.splice(index, 1);
+                    removedPatterns.push(normalizedPattern);
                 }
-                // Circular dependency detection (simplified - look for bidirectional imports)
-                if (patterns.includes('circular_deps')) {
-                    const fileNodes = allNodes.filter(n => n.type === 'file');
-                    const importMap = new Map();
-                    for (const fileNode of fileNodes) {
-                        const imports = await graphStore.getEdges(fileNode.id, 'out');
-                        const importTargets = new Set(imports.filter(e => e.type === 'imports').map(e => e.target));
-                        importMap.set(fileNode.id, importTargets);
-                    }
-                    // Check for circular imports (A imports B and B imports A)
-                    for (const [fileId, imports] of importMap.entries()) {
-                        for (const targetId of imports) {
-                            const targetImports = importMap.get(targetId);
-                            if (targetImports?.has(fileId)) {
-                                const sourceNode = allNodes.find(n => n.id === fileId);
-                                const targetNode = allNodes.find(n => n.id === targetId);
-                                if (sourceNode && targetNode) {
-                                    antiPatternItems.push({
-                                        type: 'Circular Dependency',
-                                        name: `${sourceNode.name} <-> ${targetNode.name}`,
-                                        file: path.relative(projectRecord.path, sourceNode.filePath),
-                                        description: `Bidirectional import between ${sourceNode.name} and ${targetNode.name}`,
-                                        confidence: '90%',
-                                        impact: 'high',
-                                        recommendation: 'Break the cycle using dependency inversion or extracting shared code',
-                                    });
-                                }
-                            }
-                        }
-                    }
+                else {
+                    notFound.push(normalizedPattern);
                 }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                project: projectRecord.name,
-                                graph_stats: {
-                                    total_nodes: allNodes.length,
-                                    files: allNodes.filter(n => n.type === 'file').length,
-                                    classes: allNodes.filter(n => n.type === 'class').length,
-                                    functions: allNodes.filter(n => n.type === 'function').length,
-                                },
-                                summary: {
-                                    total_issues: deadCodeItems.length + antiPatternItems.length + couplingItems.length,
-                                    dead_code_count: deadCodeItems.length,
-                                    anti_patterns_count: antiPatternItems.length,
-                                    coupling_issues_count: couplingItems.length,
-                                },
-                                dead_code: deadCodeItems.slice(0, 20),
-                                anti_patterns: antiPatternItems.slice(0, 10),
-                                coupling_issues: couplingItems.slice(0, 10),
-                            }, null, 2),
-                        }],
-                };
             }
-            catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: this.formatErrorMessage('Find dead code', error instanceof Error ? error : String(error), { projectPath: project }),
-                        }],
-                    isError: true,
-                };
-            }
-        });
+            exclusions.lastModified = new Date().toISOString();
+            fs.writeFileSync(exclusionsPath, JSON.stringify(exclusions, null, 2));
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            success: true, action: 'include', project: found.name,
+                            patterns_removed: removedPatterns,
+                            not_found: notFound.length > 0 ? notFound : undefined,
+                            total_exclusions: exclusions.patterns.length,
+                            next_step: removedPatterns.length > 0 ? 'index({action: "sync", project: "...", full_reindex: true})' : undefined,
+                        }, null, 2) }],
+            };
+        }
+        return { content: [{ type: 'text', text: `Unknown exclude_action: ${exclude_action}` }], isError: true };
     }
-    /**
-     * Start the MCP server
-     */
+    // ============================================================
+    // SERVER LIFECYCLE
+    // ============================================================
     async start() {
-        // Use stderr for logging since stdout is for JSON-RPC
         console.error('Starting CodeSeeker MCP server...');
-        // Initialize storage manager first to ensure singleton is ready
         const storageManager = await (0, storage_1.getStorageManager)();
         console.error(`Storage mode: ${storageManager.getMode()}`);
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);
         console.error('CodeSeeker MCP server running on stdio');
     }
-    /**
-     * Graceful shutdown - flush and close all storage before exit
-     */
     async shutdown() {
         console.error('Shutting down CodeSeeker MCP server...');
         try {
             const storageManager = await (0, storage_1.getStorageManager)();
-            // Flush first to ensure data is saved
             await storageManager.flushAll();
             console.error('Storage flushed successfully');
-            // Close to stop interval timers and release resources
             await storageManager.closeAll();
             console.error('Storage closed successfully');
         }
@@ -2486,16 +1551,13 @@ exports.CodeSeekerMcpServer = CodeSeekerMcpServer;
 async function startMcpServer() {
     const server = new CodeSeekerMcpServer();
     let isShuttingDown = false;
-    // Register signal handlers for graceful shutdown
     const shutdown = async (signal) => {
-        // Prevent multiple shutdown attempts
         if (isShuttingDown) {
             console.error(`Already shutting down, ignoring ${signal}`);
             return;
         }
         isShuttingDown = true;
         console.error(`\nReceived ${signal}, shutting down gracefully...`);
-        // Set a hard timeout to force exit if shutdown takes too long
         const forceExitTimeout = setTimeout(() => {
             console.error('Shutdown timeout, forcing exit...');
             process.exit(1);
@@ -2513,29 +1575,20 @@ async function startMcpServer() {
     };
     process.on('SIGINT', () => shutdown('SIGINT'));
     process.on('SIGTERM', () => shutdown('SIGTERM'));
-    // CRITICAL: Handle stdin close - this is how MCP clients signal disconnect
-    // On Windows, signals are unreliable, so stdin close is the primary shutdown mechanism
     process.stdin.on('close', () => shutdown('stdin-close'));
     process.stdin.on('end', () => shutdown('stdin-end'));
-    // Also handle stdin errors (broken pipe, etc.)
     process.stdin.on('error', (err) => {
-        // EPIPE and similar errors mean the parent process disconnected
         console.error(`stdin error: ${err.message}`);
         shutdown('stdin-error');
     });
-    // Handle Windows-specific signals
     if (process.platform === 'win32') {
         process.on('SIGHUP', () => shutdown('SIGHUP'));
-        // Windows: also listen for parent process disconnect via stdin
-        // Resume stdin to ensure we receive close/end events
         process.stdin.resume();
     }
-    // Handle uncaught exceptions - try to flush before crashing
     process.on('uncaughtException', async (error) => {
         console.error('Uncaught exception:', error);
         await shutdown('uncaughtException');
     });
-    // Handle unhandled promise rejections
     process.on('unhandledRejection', async (reason) => {
         console.error('Unhandled rejection:', reason);
         await shutdown('unhandledRejection');