claude-flow-novice 1.6.1 → 1.6.2

package/.claude-flow-novice/dist/src/coordination/config-translator.js

@@ -0,0 +1,248 @@
+/**
+ * ConfigTranslator - Unified configuration translation for V1/V2 coordination systems
+ *
+ * Provides bidirectional translation between unified configuration format
+ * and version-specific config structures for V1 (CoordinationTopologyConfig)
+ * and V2 (FactoryOptions).
+ *
+ * @module coordination/config-translator
+ */ /**
+ * ConfigTranslator - Static utility class for config translation
+ *
+ * Handles bidirectional conversion between unified config and version-specific formats.
+ * Provides intelligent defaults based on topology and agent count.
+ *
+ * Key Translation Rules:
+ * - topology: 'mesh' → V1 mesh config / V2 SDK mode
+ * - topology: 'hierarchical' → V1 hierarchical config / V2 SDK mode
+ * - maxAgents → V1 maxAgents / V2 maxConcurrentAgents
+ * - strategy → V1 strategy / V2 enableDynamicAllocation
+ * - enableConsensus → V1 consensus config / V2 N/A (built-in)
+ *
+ * @example
+ * ```typescript
+ * const unified: UnifiedCoordinatorConfig = {
+ *   topology: 'mesh',
+ *   maxAgents: 5,
+ *   strategy: 'balanced',
+ *   enableConsensus: true
+ * };
+ *
+ * // Translate to V1
+ * const v1Config = ConfigTranslator.toV1Config(unified);
+ * const coordinator = await createTopologyCoordinator(v1Config, deps);
+ *
+ * // Translate to V2
+ * const v2Config = ConfigTranslator.toV2Config(unified);
+ * const coordinator = await CoordinatorFactory.create(v2Config);
+ * ```
+ */ export class ConfigTranslator {
+    /**
+   * Translate unified config to V1 CoordinationTopologyConfig
+   *
+   * Generates topology-specific config objects for hierarchical or mesh modes.
+   * Applies intelligent defaults based on agent count and topology type.
+   *
+   * @param unified - Unified coordinator configuration
+   * @returns V1 CoordinationTopologyConfig
+   *
+   * @example
+   * ```typescript
+   * const v1Config = ConfigTranslator.toV1Config({
+   *   topology: 'hierarchical',
+   *   maxAgents: 15,
+   *   strategy: 'adaptive'
+   * });
+   * // Returns: { topology: 'hierarchical', maxAgents: 15, hierarchical: {...}, consensus: {...} }
+   * ```
+   */ static toV1Config(unified) {
+        const topology = unified.topology || 'mesh';
+        const maxAgents = unified.maxAgents || 10;
+        const strategy = unified.strategy || 'balanced';
+        const config = {
+            topology,
+            maxAgents,
+            strategy
+        };
+        // Add hierarchical-specific config
+        if (topology === 'hierarchical') {
+            const hierarchicalConfig = {
+                minWorkers: Math.min(8, maxAgents),
+                maxWorkers: maxAgents,
+                autoScale: true,
+                scalingThreshold: 0.8,
+                healthCheckInterval: 30000,
+                taskTimeout: 120000,
+                workerRetryAttempts: 3
+            };
+            config.hierarchical = hierarchicalConfig;
+        }
+        // Add mesh-specific config
+        if (topology === 'mesh') {
+            const meshConfig = {
+                maxAgents,
+                maxConnections: Math.floor(maxAgents / 3),
+                taskDistributionStrategy: 'capability-based',
+                enableDependencyTracking: true,
+                completionTimeout: 60000,
+                rebalanceInterval: 15000,
+                memoryNamespace: 'mesh-coordination'
+            };
+            config.mesh = meshConfig;
+        }
+        // Add consensus config if enabled
+        if (unified.enableConsensus) {
+            const protocol = topology === 'hierarchical' ? 'raft' : 'quorum';
+            const consensusConfig = {
+                protocol,
+                timeout: 5000,
+                maxRetries: 3,
+                quorumSize: Math.ceil(maxAgents / 2) + 1
+            };
+            config.consensus = consensusConfig;
+        }
+        return config;
+    }
+    /**
+   * Translate unified config to V2 FactoryOptions
+   *
+   * Generates V2-compatible config with SDK mode defaults and modern features.
+   * Always defaults to SDK mode with dynamic allocation enabled.
+   *
+   * @param unified - Unified coordinator configuration
+   * @returns V2 FactoryOptions
+   *
+   * @example
+   * ```typescript
+   * const v2Config = ConfigTranslator.toV2Config({
+   *   topology: 'mesh',
+   *   maxAgents: 5,
+   *   tokenBudget: 50000
+   * });
+   * // Returns: { mode: 'sdk', maxConcurrentAgents: 5, defaultTokenBudget: 50000, ... }
+   * ```
+   */ static toV2Config(unified) {
+        const maxAgents = unified.maxAgents || 10;
+        const tokenBudget = unified.tokenBudget || 20000;
+        return {
+            // V2 defaults to SDK mode
+            mode: 'sdk',
+            // Agent limits
+            maxConcurrentAgents: maxAgents,
+            defaultTokenBudget: tokenBudget,
+            // API credentials (from environment or unified config)
+            apiKey: unified.apiKey || process.env.ANTHROPIC_API_KEY,
+            // Dynamic allocation (maps from strategy)
+            enableDynamicAllocation: unified.strategy !== 'performance',
+            // Logging
+            verbose: unified.verbose || false
+        };
+    }
+    /**
+   * Validate unified config for completeness
+   *
+   * Checks that required fields are present and values are within valid ranges.
+   *
+   * @param config - Unified config to validate
+   * @returns Validation errors (empty array if valid)
+   *
+   * @example
+   * ```typescript
+   * const errors = ConfigTranslator.validate({ topology: 'mesh' });
+   * if (errors.length > 0) {
+   *   console.error('Config validation failed:', errors);
+   * }
+   * ```
+   */ static validate(config) {
+        const errors = [];
+        // Validate topology
+        if (config.topology && ![
+            'mesh',
+            'hierarchical'
+        ].includes(config.topology)) {
+            errors.push(`Invalid topology: ${config.topology}. Must be 'mesh' or 'hierarchical'.`);
+        }
+        // Validate maxAgents
+        if (config.maxAgents !== undefined) {
+            if (config.maxAgents < 1) {
+                errors.push(`Invalid maxAgents: ${config.maxAgents}. Must be at least 1.`);
+            }
+            if (config.maxAgents > 100) {
+                errors.push(`Invalid maxAgents: ${config.maxAgents}. Maximum is 100.`);
+            }
+        }
+        // Validate strategy
+        if (config.strategy && ![
+            'balanced',
+            'adaptive',
+            'performance'
+        ].includes(config.strategy)) {
+            errors.push(`Invalid strategy: ${config.strategy}. Must be 'balanced', 'adaptive', or 'performance'.`);
+        }
+        // Validate tokenBudget
+        if (config.tokenBudget !== undefined && config.tokenBudget < 1000) {
+            errors.push(`Invalid tokenBudget: ${config.tokenBudget}. Must be at least 1000.`);
+        }
+        return errors;
+    }
+    /**
+   * Merge multiple unified configs with priority
+   *
+   * Combines multiple config objects, with later configs taking precedence.
+   * Useful for layering defaults, environment, and user configs.
+   *
+   * @param configs - Config objects to merge (in priority order)
+   * @returns Merged unified config
+   *
+   * @example
+   * ```typescript
+   * const defaults = { topology: 'mesh', maxAgents: 5 };
+   * const userConfig = { maxAgents: 10, strategy: 'adaptive' };
+   * const merged = ConfigTranslator.merge(defaults, userConfig);
+   * // Returns: { topology: 'mesh', maxAgents: 10, strategy: 'adaptive' }
+   * ```
+   */ static merge(...configs) {
+        return configs.reduce((acc, config)=>{
+            return {
+                ...acc,
+                ...config
+            };
+        }, {});
+    }
+    /**
+   * Get default config for topology type
+   *
+   * Provides opinionated defaults optimized for each topology.
+   *
+   * @param topology - Topology type
+   * @returns Default unified config
+   *
+   * @example
+   * ```typescript
+   * const meshDefaults = ConfigTranslator.getDefaults('mesh');
+   * // Returns: { topology: 'mesh', maxAgents: 7, strategy: 'balanced', ... }
+   * ```
+   */ static getDefaults(topology) {
+        if (topology === 'mesh') {
+            return {
+                topology: 'mesh',
+                maxAgents: 7,
+                strategy: 'balanced',
+                enableConsensus: true,
+                tokenBudget: 20000,
+                verbose: false
+            };
+        } else {
+            return {
+                topology: 'hierarchical',
+                maxAgents: 15,
+                strategy: 'adaptive',
+                enableConsensus: true,
+                tokenBudget: 20000,
+                verbose: false
+            };
+        }
+    }
+}
+
+//# sourceMappingURL=config-translator.js.map

package/.claude-flow-novice/dist/src/coordination/config-translator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/coordination/config-translator.ts"],"names":["ConfigTranslator","toV1Config","unified","topology","maxAgents","strategy","config","hierarchicalConfig","minWorkers","Math","min","maxWorkers","autoScale","scalingThreshold","healthCheckInterval","taskTimeout","workerRetryAttempts","hierarchical","meshConfig","maxConnections","floor","taskDistributionStrategy","enableDependencyTracking","completionTimeout","rebalanceInterval","memoryNamespace","mesh","enableConsensus","protocol","consensusConfig","timeout","maxRetries","quorumSize","ceil","consensus","toV2Config","tokenBudget","mode","maxConcurrentAgents","defaultTokenBudget","apiKey","process","env","ANTHROPIC_API_KEY","enableDynamicAllocation","verbose","validate","errors","includes","push","undefined","merge","configs","reduce","acc","getDefaults"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/coordination-toggle.js

@@ -0,0 +1,287 @@
+/**
+ * CoordinationToggle - Version-aware coordinator factory
+ *
+ * Provides unified factory interface for V1/V2 coordination systems.
+ * Auto-detects version from environment and instantiates appropriate coordinator.
+ *
+ * @module coordination/coordination-toggle
+ */ import { CoordinatorFactory } from './v2/coordinator-factory.js';
+import { createTopologyCoordinator } from './index.js';
+import { Logger } from '../core/logger.js';
+import { V1CoordinatorAdapter } from './adapters/v1-coordinator-adapter.js';
+import { ConfigTranslator } from './config-translator.js';
+import { TelemetrySystem } from '../observability/telemetry.js';
+// Re-export ConfigTranslator for test compatibility
+export { ConfigTranslator } from './config-translator.js';
+/**
+ * CoordinationToggle - Factory selector for V1/V2 coordinators
+ *
+ * Features:
+ * - Auto-detects coordination version from COORDINATION_VERSION env var
+ * - Translates unified config to version-specific formats
+ * - Returns ICoordinator interface regardless of version
+ * - Enables gradual V2 migration without breaking V1 usage
+ *
+ * Version Selection Priority:
+ * 1. Explicit config.version ('v1' | 'v2')
+ * 2. COORDINATION_VERSION environment variable
+ * 3. Default: 'v2' (current recommended version)
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect version (uses COORDINATION_VERSION env var or defaults to v2)
+ * const coordinator = await CoordinationToggle.create({
+ *   topology: 'mesh',
+ *   maxAgents: 5
+ * });
+ *
+ * // Explicit V1 coordinator
+ * const v1Coordinator = await CoordinationToggle.create({
+ *   version: 'v1',
+ *   topology: 'hierarchical',
+ *   maxAgents: 12
+ * });
+ *
+ * // Explicit V2 coordinator
+ * const v2Coordinator = await CoordinationToggle.create({
+ *   version: 'v2',
+ *   topology: 'mesh',
+ *   maxAgents: 5,
+ *   tokenBudget: 20000
+ * });
+ * ```
+ */ export class CoordinationToggle {
+    static logger = new Logger({
+        level: 'info',
+        format: 'text',
+        destination: 'console'
+    });
+    static telemetry = new TelemetrySystem({
+        enableMetrics: true,
+        enablePersistence: true
+    });
+    /**
+   * Create coordinator instance based on version
+   *
+   * Auto-detects coordination version and instantiates appropriate coordinator:
+   * - V1: Legacy coordination system (QueenAgent/MeshCoordinator)
+   * - V2: Modern coordination system (SDK/CLI/Hybrid modes)
+   *
+   * @param config - Unified coordinator configuration
+   * @returns Promise resolving to ICoordinator instance
+   * @throws Error if version not supported or dependencies missing
+   */ static async create(config = {}) {
+        const startTime = Date.now();
+        // Determine effective version
+        const version = this.detectVersion(config);
+        this.logger.info('CoordinationToggle: Creating coordinator', {
+            requestedVersion: config.version ?? 'auto',
+            detectedVersion: version,
+            topology: config.topology ?? 'mesh',
+            maxAgents: config.maxAgents ?? 10
+        });
+        // Create version-specific coordinator
+        let coordinator;
+        if (version === 'v1') {
+            coordinator = await this.createV1Coordinator(config);
+        } else {
+            coordinator = await this.createV2Coordinator(config);
+        }
+        const initTime = Date.now() - startTime;
+        this.logger.info('CoordinationToggle: Coordinator created', {
+            version,
+            initTimeMs: initTime
+        });
+        // Track coordinator initialization time
+        this.telemetry.recordTimer('coordination.initialization', initTime, {
+            version,
+            topology: config.topology || 'mesh',
+            maxAgents: String(config.maxAgents || 5)
+        });
+        return coordinator;
+    }
+    /**
+   * Detect coordination version from config or environment
+   *
+   * Priority:
+   * 1. Explicit config.version
+   * 2. COORDINATION_VERSION environment variable
+   * 3. Default: 'v2'
+   *
+   * @private
+   * @param config - Unified configuration
+   * @returns Detected version ('v1' | 'v2')
+   */ static detectVersion(config) {
+        // Priority 1: Explicit version in config
+        if (config.version) {
+            return config.version;
+        }
+        // Priority 2: Environment variable (VUL-1 FIX: strict validation with case-insensitive support)
+        const envVersion = process.env.COORDINATION_VERSION;
+        if (envVersion) {
+            const normalized = envVersion.toLowerCase();
+            // Strict regex validation to prevent injection
+            if (!/^v[12]$/.test(normalized)) {
+                throw new Error(`Invalid COORDINATION_VERSION: "${envVersion}". Must be exactly 'v1' or 'v2' (case-insensitive).`);
+            }
+            return normalized;
+        }
+        // Priority 3: Default to v2
+        return 'v2';
+    }
+    /**
+   * Create V1 coordinator (legacy system)
+   *
+   * Translates unified config to V1 CoordinationTopologyConfig format
+   * and wraps result in V1CoordinatorAdapter for ICoordinator compatibility.
+   *
+   * @private
+   * @param config - Unified configuration
+   * @returns Promise resolving to V1 coordinator wrapped in adapter
+   * @throws Error if V1 dependencies not provided
+   */ static async createV1Coordinator(config) {
+        this.logger.debug('Creating V1 coordinator', {
+            topology: config.topology,
+            maxAgents: config.maxAgents
+        });
+        // Translate unified config to V1 format
+        const v1Config = ConfigTranslator.toV1Config(config);
+        // V1 requires dependencies (memory, broker, dependencyGraph, logger)
+        if (!config.dependencies) {
+            this.getDefaultV1Dependencies(); // Will throw error
+        }
+        // VUL-4 FIX: Validate dependency object structure
+        this.validateV1Dependencies(config.dependencies);
+        const dependencies = config.dependencies;
+        // VUL-5 FIX: Log selected version for transparency
+        this.logger.info('V1 coordinator selected', {
+            version: 'v1',
+            topology: config.topology,
+            source: config.version ? 'explicit' : 'environment/default'
+        });
+        // Track V1 coordinator usage metrics
+        this.telemetry.recordCounter('coordination.version.selected', 1, {
+            version: 'v1',
+            topology: config.topology || 'mesh',
+            source: config.version ? 'explicit' : 'environment'
+        });
+        // Create V1 topology coordinator
+        const v1Coordinator = await createTopologyCoordinator(v1Config, dependencies);
+        // Wrap V1 coordinator with adapter for ICoordinator compatibility
+        return new V1CoordinatorAdapter(v1Coordinator);
+    }
+    /**
+   * Create V2 coordinator (modern system)
+   *
+   * Translates unified config to V2 FactoryOptions format
+   * and uses CoordinatorFactory for instantiation.
+   *
+   * @private
+   * @param config - Unified configuration
+   * @returns Promise resolving to V2 coordinator
+   */ static async createV2Coordinator(config) {
+        this.logger.debug('Creating V2 coordinator', {
+            topology: config.topology,
+            maxAgents: config.maxAgents,
+            tokenBudget: config.tokenBudget
+        });
+        // Translate unified config to V2 format
+        const v2Config = ConfigTranslator.toV2Config(config);
+        // VUL-5 FIX: Log selected version for transparency
+        this.logger.info('V2 coordinator selected', {
+            version: 'v2',
+            topology: config.topology,
+            source: config.version ? 'explicit' : 'environment/default'
+        });
+        // Track V2 coordinator usage metrics
+        this.telemetry.recordCounter('coordination.version.selected', 1, {
+            version: 'v2',
+            topology: config.topology || 'mesh',
+            source: config.version ? 'explicit' : 'environment',
+            mode: v2Config.mode || 'sdk'
+        });
+        // Use CoordinatorFactory to create V2 coordinator
+        return await CoordinatorFactory.create(v2Config);
+    }
+    /**
+   * Get default V1 dependencies for standalone usage
+   *
+   * Creates minimal dependency set when not provided in config.
+   * Uses in-memory implementations for testing/development.
+   *
+   * @private
+   * @returns Default V1 dependencies
+   */ static getDefaultV1Dependencies() {
+        // TODO: Implement default in-memory dependencies
+        // For now, throw error requiring explicit dependencies
+        throw new Error('V1 coordination requires dependencies (memory, broker, dependencyGraph, logger).\n' + 'Provide via config.dependencies or use V2 mode: { version: "v2" }');
+    }
+    /**
+   * Validate V1 dependencies for security (VUL-4 FIX)
+   *
+   * Prevents prototype pollution and ensures required keys exist.
+   *
+   * @private
+   * @param dependencies - Dependencies object to validate
+   * @throws Error if validation fails
+   */ static validateV1Dependencies(dependencies) {
+        if (!dependencies || typeof dependencies !== 'object') {
+            throw new Error('V1 dependencies must be a valid object');
+        }
+        // VUL-4: Check for prototype pollution attack vectors
+        const dangerousKeys = [
+            '__proto__',
+            'constructor',
+            'prototype'
+        ];
+        for (const key of dangerousKeys){
+            if (key in dependencies) {
+                throw new Error(`Security violation: Dependencies object contains dangerous key "${key}"`);
+            }
+        }
+        // VUL-4: Validate required keys
+        const requiredKeys = [
+            'memory',
+            'broker',
+            'dependencyGraph',
+            'logger'
+        ];
+        for (const key of requiredKeys){
+            if (!(key in dependencies)) {
+                throw new Error(`V1 dependencies missing required key: "${key}". Required: ${requiredKeys.join(', ')}`);
+            }
+            if (!dependencies[key]) {
+                throw new Error(`V1 dependency "${key}" is null or undefined. All dependencies must be valid objects.`);
+            }
+        }
+    }
+    /**
+   * Get version detection summary for debugging
+   *
+   * @returns Human-readable version detection info
+   *
+   * @example
+   * ```typescript
+   * console.log(CoordinationToggle.getVersionSummary());
+   * // Output:
+   * // Coordination Version Detection:
+   * // - COORDINATION_VERSION: v2
+   * // - Default Version: v2
+   * // - V1 Available: true
+   * // - V2 Available: true
+   * ```
+   */ static getVersionSummary() {
+        const envVersion = process.env.COORDINATION_VERSION?.toLowerCase();
+        const defaultVersion = 'v2';
+        const lines = [
+            'Coordination Version Detection:',
+            `- COORDINATION_VERSION: ${envVersion ?? 'not set'}`,
+            `- Default Version: ${defaultVersion}`,
+            '- V1 Available: true (legacy)',
+            '- V2 Available: true (recommended)'
+        ];
+        return lines.join('\n');
+    }
+}
+
+//# sourceMappingURL=coordination-toggle.js.map

package/.claude-flow-novice/dist/src/coordination/coordination-toggle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/coordination/coordination-toggle.ts"],"names":["CoordinatorFactory","createTopologyCoordinator","Logger","V1CoordinatorAdapter","ConfigTranslator","TelemetrySystem","CoordinationToggle","logger","level","format","destination","telemetry","enableMetrics","enablePersistence","create","config","startTime","Date","now","version","detectVersion","info","requestedVersion","detectedVersion","topology","maxAgents","coordinator","createV1Coordinator","createV2Coordinator","initTime","initTimeMs","recordTimer","String","envVersion","process","env","COORDINATION_VERSION","normalized","toLowerCase","test","Error","debug","v1Config","toV1Config","dependencies","getDefaultV1Dependencies","validateV1Dependencies","source","recordCounter","v1Coordinator","tokenBudget","v2Config","toV2Config","mode","dangerousKeys","key","requiredKeys","join","getVersionSummary","defaultVersion","lines"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/distributed-consensus.js

@@ -11,7 +11,7 @@
  * Based on PBFT (Practical Byzantine Fault Tolerance) adapted for mesh coordination.
  */ import { EventEmitter } from 'node:events';
 import { performance } from 'perf_hooks';
-import crypto from 'crypto';
+import * as crypto from 'crypto';
 // ============================================================================
 // Distributed Consensus Manager
 // ============================================================================
@@ -21,6 +21,7 @@ export class DistributedConsensusManager extends EventEmitter {
     agentStakes;
     consensusHistory;
     activeProposals;
+    agentKeyPairs;
     constructor(config = {}){
         super();
         this.config = {
@@ -37,6 +38,7 @@ export class DistributedConsensusManager extends EventEmitter {
         this.agentStakes = new Map();
         this.consensusHistory = [];
         this.activeProposals = new Map();
+        this.agentKeyPairs = new Map();
     }
     /**
    * Register agent with proof-of-work verification
@@ -202,6 +204,8 @@ export class DistributedConsensusManager extends EventEmitter {
     /**
    * Request vote from a specific peer
    */ async requestVoteFromPeer(agentId, proposal) {
+        // Ensure agent has RSA keypair
+        this.ensureAgentKeypair(agentId);
         // Simulate network latency
         await new Promise((resolve)=>setTimeout(resolve, Math.random() * 100));
         // Simulate agent validation
@@ -218,13 +222,14 @@ export class DistributedConsensusManager extends EventEmitter {
         return vote;
     }
     /**
-   * Validate votes for cryptographic integrity
+   * Validate votes for cryptographic integrity using RSA public key verification
    */ validateVotes(votes, agents) {
         const validVotes = [];
         for (const vote of votes){
-            // Verify signature
-            const expectedSignature = this.signVote(vote.voterId, vote.proposalId, vote.validations);
-            if (vote.signature === expectedSignature) {
+            // Verify RSA signature using agent's public key
+            const voteData = `${vote.voterId}:${vote.proposalId}:${vote.validations.overallScore}:${vote.validations.nonce}`;
+            const isValid = this.verifySignature(vote.voterId, voteData, vote.signature);
+            if (isValid) {
                 validVotes.push(vote);
             } else {
                 this.emit('vote:invalid_signature', {
@@ -511,21 +516,75 @@ export class DistributedConsensusManager extends EventEmitter {
         return validation;
     }
     /**
-   * Sign validation with agent's private key (simulated)
+   * Ensure agent has RSA keypair (2048-bit)
+   */ ensureAgentKeypair(agentId) {
+        if (!this.agentKeyPairs.has(agentId)) {
+            const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
+                modulusLength: 2048,
+                publicKeyEncoding: {
+                    type: 'spki',
+                    format: 'pem'
+                },
+                privateKeyEncoding: {
+                    type: 'pkcs8',
+                    format: 'pem'
+                }
+            });
+            this.agentKeyPairs.set(agentId, {
+                publicKey,
+                privateKey
+            });
+        }
+    }
+    /**
+   * Sign validation with agent's RSA private key
    */ signValidation(validation) {
+        this.ensureAgentKeypair(validation.agentId);
         const data = JSON.stringify({
             agentId: validation.agentId,
             timestamp: validation.timestamp,
             dimensions: validation.dimensions,
             nonce: validation.nonce
         });
-        return this.hash(data + validation.agentId);
+        const keypair = this.agentKeyPairs.get(validation.agentId);
+        const signature = crypto.sign('sha256', Buffer.from(data), {
+            key: keypair.privateKey,
+            padding: crypto.constants.RSA_PKCS1_PSS_PADDING
+        });
+        return signature.toString('base64');
     }
     /**
-   * Sign vote with agent's private key (simulated)
+   * Sign vote with agent's RSA private key
    */ signVote(agentId, proposalId, validation) {
+        this.ensureAgentKeypair(agentId);
         const data = `${agentId}:${proposalId}:${validation.overallScore}:${validation.nonce}`;
-        return this.hash(data);
+        const keypair = this.agentKeyPairs.get(agentId);
+        const signature = crypto.sign('sha256', Buffer.from(data), {
+            key: keypair.privateKey,
+            padding: crypto.constants.RSA_PKCS1_PSS_PADDING
+        });
+        return signature.toString('base64');
+    }
+    /**
+   * Verify RSA signature using agent's public key
+   */ verifySignature(agentId, data, signature) {
+        const keypair = this.agentKeyPairs.get(agentId);
+        if (!keypair) {
+            return false;
+        }
+        try {
+            const isValid = crypto.verify('sha256', Buffer.from(data), {
+                key: keypair.publicKey,
+                padding: crypto.constants.RSA_PKCS1_PSS_PADDING
+            }, Buffer.from(signature, 'base64'));
+            return isValid;
+        } catch (error) {
+            this.emit('signature:verification_failed', {
+                agentId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return false;
+        }
     }
     /**
    * Generate cryptographic hash