ruvector 0.2.21 → 0.2.23

package/dist/core/neural-embeddings.js

@@ -1,1091 +0,0 @@
-"use strict";
-/**
- * Neural Embedding System - Frontier Embedding Intelligence
- *
- * Implements late-2025 research concepts treating embeddings as:
- * 1. CONTROL SIGNALS - Semantic drift detection, reflex triggers
- * 2. MEMORY PHYSICS - Forgetting curves, interference, consolidation
- * 3. PROGRAM STATE - Agent state management via geometry
- * 4. COORDINATION PRIMITIVES - Multi-agent swarm alignment
- * 5. SAFETY MONITORS - Coherence detection, misalignment alerts
- * 6. NEURAL SUBSTRATE - Synthetic nervous system layer
- *
- * Based on:
- * - TinyTE (EMNLP 2025): Embedding-layer steering
- * - DoRA (ICML 2024): Magnitude-direction decomposition
- * - S-LoRA/Punica: Multi-adapter serving patterns
- * - MMTEB: Multilingual embedding benchmarks
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NeuralSubstrate = exports.CoherenceMonitor = exports.SwarmCoordinator = exports.EmbeddingStateMachine = exports.MemoryPhysics = exports.SemanticDriftDetector = exports.silentLogger = exports.defaultLogger = exports.NEURAL_CONSTANTS = void 0;
-// ============================================================================
-// Constants - Replace magic numbers with named constants
-// ============================================================================
-exports.NEURAL_CONSTANTS = {
-    // Drift Detection
-    MAX_DRIFT_EVENTS: 1000,
-    MAX_HISTORY_SIZE: 500,
-    DEFAULT_DRIFT_THRESHOLD: 0.15,
-    DEFAULT_DRIFT_WINDOW_MS: 60000,
-    DRIFT_CRITICAL_MULTIPLIER: 2,
-    VELOCITY_WINDOW_SIZE: 10,
-    // Memory Physics
-    MAX_MEMORIES: 10000,
-    MAX_CONTENT_LENGTH: 10000,
-    MAX_ID_LENGTH: 256,
-    DEFAULT_MEMORY_DECAY_RATE: 0.01,
-    DEFAULT_INTERFERENCE_THRESHOLD: 0.8,
-    DEFAULT_CONSOLIDATION_RATE: 0.1,
-    MEMORY_FORGET_THRESHOLD: 0.01,
-    CONSOLIDATION_SCORE_THRESHOLD: 0.5,
-    MEMORY_CLEANUP_PERCENT: 0.1,
-    RECALL_STRENGTH_BOOST: 0.1,
-    MAX_TIME_JUMP_MINUTES: 1440,
-    // Agent State
-    MAX_AGENTS: 1000,
-    MAX_SPECIALTY_LENGTH: 100,
-    AGENT_TIMEOUT_MS: 3600000, // 1 hour
-    DEFAULT_AGENT_ENERGY: 1.0,
-    TRAJECTORY_DAMPING: 0.1,
-    MAX_TRAJECTORY_STEPS: 100,
-    // Swarm Coordination
-    MAX_CLUSTER_AGENTS: 500,
-    DEFAULT_CLUSTER_THRESHOLD: 0.7,
-    // Coherence Monitoring
-    DEFAULT_WINDOW_SIZE: 100,
-    MIN_CALIBRATION_OBSERVATIONS: 10,
-    STABILITY_WINDOW_SIZE: 10,
-    ALIGNMENT_WINDOW_SIZE: 50,
-    RECENT_OBSERVATIONS_SIZE: 20,
-    DRIFT_WARNING_THRESHOLD: 0.3,
-    STABILITY_WARNING_THRESHOLD: 0.5,
-    ALIGNMENT_WARNING_THRESHOLD: 0.6,
-    COHERENCE_WARNING_THRESHOLD: 0.5,
-    // Math
-    EPSILON: 1e-8,
-    ZERO_VECTOR_THRESHOLD: 1e-10,
-    // Defaults
-    DEFAULT_DIMENSION: 384,
-    DEFAULT_REFLEX_LATENCY_MS: 10,
-};
-/** Default console logger */
-exports.defaultLogger = {
-    log(level, message, data) {
-        const prefix = `[Neural:${level.toUpperCase()}]`;
-        if (data) {
-            console[level === 'debug' ? 'log' : level](`${prefix} ${message}`, data);
-        }
-        else {
-            console[level === 'debug' ? 'log' : level](`${prefix} ${message}`);
-        }
-    },
-};
-/** Silent logger for suppressing output */
-exports.silentLogger = {
-    log() { },
-};
-// ============================================================================
-// 1. SEMANTIC DRIFT DETECTOR - Embeddings as Control Signals
-// ============================================================================
-/**
- * Detects semantic drift and triggers reflexes based on embedding movement.
- * Instead of asking "what is similar", asks "how far did we move".
- */
-class SemanticDriftDetector {
-    constructor(config = {}) {
-        this.baseline = null;
-        this.history = [];
-        this.driftEvents = [];
-        // Reflex callbacks
-        this.reflexes = new Map();
-        this.config = {
-            dimension: config.dimension ?? exports.NEURAL_CONSTANTS.DEFAULT_DIMENSION,
-            driftThreshold: config.driftThreshold ?? exports.NEURAL_CONSTANTS.DEFAULT_DRIFT_THRESHOLD,
-            driftWindowMs: config.driftWindowMs ?? exports.NEURAL_CONSTANTS.DEFAULT_DRIFT_WINDOW_MS,
-        };
-        this.logger = config.logger ?? exports.defaultLogger;
-    }
-    /**
-     * Set the baseline embedding (reference point)
-     */
-    setBaseline(embedding) {
-        this.baseline = embedding instanceof Float32Array
-            ? new Float32Array(embedding)
-            : new Float32Array(embedding);
-    }
-    /**
-     * Observe a new embedding and detect drift
-     */
-    observe(embedding, source) {
-        const emb = embedding instanceof Float32Array
-            ? embedding
-            : new Float32Array(embedding);
-        const now = Date.now();
-        // Add to history
-        this.history.push({ embedding: new Float32Array(emb), timestamp: now });
-        // Prune old history (with size limit)
-        const cutoff = now - this.config.driftWindowMs;
-        this.history = this.history.filter(h => h.timestamp > cutoff);
-        // Security: Enforce maximum history size
-        if (this.history.length > exports.NEURAL_CONSTANTS.MAX_HISTORY_SIZE) {
-            this.history = this.history.slice(-exports.NEURAL_CONSTANTS.MAX_HISTORY_SIZE);
-        }
-        // If no baseline, set first observation as baseline
-        if (!this.baseline) {
-            this.baseline = new Float32Array(emb);
-            return null;
-        }
-        // Calculate drift from baseline
-        const drift = this.calculateDrift(emb, this.baseline);
-        // Determine category
-        let category = 'normal';
-        if (drift.magnitude > this.config.driftThreshold * exports.NEURAL_CONSTANTS.DRIFT_CRITICAL_MULTIPLIER) {
-            category = 'critical';
-        }
-        else if (drift.magnitude > this.config.driftThreshold) {
-            category = 'warning';
-        }
-        const event = {
-            timestamp: now,
-            magnitude: drift.magnitude,
-            direction: drift.direction,
-            category,
-            source,
-        };
-        // Record event if significant (with size limit)
-        if (category !== 'normal') {
-            this.driftEvents.push(event);
-            // Security: Prevent unbounded growth
-            if (this.driftEvents.length > exports.NEURAL_CONSTANTS.MAX_DRIFT_EVENTS) {
-                this.driftEvents = this.driftEvents.slice(-exports.NEURAL_CONSTANTS.MAX_DRIFT_EVENTS);
-            }
-            this.triggerReflexes(event);
-        }
-        return event;
-    }
-    /**
-     * Calculate drift between two embeddings
-     */
-    calculateDrift(current, reference) {
-        const direction = new Float32Array(current.length);
-        let magnitudeSq = 0;
-        for (let i = 0; i < current.length; i++) {
-            const diff = current[i] - reference[i];
-            direction[i] = diff;
-            magnitudeSq += diff * diff;
-        }
-        const magnitude = Math.sqrt(magnitudeSq);
-        // Normalize direction
-        if (magnitude > 0) {
-            for (let i = 0; i < direction.length; i++) {
-                direction[i] /= magnitude;
-            }
-        }
-        return { magnitude, direction };
-    }
-    /**
-     * Register a reflex callback for drift events
-     */
-    registerReflex(name, callback) {
-        this.reflexes.set(name, callback);
-    }
-    /**
-     * Trigger registered reflexes
-     */
-    triggerReflexes(event) {
-        const errors = [];
-        for (const [name, callback] of this.reflexes) {
-            try {
-                callback(event);
-            }
-            catch (e) {
-                // Security: Track reflex failures but don't break execution
-                errors.push({ reflex: name, error: e });
-            }
-        }
-        // Security: Warn if multiple reflexes fail (potential attack or system issue)
-        if (errors.length > 0 && errors.length >= this.reflexes.size / 2) {
-            this.logger.log('warn', `${errors.length}/${this.reflexes.size} reflexes failed`, {
-                failedReflexes: errors.map(e => e.reflex),
-            });
-        }
-    }
-    /**
-     * Get recent drift velocity (rate of change)
-     */
-    getVelocity() {
-        if (this.history.length < 2)
-            return 0;
-        const recent = this.history.slice(-exports.NEURAL_CONSTANTS.VELOCITY_WINDOW_SIZE);
-        if (recent.length < 2)
-            return 0;
-        let totalDrift = 0;
-        for (let i = 1; i < recent.length; i++) {
-            const drift = this.calculateDrift(recent[i].embedding, recent[i - 1].embedding);
-            totalDrift += drift.magnitude;
-        }
-        const timeSpan = recent[recent.length - 1].timestamp - recent[0].timestamp;
-        return timeSpan > 0 ? totalDrift / timeSpan * 1000 : 0; // drift per second
-    }
-    /**
-     * Get drift statistics
-     */
-    getStats() {
-        const currentDrift = this.history.length > 0 && this.baseline
-            ? this.calculateDrift(this.history[this.history.length - 1].embedding, this.baseline).magnitude
-            : 0;
-        return {
-            currentDrift,
-            velocity: this.getVelocity(),
-            criticalEvents: this.driftEvents.filter(e => e.category === 'critical').length,
-            warningEvents: this.driftEvents.filter(e => e.category === 'warning').length,
-            historySize: this.history.length,
-        };
-    }
-    /**
-     * Reset baseline to current position
-     */
-    recenter() {
-        if (this.history.length > 0) {
-            this.baseline = new Float32Array(this.history[this.history.length - 1].embedding);
-        }
-    }
-}
-exports.SemanticDriftDetector = SemanticDriftDetector;
-// ============================================================================
-// 2. MEMORY PHYSICS - Forgetting, Interference, Consolidation
-// ============================================================================
-/**
- * Implements hippocampal-like memory dynamics in embedding space.
- * Memory strength decays, similar memories interfere, consolidation strengthens.
- */
-class MemoryPhysics {
-    constructor(config = {}) {
-        this.memories = new Map();
-        this.lastUpdate = Date.now();
-        this.config = {
-            dimension: config.dimension ?? exports.NEURAL_CONSTANTS.DEFAULT_DIMENSION,
-            memoryDecayRate: config.memoryDecayRate ?? exports.NEURAL_CONSTANTS.DEFAULT_MEMORY_DECAY_RATE,
-            interferenceThreshold: config.interferenceThreshold ?? exports.NEURAL_CONSTANTS.DEFAULT_INTERFERENCE_THRESHOLD,
-            consolidationRate: config.consolidationRate ?? exports.NEURAL_CONSTANTS.DEFAULT_CONSOLIDATION_RATE,
-        };
-        this.logger = config.logger ?? exports.defaultLogger;
-    }
-    /**
-     * Encode a new memory
-     */
-    encode(id, embedding, content) {
-        // Security: Validate inputs
-        if (typeof id !== 'string' || id.length === 0 || id.length > exports.NEURAL_CONSTANTS.MAX_ID_LENGTH) {
-            throw new Error(`Invalid memory ID: must be string of 1-${exports.NEURAL_CONSTANTS.MAX_ID_LENGTH} characters`);
-        }
-        if (typeof content !== 'string' || content.length > exports.NEURAL_CONSTANTS.MAX_CONTENT_LENGTH) {
-            throw new Error(`Content exceeds maximum length: ${exports.NEURAL_CONSTANTS.MAX_CONTENT_LENGTH}`);
-        }
-        if (this.memories.size >= exports.NEURAL_CONSTANTS.MAX_MEMORIES && !this.memories.has(id)) {
-            // Force cleanup of weak memories before adding new one
-            this.forceCleanup();
-        }
-        const emb = embedding instanceof Float32Array
-            ? new Float32Array(embedding)
-            : new Float32Array(embedding);
-        // Security: Validate embedding dimension
-        if (emb.length !== this.config.dimension) {
-            throw new Error(`Embedding dimension mismatch: expected ${this.config.dimension}, got ${emb.length}`);
-        }
-        const now = Date.now();
-        // Check for interference with existing memories
-        let interference = 0;
-        for (const existing of this.memories.values()) {
-            const similarity = this.cosineSimilarity(emb, existing.embedding);
-            if (similarity > this.config.interferenceThreshold) {
-                interference += similarity - this.config.interferenceThreshold;
-                existing.interference += (similarity - this.config.interferenceThreshold) * 0.5;
-            }
-        }
-        const entry = {
-            id,
-            embedding: emb,
-            content,
-            strength: 1.0 - interference * 0.3, // New memories weaker if interfered
-            lastAccess: now,
-            accessCount: 1,
-            consolidationLevel: 0,
-            interference,
-        };
-        this.memories.set(id, entry);
-        return entry;
-    }
-    /**
-     * Recall memories similar to a query (strengthens accessed memories)
-     */
-    recall(query, k = 5) {
-        const q = query instanceof Float32Array ? query : new Float32Array(query);
-        const now = Date.now();
-        // Apply decay before recall
-        this.applyDecay();
-        // Score memories
-        const scored = [];
-        for (const entry of this.memories.values()) {
-            const similarity = this.cosineSimilarity(q, entry.embedding);
-            // Effective score combines similarity and strength
-            const score = similarity * Math.sqrt(entry.strength);
-            scored.push({ entry, score });
-        }
-        // Sort and get top-k
-        scored.sort((a, b) => b.score - a.score);
-        const results = scored.slice(0, k).map(s => s.entry);
-        // Strengthen recalled memories (retrieval practice effect)
-        for (const entry of results) {
-            entry.lastAccess = now;
-            entry.accessCount++;
-            entry.strength = Math.min(1.0, entry.strength + exports.NEURAL_CONSTANTS.RECALL_STRENGTH_BOOST);
-        }
-        return results;
-    }
-    /**
-     * Apply time-based decay to all memories
-     */
-    applyDecay() {
-        const now = Date.now();
-        const elapsed = Math.max(0, now - this.lastUpdate) / 60000; // minutes, prevent negative
-        // Security: Cap maximum elapsed time to prevent manipulation
-        const cappedElapsed = Math.min(elapsed, exports.NEURAL_CONSTANTS.MAX_TIME_JUMP_MINUTES);
-        if (elapsed > exports.NEURAL_CONSTANTS.MAX_TIME_JUMP_MINUTES) {
-            this.logger.log('warn', `Large time jump detected: ${elapsed.toFixed(0)} minutes`);
-        }
-        this.lastUpdate = now;
-        const decayFactor = Math.exp(-this.config.memoryDecayRate * cappedElapsed);
-        for (const entry of this.memories.values()) {
-            // Decay is slower for consolidated memories
-            const effectiveDecay = decayFactor + entry.consolidationLevel * (1 - decayFactor) * 0.8;
-            entry.strength = Math.max(0, entry.strength * effectiveDecay);
-            // Very weak memories are forgotten
-            if (entry.strength < exports.NEURAL_CONSTANTS.MEMORY_FORGET_THRESHOLD) {
-                this.memories.delete(entry.id);
-            }
-        }
-    }
-    /**
-     * Consolidate memories (like sleep consolidation)
-     * Strengthens frequently accessed, weakly interfered memories
-     */
-    consolidate() {
-        let consolidated = 0;
-        let forgotten = 0;
-        for (const entry of this.memories.values()) {
-            // Consolidation score based on access pattern and low interference
-            const consolidationScore = Math.log(entry.accessCount + 1) * entry.strength * (1 - entry.interference * 0.5);
-            if (consolidationScore > exports.NEURAL_CONSTANTS.CONSOLIDATION_SCORE_THRESHOLD) {
-                entry.consolidationLevel = Math.min(1.0, entry.consolidationLevel + this.config.consolidationRate);
-                entry.strength = Math.min(1.0, entry.strength + 0.05);
-                consolidated++;
-            }
-            else if (entry.strength < exports.NEURAL_CONSTANTS.MEMORY_CLEANUP_PERCENT) {
-                this.memories.delete(entry.id);
-                forgotten++;
-            }
-        }
-        return { consolidated, forgotten };
-    }
-    /**
-     * Get memory statistics
-     */
-    getStats() {
-        if (this.memories.size === 0) {
-            return { totalMemories: 0, avgStrength: 0, avgConsolidation: 0, avgInterference: 0 };
-        }
-        let sumStrength = 0, sumConsolidation = 0, sumInterference = 0;
-        for (const entry of this.memories.values()) {
-            sumStrength += entry.strength;
-            sumConsolidation += entry.consolidationLevel;
-            sumInterference += entry.interference;
-        }
-        const n = this.memories.size;
-        return {
-            totalMemories: n,
-            avgStrength: sumStrength / n,
-            avgConsolidation: sumConsolidation / n,
-            avgInterference: sumInterference / n,
-        };
-    }
-    cosineSimilarity(a, b) {
-        let dot = 0, normA = 0, normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dot += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        const denom = Math.sqrt(normA * normB);
-        if (denom < 1e-10)
-            return 0; // Handle zero vectors
-        return Math.max(-1, Math.min(1, dot / denom)); // Clamp to valid range
-    }
-    /**
-     * Force cleanup of weak memories when limit reached
-     */
-    forceCleanup() {
-        const entries = Array.from(this.memories.entries())
-            .sort((a, b) => a[1].strength - b[1].strength);
-        const removeCount = Math.ceil(this.memories.size * exports.NEURAL_CONSTANTS.MEMORY_CLEANUP_PERCENT);
-        for (let i = 0; i < removeCount; i++) {
-            this.memories.delete(entries[i][0]);
-        }
-        this.logger.log('debug', `Force cleanup removed ${removeCount} weak memories`);
-    }
-}
-exports.MemoryPhysics = MemoryPhysics;
-// ============================================================================
-// 3. EMBEDDING STATE MACHINE - Agent State via Geometry
-// ============================================================================
-/**
- * Manages agent state as movement through embedding space.
- * Decisions become geometric - no explicit state machine.
- */
-class EmbeddingStateMachine {
-    constructor(config = {}) {
-        this.agents = new Map();
-        this.modeRegions = new Map();
-        this.lastCleanup = Date.now();
-        this.config = {
-            dimension: config.dimension ?? exports.NEURAL_CONSTANTS.DEFAULT_DIMENSION,
-        };
-        this.logger = config.logger ?? exports.defaultLogger;
-    }
-    /**
-     * Create or update an agent
-     */
-    updateAgent(id, embedding) {
-        // Periodically clean up stale agents
-        this.cleanupStaleAgents();
-        // Security: Enforce agent limit
-        if (!this.agents.has(id) && this.agents.size >= exports.NEURAL_CONSTANTS.MAX_AGENTS) {
-            throw new Error(`Agent limit reached: ${exports.NEURAL_CONSTANTS.MAX_AGENTS}`);
-        }
-        const position = embedding instanceof Float32Array
-            ? new Float32Array(embedding)
-            : new Float32Array(embedding);
-        const existing = this.agents.get(id);
-        const now = Date.now();
-        if (existing) {
-            // Calculate velocity (direction of movement)
-            for (let i = 0; i < position.length; i++) {
-                existing.velocity[i] = position[i] - existing.position[i];
-            }
-            existing.position = position;
-            existing.lastUpdate = now;
-            // Update mode based on nearest region
-            existing.mode = this.determineMode(position);
-        }
-        else {
-            // New agent
-            const state = {
-                id,
-                position,
-                velocity: new Float32Array(this.config.dimension),
-                attention: new Float32Array(this.config.dimension).fill(1 / this.config.dimension),
-                energy: exports.NEURAL_CONSTANTS.DEFAULT_AGENT_ENERGY,
-                mode: this.determineMode(position),
-                lastUpdate: now,
-            };
-            this.agents.set(id, state);
-            return state;
-        }
-        return existing;
-    }
-    /**
-     * Remove stale agents that haven't been updated recently
-     */
-    cleanupStaleAgents() {
-        const now = Date.now();
-        // Only run cleanup every minute
-        if (now - this.lastCleanup < 60000)
-            return;
-        this.lastCleanup = now;
-        const cutoff = now - exports.NEURAL_CONSTANTS.AGENT_TIMEOUT_MS;
-        let removed = 0;
-        for (const [id, state] of this.agents) {
-            if (state.lastUpdate < cutoff) {
-                this.agents.delete(id);
-                removed++;
-            }
-        }
-        if (removed > 0) {
-            this.logger.log('debug', `Cleaned up ${removed} stale agents`);
-        }
-    }
-    /**
-     * Manually remove an agent
-     */
-    removeAgent(id) {
-        return this.agents.delete(id);
-    }
-    /**
-     * Define a mode region in embedding space
-     */
-    defineMode(name, centroid, radius = 0.3) {
-        const c = centroid instanceof Float32Array
-            ? new Float32Array(centroid)
-            : new Float32Array(centroid);
-        this.modeRegions.set(name, { centroid: c, radius });
-    }
-    /**
-     * Determine which mode an agent is in based on position
-     */
-    determineMode(position) {
-        let bestMode = 'unknown';
-        let bestScore = -Infinity;
-        for (const [name, region] of this.modeRegions) {
-            const distance = this.euclideanDistance(position, region.centroid);
-            const score = region.radius - distance;
-            if (score > bestScore) {
-                bestScore = score;
-                bestMode = name;
-            }
-        }
-        return bestScore > 0 ? bestMode : 'exploring';
-    }
-    /**
-     * Get agent trajectory prediction
-     */
-    predictTrajectory(id, steps = 5) {
-        // Security: Limit trajectory steps
-        if (!Number.isInteger(steps) || steps < 1) {
-            throw new Error('Steps must be a positive integer');
-        }
-        const limitedSteps = Math.min(steps, exports.NEURAL_CONSTANTS.MAX_TRAJECTORY_STEPS);
-        const agent = this.agents.get(id);
-        if (!agent)
-            return [];
-        const trajectory = [];
-        let current = new Float32Array(agent.position);
-        for (let i = 0; i < limitedSteps; i++) {
-            const next = new Float32Array(current.length);
-            for (let j = 0; j < current.length; j++) {
-                next[j] = current[j] + agent.velocity[j] * (1 - i * exports.NEURAL_CONSTANTS.TRAJECTORY_DAMPING);
-            }
-            trajectory.push(next);
-            current = next;
-        }
-        return trajectory;
-    }
-    /**
-     * Apply attention to agent state
-     */
-    attendTo(agentId, focusEmbedding) {
-        const agent = this.agents.get(agentId);
-        if (!agent)
-            return;
-        const focus = focusEmbedding instanceof Float32Array
-            ? focusEmbedding
-            : new Float32Array(focusEmbedding);
-        // Update attention weights based on similarity to focus
-        let sum = 0;
-        for (let i = 0; i < agent.attention.length; i++) {
-            agent.attention[i] = Math.abs(focus[i]) + 0.01;
-            sum += agent.attention[i];
-        }
-        // Normalize
-        for (let i = 0; i < agent.attention.length; i++) {
-            agent.attention[i] /= sum;
-        }
-    }
-    /**
-     * Get all agents in a specific mode
-     */
-    getAgentsInMode(mode) {
-        return Array.from(this.agents.values()).filter(a => a.mode === mode);
-    }
-    euclideanDistance(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            const diff = a[i] - b[i];
-            sum += diff * diff;
-        }
-        return Math.sqrt(sum);
-    }
-}
-exports.EmbeddingStateMachine = EmbeddingStateMachine;
-// ============================================================================
-// 4. SWARM COORDINATOR - Multi-Agent Coordination via Embeddings
-// ============================================================================
-/**
- * Enables multi-agent coordination through shared embedding space.
- * Swarm behavior emerges from geometry, not protocol.
- */
-class SwarmCoordinator {
-    constructor(config = {}) {
-        this.agents = new Map();
-        this.config = { dimension: config.dimension ?? exports.NEURAL_CONSTANTS.DEFAULT_DIMENSION };
-        this.sharedContext = new Float32Array(this.config.dimension);
-        this.logger = config.logger ?? exports.defaultLogger;
-    }
-    /**
-     * Register an agent with the swarm
-     */
-    register(id, embedding, specialty = 'general') {
-        // Security: Validate inputs
-        if (typeof id !== 'string' || id.length === 0 || id.length > exports.NEURAL_CONSTANTS.MAX_ID_LENGTH) {
-            throw new Error(`Invalid agent ID: must be string of 1-${exports.NEURAL_CONSTANTS.MAX_ID_LENGTH} characters`);
-        }
-        if (typeof specialty !== 'string' || specialty.length > exports.NEURAL_CONSTANTS.MAX_SPECIALTY_LENGTH) {
-            throw new Error(`Specialty exceeds maximum length: ${exports.NEURAL_CONSTANTS.MAX_SPECIALTY_LENGTH}`);
-        }
-        if (this.agents.size >= exports.NEURAL_CONSTANTS.MAX_AGENTS && !this.agents.has(id)) {
-            throw new Error(`Agent limit reached: ${exports.NEURAL_CONSTANTS.MAX_AGENTS}`);
-        }
-        const position = embedding instanceof Float32Array
-            ? new Float32Array(embedding)
-            : new Float32Array(embedding);
-        // Security: Validate embedding dimension
-        if (position.length !== this.config.dimension) {
-            throw new Error(`Embedding dimension mismatch: expected ${this.config.dimension}, got ${position.length}`);
-        }
-        this.agents.set(id, {
-            position,
-            velocity: new Float32Array(this.config.dimension),
-            lastUpdate: Date.now(),
-            specialty,
-        });
-        this.updateSharedContext();
-    }
-    /**
-     * Update agent position (from their work/observations)
-     */
-    update(id, embedding) {
-        const agent = this.agents.get(id);
-        if (!agent)
-            return;
-        const newPosition = embedding instanceof Float32Array
-            ? embedding
-            : new Float32Array(embedding);
-        // Calculate velocity
-        for (let i = 0; i < agent.position.length; i++) {
-            agent.velocity[i] = newPosition[i] - agent.position[i];
-            agent.position[i] = newPosition[i];
-        }
-        agent.lastUpdate = Date.now();
-        this.updateSharedContext();
-    }
-    /**
-     * Update shared context (centroid of all agents)
-     */
-    updateSharedContext() {
-        if (this.agents.size === 0)
-            return;
-        this.sharedContext.fill(0);
-        for (const agent of this.agents.values()) {
-            for (let i = 0; i < this.sharedContext.length; i++) {
-                this.sharedContext[i] += agent.position[i];
-            }
-        }
-        for (let i = 0; i < this.sharedContext.length; i++) {
-            this.sharedContext[i] /= this.agents.size;
-        }
-    }
-    /**
-     * Get coordination signal for an agent (how to align with swarm)
-     */
-    getCoordinationSignal(id) {
-        const agent = this.agents.get(id);
-        if (!agent)
-            return new Float32Array(this.config.dimension);
-        // Signal points toward shared context
-        const signal = new Float32Array(this.config.dimension);
-        for (let i = 0; i < signal.length; i++) {
-            signal[i] = this.sharedContext[i] - agent.position[i];
-        }
-        return signal;
-    }
-    /**
-     * Find agents working on similar things (for collaboration)
-     */
-    findCollaborators(id, k = 3) {
-        const agent = this.agents.get(id);
-        if (!agent)
-            return [];
-        const scored = [];
-        for (const [otherId, other] of this.agents) {
-            if (otherId === id)
-                continue;
-            const similarity = this.cosineSimilarity(agent.position, other.position);
-            scored.push({ id: otherId, similarity, specialty: other.specialty });
-        }
-        scored.sort((a, b) => b.similarity - a.similarity);
-        return scored.slice(0, k);
-    }
-    /**
-     * Detect emergent clusters (specialization)
-     */
-    detectClusters(threshold = exports.NEURAL_CONSTANTS.DEFAULT_CLUSTER_THRESHOLD) {
-        // Security: Validate threshold
-        if (threshold < 0 || threshold > 1) {
-            throw new Error('Threshold must be between 0 and 1');
-        }
-        // Security: Limit clustering for performance (O(n²) algorithm)
-        if (this.agents.size > exports.NEURAL_CONSTANTS.MAX_CLUSTER_AGENTS) {
-            this.logger.log('warn', `Too many agents for clustering: ${this.agents.size} > ${exports.NEURAL_CONSTANTS.MAX_CLUSTER_AGENTS}`);
-            // Return single cluster with all agents
-            return new Map([['all', Array.from(this.agents.keys())]]);
-        }
-        const clusters = new Map();
-        const assigned = new Set();
-        for (const [id, agent] of this.agents) {
-            if (assigned.has(id))
-                continue;
-            const cluster = [id];
-            assigned.add(id);
-            for (const [otherId, other] of this.agents) {
-                if (assigned.has(otherId))
-                    continue;
-                const similarity = this.cosineSimilarity(agent.position, other.position);
-                if (similarity > threshold) {
-                    cluster.push(otherId);
-                    assigned.add(otherId);
-                }
-            }
-            clusters.set(id, cluster);
-        }
-        return clusters;
-    }
-    /**
-     * Get swarm coherence (how aligned are agents)
-     */
-    getCoherence() {
-        if (this.agents.size < 2)
-            return 1.0;
-        let totalSimilarity = 0;
-        let pairs = 0;
-        const agentList = Array.from(this.agents.values());
-        for (let i = 0; i < agentList.length; i++) {
-            for (let j = i + 1; j < agentList.length; j++) {
-                totalSimilarity += this.cosineSimilarity(agentList[i].position, agentList[j].position);
-                pairs++;
-            }
-        }
-        return pairs > 0 ? totalSimilarity / pairs : 1.0;
-    }
-    cosineSimilarity(a, b) {
-        let dot = 0, normA = 0, normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dot += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        const denom = Math.sqrt(normA * normB);
-        if (denom < exports.NEURAL_CONSTANTS.ZERO_VECTOR_THRESHOLD)
-            return 0;
-        return Math.max(-1, Math.min(1, dot / denom));
-    }
-    /**
-     * Remove an agent from the swarm
-     */
-    removeAgent(id) {
-        const removed = this.agents.delete(id);
-        if (removed) {
-            this.updateSharedContext();
-        }
-        return removed;
-    }
-}
-exports.SwarmCoordinator = SwarmCoordinator;
-// ============================================================================
-// 5. COHERENCE MONITOR - Safety and Alignment Detection
-// ============================================================================
-/**
- * Monitors system coherence via embedding patterns.
- * Detects degradation, poisoning, misalignment before explicit failures.
- */
-class CoherenceMonitor {
-    constructor(config = {}) {
-        this.history = [];
-        this.baselineDistribution = null;
-        this.config = {
-            dimension: config.dimension ?? exports.NEURAL_CONSTANTS.DEFAULT_DIMENSION,
-            windowSize: config.windowSize ?? exports.NEURAL_CONSTANTS.DEFAULT_WINDOW_SIZE,
-        };
-        this.logger = config.logger ?? exports.defaultLogger;
-    }
-    /**
-     * Record an observation
-     */
-    observe(embedding, source = 'unknown') {
-        const emb = embedding instanceof Float32Array
-            ? new Float32Array(embedding)
-            : new Float32Array(embedding);
-        this.history.push({
-            embedding: emb,
-            timestamp: Date.now(),
-            source,
-        });
-        // Keep window size
-        while (this.history.length > this.config.windowSize * 2) {
-            this.history.shift();
-        }
-    }
-    /**
-     * Establish baseline distribution
-     */
-    calibrate() {
-        if (this.history.length < exports.NEURAL_CONSTANTS.MIN_CALIBRATION_OBSERVATIONS) {
-            throw new Error(`Need at least ${exports.NEURAL_CONSTANTS.MIN_CALIBRATION_OBSERVATIONS} observations to calibrate`);
-        }
-        const mean = new Float32Array(this.config.dimension);
-        const variance = new Float32Array(this.config.dimension);
-        // Calculate mean
-        for (const obs of this.history) {
-            for (let i = 0; i < mean.length; i++) {
-                mean[i] += obs.embedding[i];
-            }
-        }
-        for (let i = 0; i < mean.length; i++) {
-            mean[i] /= this.history.length;
-        }
-        // Calculate variance
-        for (const obs of this.history) {
-            for (let i = 0; i < variance.length; i++) {
-                const diff = obs.embedding[i] - mean[i];
-                variance[i] += diff * diff;
-            }
-        }
-        for (let i = 0; i < variance.length; i++) {
-            variance[i] /= this.history.length;
-        }
-        this.baselineDistribution = { mean, variance };
-    }
-    /**
-     * Generate coherence report
-     */
-    report() {
-        const anomalies = [];
-        // Drift score: how much has distribution shifted
-        const driftScore = this.calculateDriftScore();
-        if (driftScore > exports.NEURAL_CONSTANTS.DRIFT_WARNING_THRESHOLD) {
-            anomalies.push({
-                type: 'distribution_drift',
-                severity: driftScore,
-                description: 'Embedding distribution has shifted significantly from baseline',
-            });
-        }
-        // Stability score: variance in recent observations
-        const stabilityScore = this.calculateStabilityScore();
-        if (stabilityScore < exports.NEURAL_CONSTANTS.STABILITY_WARNING_THRESHOLD) {
-            anomalies.push({
-                type: 'instability',
-                severity: 1 - stabilityScore,
-                description: 'High variance in recent embeddings suggests instability',
-            });
-        }
-        // Alignment score: consistency of embeddings from same source
-        const alignmentScore = this.calculateAlignmentScore();
-        if (alignmentScore < exports.NEURAL_CONSTANTS.ALIGNMENT_WARNING_THRESHOLD) {
-            anomalies.push({
-                type: 'misalignment',
-                severity: 1 - alignmentScore,
-                description: 'Embeddings from same source show inconsistent patterns',
-            });
-        }
-        // Overall score
-        const overallScore = ((1 - driftScore) * 0.3 +
-            stabilityScore * 0.3 +
-            alignmentScore * 0.4);
-        return {
-            timestamp: Date.now(),
-            overallScore,
-            driftScore,
-            stabilityScore,
-            alignmentScore,
-            anomalies,
-        };
-    }
-    calculateDriftScore() {
-        if (!this.baselineDistribution || this.history.length < exports.NEURAL_CONSTANTS.RECENT_OBSERVATIONS_SIZE)
-            return 0;
-        const recent = this.history.slice(-exports.NEURAL_CONSTANTS.RECENT_OBSERVATIONS_SIZE);
-        const recentMean = new Float32Array(this.config.dimension);
-        for (const obs of recent) {
-            for (let i = 0; i < recentMean.length; i++) {
-                recentMean[i] += obs.embedding[i];
-            }
-        }
-        for (let i = 0; i < recentMean.length; i++) {
-            recentMean[i] /= recent.length;
-        }
-        // Calculate distance between means
-        let distance = 0;
-        for (let i = 0; i < recentMean.length; i++) {
-            const diff = recentMean[i] - this.baselineDistribution.mean[i];
-            distance += diff * diff;
-        }
-        return Math.min(1, Math.sqrt(distance));
-    }
-    calculateStabilityScore() {
-        if (this.history.length < exports.NEURAL_CONSTANTS.STABILITY_WINDOW_SIZE)
-            return 1.0;
-        const recent = this.history.slice(-exports.NEURAL_CONSTANTS.STABILITY_WINDOW_SIZE);
-        let totalVariance = 0;
-        // Calculate pairwise distances
-        for (let i = 1; i < recent.length; i++) {
-            let distance = 0;
-            for (let j = 0; j < recent[i].embedding.length; j++) {
-                const diff = recent[i].embedding[j] - recent[i - 1].embedding[j];
-                distance += diff * diff;
-            }
-            totalVariance += Math.sqrt(distance);
-        }
-        const avgVariance = totalVariance / (recent.length - 1);
-        return Math.max(0, 1 - avgVariance * 2);
-    }
-    calculateAlignmentScore() {
-        // Group by source and check consistency
-        const bySource = new Map();
-        for (const obs of this.history.slice(-exports.NEURAL_CONSTANTS.ALIGNMENT_WINDOW_SIZE)) {
-            if (!bySource.has(obs.source)) {
-                bySource.set(obs.source, []);
-            }
-            bySource.get(obs.source).push(obs.embedding);
-        }
-        if (bySource.size < 2)
-            return 1.0;
-        let totalConsistency = 0;
-        let count = 0;
-        for (const embeddings of bySource.values()) {
-            if (embeddings.length < 2)
-                continue;
-            // Calculate average pairwise similarity within source
-            for (let i = 0; i < embeddings.length; i++) {
-                for (let j = i + 1; j < embeddings.length; j++) {
-                    totalConsistency += this.cosineSimilarity(embeddings[i], embeddings[j]);
-                    count++;
-                }
-            }
-        }
-        return count > 0 ? totalConsistency / count : 1.0;
-    }
-    cosineSimilarity(a, b) {
-        let dot = 0, normA = 0, normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dot += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        return dot / (Math.sqrt(normA * normB) + 1e-8);
-    }
-}
-exports.CoherenceMonitor = CoherenceMonitor;
-// ============================================================================
-// 6. NEURAL SUBSTRATE - Synthetic Nervous System
-// ============================================================================
-/**
- * Unified neural embedding substrate combining all components.
- * Acts like a synthetic nervous system with reflexes, memory, and coordination.
- */
-class NeuralSubstrate {
-    constructor(config = {}) {
-        this.logger = config.logger ?? exports.defaultLogger;
-        this.config = {
-            dimension: config.dimension ?? exports.NEURAL_CONSTANTS.DEFAULT_DIMENSION,
-            driftThreshold: config.driftThreshold ?? exports.NEURAL_CONSTANTS.DEFAULT_DRIFT_THRESHOLD,
-            driftWindowMs: config.driftWindowMs ?? exports.NEURAL_CONSTANTS.DEFAULT_DRIFT_WINDOW_MS,
-            memoryDecayRate: config.memoryDecayRate ?? exports.NEURAL_CONSTANTS.DEFAULT_MEMORY_DECAY_RATE,
-            interferenceThreshold: config.interferenceThreshold ?? exports.NEURAL_CONSTANTS.DEFAULT_INTERFERENCE_THRESHOLD,
-            consolidationRate: config.consolidationRate ?? exports.NEURAL_CONSTANTS.DEFAULT_CONSOLIDATION_RATE,
-            reflexLatencyMs: config.reflexLatencyMs ?? exports.NEURAL_CONSTANTS.DEFAULT_REFLEX_LATENCY_MS,
-            logger: this.logger,
-        };
-        this.reflexLatency = this.config.reflexLatencyMs;
-        // Pass logger to all sub-components
-        this.drift = new SemanticDriftDetector(this.config);
-        this.memory = new MemoryPhysics(this.config);
-        this.state = new EmbeddingStateMachine(this.config);
-        this.swarm = new SwarmCoordinator(this.config);
-        this.coherence = new CoherenceMonitor(this.config);
-        // Wire up default reflexes
-        this.drift.registerReflex('memory_consolidation', (event) => {
-            if (event.category === 'critical') {
-                // Consolidate memory on critical drift
-                this.memory.consolidate();
-            }
-        });
-        this.drift.registerReflex('coherence_check', (event) => {
-            if (event.category !== 'normal') {
-                // Check coherence on any significant drift
-                const report = this.coherence.report();
-                if (report.overallScore < exports.NEURAL_CONSTANTS.COHERENCE_WARNING_THRESHOLD) {
-                    this.logger.log('warn', 'Neural substrate coherence warning', {
-                        overallScore: report.overallScore,
-                        driftScore: report.driftScore,
-                        stabilityScore: report.stabilityScore,
-                        alignmentScore: report.alignmentScore,
-                        anomalyCount: report.anomalies.length,
-                    });
-                }
-            }
-        });
-    }
-    /**
-     * Process an embedding through the entire substrate
-     */
-    process(embedding, options = {}) {
-        const emb = embedding instanceof Float32Array
-            ? embedding
-            : new Float32Array(embedding);
-        // 1. Observe for drift
-        const driftEvent = this.drift.observe(emb, options.source);
-        // 2. Encode to memory if content provided
-        let memoryEntry = null;
-        if (options.memoryId && options.content) {
-            memoryEntry = this.memory.encode(options.memoryId, emb, options.content);
-        }
-        // 3. Update agent state if ID provided
-        let agentState = null;
-        if (options.agentId) {
-            agentState = this.state.updateAgent(options.agentId, emb);
-            this.swarm.register(options.agentId, emb);
-        }
-        // 4. Record for coherence monitoring
-        this.coherence.observe(emb, options.source);
-        return { drift: driftEvent, memory: memoryEntry, state: agentState };
-    }
-    /**
-     * Query the substrate
-     */
-    query(embedding, k = 5) {
-        const emb = embedding instanceof Float32Array
-            ? embedding
-            : new Float32Array(embedding);
-        return {
-            memories: this.memory.recall(emb, k),
-            collaborators: [], // Would need agent context
-            coherence: this.coherence.report(),
-        };
-    }
-    /**
-     * Get overall system health
-     */
-    health() {
-        return {
-            driftStats: this.drift.getStats(),
-            memoryStats: this.memory.getStats(),
-            swarmCoherence: this.swarm.getCoherence(),
-            coherenceReport: this.coherence.report(),
-        };
-    }
-    /**
-     * Run consolidation (like "sleep")
-     */
-    consolidate() {
-        return this.memory.consolidate();
-    }
-    /**
-     * Calibrate coherence baseline
-     */
-    calibrate() {
-        this.coherence.calibrate();
-    }
-}
-exports.NeuralSubstrate = NeuralSubstrate;
-// ============================================================================
-// Exports
-// ============================================================================
-exports.default = NeuralSubstrate;