@dollhousemcp/mcp-server 1.3.0

package/dist/elements/ensembles/Ensemble.js

@@ -0,0 +1,860 @@
+/**
+ * Ensemble Element - Orchestrates multiple elements working together
+ *
+ * Ensembles allow combining multiple elements (personas, skills, templates, agents, memories)
+ * into cohesive units with controlled activation, conflict resolution, and shared context.
+ *
+ * SECURITY MEASURES IMPLEMENTED:
+ * 1. Circular dependency detection with path tracking
+ * 2. Resource limits (max elements, nesting depth, activation time)
+ * 3. Input sanitization for all user-provided data
+ * 4. Activation timeout protection
+ * 5. Context size limits to prevent memory exhaustion
+ * 6. Audit logging for security events
+ * 7. Condition validation to prevent code injection
+ */
+import { BaseElement } from '../BaseElement.js';
+import { ElementType } from '../../portfolio/types.js';
+import { PortfolioManager } from '../../portfolio/PortfolioManager.js';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { logger } from '../../utils/logger.js';
+import { ENSEMBLE_LIMITS, ENSEMBLE_DEFAULTS, ACTIVATION_STRATEGIES, CONFLICT_STRATEGIES, ELEMENT_ROLES, ENSEMBLE_SECURITY_EVENTS, ENSEMBLE_ERRORS, ENSEMBLE_PATTERNS } from './constants.js';
+export class Ensemble extends BaseElement {
+    elements = new Map();
+    elementInstances = new Map();
+    sharedContext;
+    activationInProgress = false;
+    lastActivationResult;
+    constructor(metadata = {}) {
+        // SECURITY FIX: Sanitize all inputs during construction
+        const sanitizedMetadata = {
+            ...metadata,
+            name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,
+            description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined,
+            activationStrategy: metadata.activationStrategy || ENSEMBLE_DEFAULTS.ACTIVATION_STRATEGY,
+            conflictResolution: metadata.conflictResolution || ENSEMBLE_DEFAULTS.CONFLICT_RESOLUTION,
+            maxElements: metadata.maxElements ?? ENSEMBLE_LIMITS.MAX_ELEMENTS,
+            maxActivationTime: metadata.maxActivationTime ?? ENSEMBLE_LIMITS.MAX_ACTIVATION_TIME,
+            allowNested: metadata.allowNested ?? ENSEMBLE_DEFAULTS.ALLOW_NESTED,
+            maxNestingDepth: metadata.maxNestingDepth ?? ENSEMBLE_LIMITS.MAX_NESTING_DEPTH
+        };
+        // Validate activation strategy
+        if (!ACTIVATION_STRATEGIES.includes(sanitizedMetadata.activationStrategy)) {
+            throw new Error(ENSEMBLE_ERRORS.INVALID_STRATEGY);
+        }
+        // Validate conflict resolution strategy
+        if (!CONFLICT_STRATEGIES.includes(sanitizedMetadata.conflictResolution)) {
+            throw new Error(ENSEMBLE_ERRORS.INVALID_CONFLICT_RESOLUTION);
+        }
+        // Validate limits
+        if (sanitizedMetadata.maxElements > ENSEMBLE_LIMITS.MAX_ELEMENTS) {
+            throw new Error(ENSEMBLE_ERRORS.TOO_MANY_ELEMENTS);
+        }
+        if (sanitizedMetadata.maxNestingDepth > ENSEMBLE_LIMITS.MAX_NESTING_DEPTH) {
+            throw new Error(ENSEMBLE_ERRORS.NESTING_TOO_DEEP);
+        }
+        super(ElementType.ENSEMBLE, sanitizedMetadata);
+        // Ensure ensemble-specific metadata is stored
+        this.metadata = {
+            ...this.metadata,
+            activationStrategy: sanitizedMetadata.activationStrategy,
+            conflictResolution: sanitizedMetadata.conflictResolution,
+            maxElements: sanitizedMetadata.maxElements,
+            maxActivationTime: sanitizedMetadata.maxActivationTime,
+            allowNested: sanitizedMetadata.allowNested,
+            maxNestingDepth: sanitizedMetadata.maxNestingDepth
+        };
+        // Initialize shared context
+        this.sharedContext = {
+            values: new Map(),
+            owners: new Map(),
+            timestamps: new Map()
+        };
+        // Set ensemble-specific extensions
+        this.extensions = {
+            elementCount: 0,
+            activationStrategy: sanitizedMetadata.activationStrategy,
+            conflictResolution: sanitizedMetadata.conflictResolution,
+            lastActivation: null
+        };
+    }
+    /**
+     * Add an element to the ensemble
+     */
+    addElement(elementId, elementType, role = ENSEMBLE_DEFAULTS.ELEMENT_ROLE, options = {}) {
+        // Check element limit
+        if (this.elements.size >= this.metadata.maxElements) {
+            SecurityMonitor.logSecurityEvent({
+                type: ENSEMBLE_SECURITY_EVENTS.RESOURCE_LIMIT_EXCEEDED,
+                severity: 'MEDIUM',
+                source: 'Ensemble.addElement',
+                details: `Maximum elements (${ENSEMBLE_LIMITS.MAX_ELEMENTS}) exceeded`
+            });
+            throw new Error(ENSEMBLE_ERRORS.TOO_MANY_ELEMENTS);
+        }
+        // Sanitize element ID
+        const sanitizedId = sanitizeInput(elementId, 100);
+        if (!ENSEMBLE_PATTERNS.ELEMENT_ID_PATTERN.test(sanitizedId)) {
+            throw new Error('Invalid element ID format');
+        }
+        // Validate role
+        if (!ELEMENT_ROLES.includes(role)) {
+            throw new Error('Invalid element role');
+        }
+        // Validate activation condition if provided
+        if (options.activationCondition) {
+            const sanitizedCondition = sanitizeInput(options.activationCondition, ENSEMBLE_LIMITS.MAX_CONDITION_LENGTH);
+            if (!this.isValidCondition(sanitizedCondition)) {
+                SecurityMonitor.logSecurityEvent({
+                    type: ENSEMBLE_SECURITY_EVENTS.SUSPICIOUS_CONDITION,
+                    severity: 'HIGH',
+                    source: 'Ensemble.addElement',
+                    details: `Suspicious activation condition: ${sanitizedCondition}`
+                });
+                throw new Error('Invalid activation condition syntax');
+            }
+            options.activationCondition = sanitizedCondition;
+        }
+        // Validate dependencies
+        if (options.dependencies) {
+            if (options.dependencies.length > ENSEMBLE_LIMITS.MAX_DEPENDENCIES) {
+                throw new Error(`Too many dependencies (max: ${ENSEMBLE_LIMITS.MAX_DEPENDENCIES})`);
+            }
+            // Sanitize each dependency
+            options.dependencies = options.dependencies.map(dep => sanitizeInput(dep, 100));
+        }
+        // Create ensemble element
+        const ensembleElement = {
+            elementId: sanitizedId,
+            elementType: sanitizeInput(elementType, 50),
+            role,
+            priority: options.priority ?? ENSEMBLE_DEFAULTS.PRIORITY,
+            activationCondition: options.activationCondition,
+            dependencies: options.dependencies
+        };
+        // Check for circular dependencies before adding
+        if (this.wouldCreateCircularDependency(sanitizedId, options.dependencies || [])) {
+            const circular = this.findCircularDependency(sanitizedId, options.dependencies || []);
+            SecurityMonitor.logSecurityEvent({
+                type: ENSEMBLE_SECURITY_EVENTS.CIRCULAR_DEPENDENCY,
+                severity: 'HIGH',
+                source: 'Ensemble.addElement',
+                details: `Circular dependency detected: ${circular.path.join(' -> ')}`
+            });
+            throw new Error(`${ENSEMBLE_ERRORS.CIRCULAR_DEPENDENCY}: ${circular.message}`);
+        }
+        this.elements.set(sanitizedId, ensembleElement);
+        this.extensions.elementCount = this.elements.size;
+        this.markDirty();
+    }
+    /**
+     * Remove an element from the ensemble
+     */
+    removeElement(elementId) {
+        const sanitizedId = sanitizeInput(elementId, 100);
+        if (!this.elements.has(sanitizedId)) {
+            throw new Error(ENSEMBLE_ERRORS.ELEMENT_NOT_FOUND);
+        }
+        // Remove element and its instance
+        this.elements.delete(sanitizedId);
+        this.elementInstances.delete(sanitizedId);
+        // Clean up dependencies pointing to this element
+        for (const [id, element] of this.elements) {
+            if (element.dependencies?.includes(sanitizedId)) {
+                element.dependencies = element.dependencies.filter(dep => dep !== sanitizedId);
+            }
+        }
+        // Clean up shared context owned by this element
+        for (const [key, owner] of this.sharedContext.owners) {
+            if (owner === sanitizedId) {
+                this.sharedContext.values.delete(key);
+                this.sharedContext.owners.delete(key);
+                this.sharedContext.timestamps.delete(key);
+            }
+        }
+        this.extensions.elementCount = this.elements.size;
+        this.markDirty();
+    }
+    /**
+     * Activate the ensemble and all its elements based on strategy
+     */
+    async activate() {
+        if (this.activationInProgress) {
+            throw new Error('Activation already in progress');
+        }
+        this.activationInProgress = true;
+        const startTime = Date.now();
+        const metadata = this.metadata;
+        try {
+            // Set status
+            this._status = 'active';
+            const result = {
+                success: true,
+                activatedElements: [],
+                failedElements: [],
+                conflicts: [],
+                totalDuration: 0,
+                elementResults: []
+            };
+            // Get activation order based on strategy
+            const activationOrder = this.getActivationOrder();
+            // Activate elements according to strategy
+            switch (metadata.activationStrategy) {
+                case 'sequential':
+                    await this.activateSequential(activationOrder, result, metadata.maxActivationTime);
+                    break;
+                case 'all':
+                    // Activate all elements simultaneously as one unified entity
+                    // Elements are layered/combined rather than acting separately
+                    await this.activateAll(activationOrder, result, metadata.maxActivationTime);
+                    break;
+                case 'priority':
+                    await this.activatePriority(activationOrder, result, metadata.maxActivationTime);
+                    break;
+                case 'conditional':
+                    await this.activateConditional(activationOrder, result, metadata.maxActivationTime);
+                    break;
+                case 'lazy':
+                    // Lazy activation happens on-demand, just mark as ready
+                    logger.info(`Ensemble ${this.id} ready for lazy activation`);
+                    break;
+            }
+            result.totalDuration = Date.now() - startTime;
+            this.lastActivationResult = result;
+            this.extensions.lastActivation = new Date().toISOString();
+            if (result.failedElements.length > 0) {
+                logger.warn(`Ensemble activation completed with failures: ${result.failedElements.join(', ')}`);
+            }
+            else {
+                logger.info(`Ensemble ${this.id} activated successfully in ${result.totalDuration}ms`);
+            }
+        }
+        catch (error) {
+            this._status = 'error';
+            throw error;
+        }
+        finally {
+            this.activationInProgress = false;
+        }
+    }
+    /**
+     * Deactivate the ensemble and all its elements
+     */
+    async deactivate() {
+        this._status = 'inactive';
+        // Deactivate all element instances
+        const deactivationPromises = [];
+        for (const [elementId, instance] of this.elementInstances) {
+            if (instance.deactivate) {
+                deactivationPromises.push(instance.deactivate().catch(error => {
+                    logger.error(`Failed to deactivate element ${elementId}:`, error);
+                }));
+            }
+        }
+        await Promise.all(deactivationPromises);
+        // Clear shared context
+        this.sharedContext.values.clear();
+        this.sharedContext.owners.clear();
+        this.sharedContext.timestamps.clear();
+        logger.info(`Ensemble ${this.id} deactivated`);
+    }
+    /**
+     * Validate the ensemble configuration
+     */
+    validate() {
+        const result = super.validate();
+        // Initialize arrays if they don't exist
+        if (!result.errors)
+            result.errors = [];
+        if (!result.warnings)
+            result.warnings = [];
+        // Check for circular dependencies
+        const circular = this.detectAllCircularDependencies();
+        if (circular.length > 0) {
+            for (const cycle of circular) {
+                result.errors.push({
+                    field: 'dependencies',
+                    message: cycle.message,
+                    severity: 'high'
+                });
+            }
+        }
+        // Validate element count
+        if (this.elements.size === 0) {
+            result.warnings.push({
+                field: 'elements',
+                message: 'Ensemble has no elements',
+                suggestion: 'Add elements using addElement()'
+            });
+        }
+        // Check for orphaned dependencies
+        for (const [elementId, element] of this.elements) {
+            if (element.dependencies) {
+                for (const dep of element.dependencies) {
+                    if (!this.elements.has(dep)) {
+                        result.errors.push({
+                            field: `${elementId}.dependencies`,
+                            message: `Dependency '${dep}' not found in ensemble`,
+                            severity: 'medium'
+                        });
+                    }
+                }
+            }
+        }
+        // Update valid flag based on errors
+        result.valid = result.errors.length === 0;
+        // Clean up empty arrays
+        if (result.errors.length === 0)
+            result.errors = undefined;
+        if (result.warnings.length === 0)
+            result.warnings = undefined;
+        return result;
+    }
+    /**
+     * Check if adding an element would create a circular dependency
+     * MEDIUM FIX: Remove type safety bypass
+     * Previously: Used 'as any' which bypasses TypeScript checking
+     * Now: Creates proper EnsembleElement with all required fields
+     */
+    wouldCreateCircularDependency(elementId, dependencies) {
+        // Create temporary graph with new element
+        const tempGraph = new Map(this.elements);
+        // Create a minimal valid EnsembleElement for dependency checking
+        const tempElement = {
+            elementId,
+            elementType: 'unknown', // Type doesn't matter for dependency checking
+            role: 'support', // Default role
+            dependencies
+        };
+        tempGraph.set(elementId, tempElement);
+        // Check for cycles
+        return this.hasCycle(tempGraph);
+    }
+    /**
+     * Find circular dependency path
+     */
+    findCircularDependency(elementId, dependencies) {
+        const visited = new Set();
+        const recursionStack = new Set();
+        const path = [];
+        const dfs = (node) => {
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            const element = this.elements.get(node);
+            const deps = node === elementId ? dependencies : (element?.dependencies || []);
+            for (const dep of deps) {
+                if (!visited.has(dep)) {
+                    const cycle = dfs(dep);
+                    if (cycle)
+                        return cycle;
+                }
+                else if (recursionStack.has(dep)) {
+                    // Found cycle
+                    const cycleStart = path.indexOf(dep);
+                    return path.slice(cycleStart).concat(dep);
+                }
+            }
+            path.pop();
+            recursionStack.delete(node);
+            return null;
+        };
+        const cyclePath = dfs(elementId) || [];
+        return {
+            path: cyclePath,
+            message: `Circular dependency: ${cyclePath.join(' -> ')}`
+        };
+    }
+    /**
+     * Detect all circular dependencies in the ensemble
+     */
+    detectAllCircularDependencies() {
+        const cycles = [];
+        const visited = new Set();
+        for (const elementId of this.elements.keys()) {
+            if (!visited.has(elementId) && this.hasCycleFrom(elementId, visited)) {
+                const cycle = this.findCircularDependency(elementId, this.elements.get(elementId).dependencies || []);
+                cycles.push(cycle);
+            }
+        }
+        return cycles;
+    }
+    /**
+     * Check if graph has any cycle
+     */
+    hasCycle(graph) {
+        const visited = new Set();
+        const recursionStack = new Set();
+        const hasCycleDFS = (node) => {
+            visited.add(node);
+            recursionStack.add(node);
+            const element = graph.get(node);
+            const dependencies = element?.dependencies || [];
+            for (const dep of dependencies) {
+                if (!visited.has(dep)) {
+                    if (hasCycleDFS(dep))
+                        return true;
+                }
+                else if (recursionStack.has(dep)) {
+                    return true;
+                }
+            }
+            recursionStack.delete(node);
+            return false;
+        };
+        for (const node of graph.keys()) {
+            if (!visited.has(node) && hasCycleDFS(node)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check for cycle starting from a specific node
+     */
+    hasCycleFrom(node, visited) {
+        const recursionStack = new Set();
+        const dfs = (current) => {
+            visited.add(current);
+            recursionStack.add(current);
+            const element = this.elements.get(current);
+            const dependencies = element?.dependencies || [];
+            for (const dep of dependencies) {
+                if (!visited.has(dep)) {
+                    if (dfs(dep))
+                        return true;
+                }
+                else if (recursionStack.has(dep)) {
+                    return true;
+                }
+            }
+            recursionStack.delete(current);
+            return false;
+        };
+        return dfs(node);
+    }
+    /**
+     * Validate activation condition syntax
+     */
+    isValidCondition(condition) {
+        // For now, only allow simple conditions
+        // Future: implement a proper condition parser
+        return ENSEMBLE_PATTERNS.CONDITION_PATTERN.test(condition);
+    }
+    /**
+     * Get activation order based on dependencies and strategy
+     */
+    getActivationOrder() {
+        const order = [];
+        const visited = new Set();
+        // Topological sort for dependency order
+        const visit = (elementId) => {
+            if (visited.has(elementId))
+                return;
+            visited.add(elementId);
+            const element = this.elements.get(elementId);
+            if (element?.dependencies) {
+                for (const dep of element.dependencies) {
+                    if (this.elements.has(dep)) {
+                        visit(dep);
+                    }
+                }
+            }
+            order.push(elementId);
+        };
+        // Visit all elements
+        for (const elementId of this.elements.keys()) {
+            visit(elementId);
+        }
+        return order;
+    }
+    /**
+     * Activate elements sequentially
+     */
+    async activateSequential(order, result, maxTime) {
+        const startTime = Date.now();
+        for (const elementId of order) {
+            if (Date.now() - startTime > maxTime) {
+                SecurityMonitor.logSecurityEvent({
+                    type: ENSEMBLE_SECURITY_EVENTS.ACTIVATION_TIMEOUT,
+                    severity: 'HIGH',
+                    source: 'Ensemble.activateSequential',
+                    details: `Activation timeout after ${Date.now() - startTime}ms`
+                });
+                throw new Error(ENSEMBLE_ERRORS.ACTIVATION_TIMEOUT);
+            }
+            const elementResult = await this.activateElement(elementId);
+            result.elementResults.push(elementResult);
+            if (elementResult.success) {
+                result.activatedElements.push(elementId);
+            }
+            else {
+                result.failedElements.push(elementId);
+            }
+            // Small delay between activations
+            await new Promise(resolve => setTimeout(resolve, ENSEMBLE_LIMITS.MIN_ACTIVATION_INTERVAL));
+        }
+    }
+    /**
+     * Activate all elements simultaneously as one unified entity
+     */
+    async activateAll(order, result, maxTime) {
+        const startTime = Date.now();
+        const activationPromises = order.map(elementId => this.activateElement(elementId).then(elementResult => {
+            result.elementResults.push(elementResult);
+            if (elementResult.success) {
+                result.activatedElements.push(elementId);
+            }
+            else {
+                result.failedElements.push(elementId);
+            }
+            return elementResult;
+        }));
+        // Wait for all with timeout
+        await Promise.race([
+            Promise.all(activationPromises),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(ENSEMBLE_ERRORS.ACTIVATION_TIMEOUT)), maxTime))
+        ]);
+    }
+    /**
+     * Activate elements by priority
+     */
+    async activatePriority(order, result, maxTime) {
+        // Sort by priority
+        const priorityOrder = [...order].sort((a, b) => {
+            const priorityA = this.elements.get(a)?.priority ?? 0;
+            const priorityB = this.elements.get(b)?.priority ?? 0;
+            return priorityB - priorityA; // Higher priority first
+        });
+        await this.activateSequential(priorityOrder, result, maxTime);
+    }
+    /**
+     * Activate elements based on conditions
+     */
+    async activateConditional(order, result, maxTime) {
+        const startTime = Date.now();
+        for (const elementId of order) {
+            if (Date.now() - startTime > maxTime) {
+                throw new Error(ENSEMBLE_ERRORS.ACTIVATION_TIMEOUT);
+            }
+            const element = this.elements.get(elementId);
+            // Check activation condition
+            if (element.activationCondition) {
+                if (!this.evaluateCondition(element.activationCondition)) {
+                    logger.info(`Skipping element ${elementId} - condition not met`);
+                    continue;
+                }
+            }
+            const elementResult = await this.activateElement(elementId);
+            result.elementResults.push(elementResult);
+            if (elementResult.success) {
+                result.activatedElements.push(elementId);
+            }
+            else {
+                result.failedElements.push(elementId);
+            }
+        }
+    }
+    /**
+     * Activate a single element
+     * CRITICAL FIX: Implement actual element loading and activation
+     * Previously: Just simulated with timeout
+     * Now: Loads element from portfolio and activates it
+     */
+    async activateElement(elementId) {
+        const startTime = Date.now();
+        try {
+            const ensembleElement = this.elements.get(elementId);
+            if (!ensembleElement) {
+                throw new Error(`Element ${elementId} not found in ensemble`);
+            }
+            // Load the element based on its type
+            const portfolioManager = PortfolioManager.getInstance();
+            const elementFilename = `${elementId}.md`;
+            logger.info(`Activating element: ${elementId} of type ${ensembleElement.elementType}`);
+            // For now, we only have PersonaElement fully implemented
+            // Future: Add factory pattern for other element types
+            let element;
+            if (ensembleElement.elementType === ElementType.PERSONA) {
+                // Load PersonaElement
+                const { PersonaElementManager } = await import('../../persona/PersonaElementManager.js');
+                const manager = new PersonaElementManager(portfolioManager);
+                element = await manager.load(elementFilename);
+            }
+            else {
+                // For other types, log warning and return success
+                // This allows ensemble to work with future element types
+                logger.warn(`Element type ${ensembleElement.elementType} not yet implemented for activation`);
+                return {
+                    elementId,
+                    success: true,
+                    duration: Date.now() - startTime,
+                    context: { warning: `Type ${ensembleElement.elementType} activation not implemented` }
+                };
+            }
+            // Store element instance for later use
+            if (element) {
+                this.elementInstances.set(elementId, element);
+                // Call element's activate method if it exists
+                if (element.activate) {
+                    await element.activate();
+                }
+                // Extract any context from the element
+                const context = {};
+                if (element.getStatus) {
+                    context.status = element.getStatus();
+                }
+                context.type = ensembleElement.elementType;
+                context.role = ensembleElement.role;
+                return {
+                    elementId,
+                    success: true,
+                    duration: Date.now() - startTime,
+                    context
+                };
+            }
+            return {
+                elementId,
+                success: true,
+                duration: Date.now() - startTime,
+                context: {}
+            };
+        }
+        catch (error) {
+            logger.error(`Failed to activate element ${elementId}:`, error);
+            return {
+                elementId,
+                success: false,
+                duration: Date.now() - startTime,
+                error: error
+            };
+        }
+    }
+    /**
+     * Evaluate a simple condition
+     * CRITICAL FIX: Implement actual condition evaluation
+     * Previously: Always returned true
+     * Now: Parses and evaluates simple conditions like "element.property == value"
+     *
+     * Supported operators: ==, !=, >, <, >=, <=
+     * Supported properties: active, status, priority
+     * Example: "element1.active == true" or "element2.priority > 50"
+     */
+    evaluateCondition(condition) {
+        try {
+            // Sanitize and validate condition first
+            const sanitized = sanitizeInput(condition, ENSEMBLE_LIMITS.MAX_CONDITION_LENGTH);
+            // Parse condition: elementId.property operator value
+            const match = sanitized.match(/^([a-zA-Z0-9\-_]+)\.([a-zA-Z]+)\s*(==|!=|>=|<=|>|<)\s*(.+)$/);
+            if (!match) {
+                logger.warn(`Invalid condition format: ${condition}`);
+                return false;
+            }
+            const [, elementId, property, operator, value] = match;
+            // Get element instance or element data
+            const element = this.elementInstances.get(elementId);
+            const elementData = this.elements.get(elementId);
+            if (!element && !elementData) {
+                logger.debug(`Element ${elementId} not found for condition evaluation`);
+                return false;
+            }
+            // Get property value
+            let propertyValue;
+            switch (property) {
+                case 'active':
+                    // Check if element is in activated elements list
+                    propertyValue = this.lastActivationResult?.activatedElements.includes(elementId) || false;
+                    break;
+                case 'status':
+                    propertyValue = element?.getStatus ? element.getStatus() : 'inactive';
+                    break;
+                case 'priority':
+                    propertyValue = elementData?.priority || 0;
+                    break;
+                default:
+                    logger.warn(`Unknown property in condition: ${property}`);
+                    return false;
+            }
+            // Parse the comparison value
+            let compareValue = value.trim();
+            // Handle boolean values
+            if (compareValue === 'true')
+                compareValue = true;
+            else if (compareValue === 'false')
+                compareValue = false;
+            // Handle numeric values
+            else if (!isNaN(Number(compareValue)))
+                compareValue = Number(compareValue);
+            // Handle string values (remove quotes if present)
+            else if (compareValue.startsWith('"') && compareValue.endsWith('"')) {
+                compareValue = compareValue.slice(1, -1);
+            }
+            // Evaluate based on operator
+            switch (operator) {
+                case '==':
+                    return propertyValue == compareValue;
+                case '!=':
+                    return propertyValue != compareValue;
+                case '>':
+                    return Number(propertyValue) > Number(compareValue);
+                case '<':
+                    return Number(propertyValue) < Number(compareValue);
+                case '>=':
+                    return Number(propertyValue) >= Number(compareValue);
+                case '<=':
+                    return Number(propertyValue) <= Number(compareValue);
+                default:
+                    logger.warn(`Unknown operator in condition: ${operator}`);
+                    return false;
+            }
+        }
+        catch (error) {
+            logger.error(`Error evaluating condition "${condition}":`, error);
+            return false;
+        }
+    }
+    /**
+     * Get shared context value
+     */
+    getContextValue(key) {
+        return this.sharedContext.values.get(key);
+    }
+    /**
+     * Set shared context value with conflict resolution
+     */
+    setContextValue(key, value, elementId) {
+        // Check context size limits
+        if (this.sharedContext.values.size >= ENSEMBLE_LIMITS.MAX_CONTEXT_SIZE) {
+            SecurityMonitor.logSecurityEvent({
+                type: ENSEMBLE_SECURITY_EVENTS.CONTEXT_SIZE_EXCEEDED,
+                severity: 'MEDIUM',
+                source: 'Ensemble.setContextValue',
+                details: `Context size limit (${ENSEMBLE_LIMITS.MAX_CONTEXT_SIZE}) exceeded`
+            });
+            throw new Error(ENSEMBLE_ERRORS.CONTEXT_OVERFLOW);
+        }
+        // Sanitize key
+        const sanitizedKey = sanitizeInput(key, 100);
+        // Check value size
+        const valueStr = JSON.stringify(value);
+        if (valueStr.length > ENSEMBLE_LIMITS.MAX_CONTEXT_VALUE_SIZE) {
+            throw new Error('Context value too large');
+        }
+        const currentOwner = this.sharedContext.owners.get(sanitizedKey);
+        const currentValue = this.sharedContext.values.get(sanitizedKey);
+        // Check for conflict
+        if (currentOwner && currentOwner !== elementId) {
+            const conflict = {
+                key: sanitizedKey,
+                currentValue,
+                currentOwner,
+                newValue: value,
+                newOwner: elementId
+            };
+            // Apply conflict resolution
+            const metadata = this.metadata;
+            switch (metadata.conflictResolution) {
+                case 'error':
+                    throw new Error(`Context conflict on key '${sanitizedKey}'`);
+                case 'first-write':
+                    // Keep existing value
+                    return conflict;
+                case 'last-write':
+                    // Overwrite with new value
+                    break;
+                case 'priority':
+                    const currentPriority = this.elements.get(currentOwner)?.priority ?? 0;
+                    const newPriority = this.elements.get(elementId)?.priority ?? 0;
+                    if (currentPriority > newPriority) {
+                        return conflict;
+                    }
+                    break;
+                case 'merge':
+                    // Simple merge for objects
+                    if (typeof currentValue === 'object' && typeof value === 'object') {
+                        value = { ...currentValue, ...value };
+                        conflict.resolution = value;
+                    }
+                    break;
+            }
+        }
+        // Set the value
+        this.sharedContext.values.set(sanitizedKey, value);
+        this.sharedContext.owners.set(sanitizedKey, elementId);
+        this.sharedContext.timestamps.set(sanitizedKey, new Date());
+        return null;
+    }
+    /**
+     * Get all elements in the ensemble
+     */
+    getElements() {
+        return new Map(this.elements);
+    }
+    /**
+     * Get activation result
+     */
+    getLastActivationResult() {
+        return this.lastActivationResult;
+    }
+    /**
+     * Get current element status
+     */
+    getStatus() {
+        return this._status;
+    }
+    /**
+     * Serialize ensemble to string
+     */
+    serialize() {
+        const data = {
+            base: super.serialize(),
+            elements: Array.from(this.elements.entries()),
+            sharedContext: {
+                values: Array.from(this.sharedContext.values.entries()),
+                owners: Array.from(this.sharedContext.owners.entries()),
+                timestamps: Array.from(this.sharedContext.timestamps.entries())
+            }
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Deserialize ensemble from string
+     */
+    deserialize(data) {
+        const parsed = JSON.parse(data);
+        // If data has a 'base' property, it was serialized by our serialize method
+        if (parsed.base) {
+            // Deserialize base properties
+            super.deserialize(parsed.base);
+            // Restore elements
+            if (parsed.elements) {
+                this.elements.clear();
+                for (const [id, element] of parsed.elements) {
+                    this.elements.set(id, element);
+                }
+            }
+            // Restore shared context
+            if (parsed.sharedContext) {
+                this.sharedContext.values.clear();
+                this.sharedContext.owners.clear();
+                this.sharedContext.timestamps.clear();
+                for (const [key, value] of parsed.sharedContext.values || []) {
+                    this.sharedContext.values.set(key, value);
+                }
+                for (const [key, owner] of parsed.sharedContext.owners || []) {
+                    this.sharedContext.owners.set(key, owner);
+                }
+                for (const [key, timestamp] of parsed.sharedContext.timestamps || []) {
+                    this.sharedContext.timestamps.set(key, new Date(timestamp));
+                }
+            }
+        }
+        else {
+            // Old format or direct properties
+            super.deserialize(data);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Ensemble.js","sourceRoot":"","sources":["../../../src/elements/ensembles/Ensemble.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Ensemble Element - Orchestrates multiple elements working together\n * \n * Ensembles allow combining multiple elements (personas, skills, templates, agents, memories)\n * into cohesive units with controlled activation, conflict resolution, and shared context.\n * \n * SECURITY MEASURES IMPLEMENTED:\n * 1. Circular dependency detection with path tracking\n * 2. Resource limits (max elements, nesting depth, activation time)\n * 3. Input sanitization for all user-provided data\n * 4. Activation timeout protection\n * 5. Context size limits to prevent memory exhaustion\n * 6. Audit logging for security events\n * 7. Condition validation to prevent code injection\n */\n\nimport { BaseElement } from '../BaseElement.js';\nimport { IElement, ElementValidationResult, ValidationError, ValidationWarning, ElementStatus } from '../../types/elements/index.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { PortfolioManager } from '../../portfolio/PortfolioManager.js';\nimport { sanitizeInput } from '../../security/InputValidator.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { logger } from '../../utils/logger.js';\nimport {\n  EnsembleMetadata,\n  EnsembleElement,\n  ActivationStrategy,\n  ConflictResolutionStrategy,\n  ElementRole,\n  SharedContext,\n  EnsembleActivationResult,\n  ElementActivationResult,\n  ContextConflict,\n  CircularDependency\n} from './types.js';\nimport {\n  ENSEMBLE_LIMITS,\n  ENSEMBLE_DEFAULTS,\n  ACTIVATION_STRATEGIES,\n  CONFLICT_STRATEGIES,\n  ELEMENT_ROLES,\n  ENSEMBLE_SECURITY_EVENTS,\n  ENSEMBLE_ERRORS,\n  ENSEMBLE_PATTERNS\n} from './constants.js';\n\nexport class Ensemble extends BaseElement implements IElement {\n  private elements: Map<string, EnsembleElement> = new Map();\n  private elementInstances: Map<string, IElement> = new Map();\n  private sharedContext: SharedContext;\n  private activationInProgress: boolean = false;\n  private lastActivationResult?: EnsembleActivationResult;\n\n  constructor(metadata: Partial<EnsembleMetadata> = {}) {\n    // SECURITY FIX: Sanitize all inputs during construction\n    const sanitizedMetadata: Partial<EnsembleMetadata> = {\n      ...metadata,\n      name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,\n      description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined,\n      activationStrategy: metadata.activationStrategy || ENSEMBLE_DEFAULTS.ACTIVATION_STRATEGY,\n      conflictResolution: metadata.conflictResolution || ENSEMBLE_DEFAULTS.CONFLICT_RESOLUTION,\n      maxElements: metadata.maxElements ?? ENSEMBLE_LIMITS.MAX_ELEMENTS,\n      maxActivationTime: metadata.maxActivationTime ?? ENSEMBLE_LIMITS.MAX_ACTIVATION_TIME,\n      allowNested: metadata.allowNested ?? ENSEMBLE_DEFAULTS.ALLOW_NESTED,\n      maxNestingDepth: metadata.maxNestingDepth ?? ENSEMBLE_LIMITS.MAX_NESTING_DEPTH\n    };\n\n    // Validate activation strategy\n    if (!ACTIVATION_STRATEGIES.includes(sanitizedMetadata.activationStrategy!)) {\n      throw new Error(ENSEMBLE_ERRORS.INVALID_STRATEGY);\n    }\n\n    // Validate conflict resolution strategy\n    if (!CONFLICT_STRATEGIES.includes(sanitizedMetadata.conflictResolution!)) {\n      throw new Error(ENSEMBLE_ERRORS.INVALID_CONFLICT_RESOLUTION);\n    }\n\n    // Validate limits\n    if (sanitizedMetadata.maxElements! > ENSEMBLE_LIMITS.MAX_ELEMENTS) {\n      throw new Error(ENSEMBLE_ERRORS.TOO_MANY_ELEMENTS);\n    }\n\n    if (sanitizedMetadata.maxNestingDepth! > ENSEMBLE_LIMITS.MAX_NESTING_DEPTH) {\n      throw new Error(ENSEMBLE_ERRORS.NESTING_TOO_DEEP);\n    }\n\n    super(ElementType.ENSEMBLE, sanitizedMetadata);\n\n    // Ensure ensemble-specific metadata is stored\n    this.metadata = {\n      ...this.metadata,\n      activationStrategy: sanitizedMetadata.activationStrategy,\n      conflictResolution: sanitizedMetadata.conflictResolution,\n      maxElements: sanitizedMetadata.maxElements,\n      maxActivationTime: sanitizedMetadata.maxActivationTime,\n      allowNested: sanitizedMetadata.allowNested,\n      maxNestingDepth: sanitizedMetadata.maxNestingDepth\n    } as EnsembleMetadata;\n\n    // Initialize shared context\n    this.sharedContext = {\n      values: new Map(),\n      owners: new Map(),\n      timestamps: new Map()\n    };\n\n    // Set ensemble-specific extensions\n    this.extensions = {\n      elementCount: 0,\n      activationStrategy: sanitizedMetadata.activationStrategy,\n      conflictResolution: sanitizedMetadata.conflictResolution,\n      lastActivation: null\n    };\n  }\n\n  /**\n   * Add an element to the ensemble\n   */\n  public addElement(\n    elementId: string, \n    elementType: string,\n    role: ElementRole = ENSEMBLE_DEFAULTS.ELEMENT_ROLE,\n    options: {\n      priority?: number;\n      activationCondition?: string;\n      dependencies?: string[];\n    } = {}\n  ): void {\n    // Check element limit\n    if (this.elements.size >= (this.metadata as EnsembleMetadata).maxElements!) {\n      SecurityMonitor.logSecurityEvent({\n        type: ENSEMBLE_SECURITY_EVENTS.RESOURCE_LIMIT_EXCEEDED,\n        severity: 'MEDIUM',\n        source: 'Ensemble.addElement',\n        details: `Maximum elements (${ENSEMBLE_LIMITS.MAX_ELEMENTS}) exceeded`\n      });\n      throw new Error(ENSEMBLE_ERRORS.TOO_MANY_ELEMENTS);\n    }\n\n    // Sanitize element ID\n    const sanitizedId = sanitizeInput(elementId, 100);\n    if (!ENSEMBLE_PATTERNS.ELEMENT_ID_PATTERN.test(sanitizedId)) {\n      throw new Error('Invalid element ID format');\n    }\n\n    // Validate role\n    if (!ELEMENT_ROLES.includes(role)) {\n      throw new Error('Invalid element role');\n    }\n\n    // Validate activation condition if provided\n    if (options.activationCondition) {\n      const sanitizedCondition = sanitizeInput(options.activationCondition, ENSEMBLE_LIMITS.MAX_CONDITION_LENGTH);\n      if (!this.isValidCondition(sanitizedCondition)) {\n        SecurityMonitor.logSecurityEvent({\n          type: ENSEMBLE_SECURITY_EVENTS.SUSPICIOUS_CONDITION,\n          severity: 'HIGH',\n          source: 'Ensemble.addElement',\n          details: `Suspicious activation condition: ${sanitizedCondition}`\n        });\n        throw new Error('Invalid activation condition syntax');\n      }\n      options.activationCondition = sanitizedCondition;\n    }\n\n    // Validate dependencies\n    if (options.dependencies) {\n      if (options.dependencies.length > ENSEMBLE_LIMITS.MAX_DEPENDENCIES) {\n        throw new Error(`Too many dependencies (max: ${ENSEMBLE_LIMITS.MAX_DEPENDENCIES})`);\n      }\n      // Sanitize each dependency\n      options.dependencies = options.dependencies.map(dep => sanitizeInput(dep, 100));\n    }\n\n    // Create ensemble element\n    const ensembleElement: EnsembleElement = {\n      elementId: sanitizedId,\n      elementType: sanitizeInput(elementType, 50),\n      role,\n      priority: options.priority ?? ENSEMBLE_DEFAULTS.PRIORITY,\n      activationCondition: options.activationCondition,\n      dependencies: options.dependencies\n    };\n\n    // Check for circular dependencies before adding\n    if (this.wouldCreateCircularDependency(sanitizedId, options.dependencies || [])) {\n      const circular = this.findCircularDependency(sanitizedId, options.dependencies || []);\n      SecurityMonitor.logSecurityEvent({\n        type: ENSEMBLE_SECURITY_EVENTS.CIRCULAR_DEPENDENCY,\n        severity: 'HIGH',\n        source: 'Ensemble.addElement',\n        details: `Circular dependency detected: ${circular.path.join(' -> ')}`\n      });\n      throw new Error(`${ENSEMBLE_ERRORS.CIRCULAR_DEPENDENCY}: ${circular.message}`);\n    }\n\n    this.elements.set(sanitizedId, ensembleElement);\n    this.extensions!.elementCount = this.elements.size;\n    this.markDirty();\n  }\n\n  /**\n   * Remove an element from the ensemble\n   */\n  public removeElement(elementId: string): void {\n    const sanitizedId = sanitizeInput(elementId, 100);\n    \n    if (!this.elements.has(sanitizedId)) {\n      throw new Error(ENSEMBLE_ERRORS.ELEMENT_NOT_FOUND);\n    }\n\n    // Remove element and its instance\n    this.elements.delete(sanitizedId);\n    this.elementInstances.delete(sanitizedId);\n    \n    // Clean up dependencies pointing to this element\n    for (const [id, element] of this.elements) {\n      if (element.dependencies?.includes(sanitizedId)) {\n        element.dependencies = element.dependencies.filter(dep => dep !== sanitizedId);\n      }\n    }\n\n    // Clean up shared context owned by this element\n    for (const [key, owner] of this.sharedContext.owners) {\n      if (owner === sanitizedId) {\n        this.sharedContext.values.delete(key);\n        this.sharedContext.owners.delete(key);\n        this.sharedContext.timestamps.delete(key);\n      }\n    }\n\n    this.extensions!.elementCount = this.elements.size;\n    this.markDirty();\n  }\n\n  /**\n   * Activate the ensemble and all its elements based on strategy\n   */\n  public override async activate(): Promise<void> {\n    if (this.activationInProgress) {\n      throw new Error('Activation already in progress');\n    }\n\n    this.activationInProgress = true;\n    const startTime = Date.now();\n    const metadata = this.metadata as EnsembleMetadata;\n    \n    try {\n      // Set status\n      this._status = 'active' as ElementStatus;\n      \n      const result: EnsembleActivationResult = {\n        success: true,\n        activatedElements: [],\n        failedElements: [],\n        conflicts: [],\n        totalDuration: 0,\n        elementResults: []\n      };\n\n      // Get activation order based on strategy\n      const activationOrder = this.getActivationOrder();\n      \n      // Activate elements according to strategy\n      switch (metadata.activationStrategy) {\n        case 'sequential':\n          await this.activateSequential(activationOrder, result, metadata.maxActivationTime!);\n          break;\n        case 'all':\n          // Activate all elements simultaneously as one unified entity\n          // Elements are layered/combined rather than acting separately\n          await this.activateAll(activationOrder, result, metadata.maxActivationTime!);\n          break;\n        case 'priority':\n          await this.activatePriority(activationOrder, result, metadata.maxActivationTime!);\n          break;\n        case 'conditional':\n          await this.activateConditional(activationOrder, result, metadata.maxActivationTime!);\n          break;\n        case 'lazy':\n          // Lazy activation happens on-demand, just mark as ready\n          logger.info(`Ensemble ${this.id} ready for lazy activation`);\n          break;\n      }\n\n      result.totalDuration = Date.now() - startTime;\n      this.lastActivationResult = result;\n      this.extensions!.lastActivation = new Date().toISOString();\n\n      if (result.failedElements.length > 0) {\n        logger.warn(`Ensemble activation completed with failures: ${result.failedElements.join(', ')}`);\n      } else {\n        logger.info(`Ensemble ${this.id} activated successfully in ${result.totalDuration}ms`);\n      }\n\n    } catch (error) {\n      this._status = 'error' as ElementStatus;\n      throw error;\n    } finally {\n      this.activationInProgress = false;\n    }\n  }\n\n  /**\n   * Deactivate the ensemble and all its elements\n   */\n  public override async deactivate(): Promise<void> {\n    this._status = 'inactive' as ElementStatus;\n    \n    // Deactivate all element instances\n    const deactivationPromises: Promise<void>[] = [];\n    \n    for (const [elementId, instance] of this.elementInstances) {\n      if (instance.deactivate) {\n        deactivationPromises.push(\n          instance.deactivate().catch(error => {\n            logger.error(`Failed to deactivate element ${elementId}:`, error);\n          })\n        );\n      }\n    }\n\n    await Promise.all(deactivationPromises);\n    \n    // Clear shared context\n    this.sharedContext.values.clear();\n    this.sharedContext.owners.clear();\n    this.sharedContext.timestamps.clear();\n    \n    logger.info(`Ensemble ${this.id} deactivated`);\n  }\n\n  /**\n   * Validate the ensemble configuration\n   */\n  public override validate(): ElementValidationResult {\n    const result = super.validate();\n    \n    // Initialize arrays if they don't exist\n    if (!result.errors) result.errors = [];\n    if (!result.warnings) result.warnings = [];\n    \n    // Check for circular dependencies\n    const circular = this.detectAllCircularDependencies();\n    if (circular.length > 0) {\n      for (const cycle of circular) {\n        result.errors.push({\n          field: 'dependencies',\n          message: cycle.message,\n          severity: 'high'\n        } as ValidationError);\n      }\n    }\n\n    // Validate element count\n    if (this.elements.size === 0) {\n      result.warnings.push({\n        field: 'elements',\n        message: 'Ensemble has no elements',\n        suggestion: 'Add elements using addElement()'\n      } as ValidationWarning);\n    }\n\n    // Check for orphaned dependencies\n    for (const [elementId, element] of this.elements) {\n      if (element.dependencies) {\n        for (const dep of element.dependencies) {\n          if (!this.elements.has(dep)) {\n            result.errors.push({\n              field: `${elementId}.dependencies`,\n              message: `Dependency '${dep}' not found in ensemble`,\n              severity: 'medium'\n            } as ValidationError);\n          }\n        }\n      }\n    }\n\n    // Update valid flag based on errors\n    result.valid = result.errors.length === 0;\n    \n    // Clean up empty arrays\n    if (result.errors.length === 0) result.errors = undefined;\n    if (result.warnings.length === 0) result.warnings = undefined;\n\n    return result;\n  }\n\n  /**\n   * Check if adding an element would create a circular dependency\n   * MEDIUM FIX: Remove type safety bypass\n   * Previously: Used 'as any' which bypasses TypeScript checking\n   * Now: Creates proper EnsembleElement with all required fields\n   */\n  private wouldCreateCircularDependency(elementId: string, dependencies: string[]): boolean {\n    // Create temporary graph with new element\n    const tempGraph = new Map(this.elements);\n    \n    // Create a minimal valid EnsembleElement for dependency checking\n    const tempElement: EnsembleElement = {\n      elementId,\n      elementType: 'unknown', // Type doesn't matter for dependency checking\n      role: 'support' as ElementRole, // Default role\n      dependencies\n    };\n    \n    tempGraph.set(elementId, tempElement);\n    \n    // Check for cycles\n    return this.hasCycle(tempGraph);\n  }\n\n  /**\n   * Find circular dependency path\n   */\n  private findCircularDependency(elementId: string, dependencies: string[]): CircularDependency {\n    const visited = new Set<string>();\n    const recursionStack = new Set<string>();\n    const path: string[] = [];\n\n    const dfs = (node: string): string[] | null => {\n      visited.add(node);\n      recursionStack.add(node);\n      path.push(node);\n\n      const element = this.elements.get(node);\n      const deps = node === elementId ? dependencies : (element?.dependencies || []);\n\n      for (const dep of deps) {\n        if (!visited.has(dep)) {\n          const cycle = dfs(dep);\n          if (cycle) return cycle;\n        } else if (recursionStack.has(dep)) {\n          // Found cycle\n          const cycleStart = path.indexOf(dep);\n          return path.slice(cycleStart).concat(dep);\n        }\n      }\n\n      path.pop();\n      recursionStack.delete(node);\n      return null;\n    };\n\n    const cyclePath = dfs(elementId) || [];\n    \n    return {\n      path: cyclePath,\n      message: `Circular dependency: ${cyclePath.join(' -> ')}`\n    };\n  }\n\n  /**\n   * Detect all circular dependencies in the ensemble\n   */\n  private detectAllCircularDependencies(): CircularDependency[] {\n    const cycles: CircularDependency[] = [];\n    const visited = new Set<string>();\n\n    for (const elementId of this.elements.keys()) {\n      if (!visited.has(elementId) && this.hasCycleFrom(elementId, visited)) {\n        const cycle = this.findCircularDependency(elementId, this.elements.get(elementId)!.dependencies || []);\n        cycles.push(cycle);\n      }\n    }\n\n    return cycles;\n  }\n\n  /**\n   * Check if graph has any cycle\n   */\n  private hasCycle(graph: Map<string, EnsembleElement>): boolean {\n    const visited = new Set<string>();\n    const recursionStack = new Set<string>();\n\n    const hasCycleDFS = (node: string): boolean => {\n      visited.add(node);\n      recursionStack.add(node);\n\n      const element = graph.get(node);\n      const dependencies = element?.dependencies || [];\n\n      for (const dep of dependencies) {\n        if (!visited.has(dep)) {\n          if (hasCycleDFS(dep)) return true;\n        } else if (recursionStack.has(dep)) {\n          return true;\n        }\n      }\n\n      recursionStack.delete(node);\n      return false;\n    };\n\n    for (const node of graph.keys()) {\n      if (!visited.has(node) && hasCycleDFS(node)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Check for cycle starting from a specific node\n   */\n  private hasCycleFrom(node: string, visited: Set<string>): boolean {\n    const recursionStack = new Set<string>();\n\n    const dfs = (current: string): boolean => {\n      visited.add(current);\n      recursionStack.add(current);\n\n      const element = this.elements.get(current);\n      const dependencies = element?.dependencies || [];\n\n      for (const dep of dependencies) {\n        if (!visited.has(dep)) {\n          if (dfs(dep)) return true;\n        } else if (recursionStack.has(dep)) {\n          return true;\n        }\n      }\n\n      recursionStack.delete(current);\n      return false;\n    };\n\n    return dfs(node);\n  }\n\n  /**\n   * Validate activation condition syntax\n   */\n  private isValidCondition(condition: string): boolean {\n    // For now, only allow simple conditions\n    // Future: implement a proper condition parser\n    return ENSEMBLE_PATTERNS.CONDITION_PATTERN.test(condition);\n  }\n\n  /**\n   * Get activation order based on dependencies and strategy\n   */\n  private getActivationOrder(): string[] {\n    const order: string[] = [];\n    const visited = new Set<string>();\n\n    // Topological sort for dependency order\n    const visit = (elementId: string) => {\n      if (visited.has(elementId)) return;\n      visited.add(elementId);\n\n      const element = this.elements.get(elementId);\n      if (element?.dependencies) {\n        for (const dep of element.dependencies) {\n          if (this.elements.has(dep)) {\n            visit(dep);\n          }\n        }\n      }\n\n      order.push(elementId);\n    };\n\n    // Visit all elements\n    for (const elementId of this.elements.keys()) {\n      visit(elementId);\n    }\n\n    return order;\n  }\n\n  /**\n   * Activate elements sequentially\n   */\n  private async activateSequential(\n    order: string[], \n    result: EnsembleActivationResult,\n    maxTime: number\n  ): Promise<void> {\n    const startTime = Date.now();\n\n    for (const elementId of order) {\n      if (Date.now() - startTime > maxTime) {\n        SecurityMonitor.logSecurityEvent({\n          type: ENSEMBLE_SECURITY_EVENTS.ACTIVATION_TIMEOUT,\n          severity: 'HIGH',\n          source: 'Ensemble.activateSequential',\n          details: `Activation timeout after ${Date.now() - startTime}ms`\n        });\n        throw new Error(ENSEMBLE_ERRORS.ACTIVATION_TIMEOUT);\n      }\n\n      const elementResult = await this.activateElement(elementId);\n      result.elementResults.push(elementResult);\n\n      if (elementResult.success) {\n        result.activatedElements.push(elementId);\n      } else {\n        result.failedElements.push(elementId);\n      }\n\n      // Small delay between activations\n      await new Promise(resolve => setTimeout(resolve, ENSEMBLE_LIMITS.MIN_ACTIVATION_INTERVAL));\n    }\n  }\n\n  /**\n   * Activate all elements simultaneously as one unified entity\n   */\n  private async activateAll(\n    order: string[], \n    result: EnsembleActivationResult,\n    maxTime: number\n  ): Promise<void> {\n    const startTime = Date.now();\n    \n    const activationPromises = order.map(elementId => \n      this.activateElement(elementId).then(elementResult => {\n        result.elementResults.push(elementResult);\n        if (elementResult.success) {\n          result.activatedElements.push(elementId);\n        } else {\n          result.failedElements.push(elementId);\n        }\n        return elementResult;\n      })\n    );\n\n    // Wait for all with timeout\n    await Promise.race([\n      Promise.all(activationPromises),\n      new Promise((_, reject) => \n        setTimeout(() => reject(new Error(ENSEMBLE_ERRORS.ACTIVATION_TIMEOUT)), maxTime)\n      )\n    ]);\n  }\n\n  /**\n   * Activate elements by priority\n   */\n  private async activatePriority(\n    order: string[], \n    result: EnsembleActivationResult,\n    maxTime: number\n  ): Promise<void> {\n    // Sort by priority\n    const priorityOrder = [...order].sort((a, b) => {\n      const priorityA = this.elements.get(a)?.priority ?? 0;\n      const priorityB = this.elements.get(b)?.priority ?? 0;\n      return priorityB - priorityA; // Higher priority first\n    });\n\n    await this.activateSequential(priorityOrder, result, maxTime);\n  }\n\n  /**\n   * Activate elements based on conditions\n   */\n  private async activateConditional(\n    order: string[], \n    result: EnsembleActivationResult,\n    maxTime: number\n  ): Promise<void> {\n    const startTime = Date.now();\n\n    for (const elementId of order) {\n      if (Date.now() - startTime > maxTime) {\n        throw new Error(ENSEMBLE_ERRORS.ACTIVATION_TIMEOUT);\n      }\n\n      const element = this.elements.get(elementId)!;\n      \n      // Check activation condition\n      if (element.activationCondition) {\n        if (!this.evaluateCondition(element.activationCondition)) {\n          logger.info(`Skipping element ${elementId} - condition not met`);\n          continue;\n        }\n      }\n\n      const elementResult = await this.activateElement(elementId);\n      result.elementResults.push(elementResult);\n\n      if (elementResult.success) {\n        result.activatedElements.push(elementId);\n      } else {\n        result.failedElements.push(elementId);\n      }\n    }\n  }\n\n  /**\n   * Activate a single element\n   * CRITICAL FIX: Implement actual element loading and activation\n   * Previously: Just simulated with timeout\n   * Now: Loads element from portfolio and activates it\n   */\n  private async activateElement(elementId: string): Promise<ElementActivationResult> {\n    const startTime = Date.now();\n    \n    try {\n      const ensembleElement = this.elements.get(elementId);\n      if (!ensembleElement) {\n        throw new Error(`Element ${elementId} not found in ensemble`);\n      }\n\n      // Load the element based on its type\n      const portfolioManager = PortfolioManager.getInstance();\n      const elementFilename = `${elementId}.md`;\n\n      logger.info(`Activating element: ${elementId} of type ${ensembleElement.elementType}`);\n      \n      // For now, we only have PersonaElement fully implemented\n      // Future: Add factory pattern for other element types\n      let element: IElement | undefined;\n      \n      if (ensembleElement.elementType === ElementType.PERSONA) {\n        // Load PersonaElement\n        const { PersonaElementManager } = await import('../../persona/PersonaElementManager.js');\n        const manager = new PersonaElementManager(portfolioManager);\n        element = await manager.load(elementFilename);\n      } else {\n        // For other types, log warning and return success\n        // This allows ensemble to work with future element types\n        logger.warn(`Element type ${ensembleElement.elementType} not yet implemented for activation`);\n        return {\n          elementId,\n          success: true,\n          duration: Date.now() - startTime,\n          context: { warning: `Type ${ensembleElement.elementType} activation not implemented` }\n        };\n      }\n\n      // Store element instance for later use\n      if (element) {\n        this.elementInstances.set(elementId, element);\n        \n        // Call element's activate method if it exists\n        if (element.activate) {\n          await element.activate();\n        }\n        \n        // Extract any context from the element\n        const context: Record<string, any> = {};\n        if (element.getStatus) {\n          context.status = element.getStatus();\n        }\n        context.type = ensembleElement.elementType;\n        context.role = ensembleElement.role;\n        \n        return {\n          elementId,\n          success: true,\n          duration: Date.now() - startTime,\n          context\n        };\n      }\n      \n      return {\n        elementId,\n        success: true,\n        duration: Date.now() - startTime,\n        context: {}\n      };\n      \n    } catch (error) {\n      logger.error(`Failed to activate element ${elementId}:`, error);\n      return {\n        elementId,\n        success: false,\n        duration: Date.now() - startTime,\n        error: error as Error\n      };\n    }\n  }\n\n  /**\n   * Evaluate a simple condition\n   * CRITICAL FIX: Implement actual condition evaluation\n   * Previously: Always returned true\n   * Now: Parses and evaluates simple conditions like \"element.property == value\"\n   * \n   * Supported operators: ==, !=, >, <, >=, <=\n   * Supported properties: active, status, priority\n   * Example: \"element1.active == true\" or \"element2.priority > 50\"\n   */\n  private evaluateCondition(condition: string): boolean {\n    try {\n      // Sanitize and validate condition first\n      const sanitized = sanitizeInput(condition, ENSEMBLE_LIMITS.MAX_CONDITION_LENGTH);\n      \n      // Parse condition: elementId.property operator value\n      const match = sanitized.match(/^([a-zA-Z0-9\\-_]+)\\.([a-zA-Z]+)\\s*(==|!=|>=|<=|>|<)\\s*(.+)$/);\n      \n      if (!match) {\n        logger.warn(`Invalid condition format: ${condition}`);\n        return false;\n      }\n      \n      const [, elementId, property, operator, value] = match;\n      \n      // Get element instance or element data\n      const element = this.elementInstances.get(elementId);\n      const elementData = this.elements.get(elementId);\n      \n      if (!element && !elementData) {\n        logger.debug(`Element ${elementId} not found for condition evaluation`);\n        return false;\n      }\n      \n      // Get property value\n      let propertyValue: any;\n      \n      switch (property) {\n        case 'active':\n          // Check if element is in activated elements list\n          propertyValue = this.lastActivationResult?.activatedElements.includes(elementId) || false;\n          break;\n          \n        case 'status':\n          propertyValue = element?.getStatus ? element.getStatus() : 'inactive';\n          break;\n          \n        case 'priority':\n          propertyValue = elementData?.priority || 0;\n          break;\n          \n        default:\n          logger.warn(`Unknown property in condition: ${property}`);\n          return false;\n      }\n      \n      // Parse the comparison value\n      let compareValue: any = value.trim();\n      \n      // Handle boolean values\n      if (compareValue === 'true') compareValue = true;\n      else if (compareValue === 'false') compareValue = false;\n      // Handle numeric values\n      else if (!isNaN(Number(compareValue))) compareValue = Number(compareValue);\n      // Handle string values (remove quotes if present)\n      else if (compareValue.startsWith('\"') && compareValue.endsWith('\"')) {\n        compareValue = compareValue.slice(1, -1);\n      }\n      \n      // Evaluate based on operator\n      switch (operator) {\n        case '==':\n          return propertyValue == compareValue;\n        case '!=':\n          return propertyValue != compareValue;\n        case '>':\n          return Number(propertyValue) > Number(compareValue);\n        case '<':\n          return Number(propertyValue) < Number(compareValue);\n        case '>=':\n          return Number(propertyValue) >= Number(compareValue);\n        case '<=':\n          return Number(propertyValue) <= Number(compareValue);\n        default:\n          logger.warn(`Unknown operator in condition: ${operator}`);\n          return false;\n      }\n      \n    } catch (error) {\n      logger.error(`Error evaluating condition \"${condition}\":`, error);\n      return false;\n    }\n  }\n\n  /**\n   * Get shared context value\n   */\n  public getContextValue(key: string): any {\n    return this.sharedContext.values.get(key);\n  }\n\n  /**\n   * Set shared context value with conflict resolution\n   */\n  public setContextValue(key: string, value: any, elementId: string): ContextConflict | null {\n    // Check context size limits\n    if (this.sharedContext.values.size >= ENSEMBLE_LIMITS.MAX_CONTEXT_SIZE) {\n      SecurityMonitor.logSecurityEvent({\n        type: ENSEMBLE_SECURITY_EVENTS.CONTEXT_SIZE_EXCEEDED,\n        severity: 'MEDIUM',\n        source: 'Ensemble.setContextValue',\n        details: `Context size limit (${ENSEMBLE_LIMITS.MAX_CONTEXT_SIZE}) exceeded`\n      });\n      throw new Error(ENSEMBLE_ERRORS.CONTEXT_OVERFLOW);\n    }\n\n    // Sanitize key\n    const sanitizedKey = sanitizeInput(key, 100);\n    \n    // Check value size\n    const valueStr = JSON.stringify(value);\n    if (valueStr.length > ENSEMBLE_LIMITS.MAX_CONTEXT_VALUE_SIZE) {\n      throw new Error('Context value too large');\n    }\n\n    const currentOwner = this.sharedContext.owners.get(sanitizedKey);\n    const currentValue = this.sharedContext.values.get(sanitizedKey);\n    \n    // Check for conflict\n    if (currentOwner && currentOwner !== elementId) {\n      const conflict: ContextConflict = {\n        key: sanitizedKey,\n        currentValue,\n        currentOwner,\n        newValue: value,\n        newOwner: elementId\n      };\n\n      // Apply conflict resolution\n      const metadata = this.metadata as EnsembleMetadata;\n      switch (metadata.conflictResolution) {\n        case 'error':\n          throw new Error(`Context conflict on key '${sanitizedKey}'`);\n        \n        case 'first-write':\n          // Keep existing value\n          return conflict;\n        \n        case 'last-write':\n          // Overwrite with new value\n          break;\n        \n        case 'priority':\n          const currentPriority = this.elements.get(currentOwner)?.priority ?? 0;\n          const newPriority = this.elements.get(elementId)?.priority ?? 0;\n          if (currentPriority > newPriority) {\n            return conflict;\n          }\n          break;\n        \n        case 'merge':\n          // Simple merge for objects\n          if (typeof currentValue === 'object' && typeof value === 'object') {\n            value = { ...currentValue, ...value };\n            conflict.resolution = value;\n          }\n          break;\n      }\n    }\n\n    // Set the value\n    this.sharedContext.values.set(sanitizedKey, value);\n    this.sharedContext.owners.set(sanitizedKey, elementId);\n    this.sharedContext.timestamps.set(sanitizedKey, new Date());\n\n    return null;\n  }\n\n  /**\n   * Get all elements in the ensemble\n   */\n  public getElements(): Map<string, EnsembleElement> {\n    return new Map(this.elements);\n  }\n\n  /**\n   * Get activation result\n   */\n  public getLastActivationResult(): EnsembleActivationResult | undefined {\n    return this.lastActivationResult;\n  }\n\n  /**\n   * Get current element status\n   */\n  public override getStatus(): ElementStatus {\n    return this._status;\n  }\n\n  /**\n   * Serialize ensemble to string\n   */\n  public override serialize(): string {\n    const data = {\n      base: super.serialize(),\n      elements: Array.from(this.elements.entries()),\n      sharedContext: {\n        values: Array.from(this.sharedContext.values.entries()),\n        owners: Array.from(this.sharedContext.owners.entries()),\n        timestamps: Array.from(this.sharedContext.timestamps.entries())\n      }\n    };\n    return JSON.stringify(data, null, 2);\n  }\n\n  /**\n   * Deserialize ensemble from string\n   */\n  public override deserialize(data: string): void {\n    const parsed = JSON.parse(data);\n    \n    // If data has a 'base' property, it was serialized by our serialize method\n    if (parsed.base) {\n      // Deserialize base properties\n      super.deserialize(parsed.base);\n      \n      // Restore elements\n      if (parsed.elements) {\n        this.elements.clear();\n        for (const [id, element] of parsed.elements) {\n          this.elements.set(id, element);\n        }\n      }\n\n      // Restore shared context\n      if (parsed.sharedContext) {\n        this.sharedContext.values.clear();\n        this.sharedContext.owners.clear();\n        this.sharedContext.timestamps.clear();\n        \n        for (const [key, value] of parsed.sharedContext.values || []) {\n          this.sharedContext.values.set(key, value);\n        }\n        for (const [key, owner] of parsed.sharedContext.owners || []) {\n          this.sharedContext.owners.set(key, owner);\n        }\n        for (const [key, timestamp] of parsed.sharedContext.timestamps || []) {\n          this.sharedContext.timestamps.set(key, new Date(timestamp));\n        }\n      }\n    } else {\n      // Old format or direct properties\n      super.deserialize(data);\n    }\n  }\n}"]}