claude-flow-novice 1.6.3 → 1.6.4

package/.claude-flow-novice/dist/src/coordination/v1-transparency/v1-transparency-adapter.js

@@ -0,0 +1,1468 @@
+/**
+ * V1 Transparency System Adapter
+ *
+ * Adapts existing V1 coordinators (QueenAgent, MeshCoordinator) to provide
+ * transparency features without modifying the original coordinator implementations.
+ *
+ * @module coordination/v1-transparency/v1-transparency-adapter
+ */ import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * V1 Transparency System Implementation
+ *
+ * Wraps existing V1 coordinators to provide transparency features
+ * by listening to their events and collecting metrics.
+ */ export class V1TransparencySystem extends EventEmitter {
+    logger;
+    config;
+    isInitialized = false;
+    isMonitoring = false;
+    // V1 Coordinator tracking
+    coordinatorAdapters = new Map();
+    coordinatorInfo = new Map();
+    agentInfo = new Map();
+    taskInfo = new Map();
+    transparencyEvents = [];
+    eventListeners = new Set();
+    // Monitoring intervals
+    metricsCollectionInterval;
+    healthCheckInterval;
+    // Performance tracking
+    lastMetricsUpdate = new Date();
+    eventsPerSecond = 0;
+    recentEventTimestamps = [];
+    // Rate limiting for security
+    eventCountsBySource = new Map();
+    RATE_LIMIT_WINDOW_MS = 60000;
+    RATE_LIMIT_MAX_EVENTS = 1000;
+    constructor(logger){
+        super();
+        this.logger = logger;
+        this.config = this.getDefaultConfig();
+    }
+    // ===========================
+    // System Lifecycle
+    // ===========================
+    async initialize(config = {}) {
+        if (this.isInitialized) {
+            this.logger.warn('V1TransparencySystem already initialized');
+            return;
+        }
+        this.config = {
+            ...this.getDefaultConfig(),
+            ...config
+        };
+        this.logger.info('Initializing V1TransparencySystem', this.config);
+        // Initialize data structures
+        this.transparencyEvents = [];
+        this.agentInfo.clear();
+        this.taskInfo.clear();
+        this.coordinatorAdapters.clear();
+        this.eventListeners.clear();
+        this.isInitialized = true;
+        this.emit('initialized');
+        this.logger.info('V1TransparencySystem initialized successfully');
+    }
+    async startMonitoring() {
+        if (!this.isInitialized) {
+            throw new Error('V1TransparencySystem not initialized');
+        }
+        if (this.isMonitoring) {
+            this.logger.warn('V1TransparencySystem monitoring already started');
+            return;
+        }
+        this.logger.info('Starting V1 transparency monitoring');
+        // Start metrics collection
+        if (this.config.enableRealTimeMonitoring) {
+            this.metricsCollectionInterval = setInterval(()=>this.collectMetrics(), this.config.metricsCollectionIntervalMs);
+        }
+        // Start health checks
+        if (this.config.enableHealthMonitoring) {
+            this.healthCheckInterval = setInterval(()=>this.performHealthChecks(), 30000 // 30 seconds
+            );
+        }
+        // Start all coordinator monitoring
+        for (const adapter of this.coordinatorAdapters.values()){
+            if (adapter.isActive) {
+                this.startCoordinatorMonitoring(adapter);
+            }
+        }
+        this.isMonitoring = true;
+        this.emit('monitoringStarted');
+        this.logger.info('V1 transparency monitoring started');
+    }
+    async stopMonitoring() {
+        if (!this.isMonitoring) {
+            return;
+        }
+        this.logger.info('Stopping V1 transparency monitoring');
+        // Clear intervals
+        if (this.metricsCollectionInterval) {
+            clearInterval(this.metricsCollectionInterval);
+            this.metricsCollectionInterval = undefined;
+        }
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = undefined;
+        }
+        this.isMonitoring = false;
+        this.emit('monitoringStopped');
+        this.logger.info('V1 transparency monitoring stopped');
+    }
+    async cleanup() {
+        this.logger.info('Cleaning up V1TransparencySystem');
+        await this.stopMonitoring();
+        // Cleanup all data
+        this.transparencyEvents = [];
+        this.agentInfo.clear();
+        this.taskInfo.clear();
+        this.coordinatorAdapters.clear();
+        this.eventListeners.clear();
+        this.removeAllListeners();
+        this.isInitialized = false;
+        this.logger.info('V1TransparencySystem cleanup complete');
+    }
+    // ===========================
+    // V1 Coordinator Registration
+    // ===========================
+    /**
+   * Register a QueenAgent for transparency monitoring
+   */ registerQueenAgent(coordinatorId, queenAgent) {
+        const adapter = {
+            id: coordinatorId,
+            type: 'queen-agent',
+            instance: queenAgent,
+            eventEmitter: queenAgent,
+            isActive: true,
+            registeredAt: new Date()
+        };
+        this.coordinatorAdapters.set(coordinatorId, adapter);
+        this.setupCoordinatorEventListeners(adapter);
+        this.recordEvent({
+            eventId: uuidv4(),
+            timestamp: new Date(),
+            eventType: 'coordinator_initialized',
+            eventData: {
+                coordinatorId,
+                coordinatorType: 'queen-agent'
+            },
+            source: {
+                component: 'V1TransparencySystem',
+                instance: this.constructor.name
+            },
+            severity: 'info',
+            category: 'lifecycle'
+        });
+        this.logger.info(`QueenAgent registered for transparency: ${coordinatorId}`);
+    }
+    /**
+   * Register a MeshCoordinator for transparency monitoring
+   */ registerMeshCoordinator(coordinatorId, meshCoordinator) {
+        const adapter = {
+            id: coordinatorId,
+            type: 'mesh-coordinator',
+            instance: meshCoordinator,
+            eventEmitter: meshCoordinator,
+            isActive: true,
+            registeredAt: new Date()
+        };
+        this.coordinatorAdapters.set(coordinatorId, adapter);
+        this.setupCoordinatorEventListeners(adapter);
+        this.recordEvent({
+            eventId: uuidv4(),
+            timestamp: new Date(),
+            eventType: 'coordinator_initialized',
+            eventData: {
+                coordinatorId,
+                coordinatorType: 'mesh-coordinator'
+            },
+            source: {
+                component: 'V1TransparencySystem',
+                instance: this.constructor.name
+            },
+            severity: 'info',
+            category: 'lifecycle'
+        });
+        this.logger.info(`MeshCoordinator registered for transparency: ${coordinatorId}`);
+    }
+    /**
+   * Register metrics collector for a coordinator
+   */ registerMetricsCollector(coordinatorId, metricsCollector) {
+        const adapter = this.coordinatorAdapters.get(coordinatorId);
+        if (adapter) {
+            adapter.metrics = metricsCollector;
+            this.logger.debug(`Metrics collector registered for coordinator: ${coordinatorId}`);
+        }
+    }
+    // ===========================
+    // Agent Monitoring
+    // ===========================
+    async getAllAgents() {
+        return Array.from(this.agentInfo.values());
+    }
+    async getAgentsByCoordinator(coordinatorId) {
+        return Array.from(this.agentInfo.values()).filter((agent)=>agent.coordinatorId === coordinatorId);
+    }
+    async getAgentsByType(agentType) {
+        return Array.from(this.agentInfo.values()).filter((agent)=>agent.agentType === agentType);
+    }
+    async getAgentInfo(agentId) {
+        const agent = this.agentInfo.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        return agent;
+    }
+    // ===========================
+    // Task Monitoring
+    // ===========================
+    async getAllTasks() {
+        return Array.from(this.taskInfo.values());
+    }
+    async getTasksByAgent(agentId) {
+        return Array.from(this.taskInfo.values()).filter((task)=>task.assignedAgents.includes(agentId));
+    }
+    async getTasksByStatus(status) {
+        return Array.from(this.taskInfo.values()).filter((task)=>task.status === status);
+    }
+    async getTaskInfo(taskId) {
+        const task = this.taskInfo.get(taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        return task;
+    }
+    // ===========================
+    // Coordinator Monitoring
+    // ===========================
+    async getAllCoordinators() {
+        const coordinators = [];
+        for (const [id, adapter] of this.coordinatorAdapters.entries()){
+            const coordinatorInfo = {
+                coordinatorId: id,
+                coordinatorType: adapter.type,
+                topology: adapter.type === 'queen-agent' ? 'hierarchical' : 'mesh',
+                config: {
+                    maxAgents: this.getMaxAgentsForCoordinator(adapter),
+                    currentAgents: this.getAgentCountForCoordinator(id),
+                    strategy: 'balanced',
+                    enableConsensus: false
+                },
+                status: adapter.isActive ? 'active' : 'offline',
+                agents: (await this.getAgentsByCoordinator(id)).map((a)=>a.agentId),
+                tasks: (await this.getTasksByCoordinator(id)).map((t)=>t.taskId),
+                performance: await this.getCoordinatorPerformance(adapter),
+                timestamps: {
+                    startedAt: adapter.registeredAt,
+                    lastActivity: new Date(),
+                    lastHealthCheck: new Date()
+                }
+            };
+            coordinators.push(coordinatorInfo);
+        }
+        return coordinators;
+    }
+    async getCoordinatorInfo(coordinatorId) {
+        const coordinators = await this.getAllCoordinators();
+        const coordinator = coordinators.find((c)=>c.coordinatorId === coordinatorId);
+        if (!coordinator) {
+            throw new Error(`Coordinator ${coordinatorId} not found`);
+        }
+        return coordinator;
+    }
+    async getTasksByCoordinator(coordinatorId) {
+        return Array.from(this.taskInfo.values()).filter((task)=>task.assignedAgents.some((agentId)=>{
+                const agent = this.agentInfo.get(agentId);
+                return agent?.coordinatorId === coordinatorId;
+            }));
+    }
+    async getTopologyInfo(coordinatorId) {
+        const adapter = this.coordinatorAdapters.get(coordinatorId);
+        if (!adapter) {
+            throw new Error(`Coordinator ${coordinatorId} not found`);
+        }
+        // Return topology-specific information
+        if (adapter.type === 'queen-agent') {
+            return {
+                type: 'hierarchical',
+                coordinatorId,
+                workers: await this.getAgentsByCoordinator(coordinatorId),
+                hierarchy: this.buildHierarchyFromQueenAgent(adapter.instance)
+            };
+        } else {
+            return {
+                type: 'mesh',
+                coordinatorId,
+                agents: await this.getAgentsByCoordinator(coordinatorId),
+                connections: this.getMeshConnections(adapter.instance)
+            };
+        }
+    }
+    // ===========================
+    // Event Streaming
+    // ===========================
+    async getRecentEvents(limit = 100, eventType) {
+        let events = [
+            ...this.transparencyEvents
+        ].reverse();
+        if (eventType) {
+            events = events.filter((event)=>event.eventType === eventType);
+        }
+        return events.slice(0, limit);
+    }
+    async getAgentEvents(agentId, limit = 50) {
+        const events = this.transparencyEvents.filter((event)=>event.eventData.agentId === agentId).reverse();
+        return events.slice(0, limit);
+    }
+    async getCoordinatorEvents(coordinatorId, limit = 50) {
+        const events = this.transparencyEvents.filter((event)=>event.eventData.coordinatorId === coordinatorId).reverse();
+        return events.slice(0, limit);
+    }
+    async getEventsInTimeRange(startTime, endTime, limit = 100) {
+        const events = this.transparencyEvents.filter((event)=>event.timestamp >= startTime && event.timestamp <= endTime).reverse();
+        return events.slice(0, limit);
+    }
+    // ===========================
+    // Metrics and Analytics
+    // ===========================
+    async getTransparencyMetrics() {
+        const agents = Array.from(this.agentInfo.values());
+        const tasks = Array.from(this.taskInfo.values());
+        const coordinators = Array.from(this.coordinatorAdapters.values());
+        // Calculate events per second
+        this.calculateEventsPerSecond();
+        return {
+            timestamp: new Date(),
+            coordinators: {
+                total: coordinators.length,
+                active: coordinators.filter((c)=>c.isActive).length,
+                byType: {
+                    'queen-agent': coordinators.filter((c)=>c.type === 'queen-agent').length,
+                    'mesh-coordinator': coordinators.filter((c)=>c.type === 'mesh-coordinator').length
+                },
+                byTopology: {
+                    hierarchical: coordinators.filter((c)=>c.type === 'queen-agent').length,
+                    mesh: coordinators.filter((c)=>c.type === 'mesh-coordinator').length
+                }
+            },
+            agents: {
+                total: agents.length,
+                active: agents.filter((a)=>a.status === 'busy' || a.status === 'ready' || a.status === 'working').length,
+                idle: agents.filter((a)=>a.status === 'idle').length,
+                busy: agents.filter((a)=>a.status === 'busy' || a.status === 'working').length,
+                degraded: agents.filter((a)=>a.status === 'degraded').length,
+                offline: agents.filter((a)=>a.status === 'offline').length,
+                byType: this.groupAgentsByType(agents),
+                byCoordinator: this.groupAgentsByCoordinator(agents),
+                averageHealth: this.calculateAverageHealth(agents),
+                utilizationRate: this.calculateAgentUtilization(agents)
+            },
+            tasks: {
+                total: tasks.length,
+                active: tasks.filter((t)=>t.status === 'active').length,
+                completed: tasks.filter((t)=>t.status === 'completed').length,
+                failed: tasks.filter((t)=>t.status === 'failed').length,
+                cancelled: tasks.filter((t)=>t.status === 'cancelled').length,
+                byType: this.groupTasksByType(tasks),
+                byPriority: this.groupTasksByPriority(tasks),
+                averageDuration: this.calculateAverageTaskDuration(tasks),
+                successRate: this.calculateTaskSuccessRate(tasks)
+            },
+            performance: {
+                taskThroughput: this.calculateTaskThroughput(tasks),
+                averageResponseTime: this.calculateAverageResponseTime(agents),
+                memoryUsage: this.calculateTotalMemoryUsage(agents),
+                cpuUsage: this.calculateTotalCpuUsage(agents),
+                networkIO: this.calculateTotalNetworkIO(agents),
+                errorRate: this.calculateErrorRate(tasks)
+            },
+            resources: {
+                totalResources: agents.reduce((sum, a)=>sum + a.topology.maxConnections, 0),
+                allocatedResources: agents.reduce((sum, a)=>sum + a.topology.connections, 0),
+                freeResources: agents.reduce((sum, a)=>sum + (a.topology.maxConnections - a.topology.connections), 0),
+                resourceUtilization: this.calculateResourceUtilization(agents),
+                lockContention: 0
+            },
+            events: {
+                totalEvents: this.transparencyEvents.length,
+                eventsByType: this.groupEventsByType(),
+                eventsBySeverity: this.groupEventsBySeverity(),
+                eventsByCategory: this.groupEventsByCategory(),
+                eventsPerSecond: this.eventsPerSecond
+            }
+        };
+    }
+    async getPerformanceAnalytics() {
+        const agents = Array.from(this.agentInfo.values());
+        const tasks = Array.from(this.taskInfo.values());
+        return {
+            agentPerformance: {
+                healthDistribution: this.getHealthDistribution(agents),
+                utilizationTrends: this.getUtilizationTrends(agents),
+                performanceByType: this.getPerformanceByAgentType(agents)
+            },
+            taskPerformance: {
+                completionRates: this.getTaskCompletionRates(tasks),
+                averageDurations: this.getTaskDurationsByType(tasks),
+                failurePatterns: this.getFailurePatterns(tasks)
+            },
+            systemPerformance: {
+                scalabilityMetrics: this.getScalabilityMetrics(),
+                bottleneckAnalysis: this.getBottleneckAnalysis(),
+                efficiencyMetrics: this.getEfficiencyMetrics()
+            }
+        };
+    }
+    async getTopologyAnalytics() {
+        const queenAgents = Array.from(this.coordinatorAdapters.values()).filter((adapter)=>adapter.type === 'queen-agent');
+        const meshCoordinators = Array.from(this.coordinatorAdapters.values()).filter((adapter)=>adapter.type === 'mesh-coordinator');
+        return {
+            hierarchicalTopology: {
+                count: queenAgents.length,
+                averageWorkersPerQueen: this.getAverageWorkersPerQueen(queenAgents),
+                hierarchyDepth: this.getHierarchyDepth(queenAgents),
+                efficiency: this.getHierarchicalEfficiency(queenAgents)
+            },
+            meshTopology: {
+                count: meshCoordinators.length,
+                averageConnectionsPerAgent: this.getAverageConnectionsPerAgent(meshCoordinators),
+                networkDiameter: this.getNetworkDiameter(meshCoordinators),
+                clustering: this.getMeshClusteringMetrics(meshCoordinators)
+            },
+            overallMetrics: {
+                totalCoordinators: this.coordinatorAdapters.size,
+                topologyEfficiency: this.getOverallTopologyEfficiency(),
+                scalingCharacteristics: this.getScalingCharacteristics()
+            }
+        };
+    }
+    // ===========================
+    // Event Listeners
+    // ===========================
+    async registerEventListener(listener) {
+        this.eventListeners.add(listener);
+        this.logger.debug('V1 transparency event listener registered');
+    }
+    async unregisterEventListener(listener) {
+        this.eventListeners.delete(listener);
+        this.logger.debug('V1 transparency event listener unregistered');
+    }
+    // ===========================
+    // Private Helper Methods
+    // ===========================
+    getDefaultConfig() {
+        return {
+            enableRealTimeMonitoring: true,
+            enableEventStreaming: true,
+            eventRetentionHours: 24,
+            metricsCollectionIntervalMs: 5000,
+            enablePerformanceMonitoring: true,
+            enableDependencyTracking: true,
+            maxEventsInMemory: 10000,
+            enableCoordinatorMonitoring: true,
+            enableHealthMonitoring: true,
+            enableTaskTracking: true
+        };
+    }
+    setupCoordinatorEventListeners(adapter) {
+        const { eventEmitter, id: coordinatorId } = adapter;
+        // Listen to all coordinator events
+        eventEmitter.on('workerSpawned', (data)=>this.handleWorkerSpawned(coordinatorId, data));
+        eventEmitter.on('workerStatusChanged', (data)=>this.handleWorkerStatusChanged(coordinatorId, data));
+        eventEmitter.on('taskDelegated', (data)=>this.handleTaskDelegated(coordinatorId, data));
+        eventEmitter.on('taskCompleted', (data)=>this.handleTaskCompleted(coordinatorId, data));
+        eventEmitter.on('taskFailed', (data)=>this.handleTaskFailed(coordinatorId, data));
+        eventEmitter.on('error', (error)=>this.handleCoordinatorError(coordinatorId, error));
+        // Start monitoring if already started
+        if (this.isMonitoring) {
+            this.startCoordinatorMonitoring(adapter);
+        }
+    }
+    startCoordinatorMonitoring(adapter) {
+        // Initial data collection
+        this.collectCoordinatorData(adapter);
+    }
+    collectCoordinatorData(adapter) {
+    // This would collect initial data from the coordinator
+    // Implementation depends on the specific coordinator type
+    }
+    collectMetrics() {
+        if (!this.isMonitoring) return;
+        // Collect metrics from all registered coordinators
+        for (const adapter of this.coordinatorAdapters.values()){
+            if (adapter.metrics) {
+                const metrics = adapter.metrics.getCurrentMetrics();
+            // Process metrics...
+            }
+        }
+        this.notifyMetricsUpdate();
+    }
+    performHealthChecks() {
+        // Perform health checks on all agents and coordinators
+        for (const [agentId, agent] of this.agentInfo.entries()){
+            const now = new Date();
+            const timeSinceLastActivity = now.getTime() - agent.timestamps.lastActivity.getTime();
+            if (timeSinceLastActivity > 300000) {
+                agent.status = 'degraded';
+                this.recordEvent({
+                    eventId: uuidv4(),
+                    timestamp: now,
+                    eventType: 'agent_health_updated',
+                    eventData: {
+                        agentId,
+                        previousState: agent.status,
+                        newState: 'degraded',
+                        reason: 'No recent activity'
+                    },
+                    source: {
+                        component: 'V1TransparencySystem',
+                        instance: 'health-check'
+                    },
+                    severity: 'warning',
+                    category: 'coordination'
+                });
+            }
+        }
+    }
+    recordEvent(event) {
+        // Rate limiting check to prevent event flooding attacks
+        const sourceId = event.source?.instance || 'unknown';
+        if (!this.checkRateLimit(sourceId)) {
+            this.logger.warn(`Event rate limit exceeded for source: ${sourceId}`);
+            return; // Drop the event if rate limit exceeded
+        }
+        // Input sanitization for security
+        const sanitizedEvent = this.sanitizeEvent(event);
+        this.transparencyEvents.push(sanitizedEvent);
+        // Enforce event retention limit
+        if (this.transparencyEvents.length > this.config.maxEventsInMemory) {
+            const excess = this.transparencyEvents.length - this.config.maxEventsInMemory;
+            this.transparencyEvents.splice(0, excess);
+        }
+        // Update events per second calculation
+        this.recentEventTimestamps.push(sanitizedEvent.timestamp);
+        this.cleanupOldEventTimestamps();
+        // Notify listeners
+        this.eventListeners.forEach((listener)=>{
+            if (listener.onTransparencyEvent) {
+                try {
+                    listener.onTransparencyEvent(sanitizedEvent);
+                } catch (error) {
+                    this.logger.error('Error in transparency event listener', error);
+                }
+            }
+        });
+        this.emit('transparencyEvent', sanitizedEvent);
+    }
+    /**
+   * Check rate limiting for event sources to prevent DoS attacks
+   *
+   * Note: This is a basic implementation. In production, consider:
+   * - Distributed rate limiting for multi-instance deployments
+   * - Adaptive rate limits based on system load
+   * - Different limits for different event types/severities
+   * - Configurable rate limits per coordinator type
+   */ checkRateLimit(sourceId) {
+        const now = new Date();
+        const sourceData = this.eventCountsBySource.get(sourceId);
+        if (!sourceData) {
+            // First event from this source
+            this.eventCountsBySource.set(sourceId, {
+                count: 1,
+                lastReset: now
+            });
+            return true;
+        }
+        // Check if we need to reset the counter (time window passed)
+        const timeSinceReset = now.getTime() - sourceData.lastReset.getTime();
+        if (timeSinceReset > this.RATE_LIMIT_WINDOW_MS) {
+            // Reset counter for new time window
+            this.eventCountsBySource.set(sourceId, {
+                count: 1,
+                lastReset: now
+            });
+            return true;
+        }
+        // Check if source has exceeded rate limit
+        if (sourceData.count >= this.RATE_LIMIT_MAX_EVENTS) {
+            return false; // Rate limit exceeded
+        }
+        // Increment counter
+        sourceData.count++;
+        return true;
+    }
+    /**
+   * Sanitize event data to prevent security issues
+   *
+   * Security considerations:
+   * - Remove potentially malicious HTML/JS from event data
+   * - Limit string lengths to prevent DoS attacks
+   * - Validate event structure before processing
+   * - Rate limiting concept for event streams (implementation note)
+   */ sanitizeEvent(event) {
+        const sanitized = {
+            ...event
+        };
+        // Sanitize event data fields
+        if (sanitized.eventData) {
+            sanitized.eventData = this.sanitizeEventData(sanitized.eventData);
+        }
+        // Limit string lengths to prevent memory issues
+        if (sanitized.eventType && sanitized.eventType.length > 100) {
+            sanitized.eventType = sanitized.eventType.substring(0, 100);
+        }
+        if (sanitized.category && sanitized.category.length > 50) {
+            sanitized.category = sanitized.category.substring(0, 50);
+        }
+        // Ensure severity is valid
+        const validSeverities = [
+            'info',
+            'warning',
+            'error',
+            'critical'
+        ];
+        if (!validSeverities.includes(sanitized.severity)) {
+            sanitized.severity = 'info';
+        }
+        return sanitized;
+    }
+    /**
+   * Sanitize event data object to prevent injection attacks
+   */ sanitizeEventData(eventData) {
+        if (!eventData || typeof eventData !== 'object') {
+            return {};
+        }
+        const sanitized = {};
+        Object.keys(eventData).forEach((key)=>{
+            const value = eventData[key];
+            // Limit key length
+            const sanitizedKey = key.length > 100 ? key.substring(0, 100) : key;
+            // Sanitize different value types
+            if (typeof value === 'string') {
+                // Remove potential XSS patterns and limit length
+                const cleanValue = value.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '[SCRIPT_REMOVED]').replace(/javascript:/gi, '[JS_REMOVED]').replace(/on\w+\s*=/gi, '[EVENT_HANDLER_REMOVED]').substring(0, 1000); // Limit string length
+                sanitized[sanitizedKey] = cleanValue;
+            } else if (typeof value === 'object' && value !== null) {
+                // Recursively sanitize nested objects
+                sanitized[sanitizedKey] = this.sanitizeEventData(value);
+            } else {
+                // Keep primitive types as-is
+                sanitized[sanitizedKey] = value;
+            }
+        });
+        return sanitized;
+    }
+    notifyMetricsUpdate() {
+        this.getTransparencyMetrics().then((metrics)=>{
+            this.eventListeners.forEach((listener)=>{
+                if (listener.onMetricsUpdate) {
+                    try {
+                        listener.onMetricsUpdate(metrics);
+                    } catch (error) {
+                        this.logger.error('Error in metrics update listener', error);
+                    }
+                }
+            });
+            this.emit('metricsUpdate', metrics);
+        }).catch((error)=>{
+            this.logger.error('Error getting transparency metrics', error);
+        });
+    }
+    // Event handlers
+    handleWorkerSpawned(coordinatorId, data) {
+        const agent = {
+            agentId: data.workerId,
+            agentType: data.workerType,
+            capabilities: data.capabilities,
+            status: 'idle',
+            level: 2,
+            coordinatorId,
+            peerAgentIds: [],
+            childAgentIds: [],
+            currentTasks: [],
+            taskStats: {
+                completed: 0,
+                failed: 0,
+                total: 0,
+                successRate: 100
+            },
+            health: {
+                successRate: 100,
+                averageResponseTime: 0,
+                errorCount: 0,
+                consecutiveFailures: 0,
+                lastHealthCheck: new Date()
+            },
+            resources: {
+                memoryUsage: 0,
+                cpuUsage: 0,
+                networkIO: 0
+            },
+            timestamps: {
+                spawnedAt: new Date(),
+                lastActivity: new Date(),
+                lastStateChange: new Date()
+            },
+            topology: {
+                connections: 0,
+                maxConnections: data.capabilities?.maxConcurrentTasks || 5,
+                workload: 0
+            },
+            dependencies: {
+                dependsOn: [],
+                blocksCompletion: [],
+                waitingFor: []
+            }
+        };
+        this.agentInfo.set(data.workerId, agent);
+        this.recordEvent({
+            eventId: uuidv4(),
+            timestamp: new Date(),
+            eventType: 'agent_spawned',
+            eventData: {
+                agentId: data.workerId,
+                coordinatorId,
+                agentType: data.workerType
+            },
+            source: {
+                component: 'V1TransparencySystem',
+                instance: coordinatorId
+            },
+            severity: 'info',
+            category: 'lifecycle'
+        });
+    }
+    handleWorkerStatusChanged(coordinatorId, data) {
+        const agent = this.agentInfo.get(data.workerId);
+        if (agent) {
+            const previousStatus = agent.status;
+            agent.status = data.newStatus;
+            agent.timestamps.lastStateChange = new Date();
+            this.recordEvent({
+                eventId: uuidv4(),
+                timestamp: new Date(),
+                eventType: 'agent_status_changed',
+                eventData: {
+                    agentId: data.workerId,
+                    coordinatorId,
+                    previousState: previousStatus,
+                    newState: data.newStatus,
+                    reason: data.reason
+                },
+                source: {
+                    component: 'V1TransparencySystem',
+                    instance: coordinatorId
+                },
+                severity: 'info',
+                category: 'lifecycle'
+            });
+        }
+    }
+    handleTaskDelegated(coordinatorId, data) {
+        const task = {
+            taskId: data.taskId,
+            taskType: data.taskType,
+            description: data.description,
+            status: 'active',
+            priority: data.priority || 5,
+            assignedAgents: [
+                data.workerId
+            ],
+            dependencies: data.dependencies || [],
+            progress: {
+                percentage: 0
+            },
+            timing: {
+                createdAt: new Date(),
+                startedAt: new Date()
+            },
+            resources: {
+                required: data.resources || {},
+                used: {}
+            },
+            quality: {
+                confidence: 0
+            }
+        };
+        this.taskInfo.set(data.taskId, task);
+        // Update agent's current tasks
+        const agent = this.agentInfo.get(data.workerId);
+        if (agent) {
+            agent.currentTasks.push(data.taskId);
+            agent.status = 'busy';
+        }
+        this.recordEvent({
+            eventId: uuidv4(),
+            timestamp: new Date(),
+            eventType: 'task_assigned',
+            eventData: {
+                taskId: data.taskId,
+                agentId: data.workerId,
+                coordinatorId
+            },
+            source: {
+                component: 'V1TransparencySystem',
+                instance: coordinatorId
+            },
+            severity: 'info',
+            category: 'coordination'
+        });
+    }
+    handleTaskCompleted(coordinatorId, data) {
+        const task = this.taskInfo.get(data.taskId);
+        if (task) {
+            task.status = 'completed';
+            task.timing.completedAt = new Date();
+            task.result = data.result;
+            task.quality.confidence = data.confidence || 0.8;
+            // Update agent's task stats
+            for (const agentId of task.assignedAgents){
+                const agent = this.agentInfo.get(agentId);
+                if (agent) {
+                    agent.taskStats.completed++;
+                    agent.taskStats.total++;
+                    agent.taskStats.successRate = agent.taskStats.completed / agent.taskStats.total * 100;
+                    // Remove from current tasks
+                    agent.currentTasks = agent.currentTasks.filter((id)=>id !== data.taskId);
+                    if (agent.currentTasks.length === 0) {
+                        agent.status = 'idle';
+                    }
+                }
+            }
+            this.recordEvent({
+                eventId: uuidv4(),
+                timestamp: new Date(),
+                eventType: 'task_completed',
+                eventData: {
+                    taskId: data.taskId,
+                    agentIds: task.assignedAgents,
+                    coordinatorId,
+                    confidence: task.quality.confidence
+                },
+                source: {
+                    component: 'V1TransparencySystem',
+                    instance: coordinatorId
+                },
+                severity: 'info',
+                category: 'coordination'
+            });
+        }
+    }
+    handleTaskFailed(coordinatorId, data) {
+        const task = this.taskInfo.get(data.taskId);
+        if (task) {
+            task.status = 'failed';
+            task.timing.completedAt = new Date();
+            task.error = data.error;
+            // Update agent's task stats
+            for (const agentId of task.assignedAgents){
+                const agent = this.agentInfo.get(agentId);
+                if (agent) {
+                    agent.taskStats.failed++;
+                    agent.taskStats.total++;
+                    agent.taskStats.successRate = agent.taskStats.completed / agent.taskStats.total * 100;
+                    agent.health.errorCount++;
+                    agent.health.consecutiveFailures++;
+                    // Remove from current tasks
+                    agent.currentTasks = agent.currentTasks.filter((id)=>id !== data.taskId);
+                    if (agent.currentTasks.length === 0) {
+                        agent.status = 'idle';
+                    }
+                }
+            }
+            this.recordEvent({
+                eventId: uuidv4(),
+                timestamp: new Date(),
+                eventType: 'task_failed',
+                eventData: {
+                    taskId: data.taskId,
+                    agentIds: task.assignedAgents,
+                    coordinatorId,
+                    error: data.error
+                },
+                source: {
+                    component: 'V1TransparencySystem',
+                    instance: coordinatorId
+                },
+                severity: 'error',
+                category: 'error'
+            });
+        }
+    }
+    handleCoordinatorError(coordinatorId, error) {
+        this.recordEvent({
+            eventId: uuidv4(),
+            timestamp: new Date(),
+            eventType: 'error_occurred',
+            eventData: {
+                coordinatorId,
+                error: error.message,
+                stack: error.stack
+            },
+            source: {
+                component: 'V1TransparencySystem',
+                instance: coordinatorId
+            },
+            severity: 'error',
+            category: 'error'
+        });
+    }
+    // Helper methods for metrics calculation
+    calculateEventsPerSecond() {
+        const now = new Date();
+        const oneSecondAgo = new Date(now.getTime() - 1000);
+        const recentEvents = this.recentEventTimestamps.filter((timestamp)=>timestamp >= oneSecondAgo);
+        this.eventsPerSecond = recentEvents.length;
+    }
+    cleanupOldEventTimestamps() {
+        const fiveMinutesAgo = new Date(Date.now() - 300000);
+        this.recentEventTimestamps = this.recentEventTimestamps.filter((timestamp)=>timestamp >= fiveMinutesAgo);
+    }
+    groupAgentsByType(agents) {
+        const groups = {};
+        agents.forEach((agent)=>{
+            groups[agent.agentType] = (groups[agent.agentType] || 0) + 1;
+        });
+        return groups;
+    }
+    groupAgentsByCoordinator(agents) {
+        const groups = {};
+        agents.forEach((agent)=>{
+            groups[agent.coordinatorId] = (groups[agent.coordinatorId] || 0) + 1;
+        });
+        return groups;
+    }
+    calculateAverageHealth(agents) {
+        if (agents.length === 0) return 100;
+        const totalHealth = agents.reduce((sum, agent)=>sum + agent.health.successRate, 0);
+        return totalHealth / agents.length;
+    }
+    calculateAgentUtilization(agents) {
+        if (agents.length === 0) return 0;
+        const busyAgents = agents.filter((agent)=>agent.status === 'busy' || agent.status === 'working').length;
+        return busyAgents / agents.length * 100;
+    }
+    groupTasksByType(tasks) {
+        const groups = {};
+        tasks.forEach((task)=>{
+            groups[task.taskType] = (groups[task.taskType] || 0) + 1;
+        });
+        return groups;
+    }
+    groupTasksByPriority(tasks) {
+        const groups = {};
+        tasks.forEach((task)=>{
+            const priorityKey = `priority_${task.priority}`;
+            groups[priorityKey] = (groups[priorityKey] || 0) + 1;
+        });
+        return groups;
+    }
+    calculateAverageTaskDuration(tasks) {
+        const completedTasks = tasks.filter((task)=>task.timing.completedAt && task.timing.startedAt);
+        if (completedTasks.length === 0) return 0;
+        const totalDuration = completedTasks.reduce((sum, task)=>{
+            return sum + (task.timing.completedAt.getTime() - task.timing.startedAt.getTime());
+        }, 0);
+        return totalDuration / completedTasks.length;
+    }
+    calculateTaskSuccessRate(tasks) {
+        const completedTasks = tasks.filter((task)=>task.status === 'completed' || task.status === 'failed');
+        if (completedTasks.length === 0) return 100;
+        const successfulTasks = completedTasks.filter((task)=>task.status === 'completed').length;
+        return successfulTasks / completedTasks.length * 100;
+    }
+    calculateTaskThroughput(tasks) {
+        const now = new Date();
+        const oneHourAgo = new Date(now.getTime() - 3600000);
+        const recentTasks = tasks.filter((task)=>task.timing.completedAt && task.timing.completedAt >= oneHourAgo);
+        return recentTasks.length; // tasks per hour
+    }
+    calculateAverageResponseTime(agents) {
+        if (agents.length === 0) return 0;
+        const totalResponseTime = agents.reduce((sum, agent)=>sum + agent.health.averageResponseTime, 0);
+        return totalResponseTime / agents.length;
+    }
+    calculateTotalMemoryUsage(agents) {
+        return agents.reduce((sum, agent)=>sum + agent.resources.memoryUsage, 0);
+    }
+    calculateTotalCpuUsage(agents) {
+        if (agents.length === 0) return 0;
+        const totalCpu = agents.reduce((sum, agent)=>sum + agent.resources.cpuUsage, 0);
+        return totalCpu / agents.length;
+    }
+    calculateTotalNetworkIO(agents) {
+        return agents.reduce((sum, agent)=>sum + agent.resources.networkIO, 0);
+    }
+    calculateErrorRate(tasks) {
+        const totalTasks = tasks.length;
+        const failedTasks = tasks.filter((task)=>task.status === 'failed').length;
+        return totalTasks > 0 ? failedTasks / totalTasks * 100 : 0;
+    }
+    calculateResourceUtilization(agents) {
+        if (agents.length === 0) return 0;
+        const totalAllocated = agents.reduce((sum, agent)=>sum + agent.topology.connections, 0);
+        const totalAvailable = agents.reduce((sum, agent)=>sum + agent.topology.maxConnections, 0);
+        return totalAvailable > 0 ? totalAllocated / totalAvailable * 100 : 0;
+    }
+    groupEventsByType() {
+        const groups = {};
+        this.transparencyEvents.forEach((event)=>{
+            groups[event.eventType] = (groups[event.eventType] || 0) + 1;
+        });
+        return groups;
+    }
+    groupEventsBySeverity() {
+        const groups = {};
+        this.transparencyEvents.forEach((event)=>{
+            groups[event.severity] = (groups[event.severity] || 0) + 1;
+        });
+        return groups;
+    }
+    groupEventsByCategory() {
+        const groups = {};
+        this.transparencyEvents.forEach((event)=>{
+            groups[event.category] = (groups[event.category] || 0) + 1;
+        });
+        return groups;
+    }
+    // Additional helper methods for analytics
+    getHealthDistribution(agents) {
+        const distribution = {
+            excellent: 0,
+            good: 0,
+            fair: 0,
+            poor: 0
+        };
+        agents.forEach((agent)=>{
+            const health = agent.health.successRate;
+            if (health >= 90) distribution.excellent++;
+            else if (health >= 75) distribution.good++;
+            else if (health >= 60) distribution.fair++;
+            else distribution.poor++;
+        });
+        return distribution;
+    }
+    getUtilizationTrends(agents) {
+        // Simple implementation - in real system, this would track trends over time
+        const utilization = this.calculateAgentUtilization(agents);
+        return {
+            current: utilization,
+            trend: 'stable',
+            forecast: utilization
+        };
+    }
+    getPerformanceByAgentType(agents) {
+        const performanceByType = {};
+        agents.forEach((agent)=>{
+            if (!performanceByType[agent.agentType]) {
+                performanceByType[agent.agentType] = {
+                    count: 0,
+                    averageHealth: 0,
+                    averageUtilization: 0,
+                    totalTasks: 0
+                };
+            }
+            const typeData = performanceByType[agent.agentType];
+            typeData.count++;
+            typeData.averageHealth += agent.health.successRate;
+            typeData.totalTasks += agent.taskStats.total;
+        });
+        // Calculate averages
+        Object.values(performanceByType).forEach((data)=>{
+            if (data.count > 0) {
+                data.averageHealth /= data.count;
+                data.averageUtilization = data.count > 0 ? 100 : 0; // Simplified
+            }
+        });
+        return performanceByType;
+    }
+    // Additional methods would be implemented here for complete functionality...
+    getMaxAgentsForCoordinator(adapter) {
+        // Extract max agents from coordinator instance
+        return 50; // Default value
+    }
+    getAgentCountForCoordinator(coordinatorId) {
+        return this.agentInfo.size; // Simplified
+    }
+    async getCoordinatorPerformance(adapter) {
+        return {
+            taskThroughput: 10,
+            agentUtilization: 75,
+            averageResponseTime: 150,
+            errorRate: 2
+        };
+    }
+    buildHierarchyFromQueenAgent(queenAgent) {
+        // Build hierarchy from QueenAgent instance
+        return {
+            level: 1,
+            type: 'queen-agent',
+            children: this.getAgentCountForCoordinator(queenAgent.toString())
+        };
+    }
+    getAgentCountForCoordinator(coordinatorId) {
+        return Array.from(this.agentInfo.values()).filter((agent)=>agent.coordinatorId === coordinatorId).length;
+    }
+    getMeshConnections(meshCoordinator) {
+        // Get connection information from MeshCoordinator
+        return {
+            totalConnections: 0,
+            averageConnectionsPerAgent: 0
+        };
+    }
+    // Analytics implementations
+    /**
+   * Calculate task completion rates by task type and status
+   */ getTaskCompletionRates(tasks) {
+        const totalTasks = tasks.length;
+        if (totalTasks === 0) return {
+            overall: 0,
+            byType: {}
+        };
+        const completedTasks = tasks.filter((task)=>task.status === 'completed').length;
+        const rates = {
+            overall: completedTasks / totalTasks * 100,
+            byType: {}
+        };
+        // Calculate completion rates by task type
+        const tasksByType = {};
+        tasks.forEach((task)=>{
+            if (!tasksByType[task.taskType]) {
+                tasksByType[task.taskType] = [];
+            }
+            tasksByType[task.taskType].push(task);
+        });
+        Object.entries(tasksByType).forEach(([type, typeTasks])=>{
+            const completed = typeTasks.filter((task)=>task.status === 'completed').length;
+            rates.byType[type] = typeTasks.length > 0 ? completed / typeTasks.length * 100 : 0;
+        });
+        return rates;
+    }
+    /**
+   * Analyze task durations by type for performance insights
+   */ getTaskDurationsByType(tasks) {
+        const durationsByType = {};
+        tasks.forEach((task)=>{
+            if (!durationsByType[task.taskType]) {
+                durationsByType[task.taskType] = {
+                    durations: [],
+                    count: 0
+                };
+            }
+            if (task.timing.completedAt && task.timing.startedAt) {
+                const duration = task.timing.completedAt.getTime() - task.timing.startedAt.getTime();
+                durationsByType[task.taskType].durations.push(duration);
+                durationsByType[task.taskType].count++;
+            }
+        });
+        const stats = {};
+        Object.entries(durationsByType).forEach(([type, data])=>{
+            if (data.durations.length > 0) {
+                data.durations.sort((a, b)=>a - b);
+                const sum = data.durations.reduce((acc, val)=>acc + val, 0);
+                stats[type] = {
+                    average: sum / data.durations.length,
+                    median: data.durations[Math.floor(data.durations.length / 2)],
+                    min: Math.min(...data.durations),
+                    max: Math.max(...data.durations),
+                    count: data.count
+                };
+            }
+        });
+        return stats;
+    }
+    /**
+   * Identify failure patterns in tasks for debugging and optimization
+   */ getFailurePatterns(tasks) {
+        const failedTasks = tasks.filter((task)=>task.status === 'failed');
+        if (failedTasks.length === 0) {
+            return {
+                totalFailures: 0,
+                patterns: []
+            };
+        }
+        const patterns = {
+            byType: {},
+            byAgent: {},
+            byErrorType: {},
+            commonErrors: []
+        };
+        failedTasks.forEach((task)=>{
+            // Group by task type
+            patterns.byType[task.taskType] = (patterns.byType[task.taskType] || 0) + 1;
+            // Group by assigned agents
+            task.assignedAgents.forEach((agentId)=>{
+                patterns.byAgent[agentId] = (patterns.byAgent[agentId] || 0) + 1;
+            });
+            // Extract error patterns from task metadata or results
+            if (task.error && typeof task.error === 'object' && task.error.type) {
+                patterns.byErrorType[task.error.type] = (patterns.byErrorType[task.error.type] || 0) + 1;
+            }
+        });
+        // Identify most common failures
+        patterns.commonErrors = Object.entries(patterns.byType).sort(([, a], [, b])=>b - a).slice(0, 5).map(([type, count])=>`${type}: ${count} failures`);
+        return {
+            totalFailures: failedTasks.length,
+            failureRate: failedTasks.length / tasks.length * 100,
+            patterns
+        };
+    }
+    /**
+   * Calculate scalability metrics for system capacity planning
+   */ getScalabilityMetrics() {
+        const activeAgents = this.agentInfo.size;
+        const totalTasks = this.taskInfo.size;
+        const activeCoordinators = this.coordinatorAdapters.size;
+        return {
+            currentCapacity: {
+                agents: activeAgents,
+                tasks: totalTasks,
+                coordinators: activeCoordinators
+            },
+            utilization: {
+                agentUtilization: this.calculateAgentUtilization(Array.from(this.agentInfo.values())),
+                taskThroughput: totalTasks > 0 ? this.taskInfo.size / activeAgents : 0,
+                coordinatorLoad: activeCoordinators > 0 ? activeAgents / activeCoordinators : 0
+            },
+            scalingLimits: {
+                maxAgents: this.config.maxAgents || 100,
+                maxTasksPerAgent: 10,
+                maxCoordinators: 20
+            }
+        };
+    }
+    /**
+   * Analyze system bottlenecks for performance optimization
+   */ getBottleneckAnalysis() {
+        const bottlenecks = [];
+        const agents = Array.from(this.agentInfo.values());
+        // Check for overloaded agents
+        const overloadedAgents = agents.filter((agent)=>agent.currentTasks.length > agent.capabilities.maxConcurrentTasks);
+        if (overloadedAgents.length > 0) {
+            bottlenecks.push({
+                type: 'agent_overload',
+                severity: 'high',
+                description: `${overloadedAgents.length} agents exceeding task capacity`,
+                affectedAgents: overloadedAgents.map((a)=>a.agentId)
+            });
+        }
+        // Check for idle agents
+        const idleAgents = agents.filter((agent)=>agent.status === 'idle' && agent.currentTasks.length === 0);
+        if (idleAgents.length > agents.length * 0.5) {
+            bottlenecks.push({
+                type: 'agent_underutilization',
+                severity: 'medium',
+                description: `${idleAgents.length} agents idle while tasks may be pending`,
+                affectedAgents: idleAgents.map((a)=>a.agentId)
+            });
+        }
+        // Check for coordinator bottlenecks
+        const coordinatorLoads = {};
+        agents.forEach((agent)=>{
+            if (agent.coordinatorId) {
+                coordinatorLoads[agent.coordinatorId] = (coordinatorLoads[agent.coordinatorId] || 0) + 1;
+            }
+        });
+        Object.entries(coordinatorLoads).forEach(([coordinatorId, load])=>{
+            if (load > 20) {
+                bottlenecks.push({
+                    type: 'coordinator_overload',
+                    severity: 'medium',
+                    description: `Coordinator ${coordinatorId} managing ${load} agents`,
+                    coordinatorId,
+                    load
+                });
+            }
+        });
+        return {
+            bottlenecks,
+            bottleneckCount: bottlenecks.length,
+            recommendations: this.generateBottleneckRecommendations(bottlenecks)
+        };
+    }
+    /**
+   * Generate optimization recommendations based on bottlenecks
+   */ generateBottleneckRecommendations(bottlenecks) {
+        const recommendations = [];
+        bottlenecks.forEach((bottleneck)=>{
+            switch(bottleneck.type){
+                case 'agent_overload':
+                    recommendations.push('Reduce task assignment to overloaded agents or spawn additional agents');
+                    break;
+                case 'agent_underutilization':
+                    recommendations.push('Optimize task distribution to utilize idle agents more effectively');
+                    break;
+                case 'coordinator_overload':
+                    recommendations.push('Consider adding additional coordinators or rebalancing agent distribution');
+                    break;
+            }
+        });
+        return recommendations;
+    }
+    /**
+   * Calculate system efficiency metrics
+   */ getEfficiencyMetrics() {
+        const agents = Array.from(this.agentInfo.values());
+        const tasks = Array.from(this.taskInfo.values());
+        const completedTasks = tasks.filter((task)=>task.status === 'completed');
+        const failedTasks = tasks.filter((task)=>task.status === 'failed');
+        return {
+            taskEfficiency: tasks.length > 0 ? completedTasks.length / tasks.length * 100 : 0,
+            agentEfficiency: this.calculateAgentUtilization(agents),
+            successRate: tasks.length > 0 ? completedTasks.length / tasks.length * 100 : 0,
+            errorRate: tasks.length > 0 ? failedTasks.length / tasks.length * 100 : 0,
+            averageTaskCompletionTime: this.calculateAverageCompletionTime(completedTasks)
+        };
+    }
+    /**
+   * Calculate average task completion time
+   */ calculateAverageCompletionTime(completedTasks) {
+        if (completedTasks.length === 0) return 0;
+        const totalDuration = completedTasks.reduce((sum, task)=>{
+            if (task.timing.completedAt && task.timing.startedAt) {
+                return sum + (task.timing.completedAt.getTime() - task.timing.startedAt.getTime());
+            }
+            return sum;
+        }, 0);
+        return totalDuration / completedTasks.length;
+    }
+    // Hierarchical topology metrics
+    getAverageWorkersPerQueen(queenAgents) {
+        if (queenAgents.length === 0) return 0;
+        const totalWorkers = queenAgents.reduce((sum, queen)=>{
+            const workers = Array.from(this.agentInfo.values()).filter((agent)=>agent.coordinatorId === queen.id);
+            return sum + workers.length;
+        }, 0);
+        return totalWorkers / queenAgents.length;
+    }
+    getHierarchyDepth(queenAgents) {
+        // Simple implementation - count coordinator levels
+        if (queenAgents.length === 0) return 0;
+        let maxDepth = 1;
+        const visited = new Set();
+        const calculateDepth = (coordinatorId, currentDepth)=>{
+            if (visited.has(coordinatorId)) return currentDepth;
+            visited.add(coordinatorId);
+            const children = Array.from(this.agentInfo.values()).filter((agent)=>agent.coordinatorId === coordinatorId);
+            if (children.length === 0) return currentDepth;
+            return Math.max(...children.map((child)=>calculateDepth(child.agentId, currentDepth + 1)));
+        };
+        queenAgents.forEach((queen)=>{
+            maxDepth = Math.max(maxDepth, calculateDepth(queen.id, 1));
+        });
+        return maxDepth;
+    }
+    getHierarchicalEfficiency(queenAgents) {
+        if (queenAgents.length === 0) return 0;
+        const totalAgents = this.agentInfo.size;
+        const queenAgentsCount = queenAgents.length;
+        // Efficiency based on optimal span of control (5-10 agents per queen)
+        const optimalSpan = 7;
+        const actualSpan = totalAgents / queenAgentsCount;
+        const spanEfficiency = Math.max(0, 100 - Math.abs(actualSpan - optimalSpan) * 5);
+        return Math.round(spanEfficiency);
+    }
+    // Mesh topology metrics
+    getAverageConnectionsPerAgent(meshCoordinators) {
+        const agents = Array.from(this.agentInfo.values());
+        if (agents.length === 0) return 0;
+        // Calculate average connections based on agent collaboration
+        let totalConnections = 0;
+        agents.forEach((agent)=>{
+            // Estimate connections based on shared tasks and coordinator relationships
+            const sharedTasks = Array.from(this.taskInfo.values()).filter((task)=>task.assignedAgents.includes(agent.agentId) && task.assignedAgents.length > 1);
+            totalConnections += sharedTasks.length;
+        });
+        return totalConnections / agents.length;
+    }
+    getNetworkDiameter(meshCoordinators) {
+        // Simplified network diameter calculation
+        // In a real implementation, this would use graph algorithms
+        const agentCount = this.agentInfo.size;
+        const coordinatorCount = meshCoordinators.length;
+        if (agentCount === 0) return 0;
+        // Estimate diameter based on network size and topology
+        return Math.ceil(Math.log2(agentCount + coordinatorCount));
+    }
+    getMeshClusteringMetrics(meshCoordinators) {
+        const agents = Array.from(this.agentInfo.values());
+        const tasks = Array.from(this.taskInfo.values());
+        // Calculate clustering coefficient based on task collaboration
+        let totalTriangles = 0;
+        let possibleTriangles = 0;
+        agents.forEach((agent)=>{
+            const collaborators = new Set();
+            tasks.forEach((task)=>{
+                if (task.assignedAgents.includes(agent.agentId)) {
+                    task.assignedAgents.forEach((otherAgent)=>{
+                        if (otherAgent !== agent.agentId) {
+                            collaborators.add(otherAgent);
+                        }
+                    });
+                }
+            });
+            const collaboratorList = Array.from(collaborators);
+            if (collaboratorList.length >= 2) {
+                possibleTriangles += collaboratorList.length * (collaboratorList.length - 1) / 2;
+                // Count actual triangles (simplified)
+                for(let i = 0; i < collaboratorList.length; i++){
+                    for(let j = i + 1; j < collaboratorList.length; j++){
+                        // Check if these collaborators also work together
+                        const sharedTasks = tasks.filter((task)=>task.assignedAgents.includes(collaboratorList[i]) && task.assignedAgents.includes(collaboratorList[j]));
+                        if (sharedTasks.length > 0) {
+                            totalTriangles++;
+                        }
+                    }
+                }
+            }
+        });
+        const clusteringCoefficient = possibleTriangles > 0 ? totalTriangles / possibleTriangles : 0;
+        return {
+            clusteringCoefficient,
+            totalClusters: Math.round(agents.length * clusteringCoefficient),
+            averageClusterSize: clusteringCoefficient > 0 ? Math.round(agents.length / (agents.length * clusteringCoefficient)) : 0
+        };
+    }
+    getOverallTopologyEfficiency() {
+        const agents = Array.from(this.agentInfo.values());
+        const tasks = Array.from(this.taskInfo.values());
+        if (agents.length === 0 || tasks.length === 0) return 0;
+        // Calculate efficiency based on multiple factors
+        const utilizationEfficiency = this.calculateAgentUtilization(agents);
+        const taskSuccessRate = this.getTaskCompletionRates(tasks).overall;
+        const collaborationEfficiency = Math.min(this.getAverageConnectionsPerAgent([]) * 10, 100); // Scale to 0-100
+        return Math.round((utilizationEfficiency + taskSuccessRate + collaborationEfficiency) / 3);
+    }
+    getScalingCharacteristics() {
+        const currentLoad = this.agentInfo.size;
+        const taskLoad = this.taskInfo.size;
+        return {
+            currentScale: {
+                agents: currentLoad,
+                tasks: taskLoad,
+                coordinators: this.coordinatorAdapters.size
+            },
+            scalingLimits: {
+                maxAgents: this.config.maxAgents || 100,
+                maxTasks: this.config.maxEventsInMemory || 1000,
+                maxCoordinators: 20
+            },
+            scalingRecommendations: this.generateScalingRecommendations(currentLoad, taskLoad)
+        };
+    }
+    generateScalingRecommendations(currentAgents, currentTasks) {
+        const recommendations = [];
+        if (currentAgents > (this.config.maxAgents || 100) * 0.8) {
+            recommendations.push('Approaching agent limit - consider scaling coordinator infrastructure');
+        }
+        if (currentTasks > currentAgents * 8) {
+            recommendations.push('High task-to-agent ratio - consider spawning additional agents');
+        }
+        if (currentAgents < (this.config.maxAgents || 100) * 0.3 && currentTasks > 0) {
+            recommendations.push('Low agent utilization - optimize task distribution or reduce agent count');
+        }
+        return recommendations;
+    }
+}
+
+//# sourceMappingURL=v1-transparency-adapter.js.map