claude-flow 3.5.21 → 3.5.23

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

@@ -34,34 +34,224 @@ let totalForwards = 0;
 let totalSonaLearns = 0;
 let totalSonaSearches = 0;
 let lastBenchmark = null;
+// Backend tracking
+let activeBackend = 'js-fallback';
 /**
- * Initialize the RuVector training system
+ * Get which backend is active for training
+ */
+export function getActiveBackend() {
+    return activeBackend;
+}
+/**
+ * Pure-JS fallback implementations for when WASM is unavailable.
+ * These provide the same API surface with basic linear algebra.
+ */
+class JsMicroLoRA {
+    _dim;
+    _alpha;
+    _lr;
+    _adaptCount = 0n;
+    _forwardCount = 0n;
+    _deltaNorm = 0;
+    _A; // Low-rank A (rank x dim)
+    _B; // Low-rank B (dim x rank)
+    RANK = 2;
+    constructor(dim, alpha, lr) {
+        this._dim = dim;
+        this._alpha = alpha;
+        this._lr = lr;
+        this._A = new Float32Array(this.RANK * dim);
+        this._B = new Float32Array(dim * this.RANK);
+        // Xavier initialization
+        const scale = Math.sqrt(2 / (dim + this.RANK));
+        for (let i = 0; i < this._A.length; i++)
+            this._A[i] = (Math.random() - 0.5) * scale;
+        for (let i = 0; i < this._B.length; i++)
+            this._B[i] = (Math.random() - 0.5) * scale;
+    }
+    adapt_array(gradient) {
+        // Simple gradient update on low-rank matrices
+        let norm = 0;
+        for (let i = 0; i < Math.min(gradient.length, this._A.length); i++) {
+            const delta = -this._lr * gradient[i % gradient.length] * this._alpha;
+            this._A[i] += delta;
+            norm += delta * delta;
+        }
+        this._deltaNorm = Math.sqrt(norm);
+        this._adaptCount++;
+    }
+    adapt_count() { return this._adaptCount; }
+    param_count() { return this._A.length + this._B.length; }
+    forward_array(input) {
+        const output = new Float32Array(this._dim);
+        // y = x + alpha * B @ A @ x  (simplified low-rank)
+        for (let i = 0; i < this._dim; i++) {
+            output[i] = input[i];
+            let sum = 0;
+            for (let r = 0; r < this.RANK; r++) {
+                let dot = 0;
+                for (let j = 0; j < this._dim; j++) {
+                    dot += this._A[r * this._dim + j] * input[j];
+                }
+                sum += this._B[i * this.RANK + r] * dot;
+            }
+            output[i] += this._alpha * sum;
+        }
+        this._forwardCount++;
+        return output;
+    }
+    forward_count() { return this._forwardCount; }
+    adapt_with_reward(improvement) {
+        const scale = improvement * this._lr * this._alpha;
+        let norm = 0;
+        for (let i = 0; i < this._A.length; i++) {
+            const delta = scale * (Math.random() - 0.5);
+            this._A[i] += delta;
+            norm += delta * delta;
+        }
+        this._deltaNorm = Math.sqrt(norm);
+        this._adaptCount++;
+    }
+    delta_norm() { return this._deltaNorm; }
+    dim() { return this._dim; }
+    reset() {
+        this._A.fill(0);
+        this._B.fill(0);
+        this._adaptCount = 0n;
+        this._forwardCount = 0n;
+        this._deltaNorm = 0;
+    }
+    free() { }
+}
+class JsScopedLoRA {
+    adapters = new Map();
+    _dim;
+    _alpha;
+    _lr;
+    _fallback = false;
+    constructor(dim, alpha, lr) {
+        this._dim = dim;
+        this._alpha = alpha;
+        this._lr = lr;
+    }
+    getAdapter(opType) {
+        if (!this.adapters.has(opType)) {
+            if (this._fallback && opType > 0 && this.adapters.has(0)) {
+                return this.adapters.get(0);
+            }
+            this.adapters.set(opType, new JsMicroLoRA(this._dim, this._alpha, this._lr));
+        }
+        return this.adapters.get(opType);
+    }
+    adapt_array(opType, gradient) { this.getAdapter(opType).adapt_array(gradient); }
+    adapt_count(opType) { return this.getAdapter(opType).adapt_count(); }
+    forward_array(opType, input) { return this.getAdapter(opType).forward_array(input); }
+    forward_count(opType) { return this.getAdapter(opType).forward_count(); }
+    adapt_with_reward(opType, improvement) { this.getAdapter(opType).adapt_with_reward(improvement); }
+    delta_norm(opType) { return this.getAdapter(opType).delta_norm(); }
+    set_category_fallback(enabled) { this._fallback = enabled; }
+    total_adapt_count() {
+        let total = 0n;
+        for (const a of this.adapters.values())
+            total += a.adapt_count();
+        return total;
+    }
+    total_forward_count() {
+        let total = 0n;
+        for (const a of this.adapters.values())
+            total += a.forward_count();
+        return total;
+    }
+    reset_all() { this.adapters.clear(); }
+    reset_scope(opType) { this.adapters.delete(opType); }
+    free() { this.adapters.clear(); }
+}
+class JsTrajectoryBuffer {
+    entries = [];
+    capacity;
+    constructor(capacity, _dim) {
+        this.capacity = capacity;
+    }
+    record(_embedding, _opType, _attType, executionMs, baselineMs) {
+        const improvement = baselineMs > 0 ? (baselineMs - executionMs) / baselineMs : 0;
+        if (this.entries.length >= this.capacity)
+            this.entries.shift();
+        this.entries.push({ improvement });
+    }
+    is_empty() { return this.entries.length === 0; }
+    total_count() { return BigInt(this.entries.length); }
+    success_rate() {
+        if (this.entries.length === 0)
+            return 0;
+        return this.entries.filter(e => e.improvement > 0).length / this.entries.length;
+    }
+    mean_improvement() {
+        if (this.entries.length === 0)
+            return 0;
+        return this.entries.reduce((s, e) => s + e.improvement, 0) / this.entries.length;
+    }
+    best_improvement() {
+        if (this.entries.length === 0)
+            return 0;
+        return Math.max(...this.entries.map(e => e.improvement));
+    }
+    high_quality_count(threshold) {
+        return this.entries.filter(e => e.improvement > threshold).length;
+    }
+    variance() {
+        if (this.entries.length < 2)
+            return 0;
+        const mean = this.mean_improvement();
+        return this.entries.reduce((s, e) => s + (e.improvement - mean) ** 2, 0) / (this.entries.length - 1);
+    }
+    reset() { this.entries = []; }
+    free() { this.entries = []; }
+}
+/**
+ * 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 async function initializeTraining(config = {}) {
     const features = [];
     const dim = Math.min(config.dim || 256, 256); // Max 256 for WASM
     const lr = config.learningRate || 0.01;
     const alpha = config.alpha || 0.1;
+    // --- Attempt WASM backend first ---
+    let wasmLoaded = false;
     try {
-        // Initialize MicroLoRA with direct WASM loading (Node.js compatible)
         const fs = await import('fs');
         const { createRequire } = await import('module');
         const require = createRequire(import.meta.url);
-        // Load WASM file directly instead of using fetch
         const wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
         const wasmBuffer = fs.readFileSync(wasmPath);
         const learningWasm = await import('@ruvector/learning-wasm');
         learningWasm.initSync({ module: wasmBuffer });
         microLoRA = new learningWasm.WasmMicroLoRA(dim, alpha, lr);
-        features.push(`MicroLoRA (${dim}-dim, <1μs adaptation)`);
-        // Initialize ScopedLoRA for per-operator learning
+        features.push(`MicroLoRA/WASM (${dim}-dim, <1μs adaptation)`);
         scopedLoRA = new learningWasm.WasmScopedLoRA(dim, alpha, lr);
         scopedLoRA.set_category_fallback(true);
-        features.push('ScopedLoRA (17 operators)');
-        // Initialize trajectory buffer
+        features.push('ScopedLoRA/WASM (17 operators)');
         trajectoryBuffer = new learningWasm.WasmTrajectoryBuffer(config.trajectoryCapacity || 10000, dim);
-        features.push('TrajectoryBuffer');
-        // Initialize attention mechanisms
+        features.push('TrajectoryBuffer/WASM');
+        activeBackend = 'wasm';
+        wasmLoaded = true;
+    }
+    catch (wasmError) {
+        // WASM not available - fall back to JS implementation
+        const reason = wasmError instanceof Error ? wasmError.message : String(wasmError);
+        console.warn(`[ruvector] WASM backend unavailable (${reason}), using JS fallback`);
+        microLoRA = new JsMicroLoRA(dim, alpha, lr);
+        features.push(`MicroLoRA/JS (${dim}-dim, JS fallback)`);
+        scopedLoRA = new JsScopedLoRA(dim, alpha, lr);
+        scopedLoRA.set_category_fallback(true);
+        features.push('ScopedLoRA/JS (17 operators)');
+        trajectoryBuffer = new JsTrajectoryBuffer(config.trajectoryCapacity || 10000, dim);
+        features.push('TrajectoryBuffer/JS');
+        activeBackend = 'js-fallback';
+    }
+    // --- Attention mechanisms (optional, independent of WASM) ---
+    try {
         const attention = await import('@ruvector/attention');
         if (config.useFlashAttention !== false) {
             flashAttention = new attention.FlashAttention(dim, 64);
@@ -75,17 +265,14 @@ export async function initializeTraining(config = {}) {
             hyperbolicAttention = new attention.HyperbolicAttention(dim, 1.0);
             features.push('HyperbolicAttention');
         }
-        // Initialize optimizer and loss
         optimizer = new attention.AdamWOptimizer(lr, 0.9, 0.999, 1e-8, 0.01);
         features.push('AdamW Optimizer');
         contrastiveLoss = new attention.InfoNceLoss(0.07);
         features.push('InfoNCE Loss');
-        // Curriculum scheduler
         if (config.totalSteps) {
             curriculum = new attention.CurriculumScheduler(config.totalSteps, config.warmupSteps || Math.floor(config.totalSteps * 0.1));
             features.push('Curriculum Learning');
         }
-        // Hard negative mining - use string for MiningStrategy enum due to NAPI binding quirk
         try {
             hardMiner = new attention.HardNegativeMiner(5, 'semi_hard');
             features.push('Hard Negative Mining');
@@ -93,36 +280,31 @@ export async function initializeTraining(config = {}) {
         catch {
             // Mining not available, continue without it
         }
-        // Initialize SONA (optional, backward compatible)
-        if (config.useSona !== false) {
-            try {
-                const sona = await import('@ruvector/sona');
-                const sonaRank = config.sonaRank || 4;
-                // SonaEngine constructor: (dim, rank, alpha, learningRate) - TypeScript types are wrong
-                // @ts-expect-error - SonaEngine accepts 4 positional args but types say 1
-                sonaEngine = new sona.SonaEngine(dim, sonaRank, alpha, lr);
-                sonaAvailable = true;
-                features.push(`SONA (${dim}-dim, rank-${sonaRank}, 624k learn/s)`);
-            }
-            catch (sonaError) {
-                // SONA not available, continue without it (backward compatible)
-                sonaAvailable = false;
-                // Only log if explicitly requested
-                if (config.useSona === true) {
-                    console.warn('SONA requested but not available:', sonaError);
-                }
+    }
+    catch (attentionError) {
+        // @ruvector/attention not available - attention features skipped
+        const reason = attentionError instanceof Error ? attentionError.message : String(attentionError);
+        console.warn(`[ruvector] @ruvector/attention unavailable (${reason}), attention features disabled`);
+    }
+    // --- SONA (optional, backward compatible) ---
+    if (config.useSona !== false) {
+        try {
+            const sona = await import('@ruvector/sona');
+            const sonaRank = config.sonaRank || 4;
+            // @ts-expect-error - SonaEngine accepts 4 positional args but types say 1
+            sonaEngine = new sona.SonaEngine(dim, sonaRank, alpha, lr);
+            sonaAvailable = true;
+            features.push(`SONA (${dim}-dim, rank-${sonaRank}, 624k learn/s)`);
+        }
+        catch (sonaError) {
+            sonaAvailable = false;
+            if (config.useSona === true) {
+                console.warn('SONA requested but not available:', sonaError);
             }
         }
-        initialized = true;
-        return { success: true, features };
-    }
-    catch (error) {
-        return {
-            success: false,
-            features,
-            error: error instanceof Error ? error.message : String(error),
-        };
     }
+    initialized = true;
+    return { success: true, features, backend: activeBackend };
 }
 /**
  * Operator types for scoped LoRA (0-16)
@@ -396,6 +578,7 @@ export function sonaFlush() {
 export function getTrainingStats() {
     const stats = {
         initialized,
+        backend: activeBackend,
         totalAdaptations,
         totalForwards,
     };
@@ -443,6 +626,7 @@ export function resetTraining() {
     totalForwards = 0;
     totalSonaLearns = 0;
     totalSonaSearches = 0;
+    activeBackend = 'js-fallback';
 }
 /**
  * Export trained weights

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.d.ts

@@ -122,6 +122,10 @@ export declare class WorkerDaemon extends EventEmitter {
     private executeWorker;
     /**
      * Run a function with timeout (P1 fix)
+     * @param fn - The async function to execute
+     * @param timeoutMs - Timeout in milliseconds
+     * @param timeoutMessage - Error message on timeout
+     * @param onTimeout - Optional cleanup callback invoked when timeout fires (#1117: kills orphan processes)
      */
     private runWithTimeout;
     /**

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -10,7 +10,7 @@
  * - testgaps: Test coverage analysis (20 min interval)
  */
 import { EventEmitter } from 'events';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'fs';
 import { join } from 'path';
 import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
 // Default worker configurations with improved intervals (P0 fix: map 5min -> 15min)
@@ -328,7 +328,13 @@ export class WorkerDaemon extends EventEmitter {
         this.log('info', `Starting worker: ${workerConfig.type} (${this.runningWorkers.size}/${this.config.maxConcurrent} concurrent)`);
         try {
             // Execute worker logic with timeout (P1 fix)
-            const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`);
+            // Pass cleanup callback to kill orphan child processes on timeout (#1117)
+            const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`, () => {
+                // On timeout, cancel any headless execution to prevent orphan processes
+                if (this.headlessExecutor) {
+                    this.headlessExecutor.cancelAll();
+                }
+            });
             const durationMs = Date.now() - startTime;
             // Update state
             state.runCount++;
@@ -376,18 +382,41 @@ export class WorkerDaemon extends EventEmitter {
     }
     /**
      * Run a function with timeout (P1 fix)
+     * @param fn - The async function to execute
+     * @param timeoutMs - Timeout in milliseconds
+     * @param timeoutMessage - Error message on timeout
+     * @param onTimeout - Optional cleanup callback invoked when timeout fires (#1117: kills orphan processes)
      */
-    async runWithTimeout(fn, timeoutMs, timeoutMessage) {
+    async runWithTimeout(fn, timeoutMs, timeoutMessage, onTimeout) {
         return new Promise((resolve, reject) => {
+            let settled = false;
             const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                // Kill orphan child processes before rejecting (#1117)
+                if (onTimeout) {
+                    try {
+                        onTimeout();
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
                 reject(new Error(timeoutMessage));
             }, timeoutMs);
             fn()
                 .then((result) => {
+                if (settled)
+                    return;
+                settled = true;
                 clearTimeout(timer);
                 resolve(result);
             })
                 .catch((error) => {
+                if (settled)
+                    return;
+                settled = true;
                 clearTimeout(timer);
                 reject(error);
             });
@@ -714,8 +743,7 @@ export class WorkerDaemon extends EventEmitter {
         // Also write to log file
         try {
             const logFile = join(this.config.logDir, 'daemon.log');
-            const fs = require('fs');
-            fs.appendFileSync(logFile, logMessage + '\n');
+            appendFileSync(logFile, logMessage + '\n');
         }
         catch {
             // Ignore log write errors

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.21",
+  "version": "3.5.23",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",