@vfarcic/dot-ai 0.49.0 → 0.51.0

package/dist/tools/organizational-data.js

@@ -49,29 +49,33 @@ const error_handling_1 = require("../core/error-handling");
 // Import only what we need - other imports removed as they're no longer used with Vector DB
 const pattern_creation_session_1 = require("../core/pattern-creation-session");
 const index_1 = require("../core/index");
+const capabilities_1 = require("../core/capabilities");
 const session_utils_1 = require("../core/session-utils");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 // Tool metadata for MCP registration
 exports.ORGANIZATIONAL_DATA_TOOL_NAME = 'manageOrgData';
-exports.ORGANIZATIONAL_DATA_TOOL_DESCRIPTION = 'Unified tool for managing cluster data: organizational patterns (available now), resource capabilities (PRD #48), and resource dependencies (PRD #49). For patterns: supports step-by-step creation workflow. For capabilities/dependencies: returns implementation status. Use dataType parameter to specify what to manage: "pattern" for organizational patterns, "capabilities" for resource capabilities, "dependencies" for resource dependencies.';
-// Extensible schema - supports patterns, capabilities, and dependencies
+exports.ORGANIZATIONAL_DATA_TOOL_DESCRIPTION = 'Unified tool for managing cluster data: organizational patterns and resource capabilities. For patterns: supports step-by-step creation workflow. For capabilities: supports scan, list, get, delete, deleteAll, and progress operations for cluster resource capability discovery and management. Use dataType parameter to specify what to manage: "pattern" for organizational patterns, "capabilities" for resource capabilities.';
+// Extensible schema - supports patterns and capabilities
 exports.ORGANIZATIONAL_DATA_TOOL_INPUT_SCHEMA = {
-    dataType: zod_1.z.enum(['pattern', 'capabilities', 'dependencies']).describe('Type of cluster data to manage: pattern (organizational patterns), capabilities (resource capabilities), dependencies (resource dependencies)'),
-    operation: zod_1.z.enum(['create', 'list', 'get', 'delete', 'scan', 'analyze']).describe('Operation to perform on the cluster data'),
+    dataType: zod_1.z.enum(['pattern', 'capabilities']).describe('Type of cluster data to manage: "pattern" for organizational patterns, "capabilities" for resource capabilities'),
+    operation: zod_1.z.enum(['create', 'list', 'get', 'delete', 'deleteAll', 'scan', 'analyze', 'progress', 'search']).describe('Operation to perform on the cluster data'),
     // Workflow fields for step-by-step pattern creation
-    sessionId: zod_1.z.string().optional().describe('Pattern creation session ID (for continuing multi-step workflow)'),
+    sessionId: zod_1.z.string().optional().describe('Session ID (required for continuing workflow steps, optional for progress - uses latest session if omitted)'),
+    step: zod_1.z.string().optional().describe('Current workflow step (required when sessionId is provided)'),
     response: zod_1.z.string().optional().describe('User response to previous workflow step question'),
-    // Generic fields for get/delete operations
-    id: zod_1.z.string().optional().describe('Data item ID (required for get/delete operations)'),
+    // Generic fields for get/delete/search operations
+    id: zod_1.z.string().optional().describe('Data item ID (required for get/delete operations) or search query (required for search operations)'),
     // Generic fields for list operations
     limit: zod_1.z.number().optional().describe('Maximum number of items to return (default: 10)'),
-    // Resource-specific fields (for capabilities and dependencies)
+    // Resource-specific fields (for capabilities operations)
     resource: zod_1.z.object({
         kind: zod_1.z.string(),
         group: zod_1.z.string(),
         apiVersion: zod_1.z.string()
-    }).optional().describe('Kubernetes resource reference (for capabilities/dependencies operations)')
+    }).optional().describe('Kubernetes resource reference (for capabilities operations)'),
+    // Resource list for specific resource scanning
+    resourceList: zod_1.z.string().optional().describe('Comma-separated list of resources to scan (format: Kind.group or Kind for core resources)')
 };
 /**
  * Get Vector DB-based pattern service with optional embedding support
@@ -426,59 +430,1720 @@ async function handlePatternOperation(operation, args, logger, requestId) {
     }
 }
 /**
- * Handle capabilities operations (placeholder for PRD #48)
+ * Create standardized capability scan completion response
  */
-async function handleCapabilitiesOperation(operation, args, logger, requestId) {
-    logger.info('Capabilities operation requested', { requestId, operation });
+function createCapabilityScanCompletionResponse(sessionId, totalProcessed, successful, failed, processingTime, mode, stopped = false) {
+    let message;
+    if (stopped) {
+        message = `⏹️ Capability scan stopped by user after processing ${successful} of ${totalProcessed} resources.`;
+    }
+    else if (failed > 0) {
+        message = `✅ Capability scan completed with ${failed} errors. ${successful}/${totalProcessed} resources processed successfully.`;
+    }
+    else {
+        message = `✅ Capability scan completed successfully! Processed ${totalProcessed} resources.`;
+    }
     return {
-        success: false,
-        operation,
+        success: true,
+        operation: 'scan',
         dataType: 'capabilities',
-        error: {
-            message: 'Resource capabilities management not yet implemented',
-            details: 'This feature is planned for PRD #48 - Resource Capabilities Discovery & Integration',
-            status: 'coming-soon',
-            implementationPlan: {
-                prd: 'PRD #48',
-                description: 'Kubernetes resource capability discovery and semantic matching',
-                expectedFeatures: [
-                    'Cluster resource scanning',
-                    'Capability inference from schemas',
-                    'Semantic resource matching',
-                    'Vector DB storage and search'
-                ]
-            }
+        mode: mode,
+        step: 'complete',
+        sessionId: sessionId,
+        summary: {
+            totalScanned: totalProcessed,
+            successful: successful,
+            failed: failed,
+            processingTime: processingTime,
+            ...(stopped && { stopped: true })
         },
-        message: 'Capabilities management will be available after PRD #48 implementation'
+        message: message,
+        availableOptions: {
+            viewResults: "Use 'list' operation to browse all discovered capabilities",
+            getDetails: "Use 'get' operation with capability ID to view specific capability details",
+            checkStatus: successful > 0 ? "Capabilities are now available for AI-powered recommendations" : "No capabilities were stored"
+        },
+        userNote: "The above options are available for you to choose from - the system will not execute them automatically."
+    };
+}
+/**
+ * Handle capabilities operations - PRD #48 Implementation
+ */
+async function handleCapabilitiesOperation(operation, args, logger, requestId) {
+    logger.info('Capabilities operation requested', { requestId, operation });
+    switch (operation) {
+        case 'scan':
+            return await handleCapabilityScan(args, logger, requestId);
+        case 'progress':
+            return await handleCapabilityProgress(args, logger, requestId);
+        case 'list':
+        case 'get':
+        case 'search':
+        case 'delete':
+        case 'deleteAll': {
+            // Create and initialize capability service for list/get/delete operations
+            const capabilityService = new index_1.CapabilityVectorService();
+            try {
+                const vectorDBHealthy = await capabilityService.healthCheck();
+                if (!vectorDBHealthy) {
+                    return {
+                        success: false,
+                        operation,
+                        dataType: 'capabilities',
+                        error: {
+                            message: 'Vector DB (Qdrant) connection required',
+                            details: 'Capability operations require a working Qdrant connection.',
+                            setup: {
+                                docker: 'docker run -p 6333:6333 qdrant/qdrant',
+                                config: 'export QDRANT_URL=http://localhost:6333'
+                            }
+                        }
+                    };
+                }
+                await capabilityService.initialize();
+                if (operation === 'list') {
+                    return await handleCapabilityList(args, logger, requestId, capabilityService);
+                }
+                else if (operation === 'get') {
+                    return await handleCapabilityGet(args, logger, requestId, capabilityService);
+                }
+                else if (operation === 'search') {
+                    return await handleCapabilitySearch(args, logger, requestId, capabilityService);
+                }
+                else if (operation === 'delete') {
+                    return await handleCapabilityDelete(args, logger, requestId, capabilityService);
+                }
+                else if (operation === 'deleteAll') {
+                    return await handleCapabilityDeleteAll(args, logger, requestId, capabilityService);
+                }
+                else {
+                    // This should never happen since we already check the operation in the switch case
+                    throw new Error(`Unexpected operation: ${operation}`);
+                }
+            }
+            catch (error) {
+                logger.error(`Capability ${operation} operation failed`, error, { requestId });
+                return {
+                    success: false,
+                    operation,
+                    dataType: 'capabilities',
+                    error: {
+                        message: `Capability ${operation} failed`,
+                        details: error instanceof Error ? error.message : String(error)
+                    }
+                };
+            }
+        }
+        default:
+            return {
+                success: false,
+                operation,
+                dataType: 'capabilities',
+                error: {
+                    message: `Unsupported capabilities operation: ${operation}`,
+                    supportedOperations: ['scan', 'list', 'get', 'delete', 'deleteAll']
+                }
+            };
+    }
+}
+/**
+ * Convert numeric response to option value
+ */
+function parseNumericResponse(response, validOptions) {
+    // If response is a number, map it to the corresponding option
+    const num = parseInt(response, 10);
+    if (!isNaN(num) && num >= 1 && num <= validOptions.length) {
+        return validOptions[num - 1]; // Convert 1-based to 0-based index
+    }
+    // Otherwise return the original response (for backward compatibility)
+    return response;
+}
+/**
+ * Get session file path following established pattern
+ */
+function getCapabilitySessionPath(sessionId, args) {
+    const sessionDir = (0, session_utils_1.getAndValidateSessionDirectory)(args, false);
+    const sessionSubDir = path.join(sessionDir, 'capability-sessions');
+    // Ensure capability-sessions subdirectory exists
+    if (!fs.existsSync(sessionSubDir)) {
+        fs.mkdirSync(sessionSubDir, { recursive: true });
+    }
+    return path.join(sessionSubDir, `${sessionId}.json`);
+}
+/**
+ * Load session from file system following established pattern
+ */
+function loadCapabilitySession(sessionId, args) {
+    try {
+        const sessionPath = getCapabilitySessionPath(sessionId, args);
+        if (!fs.existsSync(sessionPath)) {
+            return null;
+        }
+        const sessionData = fs.readFileSync(sessionPath, 'utf8');
+        const session = JSON.parse(sessionData);
+        // Update last activity
+        session.lastActivity = new Date().toISOString();
+        saveCapabilitySession(session, args);
+        return session;
+    }
+    catch (error) {
+        // Log error but don't throw - return null to create new session
+        return null;
+    }
+}
+/**
+ * Save session to file system following established pattern
+ */
+function saveCapabilitySession(session, args) {
+    try {
+        const sessionPath = getCapabilitySessionPath(session.sessionId, args);
+        fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2), 'utf8');
+    }
+    catch (error) {
+        // Log error but don't throw - workflow can continue
+        console.warn('Failed to save capability session:', error);
+    }
+}
+/**
+ * Get or create session with file-based persistence
+ */
+function getOrCreateCapabilitySession(sessionId, args, logger, requestId) {
+    if (sessionId) {
+        const existing = loadCapabilitySession(sessionId, args);
+        if (existing) {
+            logger.info('Loaded existing capability session', {
+                requestId,
+                sessionId,
+                currentStep: existing.currentStep
+            });
+            return existing;
+        }
+    }
+    // Create new session
+    const newSessionId = sessionId || `cap-scan-${Date.now()}`;
+    const session = {
+        sessionId: newSessionId,
+        currentStep: 'resource-selection',
+        startedAt: new Date().toISOString(),
+        lastActivity: new Date().toISOString()
     };
+    saveCapabilitySession(session, args);
+    logger.info('Created new capability session', {
+        requestId,
+        sessionId: newSessionId,
+        currentStep: session.currentStep
+    });
+    return session;
+}
+/**
+ * Validate client is on the correct step - step parameter is MANDATORY
+ */
+function validateCapabilityStep(session, clientStep) {
+    if (!clientStep) {
+        return {
+            valid: false,
+            error: `Step parameter is required. You are currently on step '${session.currentStep}'. Please call with step='${session.currentStep}' and appropriate parameters.`
+        };
+    }
+    if (clientStep !== session.currentStep) {
+        return {
+            valid: false,
+            error: `Step mismatch: you're on step '${session.currentStep}', but called with step '${clientStep}'. Please call with step='${session.currentStep}'.`
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Transition session to next step with proper state updates
+ */
+function transitionCapabilitySession(session, nextStep, updates, args) {
+    session.currentStep = nextStep;
+    session.lastActivity = new Date().toISOString();
+    if (updates) {
+        Object.assign(session, updates);
+    }
+    saveCapabilitySession(session, args);
+}
+/**
+ * Clean up session file after successful completion
+ */
+function cleanupCapabilitySession(session, args, logger, requestId) {
+    try {
+        const sessionPath = getCapabilitySessionPath(session.sessionId, args);
+        if (fs.existsSync(sessionPath)) {
+            fs.unlinkSync(sessionPath);
+            logger.info('Capability session cleaned up after completion', {
+                requestId,
+                sessionId: session.sessionId
+            });
+        }
+    }
+    catch (error) {
+        // Log cleanup failure but don't fail the operation
+        logger.warn('Failed to cleanup capability session file', {
+            requestId,
+            sessionId: session.sessionId,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
 }
 /**
- * Handle dependencies operations (placeholder for PRD #49)
+ * Handle capability scanning workflow with step-based state management
  */
-async function handleDependenciesOperation(operation, args, logger, requestId) {
-    logger.info('Dependencies operation requested', { requestId, operation });
+async function handleCapabilityScan(args, logger, requestId) {
+    // Validate Vector DB and embedding service dependencies upfront
+    // This prevents users from going through the entire workflow only to fail at storage
+    const capabilityService = new index_1.CapabilityVectorService();
+    // Check Vector DB connection and initialize collection
+    try {
+        const vectorDBHealthy = await capabilityService.healthCheck();
+        if (!vectorDBHealthy) {
+            return {
+                success: false,
+                operation: 'scan',
+                dataType: 'capabilities',
+                error: {
+                    message: 'Vector DB (Qdrant) connection required for capability management',
+                    details: 'Capability scanning requires Qdrant for storing and searching capabilities. The system cannot proceed without a working Vector DB connection.',
+                    setup: {
+                        required: 'Qdrant server must be running',
+                        default: 'http://localhost:6333',
+                        docker: 'docker run -p 6333:6333 qdrant/qdrant',
+                        config: 'export QDRANT_URL=http://localhost:6333'
+                    },
+                    currentConfig: {
+                        QDRANT_URL: process.env.QDRANT_URL || 'http://localhost:6333 (default)',
+                        status: 'connection failed'
+                    }
+                }
+            };
+        }
+    }
+    catch (error) {
+        logger.error('Vector DB connection check failed', error, { requestId });
+        return {
+            success: false,
+            operation: 'scan',
+            dataType: 'capabilities',
+            error: {
+                message: 'Vector DB (Qdrant) connection failed',
+                details: 'Cannot establish connection to Qdrant server. Please ensure Qdrant is running and accessible.',
+                technicalDetails: error instanceof Error ? error.message : String(error),
+                setup: {
+                    required: 'Qdrant server must be running',
+                    default: 'http://localhost:6333',
+                    docker: 'docker run -p 6333:6333 qdrant/qdrant',
+                    config: 'export QDRANT_URL=http://localhost:6333'
+                },
+                currentConfig: {
+                    QDRANT_URL: process.env.QDRANT_URL || 'http://localhost:6333 (default)',
+                    status: 'connection error'
+                }
+            }
+        };
+    }
+    // Initialize the collection now that we know Qdrant is healthy
+    try {
+        await capabilityService.initialize();
+    }
+    catch (error) {
+        logger.error('Failed to initialize capabilities collection', error, { requestId });
+        return {
+            success: false,
+            operation: 'scan',
+            dataType: 'capabilities',
+            error: {
+                message: 'Vector DB collection initialization failed',
+                details: 'Could not create or access the capabilities collection in Qdrant.',
+                technicalDetails: error instanceof Error ? error.message : String(error),
+                setup: {
+                    possibleCauses: [
+                        'Qdrant version compatibility issue',
+                        'Insufficient permissions',
+                        'Collection dimension mismatch',
+                        'Corrupted existing collection'
+                    ],
+                    recommendations: [
+                        'Check Qdrant logs for detailed error information',
+                        'Verify Qdrant version compatibility',
+                        'Consider removing existing capabilities collection if corrupted'
+                    ]
+                }
+            }
+        };
+    }
+    // Check embedding service (OpenAI API) availability
+    const embeddingCheck = await validateEmbeddingService(logger, requestId);
+    if (!embeddingCheck.success) {
+        return {
+            success: false,
+            operation: 'scan',
+            dataType: 'capabilities',
+            error: {
+                message: 'OpenAI API required for capability semantic search',
+                details: 'Capability scanning requires OpenAI embeddings for semantic search functionality. The system cannot proceed without proper OpenAI API configuration.',
+                ...embeddingCheck.error,
+                recommendation: 'Set up OpenAI API key to enable full capability scanning with semantic search'
+            }
+        };
+    }
+    logger.info('Capability scanning dependencies validated', {
+        requestId,
+        vectorDB: 'healthy',
+        embeddings: 'available'
+    });
+    // Get or create session with step-based state management
+    const session = getOrCreateCapabilitySession(args.sessionId, args, logger, requestId);
+    // Validate client is on correct step - only for existing sessions
+    // New sessions (no sessionId provided) are allowed to start without step parameter
+    // If sessionId is provided, client must follow step-based protocol
+    const clientProvidedSessionId = !!args.sessionId;
+    if (clientProvidedSessionId) {
+        const stepValidation = validateCapabilityStep(session, args.step);
+        if (!stepValidation.valid) {
+            return {
+                success: false,
+                operation: 'scan',
+                dataType: 'capabilities',
+                error: {
+                    message: 'Step validation failed',
+                    details: stepValidation.error,
+                    currentStep: session.currentStep,
+                    expectedCall: `Call with step='${session.currentStep}' and appropriate parameters`
+                }
+            };
+        }
+    }
+    // Handle workflow based on current step
+    switch (session.currentStep) {
+        case 'resource-selection':
+            return await handleResourceSelection(session, args, logger, requestId);
+        case 'resource-specification':
+            return await handleResourceSpecification(session, args, logger, requestId);
+        case 'processing-mode':
+            return await handleProcessingMode(session, args, logger, requestId, capabilityService);
+        case 'scanning':
+            return await handleScanning(session, args, logger, requestId, capabilityService);
+        case 'complete':
+            return {
+                success: false,
+                operation: 'scan',
+                dataType: 'capabilities',
+                error: {
+                    message: 'Workflow already complete',
+                    details: `Session ${session.sessionId} has already completed capability scanning.`,
+                    sessionId: session.sessionId
+                }
+            };
+        default:
+            return {
+                success: false,
+                operation: 'scan',
+                dataType: 'capabilities',
+                error: {
+                    message: 'Invalid workflow state',
+                    details: `Unknown step: ${session.currentStep}`,
+                    currentStep: session.currentStep
+                }
+            };
+    }
+}
+/**
+ * Handle resource selection step
+ */
+async function handleResourceSelection(session, args, _logger, _requestId) {
+    if (!args.response) {
+        // Show initial resource selection prompt
+        return {
+            success: true,
+            operation: 'scan',
+            dataType: 'capabilities',
+            // CRITICAL: Put required parameters at top level for maximum visibility
+            REQUIRED_NEXT_CALL: {
+                tool: 'dot-ai:manageOrgData',
+                parameters: {
+                    dataType: 'capabilities',
+                    operation: 'scan',
+                    sessionId: session.sessionId,
+                    step: 'resource-selection', // MANDATORY PARAMETER
+                    response: 'user_choice_here' // Replace with actual user choice
+                },
+                note: 'The step parameter is MANDATORY when sessionId is provided'
+            },
+            workflow: {
+                step: 'resource-selection',
+                question: 'Scan all cluster resources or specify subset?',
+                options: [
+                    { number: 1, value: 'all', display: '1. all - Scan all available cluster resources' },
+                    { number: 2, value: 'specific', display: '2. specific - Specify particular resource types to scan' }
+                ],
+                sessionId: session.sessionId,
+                instruction: 'IMPORTANT: You MUST ask the user to make a choice. Do NOT automatically select an option.',
+                userPrompt: 'Would you like to scan all cluster resources or specify a subset?',
+                clientInstructions: {
+                    behavior: 'interactive',
+                    requirement: 'Ask user to choose between options',
+                    prohibit: 'Do not auto-select options',
+                    nextStep: `Call with step='resource-selection', sessionId='${session.sessionId}', and response parameter containing the semantic value (all or specific)`,
+                    responseFormat: 'Convert user input to semantic values: 1→all, 2→specific, or pass through semantic words directly',
+                    requiredParameters: {
+                        step: 'resource-selection',
+                        sessionId: session.sessionId,
+                        response: 'user choice (all or specific)'
+                    }
+                }
+            }
+        };
+    }
+    // Process user response
+    const normalizedResponse = parseNumericResponse(args.response, ['all', 'specific']);
+    if (normalizedResponse === 'all') {
+        // Transition to processing mode for all resources
+        transitionCapabilitySession(session, 'processing-mode', { selectedResources: 'all' }, args);
+        return {
+            success: true,
+            operation: 'scan',
+            dataType: 'capabilities',
+            // CRITICAL: Put required parameters at top level for maximum visibility
+            REQUIRED_NEXT_CALL: {
+                tool: 'dot-ai:manageOrgData',
+                parameters: {
+                    dataType: 'capabilities',
+                    operation: 'scan',
+                    sessionId: session.sessionId,
+                    step: 'processing-mode', // MANDATORY PARAMETER
+                    response: 'user_choice_here' // Replace with actual user choice
+                },
+                note: 'The step parameter is MANDATORY when sessionId is provided'
+            },
+            workflow: {
+                step: 'processing-mode',
+                question: 'Processing mode: auto (batch process) or manual (review each)?',
+                options: [
+                    { number: 1, value: 'auto', display: '1. auto - Batch process automatically' },
+                    { number: 2, value: 'manual', display: '2. manual - Review each step' }
+                ],
+                sessionId: session.sessionId,
+                selectedResources: 'all',
+                instruction: 'IMPORTANT: You MUST ask the user to make a choice. Do NOT automatically select a processing mode.',
+                userPrompt: 'How would you like to process the resources?',
+                clientInstructions: {
+                    behavior: 'interactive',
+                    requirement: 'Ask user to choose processing mode',
+                    prohibit: 'Do not auto-select processing mode',
+                    nextStep: `Call with step='processing-mode', sessionId='${session.sessionId}', and response parameter containing the semantic value (auto or manual)`,
+                    responseFormat: 'Convert user input to semantic values: 1→auto, 2→manual, or pass through semantic words directly',
+                    requiredParameters: {
+                        step: 'processing-mode',
+                        sessionId: session.sessionId,
+                        response: 'user choice (auto or manual)'
+                    }
+                }
+            }
+        };
+    }
+    if (normalizedResponse === 'specific') {
+        // Transition to resource specification
+        transitionCapabilitySession(session, 'resource-specification', {}, args);
+        return {
+            success: true,
+            operation: 'scan',
+            dataType: 'capabilities',
+            // CRITICAL: Put required parameters at top level for maximum visibility
+            REQUIRED_NEXT_CALL: {
+                tool: 'dot-ai:manageOrgData',
+                parameters: {
+                    dataType: 'capabilities',
+                    operation: 'scan',
+                    sessionId: session.sessionId,
+                    step: 'resource-specification', // MANDATORY PARAMETER
+                    resourceList: 'user_resource_list_here' // Replace with actual resource list
+                },
+                note: 'The step parameter is MANDATORY when sessionId is provided'
+            },
+            workflow: {
+                step: 'resource-specification',
+                question: 'Which resources would you like to scan?',
+                sessionId: session.sessionId,
+                instruction: 'IMPORTANT: You MUST ask the user to specify which resources to scan. Do NOT provide a default list.',
+                userPrompt: 'Please specify which resources you want to scan.',
+                resourceFormat: {
+                    description: 'Specify resources using Kubernetes naming convention',
+                    format: 'Kind.group for CRDs, Kind for core resources',
+                    examples: {
+                        crds: ['SQL.devopstoolkit.live', 'Server.dbforpostgresql.azure.upbound.io'],
+                        core: ['Pod', 'Service', 'ConfigMap'],
+                        apps: ['Deployment.apps', 'StatefulSet.apps']
+                    },
+                    input: 'Comma-separated list (e.g.: SQL.devopstoolkit.live, Deployment.apps, Pod)'
+                },
+                clientInstructions: {
+                    behavior: 'interactive',
+                    requirement: 'Ask user to provide specific resource list',
+                    prohibit: 'Do not suggest or auto-select resources',
+                    nextStep: `Call with step='resource-specification', sessionId='${session.sessionId}', and resourceList parameter`,
+                    requiredParameters: {
+                        step: 'resource-specification',
+                        sessionId: session.sessionId,
+                        resourceList: 'comma-separated list of resources'
+                    }
+                }
+            }
+        };
+    }
     return {
         success: false,
-        operation,
-        dataType: 'dependencies',
+        operation: 'scan',
+        dataType: 'capabilities',
         error: {
-            message: 'Resource dependencies management not yet implemented',
-            details: 'This feature is planned for PRD #49 - Resource Dependencies Discovery & Integration',
-            status: 'coming-soon',
-            implementationPlan: {
-                prd: 'PRD #49',
-                description: 'Resource dependency discovery and complete solution assembly',
-                expectedFeatures: [
-                    'Dependency relationship discovery',
-                    'Complete solution assembly',
-                    'Deployment order optimization',
-                    'Vector DB storage and search'
-                ]
+            message: 'Invalid resource selection response',
+            details: `Expected 'all' or 'specific', got: ${args.response}`,
+            currentStep: session.currentStep
+        }
+    };
+}
+/**
+ * Handle resource specification step
+ */
+async function handleResourceSpecification(session, args, _logger, _requestId) {
+    if (!args.resourceList) {
+        return {
+            success: false,
+            operation: 'scan',
+            dataType: 'capabilities',
+            error: {
+                message: 'Missing resource list',
+                details: 'Expected resourceList parameter with comma-separated resource names',
+                currentStep: session.currentStep,
+                expectedCall: `Call with step='resource-specification' and resourceList parameter`
+            }
+        };
+    }
+    // Parse and validate resource list
+    const resources = args.resourceList.split(',').map((r) => r.trim()).filter((r) => r.length > 0);
+    if (resources.length === 0) {
+        return {
+            success: false,
+            operation: 'scan',
+            dataType: 'capabilities',
+            error: {
+                message: 'Empty resource list',
+                details: 'Resource list cannot be empty',
+                currentStep: session.currentStep
             }
+        };
+    }
+    // Transition to processing mode for specific resources
+    transitionCapabilitySession(session, 'processing-mode', {
+        selectedResources: resources,
+        resourceList: args.resourceList
+    }, args);
+    return {
+        success: true,
+        operation: 'scan',
+        dataType: 'capabilities',
+        // CRITICAL: Put required parameters at top level for maximum visibility
+        REQUIRED_NEXT_CALL: {
+            tool: 'dot-ai:manageOrgData',
+            parameters: {
+                dataType: 'capabilities',
+                operation: 'scan',
+                sessionId: session.sessionId,
+                step: 'processing-mode', // MANDATORY PARAMETER
+                response: 'user_choice_here' // Replace with actual user choice
+            },
+            note: 'The step parameter is MANDATORY when sessionId is provided'
         },
-        message: 'Dependencies management will be available after PRD #49 implementation'
+        workflow: {
+            step: 'processing-mode',
+            question: `Processing mode for ${resources.length} selected resources: auto (batch process) or manual (review each)?`,
+            options: [
+                { number: 1, value: 'auto', display: '1. auto - Batch process automatically' },
+                { number: 2, value: 'manual', display: '2. manual - Review each step' }
+            ],
+            sessionId: session.sessionId,
+            selectedResources: resources,
+            instruction: 'IMPORTANT: You MUST ask the user to choose processing mode for the specified resources.',
+            userPrompt: `How would you like to process these ${resources.length} resources?`,
+            clientInstructions: {
+                behavior: 'interactive',
+                requirement: 'Ask user to choose processing mode for specific resources',
+                context: `Processing ${resources.length} user-specified resources: ${resources.join(', ')}`,
+                prohibit: 'Do not auto-select processing mode',
+                nextStep: `Call with step='processing-mode', sessionId='${session.sessionId}', and response parameter containing the semantic value (auto or manual)`,
+                responseFormat: 'Convert user input to semantic values: 1→auto, 2→manual, or pass through semantic words directly',
+                requiredParameters: {
+                    step: 'processing-mode',
+                    sessionId: session.sessionId,
+                    response: 'user choice (auto or manual)'
+                }
+            }
+        }
     };
 }
+/**
+ * Handle processing mode step
+ */
+async function handleProcessingMode(session, args, logger, requestId, capabilityService) {
+    if (!args.response) {
+        return {
+            success: false,
+            operation: 'scan',
+            dataType: 'capabilities',
+            error: {
+                message: 'Missing processing mode response',
+                details: 'Expected response parameter with processing mode choice',
+                currentStep: session.currentStep,
+                expectedCall: `Call with step='processing-mode' and response parameter (auto or manual)`
+            }
+        };
+    }
+    // Process user response
+    const processingModeResponse = parseNumericResponse(args.response, ['auto', 'manual']);
+    if (processingModeResponse !== 'auto' && processingModeResponse !== 'manual') {
+        return {
+            success: false,
+            operation: 'scan',
+            dataType: 'capabilities',
+            error: {
+                message: 'Invalid processing mode response',
+                details: `Expected 'auto' or 'manual', got: ${args.response}`,
+                currentStep: session.currentStep
+            }
+        };
+    }
+    // Transition to scanning with processing mode and initialize resource tracking
+    transitionCapabilitySession(session, 'scanning', {
+        processingMode: processingModeResponse,
+        currentResourceIndex: 0 // Start with first resource
+    }, args);
+    // Begin actual capability scanning - clear response from previous step
+    return await handleScanning(session, { ...args, response: undefined }, logger, requestId, capabilityService);
+}
+/**
+ * Create user-friendly error message for resource definition failures
+ */
+function createResourceDefinitionErrorMessage(resourceName, error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    let userFriendlyMessage = `Cannot analyze resource '${resourceName}': `;
+    if (errorMessage.includes('not found') || errorMessage.includes('NotFound')) {
+        userFriendlyMessage += `Resource does not exist in cluster. Please ensure the CRD is installed.`;
+    }
+    else if (errorMessage.includes('connection refused') || errorMessage.includes('timeout')) {
+        userFriendlyMessage += `Cannot connect to Kubernetes cluster. Please check cluster connectivity.`;
+    }
+    else if (errorMessage.includes('forbidden') || errorMessage.includes('Forbidden')) {
+        userFriendlyMessage += `Insufficient permissions to read resource definitions. Please check RBAC settings.`;
+    }
+    else {
+        userFriendlyMessage += `${errorMessage}`;
+    }
+    return userFriendlyMessage;
+}
+/**
+ * Handle scanning step (actual capability analysis)
+ */
+async function handleScanning(session, args, logger, requestId, capabilityService) {
+    try {
+        // If this is a response to a manual mode preview, handle it first
+        if (session.processingMode === 'manual' && args.response) {
+            const userResponse = parseNumericResponse(args.response, ['yes', 'no', 'stop']);
+            if (userResponse === 'stop') {
+                // User wants to stop scanning
+                transitionCapabilitySession(session, 'complete', {}, args);
+                cleanupCapabilitySession(session, args, logger, requestId);
+                const currentIndex = session.currentResourceIndex || 0;
+                const totalResources = Array.isArray(session.selectedResources) ? session.selectedResources.length : 1;
+                return createCapabilityScanCompletionResponse(session.sessionId, totalResources, currentIndex, // Resources processed so far
+                0, 'stopped interactively', 'manual', true // stopped = true
+                );
+            }
+            if (userResponse === 'yes' || userResponse === 'no') {
+                // TODO: If 'yes', store the capability in Vector DB (Milestone 2)
+                // For now, just log the decision
+                logger.info(`User ${userResponse === 'yes' ? 'accepted' : 'skipped'} capability for resource`, {
+                    requestId,
+                    sessionId: session.sessionId,
+                    resourceIndex: session.currentResourceIndex,
+                    decision: userResponse
+                });
+                // Move to the next resource
+                const nextIndex = (session.currentResourceIndex || 0) + 1;
+                transitionCapabilitySession(session, 'scanning', { currentResourceIndex: nextIndex }, args);
+                // Continue processing (will handle the next resource or complete if done)
+                return await handleScanning(session, { ...args, response: undefined }, logger, requestId, capabilityService);
+            }
+            // Invalid response
+            return {
+                success: false,
+                operation: 'scan',
+                dataType: 'capabilities',
+                error: {
+                    message: 'Invalid response to capability preview',
+                    details: `Expected 'yes', 'no', or 'stop', got: ${args.response}`,
+                    currentStep: session.currentStep
+                }
+            };
+        }
+        // Import capability engine
+        const { CapabilityInferenceEngine } = await Promise.resolve().then(() => __importStar(require('../core/capabilities')));
+        const { ClaudeIntegration } = await Promise.resolve().then(() => __importStar(require('../core/claude')));
+        // Validate Claude API key
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            return {
+                success: false,
+                operation: 'scan',
+                dataType: 'capabilities',
+                error: {
+                    message: 'ANTHROPIC_API_KEY required for capability inference',
+                    details: 'Set ANTHROPIC_API_KEY environment variable to enable AI-powered capability analysis'
+                }
+            };
+        }
+        // Initialize capability engine
+        const claudeIntegration = new ClaudeIntegration(apiKey);
+        const engine = new CapabilityInferenceEngine(claudeIntegration, logger);
+        // Get the resource to analyze
+        let resourceName;
+        let currentIndex;
+        let totalResources;
+        if (session.selectedResources === 'all') {
+            // For 'all' mode, discover actual cluster resources first
+            try {
+                logger.info('Discovering all cluster resources for capability scanning', { requestId, sessionId: session.sessionId });
+                // Import discovery engine
+                const { KubernetesDiscovery } = await Promise.resolve().then(() => __importStar(require('../core/discovery')));
+                const discovery = new KubernetesDiscovery();
+                await discovery.connect();
+                // Discover all available resources
+                const resourceMap = await discovery.discoverResources();
+                const allResources = [...resourceMap.resources, ...resourceMap.custom];
+                // Extract resource names for capability analysis
+                const discoveredResourceNames = allResources.map(resource => {
+                    // For CRDs (custom resources), prioritize full name format
+                    if (resource.name && resource.name.includes('.')) {
+                        return resource.name;
+                    }
+                    // For standard resources, use kind
+                    if (resource.kind) {
+                        return resource.kind;
+                    }
+                    // Fallback to name if no kind
+                    if (resource.name) {
+                        return resource.name;
+                    }
+                    return 'unknown-resource';
+                }).filter(name => name !== 'unknown-resource');
+                logger.info('Discovered cluster resources for capability scanning', {
+                    requestId,
+                    sessionId: session.sessionId,
+                    totalDiscovered: discoveredResourceNames.length,
+                    sampleResources: discoveredResourceNames.slice(0, 5)
+                });
+                if (discoveredResourceNames.length === 0) {
+                    return {
+                        success: false,
+                        operation: 'scan',
+                        dataType: 'capabilities',
+                        error: {
+                            message: 'No resources discovered in cluster',
+                            details: 'Cluster resource discovery returned empty results. Check cluster connectivity and permissions.',
+                            sessionId: session.sessionId
+                        }
+                    };
+                }
+                // Update session with discovered resources and start batch processing
+                transitionCapabilitySession(session, 'scanning', {
+                    selectedResources: discoveredResourceNames,
+                    processingMode: session.processingMode,
+                    currentResourceIndex: 0
+                }, args);
+                // Continue to batch processing with discovered resources
+                resourceName = discoveredResourceNames[0]; // First resource for manual mode
+                currentIndex = 0;
+                totalResources = discoveredResourceNames.length;
+            }
+            catch (error) {
+                logger.error('Failed to discover cluster resources', error, {
+                    requestId,
+                    sessionId: session.sessionId
+                });
+                return {
+                    success: false,
+                    operation: 'scan',
+                    dataType: 'capabilities',
+                    error: {
+                        message: 'Cluster resource discovery failed',
+                        details: error instanceof Error ? error.message : String(error),
+                        sessionId: session.sessionId,
+                        suggestedActions: [
+                            'Check cluster connectivity',
+                            'Verify kubectl access permissions',
+                            'Try specifying specific resources instead of "all"'
+                        ]
+                    }
+                };
+            }
+        }
+        else if (Array.isArray(session.selectedResources)) {
+            // Get the current resource based on currentResourceIndex
+            currentIndex = session.currentResourceIndex || 0;
+            totalResources = session.selectedResources.length;
+            if (currentIndex >= totalResources) {
+                // All resources processed - mark as complete
+                transitionCapabilitySession(session, 'complete', {}, args);
+                cleanupCapabilitySession(session, args, logger, requestId);
+                return createCapabilityScanCompletionResponse(session.sessionId, totalResources, totalResources, // Assume all successful for manual mode
+                0, 'completed interactively', 'manual');
+            }
+            resourceName = session.selectedResources[currentIndex];
+            if (!resourceName) {
+                throw new Error(`No resource found at index ${currentIndex}`);
+            }
+        }
+        else {
+            throw new Error('Invalid selectedResources in session state');
+        }
+        // Get complete resource definition for comprehensive analysis
+        let resourceDefinition;
+        try {
+            // Import and connect to discovery engine for kubectl access
+            const { KubernetesDiscovery } = await Promise.resolve().then(() => __importStar(require('../core/discovery')));
+            const discovery = new KubernetesDiscovery();
+            await discovery.connect();
+            // Get complete CRD definition if it's a custom resource
+            if (resourceName.includes('.')) {
+                const crdOutput = await discovery.executeKubectl(['get', 'crd', resourceName, '-o', 'yaml']);
+                resourceDefinition = crdOutput;
+                logger.info('Found complete CRD definition for capability analysis', {
+                    requestId,
+                    sessionId: session.sessionId,
+                    resource: resourceName,
+                    hasDefinition: !!resourceDefinition,
+                    definitionSize: resourceDefinition?.length || 0
+                });
+            }
+            else {
+                // For core resources, use kubectl explain to get schema information
+                const explainOutput = await discovery.explainResource(resourceName);
+                resourceDefinition = explainOutput;
+                logger.info('Found core resource explanation for capability analysis', {
+                    requestId,
+                    sessionId: session.sessionId,
+                    resource: resourceName,
+                    hasDefinition: !!resourceDefinition
+                });
+            }
+        }
+        catch (error) {
+            logger.error('Failed to retrieve resource definition for capability analysis', error, {
+                requestId,
+                sessionId: session.sessionId,
+                resource: resourceName
+            });
+            throw new Error(createResourceDefinitionErrorMessage(resourceName, error));
+        }
+        logger.info('Analyzing resource for capability inference', {
+            requestId,
+            sessionId: session.sessionId,
+            resource: resourceName,
+            mode: session.processingMode
+        });
+        if (session.processingMode === 'manual') {
+            // Manual mode: Show capability data for user review
+            const capability = await engine.inferCapabilities(resourceName, resourceDefinition);
+            const capabilityId = CapabilityInferenceEngine.generateCapabilityId(resourceName);
+            return {
+                success: true,
+                operation: 'scan',
+                dataType: 'capabilities',
+                mode: 'manual',
+                step: 'scanning',
+                sessionId: session.sessionId,
+                preview: {
+                    resource: resourceName,
+                    resourceIndex: `${currentIndex + 1}/${totalResources}`,
+                    id: capabilityId,
+                    data: capability,
+                    question: 'Continue storing this capability?',
+                    options: [
+                        { number: 1, value: 'yes', display: '1. yes - Store this capability' },
+                        { number: 2, value: 'no', display: '2. no - Skip this resource' },
+                        { number: 3, value: 'stop', display: '3. stop - End scanning process' }
+                    ],
+                    instruction: 'Review the capability analysis results before storing',
+                    clientInstructions: {
+                        behavior: 'interactive',
+                        requirement: 'Ask user to review capability data and decide on storage',
+                        nextStep: `Call with step='scanning' and response parameter containing their choice (yes/no/stop)`,
+                        responseFormat: 'Convert user input to semantic values: 1→yes, 2→no, 3→stop'
+                    }
+                }
+            };
+        }
+        else {
+            // Auto mode: Process ALL resources in batch without user interaction
+            // At this point, selectedResources should always be an array (either discovered or specified)
+            if (!Array.isArray(session.selectedResources)) {
+                throw new Error(`Invalid selectedResources state: expected array, got ${typeof session.selectedResources}. This indicates a bug in resource discovery.`);
+            }
+            const resources = session.selectedResources;
+            const totalResources = resources.length;
+            const processedResults = [];
+            const errors = [];
+            logger.info('Starting auto batch processing', {
+                requestId,
+                sessionId: session.sessionId,
+                totalResources,
+                resources: resources
+            });
+            // Initialize progress tracking
+            const startTime = Date.now();
+            const updateProgress = (current, currentResource, successful, failed, recentErrors) => {
+                const elapsed = Date.now() - startTime;
+                const percentage = Math.round((current / totalResources) * 100);
+                // Calculate estimated time remaining
+                let estimatedTimeRemaining;
+                if (current > 0) {
+                    const avgTimePerResource = elapsed / current;
+                    const remainingResources = totalResources - current;
+                    const estimatedRemainingMs = remainingResources * avgTimePerResource;
+                    const estimatedMinutes = Math.round(estimatedRemainingMs / 60000 * 10) / 10;
+                    estimatedTimeRemaining = estimatedMinutes > 1 ?
+                        `${estimatedMinutes} minutes` :
+                        `${Math.round(estimatedRemainingMs / 1000)} seconds`;
+                }
+                const progressData = {
+                    status: 'processing',
+                    current: current,
+                    total: totalResources,
+                    percentage: percentage,
+                    currentResource: currentResource,
+                    startedAt: new Date(startTime).toISOString(),
+                    lastUpdated: new Date().toISOString(),
+                    estimatedTimeRemaining,
+                    successfulResources: successful,
+                    failedResources: failed,
+                    errors: recentErrors.slice(-5) // Keep last 5 errors for troubleshooting
+                };
+                // Update session file with progress
+                transitionCapabilitySession(session, 'scanning', {
+                    processingMode: session.processingMode,
+                    selectedResources: session.selectedResources,
+                    currentResourceIndex: current - 1,
+                    progress: progressData
+                }, args);
+            };
+            // Setup kubectl access for getting complete resource definitions
+            let discovery;
+            try {
+                const { KubernetesDiscovery } = await Promise.resolve().then(() => __importStar(require('../core/discovery')));
+                discovery = new KubernetesDiscovery();
+                await discovery.connect();
+                logger.info('Connected to Kubernetes for batch resource definition retrieval', {
+                    requestId,
+                    sessionId: session.sessionId
+                });
+            }
+            catch (error) {
+                logger.warn('Could not connect to Kubernetes for batch processing, falling back to name-based inference', {
+                    requestId,
+                    sessionId: session.sessionId,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+            // Process each resource in the batch with progress tracking
+            for (let i = 0; i < resources.length; i++) {
+                const currentResource = resources[i];
+                // Get complete resource definition for this resource
+                let currentResourceDefinition;
+                if (discovery) {
+                    try {
+                        if (currentResource.includes('.')) {
+                            // Get complete CRD definition
+                            currentResourceDefinition = await discovery.executeKubectl(['get', 'crd', currentResource, '-o', 'yaml']);
+                        }
+                        else {
+                            // Get core resource explanation
+                            currentResourceDefinition = await discovery.explainResource(currentResource);
+                        }
+                    }
+                    catch (error) {
+                        logger.error(`Failed to get resource definition for ${currentResource}`, error, {
+                            requestId,
+                            sessionId: session.sessionId,
+                            resource: currentResource
+                        });
+                        // Add to errors array and skip processing this resource
+                        errors.push({
+                            resource: currentResource,
+                            error: createResourceDefinitionErrorMessage(currentResource, error),
+                            timestamp: new Date().toISOString()
+                        });
+                        // Skip processing this resource
+                        continue;
+                    }
+                }
+                // Update progress before processing
+                updateProgress(i + 1, currentResource, processedResults.length, errors.length, errors);
+                try {
+                    logger.info(`Processing resource ${i + 1}/${totalResources}`, {
+                        requestId,
+                        sessionId: session.sessionId,
+                        resource: currentResource,
+                        percentage: Math.round(((i + 1) / totalResources) * 100)
+                    });
+                    const capability = await engine.inferCapabilities(currentResource, currentResourceDefinition);
+                    const capabilityId = CapabilityInferenceEngine.generateCapabilityId(currentResource);
+                    // Store capability in Vector DB
+                    await capabilityService.storeCapability(capability);
+                    processedResults.push({
+                        resource: currentResource,
+                        id: capabilityId,
+                        capabilities: capability.capabilities,
+                        providers: capability.providers,
+                        complexity: capability.complexity,
+                        confidence: capability.confidence
+                    });
+                    logger.info(`Successfully processed resource ${i + 1}/${totalResources}`, {
+                        requestId,
+                        sessionId: session.sessionId,
+                        resource: currentResource,
+                        capabilitiesFound: capability.capabilities.length,
+                        percentage: Math.round(((i + 1) / totalResources) * 100)
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const errorDetail = {
+                        resource: currentResource,
+                        error: errorMessage,
+                        index: i + 1,
+                        timestamp: new Date().toISOString()
+                    };
+                    logger.error(`Failed to process resource ${i + 1}/${totalResources}`, error, {
+                        requestId,
+                        sessionId: session.sessionId,
+                        resource: currentResource,
+                        percentage: Math.round(((i + 1) / totalResources) * 100)
+                    });
+                    errors.push(errorDetail);
+                }
+            }
+            // Final progress update - mark as completed
+            const finalElapsed = Date.now() - startTime;
+            const finalMinutes = Math.round(finalElapsed / 60000 * 10) / 10;
+            const successful = processedResults.length;
+            const failed = errors.length;
+            const completionData = {
+                status: 'completed',
+                current: totalResources,
+                total: totalResources,
+                percentage: 100,
+                currentResource: 'Processing complete',
+                startedAt: new Date(startTime).toISOString(),
+                lastUpdated: new Date().toISOString(),
+                completedAt: new Date().toISOString(),
+                totalProcessingTime: finalMinutes > 1 ? `${finalMinutes} minutes` : `${Math.round(finalElapsed / 1000)} seconds`,
+                successfulResources: successful,
+                failedResources: failed,
+                errors: errors.slice(-5)
+            };
+            // Update session with completion status
+            transitionCapabilitySession(session, 'complete', {
+                progress: completionData
+            }, args);
+            logger.info('Auto batch processing completed', {
+                requestId,
+                sessionId: session.sessionId,
+                processed: totalResources,
+                successful,
+                failed,
+                processingTime: completionData.totalProcessingTime
+            });
+            // Clean up session file after a brief delay to allow progress viewing
+            setTimeout(() => {
+                cleanupCapabilitySession(session, args, logger, requestId);
+            }, 30000); // Keep for 30 seconds after completion
+            return createCapabilityScanCompletionResponse(session.sessionId, totalResources, successful, failed, completionData.totalProcessingTime || 'completed', 'auto');
+        }
+    }
+    catch (error) {
+        logger.error('Capability scanning failed', error, {
+            requestId,
+            sessionId: session.sessionId,
+            resource: (error && typeof error === 'object' && 'resourceName' in error) ? error.resourceName : 'unknown',
+            step: session.currentStep
+        });
+        // Clean up session on error
+        cleanupCapabilitySession(session, args, logger, requestId);
+        return {
+            success: false,
+            operation: 'scan',
+            dataType: 'capabilities',
+            error: {
+                message: 'Capability scanning failed',
+                details: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+/**
+ * Handle capability listing (placeholder for future implementation)
+ */
+async function handleCapabilityList(args, logger, requestId, capabilityService) {
+    try {
+        // Get all capabilities with optional limit
+        const limit = args.limit || 10;
+        const capabilities = await capabilityService.getAllCapabilities(limit);
+        const count = await capabilityService.getCapabilitiesCount();
+        logger.info('Capabilities listed successfully', {
+            requestId,
+            count: capabilities.length,
+            totalCount: count,
+            limit
+        });
+        return {
+            success: true,
+            operation: 'list',
+            dataType: 'capabilities',
+            data: {
+                capabilities: capabilities.map(cap => ({
+                    id: cap.id,
+                    resourceName: cap.resourceName,
+                    capabilities: cap.capabilities,
+                    description: cap.description.length > 100 ? cap.description.substring(0, 100) + '...' : cap.description,
+                    complexity: cap.complexity,
+                    confidence: cap.confidence,
+                    analyzedAt: cap.analyzedAt
+                })),
+                totalCount: count,
+                returnedCount: capabilities.length,
+                limit
+            },
+            message: `Retrieved ${capabilities.length} capabilities (${count} total)`,
+            clientInstructions: {
+                behavior: 'Display capability list with IDs prominently visible for user reference',
+                requirement: 'Each capability must show: ID, resource name, main capabilities, and description',
+                format: 'List format with ID clearly labeled (e.g., "ID: abc123") so users can reference specific capabilities',
+                prohibit: 'Do not hide or omit capability IDs from the display - users need them for get operations'
+            }
+        };
+    }
+    catch (error) {
+        logger.error('Failed to list capabilities', error, {
+            requestId
+        });
+        return {
+            success: false,
+            operation: 'list',
+            dataType: 'capabilities',
+            error: {
+                message: 'Failed to list capabilities',
+                details: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+/**
+ * Handle capability retrieval (placeholder for future implementation)
+ */
+async function handleCapabilityGet(args, logger, requestId, capabilityService) {
+    try {
+        // Validate required parameters
+        if (!args.id) {
+            return {
+                success: false,
+                operation: 'get',
+                dataType: 'capabilities',
+                error: {
+                    message: 'Missing required parameter: id',
+                    details: 'Specify id to retrieve capability data',
+                    example: { id: 'capability-id-example' }
+                }
+            };
+        }
+        // Get capability by ID
+        const capability = await capabilityService.getCapability(args.id);
+        if (!capability) {
+            logger.warn('Capability not found', {
+                requestId,
+                capabilityId: args.id
+            });
+            return {
+                success: false,
+                operation: 'get',
+                dataType: 'capabilities',
+                error: {
+                    message: `Capability not found for ID: ${args.id}`,
+                    details: 'Resource capability may not have been scanned yet',
+                    suggestion: 'Use scan operation to analyze this resource first'
+                }
+            };
+        }
+        logger.info('Capability retrieved successfully', {
+            requestId,
+            capabilityId: args.id,
+            resourceName: capability.resourceName,
+            capabilitiesFound: capability.capabilities.length,
+            confidence: capability.confidence
+        });
+        return {
+            success: true,
+            operation: 'get',
+            dataType: 'capabilities',
+            data: capability,
+            message: `Retrieved capability data for ${capability.resourceName} (ID: ${args.id})`,
+            clientInstructions: {
+                behavior: 'Display comprehensive capability details in organized sections',
+                requirement: 'Show resource name, capabilities, providers, complexity, use case, and confidence prominently',
+                format: 'Structured display with clear sections: Resource Info, Capabilities, Technical Details, and Analysis Results',
+                sections: {
+                    resourceInfo: 'Resource name and description with use case',
+                    capabilities: 'List all capabilities, providers, and abstractions clearly',
+                    technicalDetails: 'Complexity level and provider information',
+                    analysisResults: 'Confidence score, analysis timestamp, and ID for reference'
+                }
+            }
+        };
+    }
+    catch (error) {
+        logger.error('Failed to get capability', error, {
+            requestId,
+            capabilityId: args.id
+        });
+        return {
+            success: false,
+            operation: 'get',
+            dataType: 'capabilities',
+            error: {
+                message: 'Failed to retrieve capability',
+                details: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+/**
+ * Handle capability progress query (check progress of running scan)
+ */
+async function handleCapabilityProgress(args, logger, requestId) {
+    try {
+        logger.info('Capability progress query requested', {
+            requestId,
+            sessionId: args.sessionId
+        });
+        // Get session directory first
+        const sessionDir = (0, session_utils_1.getAndValidateSessionDirectory)(args, false);
+        let sessionId = args.sessionId;
+        let sessionFilePath;
+        // If no sessionId provided, auto-discover the latest session
+        if (!sessionId) {
+            logger.info('No sessionId provided, searching for latest session file', { requestId });
+            try {
+                // Check if capability-sessions subdirectory exists
+                const sessionSubDir = path.join(sessionDir, 'capability-sessions');
+                if (!fs.existsSync(sessionSubDir)) {
+                    logger.info('No capability-sessions directory found', { requestId, sessionDir });
+                    return {
+                        success: false,
+                        operation: 'progress',
+                        dataType: 'capabilities',
+                        error: {
+                            message: 'No capability scan sessions found',
+                            details: 'No capability-sessions directory found in the session directory',
+                            help: 'Start a new capability scan with the scan operation first',
+                            sessionDirectory: sessionDir
+                        }
+                    };
+                }
+                // Find all capability scan session files in the subdirectory
+                const sessionFiles = fs.readdirSync(sessionSubDir)
+                    .filter(file => file.endsWith('.json'))
+                    .map(file => {
+                    const filePath = path.join(sessionSubDir, file);
+                    const stats = fs.statSync(filePath);
+                    return {
+                        filename: file,
+                        path: filePath,
+                        mtime: stats.mtime,
+                        sessionId: file.replace('.json', '') // Remove .json extension to get sessionId
+                    };
+                })
+                    .sort((a, b) => b.mtime.getTime() - a.mtime.getTime()); // Sort by newest first
+                if (sessionFiles.length === 0) {
+                    logger.info('No capability scan session files found', { requestId, sessionDir });
+                    return {
+                        success: false,
+                        operation: 'progress',
+                        dataType: 'capabilities',
+                        error: {
+                            message: 'No capability scan sessions found',
+                            details: 'No active or recent capability scans found in the session directory',
+                            help: 'Start a new capability scan with the scan operation first',
+                            sessionDirectory: sessionDir
+                        }
+                    };
+                }
+                // Use the latest session (first after sorting)
+                const latestSession = sessionFiles[0];
+                sessionId = latestSession.sessionId;
+                sessionFilePath = latestSession.path;
+                logger.info('Using latest session file', {
+                    requestId,
+                    sessionId,
+                    totalSessions: sessionFiles.length,
+                    sessionFile: latestSession.filename
+                });
+            }
+            catch (error) {
+                logger.error('Failed to discover session files', error, { requestId, sessionDir });
+                return {
+                    success: false,
+                    operation: 'progress',
+                    dataType: 'capabilities',
+                    error: {
+                        message: 'Failed to discover session files',
+                        details: error instanceof Error ? error.message : String(error),
+                        sessionDirectory: sessionDir
+                    }
+                };
+            }
+        }
+        else {
+            // Use provided sessionId - look in capability-sessions subdirectory
+            const sessionSubDir = path.join(sessionDir, 'capability-sessions');
+            sessionFilePath = path.join(sessionSubDir, `${sessionId}.json`);
+            if (!fs.existsSync(sessionFilePath)) {
+                logger.warn('Session file not found for provided sessionId', {
+                    requestId,
+                    sessionId,
+                    filePath: sessionFilePath
+                });
+                return {
+                    success: false,
+                    operation: 'progress',
+                    dataType: 'capabilities',
+                    error: {
+                        message: 'Session not found',
+                        details: `No capability scan found for session: ${sessionId}`,
+                        help: 'Use the scan operation to start a new capability scan, or omit sessionId to use the latest session'
+                    }
+                };
+            }
+        }
+        // Read and parse session file
+        const sessionData = JSON.parse(fs.readFileSync(sessionFilePath, 'utf8'));
+        // Extract progress information
+        const progress = sessionData.progress;
+        if (!progress) {
+            return {
+                success: true,
+                operation: 'progress',
+                dataType: 'capabilities',
+                sessionId: sessionId,
+                status: 'no-progress-data',
+                message: 'Session exists but no progress tracking is active',
+                currentStep: sessionData.currentStep,
+                startedAt: sessionData.startedAt,
+                lastActivity: sessionData.lastActivity
+            };
+        }
+        // Build comprehensive progress response
+        const response = {
+            success: true,
+            operation: 'progress',
+            dataType: 'capabilities',
+            sessionId: sessionId,
+            progress: {
+                status: progress.status,
+                current: progress.current,
+                total: progress.total,
+                percentage: progress.percentage,
+                currentResource: progress.currentResource,
+                startedAt: progress.startedAt,
+                lastUpdated: progress.lastUpdated
+            },
+            sessionInfo: {
+                currentStep: sessionData.currentStep,
+                processingMode: sessionData.processingMode,
+                resourceCount: Array.isArray(sessionData.selectedResources)
+                    ? sessionData.selectedResources.length
+                    : (sessionData.selectedResources === 'all' ? 'all resources' : 'unknown'),
+                startedAt: sessionData.startedAt,
+                lastActivity: sessionData.lastActivity
+            }
+        };
+        // Add completion information if scan is done
+        if (progress.status === 'completed') {
+            response.progress.completedAt = progress.completedAt;
+            response.progress.totalProcessingTime = progress.totalProcessingTime;
+            response.message = 'Capability scan completed successfully';
+        }
+        else {
+            response.progress.estimatedTimeRemaining = progress.estimatedTimeRemaining;
+            response.message = `Capability scan in progress: ${progress.current}/${progress.total} resources processed`;
+        }
+        // Add user-friendly display information with client formatting instructions
+        response.display = {
+            summary: progress.status === 'completed'
+                ? `✅ Scan complete: processed ${progress.total} resources in ${progress.totalProcessingTime}`
+                : `⏳ Processing: ${progress.current}/${progress.total} (${progress.percentage}%) - ${progress.estimatedTimeRemaining} remaining`,
+            currentResource: progress.currentResource,
+            timeline: {
+                started: progress.startedAt,
+                lastUpdate: progress.lastUpdated,
+                ...(progress.completedAt && { completed: progress.completedAt })
+            }
+        };
+        // Add client instructions for readable formatting
+        response.clientInstructions = {
+            behavior: 'Display capability scan progress in a clean, readable format',
+            requirement: 'Show progress information in separate lines, not as a single condensed line',
+            format: progress.status === 'completed'
+                ? 'Completion format: Status, total processed, processing time on separate lines'
+                : 'Progress format: Status line, current resource line, time estimates line, timestamps line',
+            example: progress.status === 'completed'
+                ? '✅ Capability Scan Complete\\n📊 Processed: X resources\\n⏰ Processing time: X minutes'
+                : '⏳ Progress: X/Y resources (Z%)\\n📊 Current resource: ResourceName\\n⏰ Est. remaining: X minutes\\n🕒 Started: timestamp\\n🔄 Last updated: timestamp',
+            prohibit: 'Do not display all progress information on a single line'
+        };
+        logger.info('Progress query completed successfully', {
+            requestId,
+            sessionId: args.sessionId,
+            status: progress.status,
+            percentage: progress.percentage
+        });
+        return response;
+    }
+    catch (error) {
+        logger.error('Failed to query capability progress', error, {
+            requestId,
+            sessionId: args.sessionId
+        });
+        return {
+            success: false,
+            operation: 'progress',
+            dataType: 'capabilities',
+            error: {
+                message: 'Failed to query scan progress',
+                details: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+/**
+ * Handle capability deletion (delete single capability by ID)
+ */
+async function handleCapabilityDelete(args, logger, requestId, capabilityService) {
+    try {
+        // Validate required parameters
+        if (!args.id) {
+            return {
+                success: false,
+                operation: 'delete',
+                dataType: 'capabilities',
+                error: {
+                    message: 'Missing required parameter: id',
+                    details: 'Specify id to delete capability data',
+                    example: { id: 'capability-id-example' }
+                }
+            };
+        }
+        // Check if capability exists before deletion
+        const capability = await capabilityService.getCapability(args.id);
+        if (!capability) {
+            logger.warn('Capability not found for deletion', {
+                requestId,
+                capabilityId: args.id
+            });
+            return {
+                success: false,
+                operation: 'delete',
+                dataType: 'capabilities',
+                error: {
+                    message: `Capability not found for ID: ${args.id}`,
+                    details: 'Cannot delete capability that does not exist'
+                }
+            };
+        }
+        // Delete capability by ID
+        await capabilityService.deleteCapabilityById(args.id);
+        logger.info('Capability deleted successfully', {
+            requestId,
+            capabilityId: args.id,
+            resourceName: capability.resourceName
+        });
+        return {
+            success: true,
+            operation: 'delete',
+            dataType: 'capabilities',
+            deletedCapability: {
+                id: args.id,
+                resourceName: capability.resourceName
+            },
+            message: `Capability deleted: ${capability.resourceName}`
+        };
+    }
+    catch (error) {
+        logger.error('Failed to delete capability', error, {
+            requestId,
+            capabilityId: args.id
+        });
+        return {
+            success: false,
+            operation: 'delete',
+            dataType: 'capabilities',
+            error: {
+                message: 'Failed to delete capability',
+                details: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+/**
+ * Handle capability bulk deletion (delete all capabilities)
+ */
+async function handleCapabilityDeleteAll(args, logger, requestId, capabilityService) {
+    try {
+        // Get count first to provide feedback (but don't retrieve all data)
+        const totalCount = await capabilityService.getCapabilitiesCount();
+        if (totalCount === 0) {
+            logger.info('No capabilities found to delete', { requestId });
+            return {
+                success: true,
+                operation: 'deleteAll',
+                dataType: 'capabilities',
+                deletedCount: 0,
+                totalCount: 0,
+                message: 'No capabilities found to delete'
+            };
+        }
+        logger.info('Starting efficient bulk capability deletion', {
+            requestId,
+            totalCapabilities: totalCount,
+            method: 'collection recreation'
+        });
+        // Efficiently delete all capabilities by recreating collection
+        await capabilityService.deleteAllCapabilities();
+        logger.info('Bulk capability deletion completed successfully', {
+            requestId,
+            deleted: totalCount,
+            method: 'collection recreation'
+        });
+        return {
+            success: true,
+            operation: 'deleteAll',
+            dataType: 'capabilities',
+            deletedCount: totalCount,
+            totalCount,
+            errorCount: 0,
+            message: `Successfully deleted all ${totalCount} capabilities`,
+            confirmation: 'All capability data has been permanently removed from the Vector DB',
+            method: 'Efficient collection recreation (no individual record retrieval)'
+        };
+    }
+    catch (error) {
+        logger.error('Failed to delete all capabilities', error, {
+            requestId
+        });
+        return {
+            success: false,
+            operation: 'deleteAll',
+            dataType: 'capabilities',
+            error: {
+                message: 'Failed to delete all capabilities',
+                details: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+/**
+ * Handle capability search operation
+ */
+async function handleCapabilitySearch(args, logger, requestId, capabilityService) {
+    try {
+        // Validate required search query (stored in id field)
+        if (!args.id || typeof args.id !== 'string' || args.id.trim() === '') {
+            return {
+                success: false,
+                operation: 'search',
+                dataType: 'capabilities',
+                error: {
+                    message: 'Search query required',
+                    details: 'The id field must contain a search query (e.g., "postgresql database in azure")'
+                }
+            };
+        }
+        const searchQuery = args.id.trim();
+        const limit = args.limit || 25;
+        logger.info('Searching capabilities', {
+            requestId,
+            query: searchQuery,
+            limit
+        });
+        // Perform the search using existing service
+        const searchResults = await capabilityService.searchCapabilities(searchQuery, { limit });
+        // Format results for user display
+        const formattedResults = searchResults.map((result, index) => ({
+            rank: index + 1,
+            score: Math.round(result.score * 100) / 100, // Round to 2 decimal places
+            id: capabilities_1.CapabilityInferenceEngine.generateCapabilityId(result.data.resourceName),
+            resourceName: result.data.resourceName,
+            capabilities: result.data.capabilities,
+            providers: result.data.providers,
+            complexity: result.data.complexity,
+            description: result.data.description,
+            useCase: result.data.useCase,
+            confidence: result.data.confidence,
+            analyzedAt: result.data.analyzedAt
+        }));
+        logger.info('Capability search completed', {
+            requestId,
+            query: searchQuery,
+            resultsFound: searchResults.length,
+            limit
+        });
+        return {
+            success: true,
+            operation: 'search',
+            dataType: 'capabilities',
+            data: {
+                query: searchQuery,
+                results: formattedResults,
+                resultCount: searchResults.length,
+                limit
+            },
+            message: `Found ${searchResults.length} capabilities matching "${searchQuery}"`,
+            clientInstructions: {
+                behavior: 'Display search results with relevance scores and capability details',
+                sections: {
+                    searchSummary: 'Show query and result count prominently',
+                    resultsList: 'Display each result with rank, score, resource name, and capabilities',
+                    capabilityDetails: 'Include providers, complexity, and description for context',
+                    actionGuidance: 'Show IDs for get operations and suggest refinement if needed'
+                },
+                format: 'Ranked list with scores (higher scores = better matches)',
+                emphasize: 'Resource names and main capabilities for easy scanning'
+            }
+        };
+    }
+    catch (error) {
+        logger.error('Failed to search capabilities', error, {
+            requestId,
+            query: args.id
+        });
+        return {
+            success: false,
+            operation: 'search',
+            dataType: 'capabilities',
+            error: {
+                message: 'Capability search failed',
+                details: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
 /**
  * Main tool handler - routes to appropriate data type handler
  */
@@ -515,15 +2180,12 @@ async function handleOrganizationalDataTool(args, _dotAI, logger, requestId) {
             case 'capabilities':
                 result = await handleCapabilitiesOperation(args.operation, args, logger, requestId);
                 break;
-            case 'dependencies':
-                result = await handleDependenciesOperation(args.operation, args, logger, requestId);
-                break;
             default:
-                throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, `Unsupported data type: ${args.dataType}. Currently supported: pattern, capabilities, dependencies`, {
+                throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, `Unsupported data type: ${args.dataType}. Currently supported: pattern, capabilities`, {
                     operation: 'data_type_validation',
                     component: 'OrganizationalDataTool',
                     requestId,
-                    input: { dataType: args.dataType, supportedTypes: ['pattern', 'capabilities', 'dependencies'] }
+                    input: { dataType: args.dataType, supportedTypes: ['pattern', 'capabilities'] }
                 });
         }
         logger.info('Organizational-data tool request completed successfully', {