🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
checkpoint: File edit:
rUvd4e73b80a909
diff --git a/v3/integration/agentic-flow-bridge.ts b/v3/integration/agentic-flow-bridge.tsindex a5dbd9df77..6a6333b8b0 100644--- a/v3/integration/agentic-flow-bridge.ts+++ b/v3/integration/agentic-flow-bridge.ts@@ -27,6 +27,46 @@ import { SONAAdapter } from './sona-adapter.js';import { AttentionCoordinator } from './attention-coordinator.js';import { SDKBridge } from './sdk-bridge.js';+/**+ * Interface for agentic-flow core module (dynamically loaded)+ * This represents the external agentic-flow@alpha package API+ */+interface AgenticFlowSONAInterface {+ setMode(mode: string): Promise<void>;+ storePattern(params: unknown): Promise<string>;+ findPatterns(query: string, options?: unknown): Promise<unknown[]>;+ getStats(): Promise<unknown>;+}++interface AgenticFlowAttentionInterface {+ compute(params: unknown): Promise<unknown>;+ setMechanism(mechanism: string): Promise<void>;+ getMetrics(): Promise<unknown>;+}++interface AgenticFlowAgentDBInterface {+ search(query: number[], options?: unknown): Promise<unknown[]>;+ insert(vector: number[], metadata?: unknown): Promise<string>;+ enableCrossAgentSharing(options?: unknown): Promise<void>;+}++/**+ * Core interface for agentic-flow@alpha package+ * Used for deep integration and code deduplication per ADR-001+ */+export interface AgenticFlowCore {+ sona: AgenticFlowSONAInterface;+ attention: AgenticFlowAttentionInterface;+ agentdb: AgenticFlowAgentDBInterface;+ version: string;+ isConnected: boolean;+}++/**+ * Factory function type for creating agentic-flow instance+ */+type AgenticFlowFactory = (config: unknown) => Promise<AgenticFlowCore>;+/*** AgenticFlowBridge - Core integration class for agentic-flow@alpha*diff --git a/v3/neural/pattern-learner.ts b/v3/neural/pattern-learner.tsnew file mode 100644index 0000000000..0c563c22be--- /dev/null+++ b/v3/neural/pattern-learner.ts@@ -0,0 +1,757 @@+/**+ * Pattern Learner+ *+ * Implements pattern extraction, matching, and evolution for+ * continuous learning from agent experiences.+ *+ * Performance Targets:+ * - Pattern matching: <1ms+ * - Pattern extraction: <5ms+ * - Evolution step: <2ms+ */++import type {+ Pattern,+ PatternMatch,+ PatternEvolution,+ Trajectory,+ DistilledMemory,+ NeuralEvent,+ NeuralEventListener,+} from './types.js';++/**+ * Configuration for Pattern Learner+ */+export interface PatternLearnerConfig {+ /** Maximum number of patterns to store */+ maxPatterns: number;++ /** Similarity threshold for matching */+ matchThreshold: number;++ /** Minimum usages before pattern is stable */+ minUsagesForStable: number;++ /** Quality threshold for pattern inclusion */+ qualityThreshold: number;++ /** Enable pattern clustering */+ enableClustering: boolean;++ /** Number of clusters (if clustering enabled) */+ numClusters: number;++ /** Evolution learning rate */+ evolutionLearningRate: number;+}++/**+ * Default Pattern Learner configuration+ */+const DEFAULT_CONFIG: PatternLearnerConfig = {+ maxPatterns: 1000,+ matchThreshold: 0.7,+ minUsagesForStable: 5,+ qualityThreshold: 0.5,+ enableClustering: true,+ numClusters: 50,+ evolutionLearningRate: 0.1,+};++/**+ * Cluster representation for fast pattern lookup+ */+interface PatternCluster {+ clusterId: number;+ centroid: Float32Array;+ patternIds: Set<string>;+}++/**+ * Pattern Learner - Manages pattern extraction, matching, and evolution+ */+export class PatternLearner {+ private config: PatternLearnerConfig;+ private patterns: Map<string, Pattern> = new Map();+ private clusters: PatternCluster[] = [];+ private patternToCluster: Map<string, number> = new Map();++ // Performance tracking+ private matchCount = 0;+ private totalMatchTime = 0;+ private extractionCount = 0;+ private totalExtractionTime = 0;+ private evolutionCount = 0;+ private totalEvolutionTime = 0;++ // Event listeners+ private eventListeners: Set<NeuralEventListener> = new Set();++ constructor(config: Partial<PatternLearnerConfig> = {}) {+ this.config = { ...DEFAULT_CONFIG, ...config };+ }++ // ==========================================================================+ // Pattern Matching+ // ==========================================================================++ /**+ * Find matching patterns for a query embedding+ * Target: <1ms+ */+ findMatches(queryEmbedding: Float32Array, k: number = 3): PatternMatch[] {+ const startTime = performance.now();++ if (this.patterns.size === 0) {+ return [];+ }++ let candidates: Pattern[];++ // Use clustering for faster search if enabled and clusters exist+ if (this.config.enableClustering && this.clusters.length > 0) {+ candidates = this.getCandidatesFromClusters(queryEmbedding);+ } else {+ candidates = Array.from(this.patterns.values());+ }++ // Compute similarities+ const matches: PatternMatch[] = [];++ for (const pattern of candidates) {+ const similarity = this.cosineSimilarity(queryEmbedding, pattern.embedding);++ if (similarity >= this.config.matchThreshold) {+ matches.push({+ pattern,+ similarity,+ confidence: this.computeMatchConfidence(pattern, similarity),+ latencyMs: 0,+ });+ }+ }++ // Sort by similarity+ matches.sort((a, b) => b.similarity - a.similarity);+ const result = matches.slice(0, k);++ // Track performance+ const elapsed = performance.now() - startTime;+ this.matchCount++;+ this.totalMatchTime += elapsed;++ // Warn if over target+ if (elapsed > 1) {+ console.warn(`Pattern matching exceeded target: ${elapsed.toFixed(2)}ms > 1ms`);+ }++ return result;+ }++ /**+ * Find best single match+ */+ findBestMatch(queryEmbedding: Float32Array): PatternMatch | null {+ const matches = this.findMatches(queryEmbedding, 1);+ return matches.length > 0 ? matches[0] : null;+ }++ // ==========================================================================+ // Pattern Extraction+ // ==========================================================================++ /**+ * Extract a pattern from a trajectory+ * Target: <5ms+ */+ extractPattern(trajectory: Trajectory, memory?: DistilledMemory): Pattern | null {+ const startTime = performance.now();++ // Validate trajectory+ if (!trajectory.isComplete || trajectory.qualityScore < this.config.qualityThreshold) {+ return null;+ }++ // Check for duplicates+ const embedding = this.computePatternEmbedding(trajectory);+ const existing = this.findSimilarPattern(embedding, 0.95);++ if (existing) {+ // Update existing pattern instead+ this.updatePatternFromTrajectory(existing, trajectory);+ return existing;+ }++ // Create new pattern+ const pattern: Pattern = {+ patternId: `pat_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,+ name: this.generatePatternName(trajectory),+ domain: trajectory.domain,+ embedding,+ strategy: this.extractStrategy(trajectory),+ successRate: trajectory.qualityScore,+ usageCount: 1,+ qualityHistory: [trajectory.qualityScore],+ evolutionHistory: [],+ createdAt: Date.now(),+ updatedAt: Date.now(),+ };++ // Store pattern+ this.patterns.set(pattern.patternId, pattern);++ // Update clusters if enabled+ if (this.config.enableClustering) {+ this.assignToCluster(pattern);+ }++ // Prune if over capacity+ if (this.patterns.size > this.config.maxPatterns) {+ this.prunePatterns();+ }++ // Track performance+ const elapsed = performance.now() - startTime;+ this.extractionCount++;+ this.totalExtractionTime += elapsed;++ return pattern;+ }++ /**+ * Extract patterns from multiple trajectories in batch+ */+ extractPatternsBatch(trajectories: Trajectory[]): Pattern[] {+ const patterns: Pattern[] = [];++ for (const trajectory of trajectories) {+ const pattern = this.extractPattern(trajectory);+ if (pattern) {+ patterns.push(pattern);+ }+ }++ // Rebuild clusters after batch extraction+ if (this.config.enableClustering && patterns.length > 10) {+ this.rebuildClusters();+ }++ return patterns;+ }++ // ==========================================================================+ // Pattern Evolution+ // ==========================================================================++ /**+ * Evolve a pattern based on new experience+ * Target: <2ms+ */+ evolvePattern(patternId: string, quality: number, context?: string): void {+ const startTime = performance.now();++ const pattern = this.patterns.get(patternId);+ if (!pattern) return;++ const previousQuality = pattern.successRate;+ const lr = this.config.evolutionLearningRate;++ // Update quality history+ pattern.qualityHistory.push(quality);+ if (pattern.qualityHistory.length > 100) {+ pattern.qualityHistory = pattern.qualityHistory.slice(-100);+ }++ // Exponential moving average for success rate+ pattern.successRate = pattern.successRate * (1 - lr) + quality * lr;+ pattern.usageCount++;+ pattern.updatedAt = Date.now();++ // Record evolution+ const evolutionType = this.determineEvolutionType(previousQuality, pattern.successRate);+ pattern.evolutionHistory.push({+ timestamp: Date.now(),+ type: evolutionType,+ previousQuality,+ newQuality: pattern.successRate,+ description: context || 'Updated from new experience',+ });++ // Keep evolution history bounded+ if (pattern.evolutionHistory.length > 50) {+ pattern.evolutionHistory = pattern.evolutionHistory.slice(-50);+ }++ // Emit event+ this.emitEvent({+ type: 'pattern_evolved',+ patternId,+ evolutionType,+ });++ // Track performance+ const elapsed = performance.now() - startTime;+ this.evolutionCount++;+ this.totalEvolutionTime += elapsed;+ }++ /**+ * Merge two similar patterns+ */+ mergePatterns(patternId1: string, patternId2: string): Pattern | null {+ const p1 = this.patterns.get(patternId1);+ const p2 = this.patterns.get(patternId2);++ if (!p1 || !p2) return null;++ // Keep the higher quality pattern as base+ const [keep, remove] = p1.successRate >= p2.successRate ? [p1, p2] : [p2, p1];++ // Merge embeddings (weighted average)+ const totalUsage = keep.usageCount + remove.usageCount;+ const w1 = keep.usageCount / totalUsage;+ const w2 = remove.usageCount / totalUsage;++ for (let i = 0; i < keep.embedding.length; i++) {+ keep.embedding[i] = keep.embedding[i] * w1 + remove.embedding[i] * w2;+ }++ // Merge statistics+ keep.usageCount += remove.usageCount;+ keep.qualityHistory.push(...remove.qualityHistory);+ keep.successRate = keep.qualityHistory.reduce((a, b) => a + b, 0) / keep.qualityHistory.length;++ // Record merge+ keep.evolutionHistory.push({+ timestamp: Date.now(),+ type: 'merge',+ previousQuality: p1.successRate,+ newQuality: keep.successRate,+ description: `Merged with pattern ${remove.patternId}`,+ });++ // Remove the merged pattern+ this.patterns.delete(remove.patternId);+ this.patternToCluster.delete(remove.patternId);++ return keep;+ }++ /**+ * Split a pattern into more specific sub-patterns+ */+ splitPattern(patternId: string, numSplits: number = 2): Pattern[] {+ const pattern = this.patterns.get(patternId);+ if (!pattern || numSplits < 2) return [];++ const splits: Pattern[] = [];++ for (let i = 0; i < numSplits; i++) {+ // Create variation of embedding with noise+ const newEmbedding = new Float32Array(pattern.embedding.length);+ for (let j = 0; j < newEmbedding.length; j++) {+ const noise = (Math.random() - 0.5) * 0.1;+ newEmbedding[j] = pattern.embedding[j] + noise;+ }++ const newPattern: Pattern = {+ patternId: `pat_${Date.now()}_${i}_${Math.random().toString(36).slice(2, 6)}`,+ name: `${pattern.name}_split_${i}`,+ domain: pattern.domain,+ embedding: newEmbedding,+ strategy: pattern.strategy,+ successRate: pattern.successRate * 0.9, // Slight penalty for uncertainty+ usageCount: 0,+ qualityHistory: [],+ evolutionHistory: [{+ timestamp: Date.now(),+ type: 'split',+ previousQuality: pattern.successRate,+ newQuality: pattern.successRate * 0.9,+ description: `Split from pattern ${patternId}`,+ }],+ createdAt: Date.now(),+ updatedAt: Date.now(),+ };++ this.patterns.set(newPattern.patternId, newPattern);+ splits.push(newPattern);+ }++ // Remove original pattern+ this.patterns.delete(patternId);+ this.patternToCluster.delete(patternId);++ // Rebuild clusters+ if (this.config.enableClustering) {+ this.rebuildClusters();+ }++ return splits;+ }++ // ==========================================================================+ // Pattern Access+ // ==========================================================================++ /**+ * Get all patterns+ */+ getPatterns(): Pattern[] {+ return Array.from(this.patterns.values());+ }++ /**+ * Get pattern by ID+ */+ getPattern(patternId: string): Pattern | undefined {+ return this.patterns.get(patternId);+ }++ /**+ * Get patterns by domain+ */+ getPatternsByDomain(domain: string): Pattern[] {+ return Array.from(this.patterns.values()).filter(p => p.domain === domain);+ }++ /**+ * Get stable patterns (sufficient usage)+ */+ getStablePatterns(): Pattern[] {+ return Array.from(this.patterns.values())+ .filter(p => p.usageCount >= this.config.minUsagesForStable);+ }++ // ==========================================================================+ // Statistics+ // ==========================================================================++ getStats(): Record<string, number> {+ const patterns = Array.from(this.patterns.values());++ return {+ totalPatterns: this.patterns.size,+ stablePatterns: patterns.filter(p => p.usageCount >= this.config.minUsagesForStable).length,+ avgSuccessRate: patterns.length > 0+ ? patterns.reduce((s, p) => s + p.successRate, 0) / patterns.length+ : 0,+ avgUsageCount: patterns.length > 0+ ? patterns.reduce((s, p) => s + p.usageCount, 0) / patterns.length+ : 0,+ numClusters: this.clusters.length,+ avgMatchTimeMs: this.matchCount > 0 ? this.totalMatchTime / this.matchCount : 0,+ avgExtractionTimeMs: this.extractionCount > 0 ? this.totalExtractionTime / this.extractionCount : 0,+ avgEvolutionTimeMs: this.evolutionCount > 0 ? this.totalEvolutionTime / this.evolutionCount : 0,+ };+ }++ // ==========================================================================+ // Event System+ // ==========================================================================++ addEventListener(listener: NeuralEventListener): void {+ this.eventListeners.add(listener);+ }++ removeEventListener(listener: NeuralEventListener): void {+ this.eventListeners.delete(listener);+ }++ private emitEvent(event: NeuralEvent): void {+ for (const listener of this.eventListeners) {+ try {+ listener(event);+ } catch (error) {+ console.error('Error in PatternLearner event listener:', error);+ }+ }+ }++ // ==========================================================================+ // Private Helper Methods+ // ==========================================================================++ private cosineSimilarity(a: Float32Array, b: Float32Array): number {+ if (a.length !== b.length) return 0;++ 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) * Math.sqrt(normB);+ return denom > 0 ? dot / denom : 0;+ }++ private computeMatchConfidence(pattern: Pattern, similarity: number): number {+ // Combine similarity with pattern reliability+ const usageWeight = Math.min(pattern.usageCount / 10, 1);+ const qualityWeight = pattern.successRate;++ return similarity * (1 - usageWeight * 0.2 - qualityWeight * 0.2) ++ usageWeight * 0.1 ++ qualityWeight * 0.1;+ }++ private getCandidatesFromClusters(queryEmbedding: Float32Array): Pattern[] {+ // Find nearest clusters+ const clusterScores: Array<{ cluster: PatternCluster; score: number }> = [];++ for (const cluster of this.clusters) {+ const score = this.cosineSimilarity(queryEmbedding, cluster.centroid);+ clusterScores.push({ cluster, score });+ }++ clusterScores.sort((a, b) => b.score - a.score);++ // Get patterns from top 3 clusters+ const candidates: Pattern[] = [];+ for (const { cluster } of clusterScores.slice(0, 3)) {+ for (const patternId of cluster.patternIds) {+ const pattern = this.patterns.get(patternId);+ if (pattern) {+ candidates.push(pattern);+ }+ }+ }++ return candidates;+ }++ private findSimilarPattern(embedding: Float32Array, threshold: number): Pattern | null {+ for (const pattern of this.patterns.values()) {+ const sim = this.cosineSimilarity(embedding, pattern.embedding);+ if (sim >= threshold) {+ return pattern;+ }+ }+ return null;+ }++ private updatePatternFromTrajectory(pattern: Pattern, trajectory: Trajectory): void {+ // Update quality+ pattern.qualityHistory.push(trajectory.qualityScore);+ if (pattern.qualityHistory.length > 100) {+ pattern.qualityHistory = pattern.qualityHistory.slice(-100);+ }++ // EMA for success rate+ const lr = this.config.evolutionLearningRate;+ pattern.successRate = pattern.successRate * (1 - lr) + trajectory.qualityScore * lr;+ pattern.usageCount++;+ pattern.updatedAt = Date.now();+ }++ private computePatternEmbedding(trajectory: Trajectory): Float32Array {+ if (trajectory.steps.length === 0) {+ return new Float32Array(768);+ }++ const dim = trajectory.steps[0].stateAfter.length;+ const embedding = new Float32Array(dim);++ // Weighted average (higher weight for later steps)+ let totalWeight = 0;+ for (let i = 0; i < trajectory.steps.length; i++) {+ const weight = (i + 1) / trajectory.steps.length;+ totalWeight += weight;+ for (let j = 0; j < dim; j++) {+ embedding[j] += trajectory.steps[i].stateAfter[j] * weight;+ }+ }++ for (let j = 0; j < dim; j++) {+ embedding[j] /= totalWeight;+ }++ return embedding;+ }++ private generatePatternName(trajectory: Trajectory): string {+ const domain = trajectory.domain;+ const quality = trajectory.qualityScore > 0.7 ? 'high' : 'mid';+ const steps = trajectory.steps.length > 5 ? 'complex' : 'simple';+ return `${domain}_${quality}_${steps}_${Date.now() % 10000}`;+ }++ private extractStrategy(trajectory: Trajectory): string {+ const actions = trajectory.steps.map(s => s.action);+ if (actions.length === 0) return 'empty';+ if (actions.length <= 3) return actions.join(' -> ');+ return `${actions.slice(0, 2).join(' -> ')} ... ${actions[actions.length - 1]}`;+ }++ private assignToCluster(pattern: Pattern): void {+ if (this.clusters.length === 0) {+ // Create first cluster+ this.clusters.push({+ clusterId: 0,+ centroid: new Float32Array(pattern.embedding),+ patternIds: new Set([pattern.patternId]),+ });+ this.patternToCluster.set(pattern.patternId, 0);+ return;+ }++ // Find nearest cluster+ let bestCluster = 0;+ let bestSim = -1;++ for (let i = 0; i < this.clusters.length; i++) {+ const sim = this.cosineSimilarity(pattern.embedding, this.clusters[i].centroid);+ if (sim > bestSim) {+ bestSim = sim;+ bestCluster = i;+ }+ }++ // Create new cluster if not similar enough and under limit+ if (bestSim < 0.7 && this.clusters.length < this.config.numClusters) {+ const newId = this.clusters.length;+ this.clusters.push({+ clusterId: newId,+ centroid: new Float32Array(pattern.embedding),+ patternIds: new Set([pattern.patternId]),+ });+ this.patternToCluster.set(pattern.patternId, newId);+ } else {+ // Add to existing cluster and update centroid+ const cluster = this.clusters[bestCluster];+ cluster.patternIds.add(pattern.patternId);+ this.patternToCluster.set(pattern.patternId, bestCluster);+ this.updateClusterCentroid(cluster);+ }+ }++ private updateClusterCentroid(cluster: PatternCluster): void {+ const dim = cluster.centroid.length;+ const newCentroid = new Float32Array(dim);+ let count = 0;++ for (const patternId of cluster.patternIds) {+ const pattern = this.patterns.get(patternId);+ if (pattern) {+ for (let i = 0; i < dim; i++) {+ newCentroid[i] += pattern.embedding[i];+ }+ count++;+ }+ }++ if (count > 0) {+ for (let i = 0; i < dim; i++) {+ newCentroid[i] /= count;+ }+ cluster.centroid = newCentroid;+ }+ }++ private rebuildClusters(): void {+ if (this.patterns.size === 0) {+ this.clusters = [];+ this.patternToCluster.clear();+ return;+ }++ const patterns = Array.from(this.patterns.values());+ const k = Math.min(this.config.numClusters, Math.ceil(patterns.length / 5));+ const dim = patterns[0].embedding.length;++ // Initialize clusters with random patterns+ this.clusters = [];+ this.patternToCluster.clear();++ const indices = new Set<number>();+ while (indices.size < k && indices.size < patterns.length) {+ indices.add(Math.floor(Math.random() * patterns.length));+ }++ let clusterId = 0;+ for (const idx of indices) {+ this.clusters.push({+ clusterId: clusterId++,+ centroid: new Float32Array(patterns[idx].embedding),+ patternIds: new Set(),+ });+ }++ // K-means iterations+ for (let iter = 0; iter < 10; iter++) {+ // Clear assignments+ for (const cluster of this.clusters) {+ cluster.patternIds.clear();+ }++ // Assign patterns to nearest cluster+ for (const pattern of patterns) {+ let bestCluster = 0;+ let bestSim = -1;++ for (let c = 0; c < this.clusters.length; c++) {+ const sim = this.cosineSimilarity(pattern.embedding, this.clusters[c].centroid);+ if (sim > bestSim) {+ bestSim = sim;+ bestCluster = c;+ }+ }++ this.clusters[bestCluster].patternIds.add(pattern.patternId);+ this.patternToCluster.set(pattern.patternId, bestCluster);+ }++ // Update centroids+ for (const cluster of this.clusters) {+ this.updateClusterCentroid(cluster);+ }+ }++ // Remove empty clusters+ this.clusters = this.clusters.filter(c => c.patternIds.size > 0);+ }++ private prunePatterns(): void {+ // Sort by score (quality * log(usage))+ const scored = Array.from(this.patterns.entries())+ .map(([id, pattern]) => ({+ id,+ pattern,+ score: pattern.successRate * Math.log(pattern.usageCount + 1),+ }))+ .sort((a, b) => a.score - b.score);++ // Remove lowest scoring patterns+ const toRemove = scored.length - Math.floor(this.config.maxPatterns * 0.8);+ for (let i = 0; i < toRemove && i < scored.length; i++) {+ this.patterns.delete(scored[i].id);+ this.patternToCluster.delete(scored[i].id);+ }++ // Rebuild clusters+ if (this.config.enableClustering) {+ this.rebuildClusters();+ }+ }++ private determineEvolutionType(+ prev: number,+ curr: number+ ): 'improvement' | 'merge' | 'split' | 'prune' {+ const delta = curr - prev;+ if (delta > 0.05) return 'improvement';+ if (delta < -0.15) return 'prune';+ return 'improvement';+ }+}++/**+ * Factory function for creating PatternLearner+ */+export function createPatternLearner(+ config?: Partial<PatternLearnerConfig>+): PatternLearner {+ return new PatternLearner(config);+}diff --git a/v3/neural/reasoning-bank.ts b/v3/neural/reasoning-bank.tsnew file mode 100644index 0000000000..4d93761cc8--- /dev/null+++ b/v3/neural/reasoning-bank.ts@@ -0,0 +1,824 @@+/**+ * ReasoningBank Integration+ *+ * Implements the 4-step learning pipeline:+ * 1. RETRIEVE - Top-k memory injection with MMR diversity+ * 2. JUDGE - LLM-as-judge trajectory evaluation+ * 3. DISTILL - Extract strategy memories from trajectories+ * 4. CONSOLIDATE - Dedup, detect contradictions, prune old patterns+ *+ * Performance Target: <10ms for learning step+ */++import type {+ Trajectory,+ TrajectoryStep,+ TrajectoryVerdict,+ DistilledMemory,+ Pattern,+ PatternEvolution,+ NeuralEvent,+ NeuralEventListener,+} from './types.js';++/**+ * Configuration for ReasoningBank+ */+export interface ReasoningBankConfig {+ /** Maximum number of trajectories to store */+ maxTrajectories: number;++ /** Minimum quality threshold for distillation */+ distillationThreshold: number;++ /** Number of similar memories to retrieve */+ retrievalK: number;++ /** Diversity factor for MMR (0-1) */+ mmrLambda: number;++ /** Maximum age of patterns in days */+ maxPatternAgeDays: number;++ /** Similarity threshold for deduplication */+ dedupThreshold: number;++ /** Enable contradiction detection */+ enableContradictionDetection: boolean;+}++/**+ * Default ReasoningBank configuration+ */+const DEFAULT_CONFIG: ReasoningBankConfig = {+ maxTrajectories: 5000,+ distillationThreshold: 0.6,+ retrievalK: 3,+ mmrLambda: 0.7,+ maxPatternAgeDays: 30,+ dedupThreshold: 0.95,+ enableContradictionDetection: true,+};++/**+ * Memory entry with metadata+ */+interface MemoryEntry {+ memory: DistilledMemory;+ trajectory: Trajectory;+ verdict: TrajectoryVerdict;+ consolidated: boolean;+}++/**+ * Retrieval result with diversity scoring+ */+export interface RetrievalResult {+ memory: DistilledMemory;+ relevanceScore: number;+ diversityScore: number;+ combinedScore: number;+}++/**+ * Consolidation result+ */+export interface ConsolidationResult {+ removedDuplicates: number;+ contradictionsDetected: number;+ prunedPatterns: number;+ mergedPatterns: number;+}++/**+ * ReasoningBank - Trajectory storage and learning pipeline+ */+export class ReasoningBank {+ private config: ReasoningBankConfig;+ private trajectories: Map<string, Trajectory> = new Map();+ private memories: Map<string, MemoryEntry> = new Map();+ private patterns: Map<string, Pattern> = new Map();+ private eventListeners: Set<NeuralEventListener> = new Set();++ // Performance tracking+ private retrievalCount = 0;+ private totalRetrievalTime = 0;+ private distillationCount = 0;+ private totalDistillationTime = 0;++ constructor(config: Partial<ReasoningBankConfig> = {}) {+ this.config = { ...DEFAULT_CONFIG, ...config };+ }++ // ==========================================================================+ // STEP 1: RETRIEVE - Top-k memory injection with MMR diversity+ // ==========================================================================++ /**+ * Retrieve relevant memories using Maximal Marginal Relevance (MMR)+ */+ async retrieve(queryEmbedding: Float32Array, k?: number): Promise<RetrievalResult[]> {+ const startTime = performance.now();+ const retrieveK = k ?? this.config.retrievalK;++ if (this.memories.size === 0) {+ return [];+ }++ // Get all memories with relevance scores+ const candidates: Array<{ entry: MemoryEntry; relevance: number }> = [];++ for (const entry of this.memories.values()) {+ const relevance = this.cosineSimilarity(queryEmbedding, entry.memory.embedding);+ candidates.push({ entry, relevance });+ }++ // Sort by relevance+ candidates.sort((a, b) => b.relevance - a.relevance);++ // Apply MMR for diversity+ const results: RetrievalResult[] = [];+ const selected: MemoryEntry[] = [];++ while (results.length < retrieveK && candidates.length > 0) {+ let bestIdx = 0;+ let bestScore = -Infinity;++ for (let i = 0; i < candidates.length; i++) {+ const candidate = candidates[i];++ // Compute MMR score: lambda * relevance - (1 - lambda) * max_similarity_to_selected+ const relevance = candidate.relevance;+ let maxSimilarity = 0;++ for (const sel of selected) {+ const sim = this.cosineSimilarity(+ candidate.entry.memory.embedding,+ sel.memory.embedding+ );+ maxSimilarity = Math.max(maxSimilarity, sim);+ }++ const diversityScore = 1 - maxSimilarity;+ const mmrScore = this.config.mmrLambda * relevance ++ (1 - this.config.mmrLambda) * diversityScore;++ if (mmrScore > bestScore) {+ bestScore = mmrScore;+ bestIdx = i;+ }+ }++ // Add best candidate+ const best = candidates[bestIdx];+ selected.push(best.entry);+ results.push({+ memory: best.entry.memory,+ relevanceScore: best.relevance,+ diversityScore: 1 - this.computeMaxSimilarity(best.entry, selected.slice(0, -1)),+ combinedScore: bestScore,+ });++ // Remove from candidates+ candidates.splice(bestIdx, 1);+ }++ // Update stats+ this.retrievalCount++;+ this.totalRetrievalTime += performance.now() - startTime;++ return results;+ }++ // ==========================================================================+ // STEP 2: JUDGE - LLM-as-judge trajectory evaluation+ // ==========================================================================++ /**+ * Judge a trajectory and produce a verdict+ */+ async judge(trajectory: Trajectory): Promise<TrajectoryVerdict> {+ if (!trajectory.isComplete) {+ throw new Error('Cannot judge incomplete trajectory');+ }++ // Analyze trajectory steps+ const stepAnalysis = this.analyzeSteps(trajectory.steps);++ // Compute success based on quality and step analysis+ const success = trajectory.qualityScore >= this.config.distillationThreshold &&+ stepAnalysis.positiveRatio > 0.6;++ // Identify strengths and weaknesses+ const strengths = this.identifyStrengths(trajectory, stepAnalysis);+ const weaknesses = this.identifyWeaknesses(trajectory, stepAnalysis);++ // Generate improvement suggestions+ const improvements = this.generateImprovements(weaknesses);++ // Compute relevance for similar future tasks+ const relevanceScore = this.computeRelevanceScore(trajectory);++ const verdict: TrajectoryVerdict = {+ success,+ confidence: this.computeConfidence(trajectory, stepAnalysis),+ strengths,+ weaknesses,+ improvements,+ relevanceScore,+ };++ // Store verdict with trajectory+ trajectory.verdict = verdict;++ return verdict;+ }++ // ==========================================================================+ // STEP 3: DISTILL - Extract strategy memories from trajectories+ // ==========================================================================++ /**+ * Distill a trajectory into a reusable memory+ */+ async distill(trajectory: Trajectory): Promise<DistilledMemory | null> {+ const startTime = performance.now();++ // Must be judged first+ if (!trajectory.verdict) {+ await this.judge(trajectory);+ }++ // Only distill successful trajectories+ if (!trajectory.verdict!.success ||+ trajectory.qualityScore < this.config.distillationThreshold) {+ return null;+ }++ // Extract strategy from trajectory+ const strategy = this.extractStrategy(trajectory);++ // Extract key learnings+ const keyLearnings = this.extractKeyLearnings(trajectory);++ // Compute aggregated embedding+ const embedding = this.computeAggregateEmbedding(trajectory);++ const memory: DistilledMemory = {+ memoryId: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,+ trajectoryId: trajectory.trajectoryId,+ strategy,+ keyLearnings,+ embedding,+ quality: trajectory.qualityScore,+ usageCount: 0,+ lastUsed: Date.now(),+ };++ // Store the memory+ const entry: MemoryEntry = {+ memory,+ trajectory,+ verdict: trajectory.verdict!,+ consolidated: false,+ };+ this.memories.set(memory.memoryId, entry);++ // Also store trajectory reference+ trajectory.distilledMemory = memory;++ // Update stats+ this.distillationCount++;+ this.totalDistillationTime += performance.now() - startTime;++ return memory;+ }++ // ==========================================================================+ // STEP 4: CONSOLIDATE - Dedup, detect contradictions, prune old patterns+ // ==========================================================================++ /**+ * Consolidate memories: deduplicate, detect contradictions, prune old+ */+ async consolidate(): Promise<ConsolidationResult> {+ const result: ConsolidationResult = {+ removedDuplicates: 0,+ contradictionsDetected: 0,+ prunedPatterns: 0,+ mergedPatterns: 0,+ };++ // 1. Deduplicate similar memories+ result.removedDuplicates = await this.deduplicateMemories();++ // 2. Detect contradictions+ if (this.config.enableContradictionDetection) {+ result.contradictionsDetected = await this.detectContradictions();+ }++ // 3. Prune old patterns+ result.prunedPatterns = await this.pruneOldPatterns();++ // 4. Merge similar patterns+ result.mergedPatterns = await this.mergePatterns();++ // Emit consolidation event+ this.emitEvent({+ type: 'memory_consolidated',+ memoriesCount: this.memories.size,+ });++ return result;+ }++ // ==========================================================================+ // Pattern Management+ // ==========================================================================++ /**+ * Convert a distilled memory to a pattern+ */+ memoryToPattern(memory: DistilledMemory): Pattern {+ const pattern: Pattern = {+ patternId: `pat_${memory.memoryId}`,+ name: this.generatePatternName(memory),+ domain: this.inferDomain(memory),+ embedding: memory.embedding,+ strategy: memory.strategy,+ successRate: memory.quality,+ usageCount: memory.usageCount,+ qualityHistory: [memory.quality],+ evolutionHistory: [],+ createdAt: Date.now(),+ updatedAt: Date.now(),+ };++ this.patterns.set(pattern.patternId, pattern);+ return pattern;+ }++ /**+ * Evolve a pattern based on new experience+ */+ evolvePattern(patternId: string, newExperience: Trajectory): void {+ const pattern = this.patterns.get(patternId);+ if (!pattern) return;++ const previousQuality = pattern.successRate;++ // Update quality history+ pattern.qualityHistory.push(newExperience.qualityScore);+ if (pattern.qualityHistory.length > 100) {+ pattern.qualityHistory = pattern.qualityHistory.slice(-100);+ }++ // Update success rate+ pattern.successRate = pattern.qualityHistory.reduce((a, b) => a + b, 0) /+ pattern.qualityHistory.length;++ pattern.usageCount++;+ pattern.updatedAt = Date.now();++ // Record evolution+ const evolutionType = this.determineEvolutionType(previousQuality, pattern.successRate);+ pattern.evolutionHistory.push({+ timestamp: Date.now(),+ type: evolutionType,+ previousQuality,+ newQuality: pattern.successRate,+ description: `Updated based on trajectory ${newExperience.trajectoryId}`,+ });++ // Emit event+ this.emitEvent({+ type: 'pattern_evolved',+ patternId,+ evolutionType,+ });+ }++ /**+ * Get all patterns+ */+ getPatterns(): Pattern[] {+ return Array.from(this.patterns.values());+ }++ // ==========================================================================+ // Trajectory Management+ // ==========================================================================++ /**+ * Store a trajectory+ */+ storeTrajectory(trajectory: Trajectory): void {+ this.trajectories.set(trajectory.trajectoryId, trajectory);++ // Prune if over capacity+ if (this.trajectories.size > this.config.maxTrajectories) {+ this.pruneTrajectories();+ }+ }++ /**+ * Get trajectory by ID+ */+ getTrajectory(trajectoryId: string): Trajectory | undefined {+ return this.trajectories.get(trajectoryId);+ }++ /**+ * Get all trajectories+ */+ getTrajectories(): Trajectory[] {+ return Array.from(this.trajectories.values());+ }++ // ==========================================================================+ // Statistics+ // ==========================================================================++ /**+ * Get ReasoningBank statistics+ */+ getStats(): Record<string, number> {+ return {+ trajectoryCount: this.trajectories.size,+ memoryCount: this.memories.size,+ patternCount: this.patterns.size,+ avgRetrievalTimeMs: this.retrievalCount > 0+ ? this.totalRetrievalTime / this.retrievalCount+ : 0,+ avgDistillationTimeMs: this.distillationCount > 0+ ? this.totalDistillationTime / this.distillationCount+ : 0,+ consolidatedMemories: Array.from(this.memories.values())+ .filter(e => e.consolidated).length,+ };+ }++ // ==========================================================================+ // Event System+ // ==========================================================================++ addEventListener(listener: NeuralEventListener): void {+ this.eventListeners.add(listener);+ }++ removeEventListener(listener: NeuralEventListener): void {+ this.eventListeners.delete(listener);+ }++ private emitEvent(event: NeuralEvent): void {+ for (const listener of this.eventListeners) {+ try {+ listener(event);+ } catch (error) {+ console.error('Error in ReasoningBank event listener:', error);+ }+ }+ }++ // ==========================================================================+ // Private Helper Methods+ // ==========================================================================++ private cosineSimilarity(a: Float32Array, b: Float32Array): number {+ if (a.length !== b.length) return 0;++ 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) * Math.sqrt(normB);+ return denom > 0 ? dot / denom : 0;+ }++ private computeMaxSimilarity(entry: MemoryEntry, selected: MemoryEntry[]): number {+ let maxSim = 0;+ for (const sel of selected) {+ const sim = this.cosineSimilarity(entry.memory.embedding, sel.memory.embedding);+ maxSim = Math.max(maxSim, sim);+ }+ return maxSim;+ }++ private analyzeSteps(steps: TrajectoryStep[]): StepAnalysis {+ const rewardSum = steps.reduce((s, step) => s + step.reward, 0);+ const positiveSteps = steps.filter(s => s.reward > 0.5).length;++ return {+ totalSteps: steps.length,+ avgReward: steps.length > 0 ? rewardSum / steps.length : 0,+ positiveRatio: steps.length > 0 ? positiveSteps / steps.length : 0,+ trajectory: steps.length > 1+ ? (steps[steps.length - 1].reward - steps[0].reward)+ : 0,+ };+ }++ private identifyStrengths(trajectory: Trajectory, analysis: StepAnalysis): string[] {+ const strengths: string[] = [];++ if (analysis.avgReward > 0.7) {+ strengths.push('High average reward across steps');+ }+ if (analysis.trajectory > 0.2) {+ strengths.push('Positive reward trajectory');+ }+ if (trajectory.qualityScore > 0.8) {+ strengths.push('High overall quality');+ }+ if (analysis.totalSteps < 5 && trajectory.qualityScore > 0.6) {+ strengths.push('Efficient solution (few steps)');+ }++ return strengths;+ }++ private identifyWeaknesses(trajectory: Trajectory, analysis: StepAnalysis): string[] {+ const weaknesses: string[] = [];++ if (analysis.avgReward < 0.4) {+ weaknesses.push('Low average reward');+ }+ if (analysis.trajectory < -0.1) {+ weaknesses.push('Declining reward trajectory');+ }+ if (analysis.positiveRatio < 0.5) {+ weaknesses.push('Many negative/neutral steps');+ }+ if (analysis.totalSteps > 10 && trajectory.qualityScore < 0.7) {+ weaknesses.push('Long trajectory with mediocre outcome');+ }++ return weaknesses;+ }++ private generateImprovements(weaknesses: string[]): string[] {+ const improvements: string[] = [];++ for (const weakness of weaknesses) {+ if (weakness.includes('Low average reward')) {+ improvements.push('Consider alternative strategies for each step');+ }+ if (weakness.includes('Declining')) {+ improvements.push('Re-evaluate approach when reward decreases');+ }+ if (weakness.includes('negative/neutral')) {+ improvements.push('Focus on steps with clearer positive signals');+ }+ if (weakness.includes('Long trajectory')) {+ improvements.push('Look for shortcuts or more direct approaches');+ }+ }++ return improvements;+ }++ private computeRelevanceScore(trajectory: Trajectory): number {+ // Base relevance on quality and recency+ const qualityFactor = trajectory.qualityScore;+ const ageDays = (Date.now() - trajectory.startTime) / (1000 * 60 * 60 * 24);+ const recencyFactor = Math.exp(-ageDays / 30); // Decay over 30 days++ return qualityFactor * 0.7 + recencyFactor * 0.3;+ }++ private computeConfidence(trajectory: Trajectory, analysis: StepAnalysis): number {+ // More steps = more confidence+ const stepFactor = Math.min(analysis.totalSteps / 10, 1);+ // Consistent rewards = more confidence+ const consistencyFactor = analysis.positiveRatio;+ // Clear outcome = more confidence+ const outcomeFactor = Math.abs(trajectory.qualityScore - 0.5) * 2;++ return (stepFactor * 0.3 + consistencyFactor * 0.4 + outcomeFactor * 0.3);+ }++ private extractStrategy(trajectory: Trajectory): string {+ const actions = trajectory.steps.map(s => s.action);+ const uniqueActions = [...new Set(actions)];++ if (uniqueActions.length <= 3) {+ return `Apply ${uniqueActions.join(' -> ')}`;+ }++ return `Multi-step approach: ${uniqueActions.slice(0, 3).join(', ')}...`;+ }++ private extractKeyLearnings(trajectory: Trajectory): string[] {+ const learnings: string[] = [];+ const verdict = trajectory.verdict!;++ // Add key success factors+ if (verdict.success) {+ learnings.push(`Successful approach for ${trajectory.domain} domain`);+ for (const strength of verdict.strengths.slice(0, 2)) {+ learnings.push(`Strength: ${strength}`);+ }+ } else {+ learnings.push(`Approach needs refinement`);+ for (const improvement of verdict.improvements.slice(0, 2)) {+ learnings.push(`Improvement: ${improvement}`);+ }+ }++ return learnings;+ }++ private computeAggregateEmbedding(trajectory: Trajectory): Float32Array {+ if (trajectory.steps.length === 0) {+ return new Float32Array(768);+ }++ const dim = trajectory.steps[0].stateAfter.length;+ const aggregate = new Float32Array(dim);++ // Weighted average of step embeddings (higher weight for later steps)+ let totalWeight = 0;+ for (let i = 0; i < trajectory.steps.length; i++) {+ const weight = (i + 1) / trajectory.steps.length;+ totalWeight += weight;+ const step = trajectory.steps[i];+ for (let j = 0; j < dim; j++) {+ aggregate[j] += step.stateAfter[j] * weight;+ }+ }++ // Normalize+ for (let j = 0; j < dim; j++) {+ aggregate[j] /= totalWeight;+ }++ return aggregate;+ }++ private async deduplicateMemories(): Promise<number> {+ let removed = 0;+ const entries = Array.from(this.memories.entries());++ for (let i = 0; i < entries.length; i++) {+ for (let j = i + 1; j < entries.length; j++) {+ const sim = this.cosineSimilarity(+ entries[i][1].memory.embedding,+ entries[j][1].memory.embedding+ );++ if (sim > this.config.dedupThreshold) {+ // Keep the higher quality one+ if (entries[i][1].memory.quality >= entries[j][1].memory.quality) {+ this.memories.delete(entries[j][0]);+ } else {+ this.memories.delete(entries[i][0]);+ }+ removed++;+ }+ }+ }++ return removed;+ }++ private async detectContradictions(): Promise<number> {+ let contradictions = 0;+ const entries = Array.from(this.memories.values());++ for (let i = 0; i < entries.length; i++) {+ for (let j = i + 1; j < entries.length; j++) {+ // Similar context but opposite outcomes+ const sim = this.cosineSimilarity(+ entries[i].memory.embedding,+ entries[j].memory.embedding+ );++ if (sim > 0.8) {+ const qualityDiff = Math.abs(+ entries[i].memory.quality - entries[j].memory.quality+ );++ if (qualityDiff > 0.4) {+ contradictions++;+ // Mark lower quality as consolidated (to exclude from retrieval)+ if (entries[i].memory.quality < entries[j].memory.quality) {+ entries[i].consolidated = true;+ } else {+ entries[j].consolidated = true;+ }+ }+ }+ }+ }++ return contradictions;+ }++ private async pruneOldPatterns(): Promise<number> {+ const now = Date.now();+ const maxAge = this.config.maxPatternAgeDays * 24 * 60 * 60 * 1000;+ let pruned = 0;++ for (const [id, pattern] of this.patterns) {+ const age = now - pattern.updatedAt;+ if (age > maxAge && pattern.usageCount < 5) {+ this.patterns.delete(id);+ pruned++;+ }+ }++ return pruned;+ }++ private async mergePatterns(): Promise<number> {+ let merged = 0;+ const patterns = Array.from(this.patterns.entries());++ for (let i = 0; i < patterns.length; i++) {+ for (let j = i + 1; j < patterns.length; j++) {+ const sim = this.cosineSimilarity(+ patterns[i][1].embedding,+ patterns[j][1].embedding+ );++ if (sim > 0.9 && patterns[i][1].domain === patterns[j][1].domain) {+ // Merge into higher quality pattern+ const [keepId, keep] = patterns[i][1].successRate >= patterns[j][1].successRate+ ? patterns[i]+ : patterns[j];+ const [removeId, remove] = patterns[i][1].successRate < patterns[j][1].successRate+ ? patterns[i]+ : patterns[j];++ // Combine statistics+ keep.usageCount += remove.usageCount;+ keep.qualityHistory.push(...remove.qualityHistory);+ keep.evolutionHistory.push({+ timestamp: Date.now(),+ type: 'merge',+ previousQuality: keep.successRate,+ newQuality: (keep.successRate + remove.successRate) / 2,+ description: `Merged with pattern ${removeId}`,+ });++ this.patterns.delete(removeId);+ merged++;+ }+ }+ }++ return merged;+ }++ private pruneTrajectories(): void {+ const entries = Array.from(this.trajectories.entries())+ .sort((a, b) => a[1].qualityScore - b[1].qualityScore);++ const toRemove = entries.length - Math.floor(this.config.maxTrajectories * 0.8);+ for (let i = 0; i < toRemove && i < entries.length; i++) {+ this.trajectories.delete(entries[i][0]);+ }+ }++ private generatePatternName(memory: DistilledMemory): string {+ const words = memory.strategy.split(' ').slice(0, 4);+ return words.join('_').toLowerCase().replace(/[^a-z0-9_]/g, '');+ }++ private inferDomain(memory: DistilledMemory): string {+ const trajectory = this.trajectories.get(memory.trajectoryId);+ return trajectory?.domain || 'general';+ }++ private determineEvolutionType(+ prev: number,+ curr: number+ ): 'improvement' | 'merge' | 'split' | 'prune' {+ const delta = curr - prev;+ if (delta > 0.05) return 'improvement';+ if (delta < -0.1) return 'prune';+ return 'improvement';+ }+}++/**+ * Step analysis result+ */+interface StepAnalysis {+ totalSteps: number;+ avgReward: number;+ positiveRatio: number;+ trajectory: number;+}++/**+ * Factory function for creating ReasoningBank+ */+export function createReasoningBank(+ config?: Partial<ReasoningBankConfig>+): ReasoningBank {+ return new ReasoningBank(config);+}