claude-flow 3.5.21 → 3.5.23

package/v3/@claude-flow/cli/dist/src/memory/intelligence.js

@@ -82,6 +82,7 @@ class LocalSonaCoordinator {
     signalCount = 0;
     trajectories = [];
     adaptationTimes = [];
+    currentTrajectorySteps = [];
     constructor(config) {
         this.config = config;
         // Pre-allocate circular buffer
@@ -136,6 +137,164 @@ class LocalSonaCoordinator {
             return 0;
         return this.adaptationTimes.reduce((a, b) => a + b, 0) / this.adaptationTimes.length;
     }
+    /**
+     * Add a step to the current in-progress trajectory
+     */
+    addTrajectoryStep(step) {
+        this.currentTrajectorySteps.push(step);
+        // Prevent unbounded growth
+        if (this.currentTrajectorySteps.length > this.config.maxTrajectorySize) {
+            this.currentTrajectorySteps.shift();
+        }
+    }
+    /**
+     * End the current trajectory with a verdict and apply RL updates.
+     * Reward mapping: success=1.0, partial=0.5, failure=-0.5
+     *
+     * For successful/partial trajectories, boosts confidence of similar patterns
+     * in the ReasoningBank. For failures, reduces confidence scores.
+     */
+    async endTrajectory(verdict, bank) {
+        const rewardMap = {
+            success: 1.0,
+            partial: 0.5,
+            failure: -0.5
+        };
+        const reward = rewardMap[verdict] ?? 0;
+        // Record the completed trajectory
+        const completedTrajectory = {
+            steps: [...this.currentTrajectorySteps],
+            verdict,
+            timestamp: Date.now()
+        };
+        this.recordTrajectory(completedTrajectory);
+        // Update pattern confidences based on reward
+        let patternsUpdated = 0;
+        const allPatterns = bank.getAll();
+        for (const step of this.currentTrajectorySteps) {
+            if (!step.embedding || step.embedding.length === 0)
+                continue;
+            // Find patterns similar to this trajectory step
+            const similar = bank.findSimilar(step.embedding, {
+                k: 3,
+                threshold: 0.3
+            });
+            for (const match of similar) {
+                const pattern = bank.get(match.id);
+                if (!pattern)
+                    continue;
+                // Adjust confidence: positive reward boosts, negative reduces
+                const delta = reward * 0.1; // small step per update
+                const newConfidence = Math.max(0.0, Math.min(1.0, pattern.confidence + delta));
+                pattern.confidence = newConfidence;
+                pattern.usageCount++;
+                pattern.lastUsedAt = Date.now();
+                patternsUpdated++;
+            }
+        }
+        // Clear current trajectory
+        this.currentTrajectorySteps = [];
+        return { reward, patternsUpdated };
+    }
+    /**
+     * Distill learning from recent successful trajectories.
+     * Applies LoRA-style confidence updates and integrates EWC++ consolidation.
+     *
+     * For each successful trajectory step with high confidence,
+     * increases the pattern's stored confidence by loraLearningRate * reward.
+     * Before applying updates, checks EWC penalty to prevent catastrophic forgetting.
+     */
+    async distillLearning(bank) {
+        let patternsDistilled = 0;
+        let totalEwcPenalty = 0;
+        // Get recent successful trajectories
+        const recentSuccessful = this.trajectories.filter(t => t.verdict === 'success' || t.verdict === 'partial').slice(-10); // last 10 successful
+        if (recentSuccessful.length === 0) {
+            return { patternsDistilled: 0, ewcPenalty: 0 };
+        }
+        // Try to get EWC consolidator
+        let ewcConsolidator = null;
+        try {
+            const ewcModule = await import('./ewc-consolidation.js');
+            ewcConsolidator = await ewcModule.getEWCConsolidator({
+                lambda: this.config.ewcLambda
+            });
+        }
+        catch {
+            // EWC not available, proceed without consolidation protection
+        }
+        const rewardMap = {
+            success: 1.0,
+            partial: 0.5
+        };
+        // Collect confidence changes for EWC Fisher update
+        const confidenceChanges = [];
+        for (const trajectory of recentSuccessful) {
+            const reward = rewardMap[trajectory.verdict] ?? 0;
+            for (const step of trajectory.steps) {
+                if (!step.embedding || step.embedding.length === 0)
+                    continue;
+                const similar = bank.findSimilar(step.embedding, {
+                    k: 3,
+                    threshold: 0.4
+                });
+                for (const match of similar) {
+                    const pattern = bank.get(match.id);
+                    if (!pattern)
+                        continue;
+                    // Only distill from high-confidence matches
+                    if (match.confidence < 0.5)
+                        continue;
+                    const oldConfidence = pattern.confidence;
+                    // Check EWC penalty before applying update
+                    if (ewcConsolidator) {
+                        const oldWeights = [oldConfidence];
+                        const proposedConfidence = Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward);
+                        const newWeights = [proposedConfidence];
+                        const penalty = ewcConsolidator.getPenalty(oldWeights, newWeights);
+                        totalEwcPenalty += penalty;
+                        // If penalty is too high, reduce the update magnitude
+                        if (penalty > this.config.ewcLambda) {
+                            const dampedDelta = (this.config.loraLearningRate * reward) / (1 + penalty);
+                            pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + dampedDelta));
+                        }
+                        else {
+                            pattern.confidence = proposedConfidence;
+                        }
+                    }
+                    else {
+                        // No EWC: apply full LoRA update
+                        pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward));
+                    }
+                    pattern.lastUsedAt = Date.now();
+                    patternsDistilled++;
+                    confidenceChanges.push({
+                        id: pattern.id,
+                        oldConf: oldConfidence,
+                        newConf: pattern.confidence,
+                        embedding: pattern.embedding
+                    });
+                }
+            }
+        }
+        // Update EWC Fisher matrix with confidence changes
+        if (ewcConsolidator && confidenceChanges.length > 0) {
+            for (const change of confidenceChanges) {
+                // Use confidence delta as gradient proxy
+                const gradient = change.embedding.map(e => e * Math.abs(change.newConf - change.oldConf));
+                ewcConsolidator.recordGradient(change.id, gradient, true);
+            }
+        }
+        // Persist updated patterns
+        bank.flushToDisk();
+        return { patternsDistilled, ewcPenalty: totalEwcPenalty };
+    }
+    /**
+     * Get current trajectory steps (for inspection)
+     */
+    getCurrentTrajectorySteps() {
+        return [...this.currentTrajectorySteps];
+    }
     /**
      * Get statistics
      */
@@ -478,6 +637,9 @@ export async function recordStep(step) {
             metadata: step.metadata,
             timestamp: step.timestamp || Date.now()
         });
+        // Add to current trajectory for RL tracking
+        const stepWithEmbedding = { ...step, embedding };
+        sonaCoordinator.addTrajectoryStep(stepWithEmbedding);
         // Store in ReasoningBank for retrieval
         if (reasoningBank) {
             reasoningBank.store({
@@ -489,6 +651,15 @@ export async function recordStep(step) {
                 metadata: step.metadata
             });
         }
+        // When a 'result' step arrives, end the trajectory and run RL loop
+        if (step.type === 'result' && reasoningBank) {
+            // Determine verdict from metadata or default to 'partial'
+            const verdict = step.metadata?.verdict || 'partial';
+            await sonaCoordinator.endTrajectory(verdict, reasoningBank);
+            // Distill learning from recent successful trajectories
+            await sonaCoordinator.distillLearning(reasoningBank);
+            globalStats.lastAdaptation = Date.now();
+        }
         globalStats.trajectoriesRecorded++;
         savePersistedStats();
         return true;
@@ -512,6 +683,15 @@ export async function recordTrajectory(steps, verdict) {
             verdict,
             timestamp: Date.now()
         });
+        // Apply RL: update pattern confidences based on verdict
+        if (reasoningBank) {
+            // Load steps into the coordinator for endTrajectory processing
+            for (const step of steps) {
+                sonaCoordinator.addTrajectoryStep(step);
+            }
+            await sonaCoordinator.endTrajectory(verdict, reasoningBank);
+            await sonaCoordinator.distillLearning(reasoningBank);
+        }
         globalStats.trajectoriesRecorded++;
         globalStats.lastAdaptation = Date.now();
         savePersistedStats();
@@ -597,6 +777,51 @@ export function getSonaCoordinator() {
 export function getReasoningBank() {
     return reasoningBank;
 }
+/**
+ * End the current trajectory with a verdict and apply RL updates.
+ * This is the public API for the SONA RL loop.
+ *
+ * @param verdict - 'success' (reward=1.0), 'partial' (0.5), or 'failure' (-0.5)
+ * @returns Update statistics or null if not initialized
+ */
+export async function endTrajectoryWithVerdict(verdict) {
+    if (!sonaCoordinator || !reasoningBank) {
+        const init = await initializeIntelligence();
+        if (!init.success)
+            return null;
+    }
+    try {
+        const result = await sonaCoordinator.endTrajectory(verdict, reasoningBank);
+        globalStats.lastAdaptation = Date.now();
+        savePersistedStats();
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Distill learning from recent successful trajectories.
+ * Applies LoRA-style confidence updates with EWC++ consolidation protection.
+ *
+ * @returns Distillation statistics or null if not initialized
+ */
+export async function distillLearning() {
+    if (!sonaCoordinator || !reasoningBank) {
+        const init = await initializeIntelligence();
+        if (!init.success)
+            return null;
+    }
+    try {
+        const result = await sonaCoordinator.distillLearning(reasoningBank);
+        globalStats.lastAdaptation = Date.now();
+        savePersistedStats();
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Clear intelligence state
  */

package/v3/@claude-flow/cli/dist/src/memory/memory-initializer.d.ts

@@ -65,6 +65,12 @@ export declare function getHNSWStatus(): {
  * Clear the HNSW index (for rebuilding)
  */
 export declare function clearHNSWIndex(): void;
+/**
+ * Invalidate the in-memory HNSW cache so the next search rebuilds from DB.
+ * Call this after deleting entries that had embeddings to prevent ghost
+ * vectors from appearing in search results.
+ */
+export declare function rebuildSearchIndex(): void;
 /**
  * Quantize a Float32 embedding to Int8 (4x memory reduction)
  * Uses symmetric quantization with scale factor stored per-vector
@@ -398,6 +404,7 @@ declare const _default: {
     listEntries: typeof listEntries;
     getEntry: typeof getEntry;
     deleteEntry: typeof deleteEntry;
+    rebuildSearchIndex: typeof rebuildSearchIndex;
     MEMORY_SCHEMA_V3: string;
     getInitialMetadata: typeof getInitialMetadata;
 };

package/v3/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -573,6 +573,15 @@ export function getHNSWStatus() {
 export function clearHNSWIndex() {
     hnswIndex = null;
 }
+/**
+ * Invalidate the in-memory HNSW cache so the next search rebuilds from DB.
+ * Call this after deleting entries that had embeddings to prevent ghost
+ * vectors from appearing in search results.
+ */
+export function rebuildSearchIndex() {
+    hnswIndex = null;
+    hnswInitializing = false;
+}
 // ============================================================================
 // INT8 VECTOR QUANTIZATION (4x memory reduction)
 // ============================================================================
@@ -2051,10 +2060,15 @@ export async function deleteEntry(options) {
                 error: `Key '${key}' not found in namespace '${namespace}'`
             };
         }
+        // Capture the entry ID for HNSW cleanup
+        const entryId = String(checkResult[0].values[0][0]);
         // Delete the entry (soft delete by setting status to 'deleted')
+        // Also null out the embedding to clean up vector data from SQLite
         db.run(`
       UPDATE memory_entries
-      SET status = 'deleted', updated_at = strftime('%s', 'now') * 1000
+      SET status = 'deleted',
+          embedding = NULL,
+          updated_at = strftime('%s', 'now') * 1000
       WHERE key = '${key.replace(/'/g, "''")}'
         AND namespace = '${namespace.replace(/'/g, "''")}'
         AND status = 'active'
@@ -2066,6 +2080,17 @@ export async function deleteEntry(options) {
         const data = db.export();
         fs.writeFileSync(dbPath, Buffer.from(data));
         db.close();
+        // Clean up in-memory HNSW index so ghost vectors don't appear in searches.
+        // Remove the entry from the HNSW entries map and invalidate the index.
+        // The next search will rebuild the HNSW index from the remaining DB rows.
+        if (hnswIndex?.entries) {
+            hnswIndex.entries.delete(entryId);
+            saveHNSWMetadata();
+            // Invalidate the HNSW index so it rebuilds from DB on next search.
+            // We can't surgically remove a vector from the HNSW graph, so we
+            // clear the entire index; it will be lazily rebuilt from SQLite.
+            rebuildSearchIndex();
+        }
         return {
             success: true,
             deleted: true,
@@ -2099,6 +2124,7 @@ export default {
     listEntries,
     getEntry,
     deleteEntry,
+    rebuildSearchIndex,
     MEMORY_SCHEMA_V3,
     getInitialMetadata
 };

package/v3/@claude-flow/cli/dist/src/ruvector/index.d.ts

@@ -27,6 +27,10 @@ export { SemanticRouter, createSemanticRouter, type Intent, type RouteResult, ty
  * Check if ruvector packages are available
  */
 export declare function isRuvectorAvailable(): Promise<boolean>;
+/**
+ * Check if @ruvector/learning-wasm is available and loadable
+ */
+export declare function isWasmBackendAvailable(): Promise<boolean>;
 /**
  * Get ruvector version if available
  */

package/v3/@claude-flow/cli/dist/src/ruvector/index.js

@@ -45,6 +45,18 @@ export async function isRuvectorAvailable() {
         return false;
     }
 }
+/**
+ * Check if @ruvector/learning-wasm is available and loadable
+ */
+export async function isWasmBackendAvailable() {
+    try {
+        const wasm = await import('@ruvector/learning-wasm');
+        return typeof wasm.WasmMicroLoRA === 'function' && typeof wasm.initSync === 'function';
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Get ruvector version if available
  */

package/v3/@claude-flow/cli/dist/src/services/ruvector-training.d.ts

@@ -14,6 +14,10 @@
  * Created with ❤️ by ruv.io
  */
 type BenchmarkResult = any;
+/**
+ * Get which backend is active for training
+ */
+export declare function getActiveBackend(): 'wasm' | 'js-fallback';
 export interface TrainingConfig {
     dim?: number;
     learningRate?: number;
@@ -41,11 +45,14 @@ export interface TrainingResult {
     benchmark?: BenchmarkResult[];
 }
 /**
- * Initialize the RuVector training system
+ * Initialize the RuVector training system.
+ * Attempts to load @ruvector/learning-wasm for WASM-accelerated training.
+ * Falls back to a pure-JS implementation if WASM is unavailable.
  */
 export declare function initializeTraining(config?: TrainingConfig): Promise<{
     success: boolean;
     features: string[];
+    backend: 'wasm' | 'js-fallback';
     error?: string;
 }>;
 /**
@@ -177,6 +184,7 @@ export declare function sonaFlush(): void;
  */
 export declare function getTrainingStats(): {
     initialized: boolean;
+    backend: 'wasm' | 'js-fallback';
     totalAdaptations: number;
     totalForwards: number;
     microLoraStats?: {