bc-code-intelligence-mcp 1.5.8 → 1.6.0

package/dist/index.d.ts

@@ -12,21 +12,19 @@ declare class BCCodeIntelligenceServer {
     private codeAnalysisService;
     private methodologyService;
     private workflowService;
+    private relevanceIndexService;
     private layerService;
     private specialistSessionManager;
-    private specialistTools;
     private specialistDiscoveryService;
-    private specialistDiscoveryTools;
-    private enhancedPromptService;
-    private agentOnboardingTools;
-    private specialistHandoffTools;
-    private configDiagnosticTools;
+    private workflowSpecialistRouter;
+    private workflowSessionManager;
     private configuration;
     private configLoader;
     private workspaceRoot;
     private availableMcps;
     private hasWarnedAboutWorkspace;
-    private workspaceTools;
+    private toolHandlers;
+    private debugToolHandlers;
     private servicesInitialized;
     private getPackageVersion;
     constructor();
@@ -59,7 +57,6 @@ declare class BCCodeIntelligenceServer {
      * Generate configuration optimization insights
      */
     private generateConfigurationInsights;
-    private generateOptimizationWorkflow;
     run(): Promise<void>;
     /**
      * Initialize only embedded knowledge layer at startup
@@ -73,6 +70,10 @@ declare class BCCodeIntelligenceServer {
      * Set workspace root and MCP ecosystem info, initialize full services
      */
     private setWorkspaceInfo;
+    /**
+     * Get current workspace info
+     */
+    private getWorkspaceInfo;
     /**
      * Get configuration quality score for startup diagnostics
      */

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAoDA;;;;;;GAMG;AACH,cAAM,wBAAwB;IAC5B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAoB;IAC5C,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,kBAAkB,CAAsB;IAChD,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,wBAAwB,CAA4B;IAC5D,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,0BAA0B,CAA8B;IAChE,OAAO,CAAC,wBAAwB,CAA4B;IAC5D,OAAO,CAAC,qBAAqB,CAAyB;IACtD,OAAO,CAAC,oBAAoB,CAAwB;IACpD,OAAO,CAAC,sBAAsB,CAA0B;IACxD,OAAO,CAAC,qBAAqB,CAAyB;IACtD,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,mBAAmB,CAAS;IAEpC,OAAO,CAAC,iBAAiB;;IA8DzB,OAAO,CAAC,iBAAiB;IAwHzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAiTpB;;OAEG;YACW,kBAAkB;IA0LhC;;OAEG;YACW,qBAAqB;IAuCnC;;OAEG;YACW,uBAAuB;IA8BrC;;OAEG;YACW,sBAAsB;IA8CpC;;OAEG;IACH,OAAO,CAAC,iCAAiC;IAqCzC;;OAEG;YACW,6BAA6B;YA2D7B,4BAA4B;IAwGpC,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAuE1B;;OAEG;YACW,sBAAsB;IAoEpC;;OAEG;YACW,2BAA2B;IAmBzC;;OAEG;YACW,gBAAgB;IAkF9B;;OAEG;YACW,uBAAuB;CAWtC;AA+ED,OAAO,EAAE,wBAAwB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAqDA;;;;;;GAMG;AACH,cAAM,wBAAwB;IAC5B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAoB;IAC5C,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,kBAAkB,CAAsB;IAChD,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,qBAAqB,CAAyB;IACtD,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,wBAAwB,CAA4B;IAC5D,OAAO,CAAC,0BAA0B,CAA8B;IAChE,OAAO,CAAC,wBAAwB,CAA4B;IAC5D,OAAO,CAAC,sBAAsB,CAA0B;IACxD,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,iBAAiB,CAA4C;IACrE,OAAO,CAAC,mBAAmB,CAAS;IAEpC,OAAO,CAAC,iBAAiB;;IA2DzB,OAAO,CAAC,iBAAiB;IAwFzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAiTpB;;OAEG;YACW,kBAAkB;IAmMhC;;OAEG;YACW,qBAAqB;IAuBnC;;OAEG;YACW,uBAAuB;IA8BrC;;OAEG;YACW,sBAAsB;IA8CpC;;OAEG;IACH,OAAO,CAAC,iCAAiC;IAqCzC;;OAEG;YACW,6BAA6B;IA4DrC,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAuE1B;;OAEG;YACW,sBAAsB;IAiDpC;;OAEG;YACW,2BAA2B;IAmBzC;;OAEG;YACW,gBAAgB;IAkF9B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;OAEG;YACW,uBAAuB;CAWtC;AA+ED,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/index.js

@@ -5,23 +5,22 @@ import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, Lis
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { readFileSync, existsSync } from 'fs';
-import { getAllToolDefinitions, STREAMLINED_TOOL_NAMES, SpecialistTools, SpecialistDiscoveryTools, AgentOnboardingTools, SpecialistHandoffTools } from './tools/index.js';
-import { createStreamlinedHandlers } from './streamlined-handlers.js';
+import { allTools, debugTools } from './tools/index.js';
+import { createToolHandlers, createDebugToolHandlers } from './tools/handlers.js';
 import { KnowledgeService } from './services/knowledge-service.js';
 import { CodeAnalysisService } from './services/code-analysis-service.js';
 import { MethodologyService } from './services/methodology-service.js';
 import { WorkflowService } from './services/workflow-service.js';
+import { WorkflowSessionManager } from './services/workflow-v2/workflow-session-manager.js';
+import { RelevanceIndexService } from './services/relevance-index-service.js';
 import { getDomainList } from './types/bc-knowledge.js';
 import { MultiContentLayerService } from './services/multi-content-layer-service.js';
 import { SpecialistSessionManager } from './services/specialist-session-manager.js';
 import { SpecialistDiscoveryService } from './services/specialist-discovery.js';
-import { EnhancedPromptService } from './services/enhanced-prompt-service.js';
+import { WorkflowSpecialistRouter } from './services/workflow-specialist-router.js';
 import { ConfigurationLoader } from './config/config-loader.js';
 import { ConfigurationValidator } from './config/config-validator.js';
-import { ConfigDiagnosticTools } from './tools/config-diagnostic-tools.js';
-import { domainWorkflows } from './workflows/domain-workflows.js';
 import { LayerSourceType } from './types/index.js';
-import { WorkspaceTools } from './tools/workspace-tools.js';
 /**
  * BC Code Intelligence MCP Server
  *
@@ -35,21 +34,19 @@ class BCCodeIntelligenceServer {
     codeAnalysisService;
     methodologyService;
     workflowService;
+    relevanceIndexService;
     layerService;
     specialistSessionManager;
-    specialistTools;
     specialistDiscoveryService;
-    specialistDiscoveryTools;
-    enhancedPromptService;
-    agentOnboardingTools;
-    specialistHandoffTools;
-    configDiagnosticTools;
+    workflowSpecialistRouter;
+    workflowSessionManager;
     configuration;
     configLoader;
     workspaceRoot = null;
     availableMcps = [];
     hasWarnedAboutWorkspace = false;
-    workspaceTools;
+    toolHandlers;
+    debugToolHandlers;
     servicesInitialized = false;
     getPackageVersion() {
         try {
@@ -89,33 +86,23 @@ class BCCodeIntelligenceServer {
         });
         // Initialize configuration loader
         this.configLoader = new ConfigurationLoader();
-        // Initialize workspace tools
+        // Initialize workspace tool handlers (these work before services are initialized)
         const workspaceContext = {
             setWorkspaceInfo: this.setWorkspaceInfo.bind(this),
-            getWorkspaceInfo: () => ({
-                workspace_root: this.workspaceRoot,
-                available_mcps: this.availableMcps
-            })
+            getWorkspaceInfo: this.getWorkspaceInfo.bind(this)
         };
-        this.workspaceTools = new WorkspaceTools(workspaceContext);
+        this.toolHandlers = createToolHandlers({}, workspaceContext);
         // Services will be initialized asynchronously in run()
         this.setupToolHandlers();
         this.setupPrompts();
     }
     setupToolHandlers() {
-        // List available tools - now using centralized registry
+        // List available tools - now using streamlined tool arrays
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            const tools = getAllToolDefinitions({
-                specialistTools: this.specialistTools,
-                specialistDiscoveryTools: this.specialistDiscoveryTools,
-                onboardingTools: this.agentOnboardingTools,
-                handoffTools: this.specialistHandoffTools
-            });
-            // Add workspace tools (always available)
-            tools.push(...this.workspaceTools.getToolDefinitions());
-            // Add configuration diagnostic tools if available AND enabled
-            if (this.configDiagnosticTools) {
-                tools.push(...this.configDiagnosticTools.getToolDefinitions());
+            const tools = [...allTools];
+            // Add configuration diagnostic tools if enabled
+            if (this.debugToolHandlers && this.debugToolHandlers.size > 0) {
+                tools.push(...debugTools);
             }
             return { tools };
         });
@@ -124,8 +111,12 @@ class BCCodeIntelligenceServer {
             const { name, arguments: args } = request.params;
             try {
                 // Workspace tools are always available (no interception)
-                if (['set_workspace_info', 'get_workspace_info', 'set_workspace_root', 'get_workspace_root'].includes(name)) {
-                    return await this.workspaceTools.handleToolCall(request);
+                if (['set_workspace_info', 'get_workspace_info'].includes(name)) {
+                    const handler = this.toolHandlers.get(name);
+                    if (!handler) {
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown workspace tool: ${name}`);
+                    }
+                    return await handler(args);
                 }
                 // Intercept all other tools if services not initialized
                 if (!this.servicesInitialized) {
@@ -138,7 +129,7 @@ The BC Code Intelligence server needs workspace information to load project-spec
 
 **Option 1: Set workspace info** (recommended for project-specific layers and MCP ecosystem awareness)
 \`\`\`
-set_workspace_info({ 
+set_workspace_info({
   workspace_root: "C:/your/project/path",
   available_mcps: []  // REQUIRED: Examine your available tools and infer MCP servers (see tool description)
 })
@@ -147,7 +138,7 @@ set_workspace_info({
 **How to populate available_mcps:**
 Check which tools you have available and add the corresponding MCP server IDs:
 - Have \`search_telemetry_traces\`? Add "bc-telemetry-buddy"
-- Have \`reserve_object_ids\`? Add "al-objid-mcp-server"  
+- Have \`reserve_object_ids\`? Add "al-objid-mcp-server"
 - Have \`analyze_dependencies\`? Add "al-dependency-mcp-server"
 - Have \`get_lsp_diagnostics\`? Add "serena-mcp"
 - Have \`create_work_item\`? Add "azure-devops-mcp"
@@ -165,36 +156,13 @@ Currently only embedded knowledge is loaded. Call \`set_workspace_info\` to enab
                             }]
                     };
                 }
-                // Check if it's a specialist tool
-                if (this.specialistTools && ['suggest_specialist', 'get_specialist_advice', 'list_specialists'].includes(name)) {
-                    return await this.specialistTools.handleToolCall(request);
-                }
-                // Check if it's a specialist discovery tool
-                if (this.specialistDiscoveryTools && ['discover_specialists', 'browse_specialists', 'get_specialist_info'].includes(name)) {
-                    return await this.specialistDiscoveryTools.handleToolCall(request);
-                }
-                // Check if it's an agent onboarding tool  
-                if (this.agentOnboardingTools && ['introduce_bc_specialists', 'get_specialist_introduction', 'suggest_next_specialist'].includes(name)) {
-                    return await this.agentOnboardingTools.handleToolCall(request);
+                // Try debug tool handlers first (if enabled)
+                if (this.debugToolHandlers && this.debugToolHandlers.has(name)) {
+                    const handler = this.debugToolHandlers.get(name);
+                    return await handler(args);
                 }
-                // Check if it's a specialist handoff tool
-                if (this.specialistHandoffTools && ['handoff_to_specialist', 'bring_in_specialist', 'get_handoff_summary'].includes(name)) {
-                    return await this.specialistHandoffTools.handleToolCall(request);
-                }
-                // Check if it's a configuration diagnostic tool
-                if (this.configDiagnosticTools && ['diagnose_git_layer', 'validate_layer_config', 'test_azure_devops_pat', 'get_layer_diagnostics', 'diagnose_local_layer', 'reload_layers'].includes(name)) {
-                    return await this.configDiagnosticTools.handleToolCall(request);
-                }
-                // Create streamlined handlers with all services
-                const handlers = createStreamlinedHandlers(this.server, {
-                    knowledgeService: this.knowledgeService,
-                    codeAnalysisService: this.codeAnalysisService,
-                    methodologyService: this.methodologyService,
-                    workflowService: this.workflowService,
-                    layerService: this.layerService
-                });
-                // Execute the appropriate handler
-                const handler = handlers[name];
+                // Execute main tool handler
+                const handler = this.toolHandlers.get(name);
                 if (!handler) {
                     throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                 }
@@ -465,7 +433,7 @@ Currently only embedded knowledge is loaded. Call \`set_workspace_info\` to enab
                     args?.performance_concern || args?.integration_type ||
                     args?.testing_scope || args?.review_target ||
                     'General workflow request';
-                const enhancedResult = await this.enhancedPromptService.enhanceWorkflowPrompt(name, userContext, initialGuidance);
+                const enhancedResult = await this.workflowSpecialistRouter.enhanceWorkflowPrompt(name, userContext, initialGuidance);
                 // Construct explicit prompt that bypasses VS Code prompt creation
                 const promptContent = `# ${prompt.description}
 
@@ -513,7 +481,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         const legacyConfig = {
             knowledge_base_path: process.env['BCKB_KB_PATH'] || join(__dirname, '../embedded-knowledge'),
             indexes_path: process.env['BCKB_INDEXES_PATH'] || join(__dirname, '../embedded-knowledge/indexes'),
-            methodologies_path: process.env['BCKB_METHODOLOGIES_PATH'] || join(__dirname, '../embedded-knowledge/methodologies'),
+            workflows_path: process.env['BCKB_WORKFLOWS_PATH'] || join(__dirname, '../embedded-knowledge/workflows'),
             cache_size: this.configuration.cache.max_size_mb * 1024, // Convert MB to entries approximation
             max_search_results: 20,
             default_bc_version: 'BC22',
@@ -594,8 +562,12 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         // Now create KnowledgeService with the initialized layerService
         this.knowledgeService = new KnowledgeService(legacyConfig, this.layerService);
         await this.knowledgeService.initialize();
-        this.codeAnalysisService = new CodeAnalysisService(this.knowledgeService);
-        this.methodologyService = new MethodologyService(this.knowledgeService, legacyConfig.methodologies_path);
+        // V2: Create RelevanceIndexService for knowledge-driven detection
+        this.relevanceIndexService = new RelevanceIndexService(this.layerService);
+        await this.relevanceIndexService.initialize();
+        // Pass relevanceIndexService to enable V2 detection
+        this.codeAnalysisService = new CodeAnalysisService(this.knowledgeService, this.relevanceIndexService);
+        this.methodologyService = new MethodologyService(this.knowledgeService, legacyConfig.workflows_path);
         // Report layer-by-layer counts after initialization
         const layerStats = this.layerService.getStatistics();
         for (const stats of layerStats) {
@@ -605,30 +577,47 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         // Get session storage configuration from layer service
         const sessionStorageConfig = this.layerService.getSessionStorageConfig();
         this.specialistSessionManager = new SpecialistSessionManager(this.layerService, sessionStorageConfig);
-        this.specialistTools = new SpecialistTools(this.layerService, this.specialistSessionManager, this.knowledgeService);
-        // Initialize specialist discovery service and tools
+        // Initialize specialist discovery service
         this.specialistDiscoveryService = new SpecialistDiscoveryService(this.layerService);
-        this.specialistDiscoveryTools = new SpecialistDiscoveryTools(this.specialistDiscoveryService, this.specialistSessionManager, this.layerService);
-        // Initialize enhanced prompt service for specialist routing
-        this.enhancedPromptService = new EnhancedPromptService(this.specialistDiscoveryService, this.specialistSessionManager, this.workflowService);
-        // Initialize agent onboarding tools for natural specialist introduction
-        this.agentOnboardingTools = new AgentOnboardingTools(this.specialistDiscoveryService, this.layerService);
-        // Initialize specialist handoff tools for seamless transitions
-        this.specialistHandoffTools = new SpecialistHandoffTools(this.specialistSessionManager, this.specialistDiscoveryService, this.layerService);
-        // Initialize configuration diagnostic tools ONLY if enabled (reduces token overhead)
+        // Initialize workflow service with specialist discovery
+        this.workflowService = new WorkflowService(this.knowledgeService, this.methodologyService, this.specialistDiscoveryService);
+        // Initialize workflow specialist router for specialist routing
+        this.workflowSpecialistRouter = new WorkflowSpecialistRouter(this.specialistDiscoveryService, this.specialistSessionManager, this.workflowService);
+        // Initialize workflow session manager for stateful workflow processing
+        this.workflowSessionManager = new WorkflowSessionManager();
+        if (this.workspaceRoot) {
+            this.workflowSessionManager.setWorkspaceRoot(this.workspaceRoot);
+        }
+        // Create tool handlers with all service dependencies
+        const workspaceContext = {
+            setWorkspaceInfo: this.setWorkspaceInfo.bind(this),
+            getWorkspaceInfo: this.getWorkspaceInfo.bind(this)
+        };
+        const handlerServices = {
+            knowledgeService: this.knowledgeService,
+            codeAnalysisService: this.codeAnalysisService,
+            methodologyService: this.methodologyService,
+            workflowService: this.workflowService,
+            layerService: this.layerService,
+            sessionManager: this.specialistSessionManager,
+            discoveryService: this.specialistDiscoveryService,
+            configLoader: this.configLoader,
+            workflowSessionManager: this.workflowSessionManager
+        };
+        this.toolHandlers = createToolHandlers(handlerServices, workspaceContext);
+        // Initialize debug tool handlers ONLY if enabled (reduces token overhead)
         if (this.configuration.developer.enable_diagnostic_tools) {
-            this.configDiagnosticTools = new ConfigDiagnosticTools(this.layerService, this.configLoader);
+            this.debugToolHandlers = createDebugToolHandlers(handlerServices);
             console.error('🔧 Configuration diagnostic tools enabled');
         }
         else {
             console.error('💡 Tip: Set developer.enable_diagnostic_tools=true for git layer diagnostics');
         }
-        // Initialize workflow service with specialist discovery
-        const specialistDiscoveryService = new SpecialistDiscoveryService(this.layerService);
-        this.workflowService = new WorkflowService(this.knowledgeService, this.methodologyService, specialistDiscoveryService);
         // Report final totals
         const specialists = await this.layerService.getAllSpecialists();
+        const relevanceStats = this.relevanceIndexService.getStatistics();
         console.error(`📊 Total: ${totalTopics} topics, ${specialists.length} specialists`);
+        console.error(`🔍 Relevance Index: ${relevanceStats.totalTopics} indexed (${relevanceStats.v2Topics} V2, ${relevanceStats.legacyTopics} legacy)`);
         // Validate tool contracts at startup
         await this.validateToolContracts();
     }
@@ -637,37 +626,22 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
      */
     async validateToolContracts() {
         try {
-            const handlers = createStreamlinedHandlers(this.server, {
-                knowledgeService: this.knowledgeService,
-                codeAnalysisService: this.codeAnalysisService,
-                methodologyService: this.methodologyService,
-                workflowService: this.workflowService,
-                layerService: this.layerService
-            });
-            const tools = getAllToolDefinitions({
-                specialistTools: this.specialistTools,
-                specialistDiscoveryTools: this.specialistDiscoveryTools,
-                onboardingTools: this.agentOnboardingTools,
-                handoffTools: this.specialistHandoffTools
-            });
-            let hasIssues = false;
+            // Simple validation: ensure all tools in the registry have handlers
+            const tools = [...allTools];
+            if (this.debugToolHandlers && this.debugToolHandlers.size > 0) {
+                tools.push(...debugTools);
+            }
             for (const tool of tools) {
-                // Only validate core streamlined tools (others handle their own routing)
-                if (Object.values(STREAMLINED_TOOL_NAMES).includes(tool.name)) {
-                    if (!handlers[tool.name]) {
-                        console.error(`❌ No handler found for core tool: ${tool.name}`);
-                        hasIssues = true;
-                    }
+                const hasHandler = this.toolHandlers.has(tool.name) ||
+                    (this.debugToolHandlers && this.debugToolHandlers.has(tool.name));
+                if (!hasHandler) {
+                    console.warn(`⚠️  Tool '${tool.name}' has no handler registered`);
                 }
             }
-            if (hasIssues) {
-                console.error('💥 Contract validation failed! Server may have dead ends.');
-                // Don't fail startup, but warn loudly
-            }
+            console.error(`✅ Validated ${tools.length} tool contracts`);
         }
         catch (error) {
-            console.error(`⚠️  Contract validation error: ${error}`);
-            // Don't fail startup for validation errors
+            console.warn(`⚠️  Tool contract validation warning: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
@@ -829,103 +803,6 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         }
         return insights;
     }
-    async generateOptimizationWorkflow(params) {
-        // Use domain workflows for comprehensive scenario coverage
-        const baseWorkflows = domainWorkflows;
-        // Additional legacy workflow mapping
-        const legacyWorkflows = {
-            'slow report': {
-                steps: [
-                    {
-                        step_number: 1,
-                        title: 'Analyze Current Data Access Patterns',
-                        description: 'Review report dataset access, joins, and aggregations to identify bottlenecks',
-                        related_topics: ['query-performance-patterns', 'sift-technology-fundamentals'],
-                        validation_criteria: ['Query execution times documented', 'Data volume assessed'],
-                        estimated_time: '30 minutes'
-                    },
-                    {
-                        step_number: 2,
-                        title: 'Implement SIFT Indexes',
-                        description: 'Add SIFT indexes for aggregation operations and enable MaintainSIFTIndex',
-                        related_topics: ['sift-index-fundamentals', 'maintainsiftindex-property-behavior'],
-                        validation_criteria: ['SIFT keys created', 'MaintainSIFTIndex enabled', 'Aggregations use CalcSums'],
-                        estimated_time: '45 minutes'
-                    },
-                    {
-                        step_number: 3,
-                        title: 'Optimize Field Loading',
-                        description: 'Use SetLoadFields to reduce memory usage and network traffic',
-                        related_topics: ['setloadfields-optimization', 'memory-optimization'],
-                        validation_criteria: ['SetLoadFields implemented', 'Only required fields loaded'],
-                        estimated_time: '20 minutes'
-                    },
-                    {
-                        step_number: 4,
-                        title: 'Performance Testing and Validation',
-                        description: 'Measure performance improvements and validate against targets',
-                        related_topics: ['performance-monitoring', 'performance-best-practices'],
-                        validation_criteria: ['Performance metrics collected', 'Target response time achieved'],
-                        estimated_time: '30 minutes'
-                    }
-                ],
-                learning_path: ['sift-technology-fundamentals', 'query-performance-patterns', 'performance-monitoring'],
-                success_metrics: ['Report execution time reduced by 70%+', 'Memory usage optimized', 'User satisfaction improved'],
-                common_pitfalls: ['Not enabling MaintainSIFTIndex', 'Loading unnecessary fields', 'Missing performance baselines']
-            }
-        };
-        // Merge domain workflows with legacy workflows
-        const allWorkflows = { ...baseWorkflows, ...legacyWorkflows };
-        // Find matching workflow or create generic one
-        const scenario = params.scenario.toLowerCase();
-        let workflow = null;
-        for (const [key, value] of Object.entries(allWorkflows)) {
-            if (scenario.includes(key)) {
-                workflow = value;
-                break;
-            }
-        }
-        if (!workflow) {
-            // Generate generic optimization workflow
-            workflow = {
-                steps: [
-                    {
-                        step_number: 1,
-                        title: 'Identify Performance Bottlenecks',
-                        description: 'Analyze the scenario to pinpoint specific performance issues',
-                        related_topics: ['performance-monitoring', 'query-performance-patterns'],
-                        validation_criteria: ['Bottlenecks identified', 'Performance baseline established'],
-                        estimated_time: '30 minutes'
-                    },
-                    {
-                        step_number: 2,
-                        title: 'Apply Targeted Optimizations',
-                        description: 'Implement specific BC optimization patterns based on identified issues',
-                        related_topics: ['performance-best-practices', 'memory-optimization'],
-                        validation_criteria: ['Optimizations implemented', 'Code patterns improved'],
-                        estimated_time: '60 minutes'
-                    },
-                    {
-                        step_number: 3,
-                        title: 'Validate and Monitor',
-                        description: 'Test improvements and establish ongoing monitoring',
-                        related_topics: ['performance-monitoring'],
-                        validation_criteria: ['Performance improved', 'Monitoring established'],
-                        estimated_time: '20 minutes'
-                    }
-                ],
-                learning_path: ['performance-best-practices', 'performance-monitoring'],
-                success_metrics: ['Measurable performance improvement', 'Sustainable solution implemented'],
-                common_pitfalls: ['Premature optimization', 'Insufficient testing', 'Missing monitoring']
-            };
-        }
-        return {
-            scenario: params.scenario,
-            workflow,
-            constraints: params.constraints || [],
-            target_performance: params.target_performance
-        };
-    }
     async run() {
         try {
             // Ultra-early diagnostics for platform issues
@@ -944,7 +821,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             console.error(`Embedded knowledge path: ${embeddedPath}`);
             console.error(`Embedded knowledge exists: ${existsSync(embeddedPath)}`);
             if (existsSync(embeddedPath)) {
-                const expectedDirs = ['domains', 'specialists', 'methodologies'];
+                const expectedDirs = ['domains', 'specialists', 'workflows'];
                 for (const dir of expectedDirs) {
                     const dirPath = join(embeddedPath, dir);
                     console.error(`  ${dir}/: ${existsSync(dirPath)}`);
@@ -1008,7 +885,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         const legacyConfig = {
             knowledge_base_path: embeddedPath,
             indexes_path: join(embeddedPath, 'indexes'),
-            methodologies_path: join(embeddedPath, 'methodologies'),
+            workflows_path: join(embeddedPath, 'workflows'),
             cache_size: 1000,
             max_search_results: 20,
             default_bc_version: 'BC22',
@@ -1025,11 +902,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         // We need these initialized so they appear in the tool list, but they won't execute
         const sessionStorageConfig = this.layerService.getSessionStorageConfig();
         this.specialistSessionManager = new SpecialistSessionManager(this.layerService, sessionStorageConfig);
-        this.specialistTools = new SpecialistTools(this.layerService, this.specialistSessionManager, this.knowledgeService);
         this.specialistDiscoveryService = new SpecialistDiscoveryService(this.layerService);
-        this.specialistDiscoveryTools = new SpecialistDiscoveryTools(this.specialistDiscoveryService, this.specialistSessionManager, this.layerService);
-        this.agentOnboardingTools = new AgentOnboardingTools(this.specialistDiscoveryService, this.layerService);
-        this.specialistHandoffTools = new SpecialistHandoffTools(this.specialistSessionManager, this.specialistDiscoveryService, this.layerService);
         // Note: Services and tools are initialized, but servicesInitialized = false 
         // This prevents tools from being called until workspace is set
         console.error('✅ Embedded knowledge loaded. Workspace-specific services pending set_workspace_info.');
@@ -1122,6 +995,15 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             };
         }
     }
+    /**
+     * Get current workspace info
+     */
+    getWorkspaceInfo() {
+        return {
+            workspace_root: this.workspaceRoot,
+            available_mcps: this.availableMcps
+        };
+    }
     /**
      * Get configuration quality score for startup diagnostics
      */