agentic-qe 2.8.0 → 2.8.1

package/dist/nervous-system/index.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * RuVector Nervous System Integration
+ *
+ * Bio-inspired neural components for QE agents:
+ * - HDC: Hyperdimensional Computing for pattern storage (<100ns)
+ * - BTSP: One-shot learning from single examples
+ * - K-WTA: Sub-microsecond reflex decisions
+ * - Global Workspace: Agent attention coordination (4-7 items)
+ * - Circadian: Duty cycling for compute efficiency
+ *
+ * @module nervous-system
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWasmInfo = exports.ensureInitialized = exports.isWasmInitialized = exports.initWasm = exports.NervousSystemFleetCoordinator = exports.WithNervousSystem = exports.enhanceWithNervousSystem = exports.createBTSPLearningEngine = exports.BTSPLearningEngine = exports.CircadianAgentManager = exports.createExpandedCoordinator = exports.createFocusedCoordinator = exports.createWorkspaceCoordinator = exports.WorkspaceAgentCoordinator = exports.createHighPerformanceHybridStore = exports.createHybridPatternStore = exports.HybridPatternStore = exports.biological_references = exports.performance_targets = exports.available_mechanisms = exports.nervousSystemVersion = exports.WorkspaceItem = exports.GlobalWorkspace = exports.KWTALayer = exports.WTALayer = exports.HdcMemory = exports.Hypervector = exports.BTSPSynapse = exports.BTSPAssociativeMemory = exports.BTSPLayer = exports.initNervousSystem = void 0;
+// Re-export core WASM components
+var nervous_system_wasm_1 = require("@ruvector/nervous-system-wasm");
+Object.defineProperty(exports, "initNervousSystem", { enumerable: true, get: function () { return __importDefault(nervous_system_wasm_1).default; } });
+Object.defineProperty(exports, "BTSPLayer", { enumerable: true, get: function () { return nervous_system_wasm_1.BTSPLayer; } });
+Object.defineProperty(exports, "BTSPAssociativeMemory", { enumerable: true, get: function () { return nervous_system_wasm_1.BTSPAssociativeMemory; } });
+Object.defineProperty(exports, "BTSPSynapse", { enumerable: true, get: function () { return nervous_system_wasm_1.BTSPSynapse; } });
+Object.defineProperty(exports, "Hypervector", { enumerable: true, get: function () { return nervous_system_wasm_1.Hypervector; } });
+Object.defineProperty(exports, "HdcMemory", { enumerable: true, get: function () { return nervous_system_wasm_1.HdcMemory; } });
+Object.defineProperty(exports, "WTALayer", { enumerable: true, get: function () { return nervous_system_wasm_1.WTALayer; } });
+Object.defineProperty(exports, "KWTALayer", { enumerable: true, get: function () { return nervous_system_wasm_1.KWTALayer; } });
+Object.defineProperty(exports, "GlobalWorkspace", { enumerable: true, get: function () { return nervous_system_wasm_1.GlobalWorkspace; } });
+Object.defineProperty(exports, "WorkspaceItem", { enumerable: true, get: function () { return nervous_system_wasm_1.WorkspaceItem; } });
+Object.defineProperty(exports, "nervousSystemVersion", { enumerable: true, get: function () { return nervous_system_wasm_1.version; } });
+Object.defineProperty(exports, "available_mechanisms", { enumerable: true, get: function () { return nervous_system_wasm_1.available_mechanisms; } });
+Object.defineProperty(exports, "performance_targets", { enumerable: true, get: function () { return nervous_system_wasm_1.performance_targets; } });
+Object.defineProperty(exports, "biological_references", { enumerable: true, get: function () { return nervous_system_wasm_1.biological_references; } });
+// Export adapters (to be implemented)
+__exportStar(require("./adapters/HdcMemoryAdapter.js"), exports);
+__exportStar(require("./adapters/BTSPAdapter.js"), exports);
+__exportStar(require("./adapters/ReflexLayer.js"), exports);
+__exportStar(require("./adapters/GlobalWorkspaceAdapter.js"), exports);
+__exportStar(require("./adapters/CircadianController.js"), exports);
+// Export integration components (named to avoid conflicts with adapters)
+var HybridPatternStore_js_1 = require("./integration/HybridPatternStore.js");
+Object.defineProperty(exports, "HybridPatternStore", { enumerable: true, get: function () { return HybridPatternStore_js_1.HybridPatternStore; } });
+Object.defineProperty(exports, "createHybridPatternStore", { enumerable: true, get: function () { return HybridPatternStore_js_1.createHybridPatternStore; } });
+Object.defineProperty(exports, "createHighPerformanceHybridStore", { enumerable: true, get: function () { return HybridPatternStore_js_1.createHighPerformanceHybridStore; } });
+var WorkspaceAgent_js_1 = require("./integration/WorkspaceAgent.js");
+Object.defineProperty(exports, "WorkspaceAgentCoordinator", { enumerable: true, get: function () { return WorkspaceAgent_js_1.WorkspaceAgentCoordinator; } });
+Object.defineProperty(exports, "createWorkspaceCoordinator", { enumerable: true, get: function () { return WorkspaceAgent_js_1.createWorkspaceCoordinator; } });
+Object.defineProperty(exports, "createFocusedCoordinator", { enumerable: true, get: function () { return WorkspaceAgent_js_1.createFocusedCoordinator; } });
+Object.defineProperty(exports, "createExpandedCoordinator", { enumerable: true, get: function () { return WorkspaceAgent_js_1.createExpandedCoordinator; } });
+var CircadianAgent_js_1 = require("./integration/CircadianAgent.js");
+Object.defineProperty(exports, "CircadianAgentManager", { enumerable: true, get: function () { return CircadianAgent_js_1.CircadianAgentManager; } });
+var BTSPLearningEngine_js_1 = require("./integration/BTSPLearningEngine.js");
+Object.defineProperty(exports, "BTSPLearningEngine", { enumerable: true, get: function () { return BTSPLearningEngine_js_1.BTSPLearningEngine; } });
+Object.defineProperty(exports, "createBTSPLearningEngine", { enumerable: true, get: function () { return BTSPLearningEngine_js_1.createBTSPLearningEngine; } });
+var NervousSystemEnhancement_js_1 = require("./integration/NervousSystemEnhancement.js");
+Object.defineProperty(exports, "enhanceWithNervousSystem", { enumerable: true, get: function () { return NervousSystemEnhancement_js_1.enhanceWithNervousSystem; } });
+Object.defineProperty(exports, "WithNervousSystem", { enumerable: true, get: function () { return NervousSystemEnhancement_js_1.WithNervousSystem; } });
+Object.defineProperty(exports, "NervousSystemFleetCoordinator", { enumerable: true, get: function () { return NervousSystemEnhancement_js_1.NervousSystemFleetCoordinator; } });
+// Export wasm-loader utilities
+var wasm_loader_js_1 = require("./wasm-loader.js");
+Object.defineProperty(exports, "initWasm", { enumerable: true, get: function () { return wasm_loader_js_1.initNervousSystem; } });
+Object.defineProperty(exports, "isWasmInitialized", { enumerable: true, get: function () { return wasm_loader_js_1.isWasmInitialized; } });
+Object.defineProperty(exports, "ensureInitialized", { enumerable: true, get: function () { return wasm_loader_js_1.ensureInitialized; } });
+Object.defineProperty(exports, "getWasmInfo", { enumerable: true, get: function () { return wasm_loader_js_1.getWasmInfo; } });
+//# sourceMappingURL=index.js.map

package/dist/nervous-system/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/nervous-system/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;;;;;;;;;;;;;;;;;;AAEH,iCAAiC;AACjC,qEAeuC;AAdrC,yIAAA,OAAO,OAAqB;AAC5B,gHAAA,SAAS,OAAA;AACT,4HAAA,qBAAqB,OAAA;AACrB,kHAAA,WAAW,OAAA;AACX,kHAAA,WAAW,OAAA;AACX,gHAAA,SAAS,OAAA;AACT,+GAAA,QAAQ,OAAA;AACR,gHAAA,SAAS,OAAA;AACT,sHAAA,eAAe,OAAA;AACf,oHAAA,aAAa,OAAA;AACb,2HAAA,OAAO,OAAwB;AAC/B,2HAAA,oBAAoB,OAAA;AACpB,0HAAA,mBAAmB,OAAA;AACnB,4HAAA,qBAAqB,OAAA;AAGvB,sCAAsC;AACtC,iEAA+C;AAC/C,4DAA0C;AAC1C,4DAA0C;AAC1C,uEAAqD;AACrD,oEAAkD;AAElD,yEAAyE;AACzE,6EAK6C;AAJ3C,2HAAA,kBAAkB,OAAA;AAElB,iIAAA,wBAAwB,OAAA;AACxB,yIAAA,gCAAgC,OAAA;AAGlC,qEASyC;AARvC,8HAAA,yBAAyB,OAAA;AAKzB,+HAAA,0BAA0B,OAAA;AAC1B,6HAAA,wBAAwB,OAAA;AACxB,8HAAA,yBAAyB,OAAA;AAG3B,qEAOyC;AANvC,0HAAA,qBAAqB,OAAA;AAQvB,6EAM6C;AAL3C,2HAAA,kBAAkB,OAAA;AAIlB,iIAAA,wBAAwB,OAAA;AAG1B,yFAQmD;AAPjD,uIAAA,wBAAwB,OAAA;AACxB,gIAAA,iBAAiB,OAAA;AACjB,4IAAA,6BAA6B,OAAA;AAO/B,+BAA+B;AAC/B,mDAK0B;AAJxB,0GAAA,iBAAiB,OAAY;AAC7B,mHAAA,iBAAiB,OAAA;AACjB,mHAAA,iBAAiB,OAAA;AACjB,6GAAA,WAAW,OAAA"}

package/dist/nervous-system/integration/BTSPLearningEngine.d.ts

@@ -0,0 +1,266 @@
+/**
+ * BTSPLearningEngine - One-shot Learning Integration
+ *
+ * Integrates BTSPAdapter with the existing LearningEngine to enable
+ * one-shot learning from single failures (vs 10+ examples with traditional RL).
+ *
+ * Key capabilities:
+ * - Learn from single failure (one-shot BTSP association)
+ * - BTSP pattern recall before Q-learning fallback
+ * - Plateau detection for stability monitoring
+ * - EWC consolidation to prevent catastrophic forgetting
+ *
+ * Architecture:
+ * - Wraps LearningEngine for hybrid learning
+ * - Uses BTSP for negative reward (failure) learning
+ * - Falls back to Q-learning for positive reward learning
+ * - Consolidates periodically to prevent forgetting
+ *
+ * @module nervous-system/integration/BTSPLearningEngine
+ */
+import { BTSPAdapter, BTSPAdapterConfig, PlateauDetectionResult } from '../adapters/BTSPAdapter.js';
+import { ExtendedLearningConfig } from '../../learning/LearningEngine.js';
+import { SwarmMemoryManager } from '../../core/memory/SwarmMemoryManager.js';
+import type { TaskState, LearningFeedback, LearningOutcome, LearnedPattern, StrategyRecommendation } from '../../learning/types.js';
+/**
+ * Configuration for BTSPLearningEngine
+ */
+export interface BTSPLearningEngineConfig {
+    /** BTSP adapter configuration */
+    btsp?: Partial<BTSPAdapterConfig>;
+    /** Learning engine configuration */
+    learning?: Partial<ExtendedLearningConfig>;
+    /** Threshold for using BTSP one-shot learning (reward below this triggers BTSP) */
+    oneShotThreshold: number;
+    /** Confidence threshold for trusting BTSP recall results */
+    recallConfidenceThreshold: number;
+    /** Consolidation interval (number of experiences before consolidation) */
+    consolidationInterval: number;
+    /** Enable automatic consolidation */
+    autoConsolidate: boolean;
+    /** Weight for BTSP recommendations vs Q-learning (0-1, higher = more BTSP influence) */
+    btspWeight: number;
+}
+/**
+ * BTSP learning outcome with additional metrics
+ */
+export interface BTSPLearningOutcome extends LearningOutcome {
+    /** Whether BTSP one-shot learning was used */
+    usedBTSP: boolean;
+    /** BTSP plateau detection result */
+    plateauResult?: PlateauDetectionResult;
+    /** BTSP confidence for this learning event */
+    btspConfidence?: number;
+    /** Whether consolidation was triggered */
+    consolidationTriggered: boolean;
+}
+/**
+ * Enhanced strategy recommendation with BTSP context
+ */
+export interface BTSPStrategyRecommendation extends StrategyRecommendation {
+    /** Source of recommendation */
+    source: 'btsp' | 'q-learning' | 'hybrid' | 'default';
+    /** BTSP recall confidence */
+    btspConfidence?: number;
+    /** Q-learning confidence */
+    qLearningConfidence?: number;
+    /** Whether BTSP associations were found */
+    hasBTSPAssociations: boolean;
+}
+/**
+ * Metrics for BTSPLearningEngine
+ */
+export interface BTSPLearningMetrics {
+    /** Total experiences processed */
+    totalExperiences: number;
+    /** Experiences learned via BTSP one-shot */
+    btspLearningCount: number;
+    /** Experiences learned via Q-learning */
+    qLearningCount: number;
+    /** Number of consolidations performed */
+    consolidationCount: number;
+    /** Average BTSP recall confidence */
+    avgBTSPRecallConfidence: number;
+    /** Number of plateau detections */
+    plateauDetectionCount: number;
+    /** BTSP capacity utilization */
+    btspCapacityUtilization: number;
+    /** Last consolidation timestamp */
+    lastConsolidation?: Date;
+}
+/**
+ * BTSPLearningEngine - Hybrid one-shot + RL learning
+ *
+ * Provides bio-inspired one-shot learning for failures while maintaining
+ * Q-learning for positive reinforcement. This enables learning from
+ * single test failures instead of requiring 10+ examples.
+ *
+ * @example
+ * ```typescript
+ * const engine = new BTSPLearningEngine('agent-1', memoryStore, {
+ *   oneShotThreshold: 0,
+ *   recallConfidenceThreshold: 0.6
+ * });
+ * await engine.initialize();
+ *
+ * // Learn from execution - BTSP for failures, Q-learning for success
+ * const outcome = await engine.learnFromExecution(task, result, feedback);
+ *
+ * // Get recommendation - checks BTSP associations first
+ * const recommendation = await engine.recommendWithBTSP(state);
+ * ```
+ */
+export declare class BTSPLearningEngine {
+    private readonly logger;
+    private readonly config;
+    private readonly agentId;
+    /** BTSP adapter for one-shot learning */
+    private btspAdapter;
+    /** Base learning engine with Q-learning */
+    private baseLearningEngine;
+    /** Memory store reference */
+    private readonly memoryStore;
+    /** Initialization state */
+    private initialized;
+    /** Metrics tracking */
+    private metrics;
+    /** Accumulated recall confidences for averaging */
+    private recallConfidences;
+    /** Experience count since last consolidation */
+    private experiencesSinceConsolidation;
+    constructor(agentId: string, memoryStore: SwarmMemoryManager, config?: Partial<BTSPLearningEngineConfig>);
+    /**
+     * Initialize both BTSP adapter and base learning engine
+     */
+    initialize(): Promise<void>;
+    /**
+     * Ensure engine is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Learn from task execution with hybrid BTSP/Q-learning
+     *
+     * Uses BTSP one-shot learning for failures (reward < threshold) and
+     * Q-learning for positive experiences. This enables learning from
+     * single failures instead of requiring many examples.
+     *
+     * @param task - Task that was executed
+     * @param result - Execution result
+     * @param feedback - Optional user/system feedback
+     * @returns Learning outcome with BTSP-specific metrics
+     */
+    learnFromExecution(task: unknown, result: unknown, feedback?: LearningFeedback): Promise<BTSPLearningOutcome>;
+    /**
+     * Recommend strategy with BTSP association check first
+     *
+     * Checks BTSP associations for the state before falling back to
+     * Q-learning. This provides faster recommendations from one-shot
+     * learned patterns.
+     *
+     * @param state - Current task state
+     * @returns Strategy recommendation with source information
+     */
+    recommendWithBTSP(state: TaskState): Promise<BTSPStrategyRecommendation>;
+    /**
+     * Get patterns from both BTSP and Q-learning
+     *
+     * Combines BTSP-learned associations with patterns from the base
+     * learning engine for a complete view of learned knowledge.
+     */
+    getPatterns(): Promise<LearnedPattern[]>;
+    /**
+     * Perform EWC consolidation to prevent catastrophic forgetting
+     *
+     * This should be called periodically (automatically if autoConsolidate is enabled)
+     * to preserve important synaptic weights.
+     */
+    consolidate(): Promise<void>;
+    /**
+     * Check if BTSP learning has reached a plateau (stable state)
+     *
+     * Returns true if recent learning signals have stabilized, indicating
+     * the model has converged on important associations.
+     */
+    isPlateauReached(): boolean;
+    /**
+     * Get comprehensive metrics for the BTSP learning engine
+     */
+    getMetrics(): BTSPLearningMetrics;
+    /**
+     * Get BTSP adapter statistics
+     */
+    getBTSPStats(): ReturnType<BTSPAdapter['getStats']> | null;
+    /**
+     * Get BTSP adapter for direct access (for serialization/persistence)
+     */
+    getBTSPAdapter(): BTSPAdapter;
+    /**
+     * Get base learning engine statistics
+     */
+    getBaseLearningStats(): {
+        algorithm: import("../../learning/LearningEngine.js").RLAlgorithmType;
+        algorithmStats: {
+            algorithm: import("../../learning/LearningEngine.js").RLAlgorithmType;
+            stats?: ReturnType<import("../../index.js").AbstractRLLearner["getStatistics"]>;
+        };
+        totalExperiences: number;
+        explorationRate: number;
+        qLearningStats: {
+            enabled: boolean;
+            stats?: {
+                steps: number;
+                episodes: number;
+                tableSize: number;
+                explorationRate: number;
+                avgQValue: number;
+                maxQValue: number;
+                minQValue: number;
+            };
+        };
+    };
+    /**
+     * Check if the engine is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Reset BTSP adapter (clears one-shot associations)
+     */
+    resetBTSP(): void;
+    /**
+     * Dispose of resources
+     */
+    dispose(): void;
+    /**
+     * Calculate reward from execution result and feedback
+     */
+    private calculateReward;
+    /**
+     * Convert task and result to a fixed-size pattern for BTSP
+     */
+    private taskToPattern;
+    /**
+     * Convert task state to pattern for BTSP recall
+     */
+    private stateToPattern;
+    /**
+     * Convert BTSP pattern to strategy recommendation
+     */
+    private patternToStrategy;
+    /**
+     * Calculate average recall confidence
+     */
+    private calculateAverageConfidence;
+    /**
+     * Simple hash function for string to number
+     */
+    private simpleHash;
+}
+/**
+ * Factory function to create a pre-configured BTSPLearningEngine
+ */
+export declare function createBTSPLearningEngine(agentId: string, memoryStore: SwarmMemoryManager, config?: Partial<BTSPLearningEngineConfig>): BTSPLearningEngine;
+/**
+ * Default export
+ */
+export default BTSPLearningEngine;
+//# sourceMappingURL=BTSPLearningEngine.d.ts.map

package/dist/nervous-system/integration/BTSPLearningEngine.d.ts.map

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