Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 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

checkpoint: File edit:

rUvd4e73b80a909
diff --git a/v3/integration/agentic-flow-bridge.ts b/v3/integration/agentic-flow-bridge.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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);
+}