ruvector 0.1.84 → 0.1.85

package/bin/cli.js

@@ -2213,6 +2213,244 @@ embedCmd
     }
   });
 
+embedCmd
+  .command('neural')
+  .description('Neural embedding substrate (frontier AI concepts)')
+  .option('--health', 'Show neural substrate health')
+  .option('--consolidate', 'Run memory consolidation (like sleep)')
+  .option('--calibrate', 'Calibrate coherence baseline')
+  .option('--swarm-status', 'Show swarm coordination status')
+  .option('--drift-stats', 'Show semantic drift statistics')
+  .option('--memory-stats', 'Show memory physics statistics')
+  .option('--demo', 'Run interactive neural demo')
+  .option('--dimension <n>', 'Embedding dimension', '384')
+  .action(async (opts) => {
+    try {
+      const { NeuralSubstrate } = require('../dist/core/neural-embeddings.js');
+      const { initOnnxEmbedder, embed } = require('../dist/core/onnx-embedder.js');
+
+      const dimension = parseInt(opts.dimension) || 384;
+      const substrate = new NeuralSubstrate({ dimension });
+
+      if (opts.demo) {
+        console.log(chalk.cyan('\n🧠 Neural Embedding Substrate Demo\n'));
+        console.log(chalk.dim('Frontier AI concepts: drift detection, memory physics, swarm coordination\n'));
+
+        // Initialize ONNX for real embeddings
+        await initOnnxEmbedder();
+
+        console.log(chalk.yellow('1. Semantic Drift Detection'));
+        console.log(chalk.dim('   Observing embeddings and detecting semantic movement...\n'));
+
+        const texts = [
+          'Machine learning optimizes neural networks',
+          'Deep learning uses backpropagation',
+          'AI models learn from data patterns',
+          'Quantum computing is completely different',  // Should trigger drift
+        ];
+
+        for (const text of texts) {
+          const result = await embed(text);
+          const driftEvent = substrate.drift.observe(result.embedding, 'demo');
+          const symbol = driftEvent?.category === 'critical' ? '🚨' :
+                        driftEvent?.category === 'warning' ? '⚠️' : '✓';
+          console.log(chalk.dim(`   ${symbol} "${text.slice(0, 40)}..." → drift: ${driftEvent?.magnitude?.toFixed(3) || '0.000'}`));
+        }
+
+        console.log(chalk.yellow('\n2. Memory Physics (Hippocampal Dynamics)'));
+        console.log(chalk.dim('   Encoding memories with strength, decay, and consolidation...\n'));
+
+        const memories = [
+          { id: 'mem1', text: 'Vector databases store embeddings' },
+          { id: 'mem2', text: 'HNSW enables fast nearest neighbor search' },
+          { id: 'mem3', text: 'Cosine similarity measures semantic closeness' },
+        ];
+
+        for (const mem of memories) {
+          const result = await embed(mem.text);
+          const entry = substrate.memory.encode(mem.id, result.embedding, mem.text);
+          console.log(chalk.dim(`   📝 Encoded "${mem.id}": strength=${entry.strength.toFixed(2)}, interference=${entry.interference.toFixed(2)}`));
+        }
+
+        // Query memory
+        const queryText = 'How do vector databases work?';
+        const queryEmb = await embed(queryText);
+        const recalled = substrate.memory.recall(queryEmb.embedding, 2);
+        console.log(chalk.dim(`\n   🔍 Query: "${queryText}"`));
+        console.log(chalk.dim(`   📚 Recalled: ${recalled.map(m => m.id).join(', ')}`));
+
+        console.log(chalk.yellow('\n3. Agent State Machine (Geometric State)'));
+        console.log(chalk.dim('   Managing agent state as movement through embedding space...\n'));
+
+        // Define mode regions
+        substrate.state.defineMode('research', queryEmb.embedding, 0.5);
+        const codeEmb = await embed('Write code and debug programs');
+        substrate.state.defineMode('coding', codeEmb.embedding, 0.5);
+
+        // Update agent state
+        const agent1State = substrate.state.updateAgent('agent-1', queryEmb.embedding);
+        console.log(chalk.dim(`   🤖 agent-1 mode: ${agent1State.mode}, energy: ${agent1State.energy.toFixed(2)}`));
+
+        const agent2State = substrate.state.updateAgent('agent-2', codeEmb.embedding);
+        console.log(chalk.dim(`   🤖 agent-2 mode: ${agent2State.mode}, energy: ${agent2State.energy.toFixed(2)}`));
+
+        console.log(chalk.yellow('\n4. Swarm Coordination'));
+        console.log(chalk.dim('   Multi-agent coordination through shared embedding geometry...\n'));
+
+        substrate.swarm.register('researcher', queryEmb.embedding, 'research');
+        substrate.swarm.register('coder', codeEmb.embedding, 'development');
+        const reviewEmb = await embed('Review code and check quality');
+        substrate.swarm.register('reviewer', reviewEmb.embedding, 'review');
+
+        const coherence = substrate.swarm.getCoherence();
+        console.log(chalk.dim(`   🌐 Swarm coherence: ${(coherence * 100).toFixed(1)}%`));
+
+        const collaborators = substrate.swarm.findCollaborators('researcher', 2);
+        console.log(chalk.dim(`   🤝 Collaborators for researcher: ${collaborators.map(c => c.id).join(', ')}`));
+
+        console.log(chalk.yellow('\n5. Coherence Monitoring (Safety)'));
+        console.log(chalk.dim('   Detecting degradation, poisoning, misalignment...\n'));
+
+        try {
+          substrate.calibrate();
+          const report = substrate.coherence.report();
+          console.log(chalk.dim(`   📊 Overall coherence: ${(report.overallScore * 100).toFixed(1)}%`));
+          console.log(chalk.dim(`   📊 Stability: ${(report.stabilityScore * 100).toFixed(1)}%`));
+          console.log(chalk.dim(`   📊 Alignment: ${(report.alignmentScore * 100).toFixed(1)}%`));
+        } catch {
+          console.log(chalk.dim('   ℹ️ Need more observations to calibrate coherence'));
+        }
+
+        console.log(chalk.cyan('\n═══════════════════════════════════════════════════════════════'));
+        console.log(chalk.bold('   Neural Substrate: Embeddings as Synthetic Nervous System'));
+        console.log(chalk.cyan('═══════════════════════════════════════════════════════════════\n'));
+
+        console.log(chalk.dim('Components:'));
+        console.log(chalk.dim('  • SemanticDriftDetector - Control signals, reflex triggers'));
+        console.log(chalk.dim('  • MemoryPhysics - Forgetting, interference, consolidation'));
+        console.log(chalk.dim('  • EmbeddingStateMachine - Agent state via geometry'));
+        console.log(chalk.dim('  • SwarmCoordinator - Multi-agent coordination'));
+        console.log(chalk.dim('  • CoherenceMonitor - Safety/alignment detection'));
+        console.log(chalk.dim('  • NeuralSubstrate - Unified nervous system layer'));
+        console.log('');
+        return;
+      }
+
+      if (opts.health) {
+        const health = substrate.health();
+        console.log(chalk.cyan('\n🧠 Neural Substrate Health\n'));
+
+        console.log(chalk.yellow('Drift Detection:'));
+        console.log(chalk.dim(`  Current drift: ${health.driftStats.currentDrift.toFixed(4)}`));
+        console.log(chalk.dim(`  Velocity: ${health.driftStats.velocity.toFixed(4)}/s`));
+        console.log(chalk.dim(`  Critical events: ${health.driftStats.criticalEvents}`));
+        console.log(chalk.dim(`  Warning events: ${health.driftStats.warningEvents}`));
+
+        console.log(chalk.yellow('\nMemory Physics:'));
+        console.log(chalk.dim(`  Total memories: ${health.memoryStats.totalMemories}`));
+        console.log(chalk.dim(`  Avg strength: ${health.memoryStats.avgStrength.toFixed(3)}`));
+        console.log(chalk.dim(`  Avg consolidation: ${health.memoryStats.avgConsolidation.toFixed(3)}`));
+        console.log(chalk.dim(`  Avg interference: ${health.memoryStats.avgInterference.toFixed(3)}`));
+
+        console.log(chalk.yellow('\nSwarm Coordination:'));
+        console.log(chalk.dim(`  Coherence: ${(health.swarmCoherence * 100).toFixed(1)}%`));
+
+        console.log(chalk.yellow('\nCoherence Report:'));
+        console.log(chalk.dim(`  Overall: ${(health.coherenceReport.overallScore * 100).toFixed(1)}%`));
+        console.log(chalk.dim(`  Drift: ${(health.coherenceReport.driftScore * 100).toFixed(1)}%`));
+        console.log(chalk.dim(`  Stability: ${(health.coherenceReport.stabilityScore * 100).toFixed(1)}%`));
+        console.log(chalk.dim(`  Alignment: ${(health.coherenceReport.alignmentScore * 100).toFixed(1)}%`));
+
+        if (health.coherenceReport.anomalies.length > 0) {
+          console.log(chalk.yellow('\nAnomalies:'));
+          for (const a of health.coherenceReport.anomalies) {
+            console.log(chalk.red(`  ⚠️ ${a.type}: ${a.description} (severity: ${a.severity.toFixed(2)})`));
+          }
+        }
+        console.log('');
+        return;
+      }
+
+      if (opts.consolidate) {
+        console.log(chalk.yellow('Running memory consolidation...'));
+        const result = substrate.consolidate();
+        console.log(chalk.green(`✓ Consolidated: ${result.consolidated} memories`));
+        console.log(chalk.dim(`  Forgotten: ${result.forgotten} weak memories`));
+        return;
+      }
+
+      if (opts.calibrate) {
+        try {
+          substrate.calibrate();
+          console.log(chalk.green('✓ Coherence baseline calibrated'));
+        } catch (e) {
+          console.log(chalk.yellow('Need more observations to calibrate'));
+          console.log(chalk.dim('Run --demo first to populate the substrate'));
+        }
+        return;
+      }
+
+      if (opts.driftStats) {
+        const stats = substrate.drift.getStats();
+        console.log(chalk.cyan('\n📊 Semantic Drift Statistics\n'));
+        console.log(chalk.dim(`Current drift: ${stats.currentDrift.toFixed(4)}`));
+        console.log(chalk.dim(`Velocity: ${stats.velocity.toFixed(4)} drift/s`));
+        console.log(chalk.dim(`Critical events: ${stats.criticalEvents}`));
+        console.log(chalk.dim(`Warning events: ${stats.warningEvents}`));
+        console.log(chalk.dim(`History size: ${stats.historySize}`));
+        console.log('');
+        return;
+      }
+
+      if (opts.memoryStats) {
+        const stats = substrate.memory.getStats();
+        console.log(chalk.cyan('\n📊 Memory Physics Statistics\n'));
+        console.log(chalk.dim(`Total memories: ${stats.totalMemories}`));
+        console.log(chalk.dim(`Average strength: ${stats.avgStrength.toFixed(3)}`));
+        console.log(chalk.dim(`Average consolidation: ${stats.avgConsolidation.toFixed(3)}`));
+        console.log(chalk.dim(`Average interference: ${stats.avgInterference.toFixed(3)}`));
+        console.log('');
+        return;
+      }
+
+      if (opts.swarmStatus) {
+        const coherence = substrate.swarm.getCoherence();
+        const clusters = substrate.swarm.detectClusters(0.7);
+        console.log(chalk.cyan('\n📊 Swarm Coordination Status\n'));
+        console.log(chalk.dim(`Coherence: ${(coherence * 100).toFixed(1)}%`));
+        console.log(chalk.dim(`Clusters detected: ${clusters.size}`));
+        for (const [leader, members] of clusters) {
+          console.log(chalk.dim(`  Cluster ${leader}: ${members.join(', ')}`));
+        }
+        console.log('');
+        return;
+      }
+
+      // Default: show help
+      console.log(chalk.cyan('\n🧠 Neural Embedding Substrate\n'));
+      console.log(chalk.dim('Frontier AI concepts treating embeddings as a synthetic nervous system.\n'));
+      console.log(chalk.yellow('Commands:'));
+      console.log(chalk.dim('  --demo          Run interactive neural demo'));
+      console.log(chalk.dim('  --health        Show neural substrate health'));
+      console.log(chalk.dim('  --consolidate   Run memory consolidation (like sleep)'));
+      console.log(chalk.dim('  --calibrate     Calibrate coherence baseline'));
+      console.log(chalk.dim('  --drift-stats   Show semantic drift statistics'));
+      console.log(chalk.dim('  --memory-stats  Show memory physics statistics'));
+      console.log(chalk.dim('  --swarm-status  Show swarm coordination status'));
+      console.log('');
+      console.log(chalk.yellow('Components:'));
+      console.log(chalk.dim('  • SemanticDriftDetector - Embeddings as control signals'));
+      console.log(chalk.dim('  • MemoryPhysics - Hippocampal memory dynamics'));
+      console.log(chalk.dim('  • EmbeddingStateMachine - Agent state via geometry'));
+      console.log(chalk.dim('  • SwarmCoordinator - Multi-agent coordination'));
+      console.log(chalk.dim('  • CoherenceMonitor - Safety/alignment detection'));
+      console.log('');
+    } catch (e) {
+      console.error(chalk.red('Error:'), e.message);
+      if (e.stack) console.error(chalk.dim(e.stack));
+    }
+  });
+
 // =============================================================================
 // Demo Command - Interactive tutorial
 // =============================================================================

package/dist/core/index.d.ts

@@ -23,6 +23,7 @@ export * from './graph-algorithms';
 export * from './tensor-compress';
 export * from './learning-engine';
 export * from './adaptive-embedder';
+export * from './neural-embeddings';
 export * from '../analysis';
 export { default as gnnWrapper } from './gnn-wrapper';
 export { default as attentionFallbacks } from './attention-fallbacks';
@@ -41,4 +42,5 @@ export { CodeParser as ASTParser } from './ast-parser';
 export { default as TensorCompress } from './tensor-compress';
 export { default as LearningEngine } from './learning-engine';
 export { default as AdaptiveEmbedder } from './adaptive-embedder';
+export { default as NeuralSubstrate } from './neural-embeddings';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,aAAa,CAAC;AAG5B,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAGrD,OAAO,EAAE,UAAU,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AAGvD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,aAAa,CAAC;AAG5B,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAGrD,OAAO,EAAE,UAAU,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AAGvD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/index.js

@@ -23,7 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptiveEmbedder = exports.LearningEngine = exports.TensorCompress = exports.ASTParser = exports.CodeParser = exports.RuvectorCluster = exports.CodeGraph = exports.SemanticRouter = exports.ExtendedWorkerPool = exports.ParallelIntelligence = exports.OptimizedOnnxEmbedder = exports.OnnxEmbedder = exports.IntelligenceEngine = exports.Sona = exports.agentdbFast = exports.attentionFallbacks = exports.gnnWrapper = void 0;
+exports.NeuralSubstrate = exports.AdaptiveEmbedder = exports.LearningEngine = exports.TensorCompress = exports.ASTParser = exports.CodeParser = exports.RuvectorCluster = exports.CodeGraph = exports.SemanticRouter = exports.ExtendedWorkerPool = exports.ParallelIntelligence = exports.OptimizedOnnxEmbedder = exports.OnnxEmbedder = exports.IntelligenceEngine = exports.Sona = exports.agentdbFast = exports.attentionFallbacks = exports.gnnWrapper = void 0;
 __exportStar(require("./gnn-wrapper"), exports);
 __exportStar(require("./attention-fallbacks"), exports);
 __exportStar(require("./agentdb-fast"), exports);
@@ -43,6 +43,7 @@ __exportStar(require("./graph-algorithms"), exports);
 __exportStar(require("./tensor-compress"), exports);
 __exportStar(require("./learning-engine"), exports);
 __exportStar(require("./adaptive-embedder"), exports);
+__exportStar(require("./neural-embeddings"), exports);
 // Analysis module (consolidated security, complexity, patterns)
 __exportStar(require("../analysis"), exports);
 // Re-export default objects for convenience
@@ -82,3 +83,5 @@ var learning_engine_1 = require("./learning-engine");
 Object.defineProperty(exports, "LearningEngine", { enumerable: true, get: function () { return __importDefault(learning_engine_1).default; } });
 var adaptive_embedder_1 = require("./adaptive-embedder");
 Object.defineProperty(exports, "AdaptiveEmbedder", { enumerable: true, get: function () { return __importDefault(adaptive_embedder_1).default; } });
+var neural_embeddings_1 = require("./neural-embeddings");
+Object.defineProperty(exports, "NeuralSubstrate", { enumerable: true, get: function () { return __importDefault(neural_embeddings_1).default; } });

package/dist/core/neural-embeddings.d.ts

@@ -0,0 +1,320 @@
+/**
+ * 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
+ */
+export interface DriftEvent {
+    timestamp: number;
+    magnitude: number;
+    direction: Float32Array;
+    category: 'normal' | 'warning' | 'critical';
+    source?: string;
+}
+export interface NeuralMemoryEntry {
+    id: string;
+    embedding: Float32Array;
+    content: string;
+    strength: number;
+    lastAccess: number;
+    accessCount: number;
+    consolidationLevel: number;
+    interference: number;
+}
+export interface AgentState {
+    id: string;
+    position: Float32Array;
+    velocity: Float32Array;
+    attention: Float32Array;
+    energy: number;
+    mode: string;
+}
+export interface CoherenceReport {
+    timestamp: number;
+    overallScore: number;
+    driftScore: number;
+    stabilityScore: number;
+    alignmentScore: number;
+    anomalies: Array<{
+        type: string;
+        severity: number;
+        description: string;
+    }>;
+}
+export interface NeuralConfig {
+    dimension?: number;
+    driftThreshold?: number;
+    driftWindowMs?: number;
+    memoryDecayRate?: number;
+    interferenceThreshold?: number;
+    consolidationRate?: number;
+    reflexLatencyMs?: number;
+}
+/**
+ * Detects semantic drift and triggers reflexes based on embedding movement.
+ * Instead of asking "what is similar", asks "how far did we move".
+ */
+export declare class SemanticDriftDetector {
+    private baseline;
+    private history;
+    private driftEvents;
+    private config;
+    private reflexes;
+    constructor(config?: NeuralConfig);
+    /**
+     * Set the baseline embedding (reference point)
+     */
+    setBaseline(embedding: number[] | Float32Array): void;
+    /**
+     * Observe a new embedding and detect drift
+     */
+    observe(embedding: number[] | Float32Array, source?: string): DriftEvent | null;
+    /**
+     * Calculate drift between two embeddings
+     */
+    private calculateDrift;
+    /**
+     * Register a reflex callback for drift events
+     */
+    registerReflex(name: string, callback: (event: DriftEvent) => void): void;
+    /**
+     * Trigger registered reflexes
+     */
+    private triggerReflexes;
+    /**
+     * Get recent drift velocity (rate of change)
+     */
+    getVelocity(): number;
+    /**
+     * Get drift statistics
+     */
+    getStats(): {
+        currentDrift: number;
+        velocity: number;
+        criticalEvents: number;
+        warningEvents: number;
+        historySize: number;
+    };
+    /**
+     * Reset baseline to current position
+     */
+    recenter(): void;
+}
+/**
+ * Implements hippocampal-like memory dynamics in embedding space.
+ * Memory strength decays, similar memories interfere, consolidation strengthens.
+ */
+export declare class MemoryPhysics {
+    private memories;
+    private config;
+    private lastUpdate;
+    constructor(config?: NeuralConfig);
+    /**
+     * Encode a new memory
+     */
+    encode(id: string, embedding: number[] | Float32Array, content: string): NeuralMemoryEntry;
+    /**
+     * Recall memories similar to a query (strengthens accessed memories)
+     */
+    recall(query: number[] | Float32Array, k?: number): NeuralMemoryEntry[];
+    /**
+     * Apply time-based decay to all memories
+     */
+    private applyDecay;
+    /**
+     * Consolidate memories (like sleep consolidation)
+     * Strengthens frequently accessed, weakly interfered memories
+     */
+    consolidate(): {
+        consolidated: number;
+        forgotten: number;
+    };
+    /**
+     * Get memory statistics
+     */
+    getStats(): {
+        totalMemories: number;
+        avgStrength: number;
+        avgConsolidation: number;
+        avgInterference: number;
+    };
+    private cosineSimilarity;
+}
+/**
+ * Manages agent state as movement through embedding space.
+ * Decisions become geometric - no explicit state machine.
+ */
+export declare class EmbeddingStateMachine {
+    private agents;
+    private modeRegions;
+    private config;
+    constructor(config?: NeuralConfig);
+    /**
+     * Create or update an agent
+     */
+    updateAgent(id: string, embedding: number[] | Float32Array): AgentState;
+    /**
+     * Define a mode region in embedding space
+     */
+    defineMode(name: string, centroid: number[] | Float32Array, radius?: number): void;
+    /**
+     * Determine which mode an agent is in based on position
+     */
+    private determineMode;
+    /**
+     * Get agent trajectory prediction
+     */
+    predictTrajectory(id: string, steps?: number): Float32Array[];
+    /**
+     * Apply attention to agent state
+     */
+    attendTo(agentId: string, focusEmbedding: number[] | Float32Array): void;
+    /**
+     * Get all agents in a specific mode
+     */
+    getAgentsInMode(mode: string): AgentState[];
+    private euclideanDistance;
+}
+/**
+ * Enables multi-agent coordination through shared embedding space.
+ * Swarm behavior emerges from geometry, not protocol.
+ */
+export declare class SwarmCoordinator {
+    private agents;
+    private sharedContext;
+    private config;
+    constructor(config?: NeuralConfig);
+    /**
+     * Register an agent with the swarm
+     */
+    register(id: string, embedding: number[] | Float32Array, specialty?: string): void;
+    /**
+     * Update agent position (from their work/observations)
+     */
+    update(id: string, embedding: number[] | Float32Array): void;
+    /**
+     * Update shared context (centroid of all agents)
+     */
+    private updateSharedContext;
+    /**
+     * Get coordination signal for an agent (how to align with swarm)
+     */
+    getCoordinationSignal(id: string): Float32Array;
+    /**
+     * Find agents working on similar things (for collaboration)
+     */
+    findCollaborators(id: string, k?: number): Array<{
+        id: string;
+        similarity: number;
+        specialty: string;
+    }>;
+    /**
+     * Detect emergent clusters (specialization)
+     */
+    detectClusters(threshold?: number): Map<string, string[]>;
+    /**
+     * Get swarm coherence (how aligned are agents)
+     */
+    getCoherence(): number;
+    private cosineSimilarity;
+}
+/**
+ * Monitors system coherence via embedding patterns.
+ * Detects degradation, poisoning, misalignment before explicit failures.
+ */
+export declare class CoherenceMonitor {
+    private history;
+    private baselineDistribution;
+    private config;
+    constructor(config?: NeuralConfig & {
+        windowSize?: number;
+    });
+    /**
+     * Record an observation
+     */
+    observe(embedding: number[] | Float32Array, source?: string): void;
+    /**
+     * Establish baseline distribution
+     */
+    calibrate(): void;
+    /**
+     * Generate coherence report
+     */
+    report(): CoherenceReport;
+    private calculateDriftScore;
+    private calculateStabilityScore;
+    private calculateAlignmentScore;
+    private cosineSimilarity;
+}
+/**
+ * Unified neural embedding substrate combining all components.
+ * Acts like a synthetic nervous system with reflexes, memory, and coordination.
+ */
+export declare class NeuralSubstrate {
+    readonly drift: SemanticDriftDetector;
+    readonly memory: MemoryPhysics;
+    readonly state: EmbeddingStateMachine;
+    readonly swarm: SwarmCoordinator;
+    readonly coherence: CoherenceMonitor;
+    private config;
+    private reflexLatency;
+    constructor(config?: NeuralConfig);
+    /**
+     * Process an embedding through the entire substrate
+     */
+    process(embedding: number[] | Float32Array, options?: {
+        agentId?: string;
+        memoryId?: string;
+        content?: string;
+        source?: string;
+    }): {
+        drift: DriftEvent | null;
+        memory: NeuralMemoryEntry | null;
+        state: AgentState | null;
+    };
+    /**
+     * Query the substrate
+     */
+    query(embedding: number[] | Float32Array, k?: number): {
+        memories: NeuralMemoryEntry[];
+        collaborators: Array<{
+            id: string;
+            similarity: number;
+            specialty: string;
+        }>;
+        coherence: CoherenceReport;
+    };
+    /**
+     * Get overall system health
+     */
+    health(): {
+        driftStats: ReturnType<SemanticDriftDetector['getStats']>;
+        memoryStats: ReturnType<MemoryPhysics['getStats']>;
+        swarmCoherence: number;
+        coherenceReport: CoherenceReport;
+    };
+    /**
+     * Run consolidation (like "sleep")
+     */
+    consolidate(): {
+        consolidated: number;
+        forgotten: number;
+    };
+    /**
+     * Calibrate coherence baseline
+     */
+    calibrate(): void;
+}
+export default NeuralSubstrate;
+//# sourceMappingURL=neural-embeddings.d.ts.map

package/dist/core/neural-embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neural-embeddings.d.ts","sourceRoot":"","sources":["../../src/core/neural-embeddings.ts"],"names":[],"mappings":"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"}