claude-flow 3.5.39 → 3.5.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.39",
+  "version": "3.5.41",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/commands/cleanup.d.ts

@@ -0,0 +1,13 @@
+/**
+ * V3 CLI Cleanup Command
+ * Removes project artifacts created by claude-flow/ruflo
+ *
+ * Created with ruv.io
+ */
+import type { Command } from '../types.js';
+/**
+ * Cleanup command definition
+ */
+export declare const cleanupCommand: Command;
+export default cleanupCommand;
+//# sourceMappingURL=cleanup.d.ts.map

package/v3/@claude-flow/cli/dist/src/commands/cleanup.js

@@ -0,0 +1,218 @@
+/**
+ * V3 CLI Cleanup Command
+ * Removes project artifacts created by claude-flow/ruflo
+ *
+ * Created with ruv.io
+ */
+import { output } from '../output.js';
+import { existsSync, statSync, rmSync, readdirSync } from 'fs';
+import { join } from 'path';
+/**
+ * Artifact directories and files that claude-flow/ruflo may create
+ */
+const ARTIFACT_DIRS = [
+    { path: '.claude', description: 'Claude settings, helpers, agents' },
+    { path: '.claude-flow', description: 'Capabilities and configuration' },
+    { path: 'data', description: 'Memory databases' },
+    { path: '.swarm', description: 'Swarm state' },
+    { path: '.hive-mind', description: 'Consensus state' },
+    { path: 'coordination', description: 'Coordination data' },
+    { path: 'memory', description: 'Memory storage' },
+];
+const ARTIFACT_FILES = [
+    { path: 'claude-flow.config.json', description: 'Claude Flow configuration' },
+];
+/**
+ * Paths to preserve when --keep-config is set
+ */
+const KEEP_CONFIG_PATHS = [
+    'claude-flow.config.json',
+    join('.claude', 'settings.json'),
+];
+/**
+ * Calculate the total size of a path (file or directory) in bytes
+ */
+function getSize(fullPath) {
+    try {
+        const stat = statSync(fullPath);
+        if (stat.isFile()) {
+            return stat.size;
+        }
+        if (stat.isDirectory()) {
+            let total = 0;
+            const entries = readdirSync(fullPath, { withFileTypes: true });
+            for (const entry of entries) {
+                total += getSize(join(fullPath, entry.name));
+            }
+            return total;
+        }
+    }
+    catch {
+        // Permission errors, broken symlinks, etc.
+    }
+    return 0;
+}
+/**
+ * Format bytes into a human-readable string
+ */
+function formatSize(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+    const value = bytes / Math.pow(1024, i);
+    return `${value.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+/**
+ * Cleanup command definition
+ */
+export const cleanupCommand = {
+    name: 'cleanup',
+    description: 'Remove project artifacts created by claude-flow/ruflo',
+    aliases: ['clean'],
+    options: [
+        {
+            name: 'dry-run',
+            short: 'n',
+            description: 'Show what would be removed without deleting (default behavior)',
+            type: 'boolean',
+            default: true,
+        },
+        {
+            name: 'force',
+            short: 'f',
+            description: 'Actually delete the artifacts',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'keep-config',
+            short: 'k',
+            description: 'Preserve claude-flow.config.json and .claude/settings.json',
+            type: 'boolean',
+            default: false,
+        },
+    ],
+    examples: [
+        {
+            command: 'cleanup',
+            description: 'Show what would be removed (dry run)',
+        },
+        {
+            command: 'cleanup --force',
+            description: 'Remove all claude-flow artifacts',
+        },
+        {
+            command: 'cleanup --force --keep-config',
+            description: 'Remove artifacts but keep configuration files',
+        },
+    ],
+    action: async (ctx) => {
+        const force = ctx.flags.force === true;
+        const keepConfig = ctx.flags['keep-config'] === true;
+        const cwd = ctx.cwd;
+        const dryRun = !force;
+        output.writeln();
+        output.writeln(output.bold(dryRun
+            ? 'Claude Flow Cleanup (dry run)'
+            : 'Claude Flow Cleanup'));
+        output.writeln();
+        const found = [];
+        let totalSize = 0;
+        // Scan directories
+        for (const artifact of ARTIFACT_DIRS) {
+            const fullPath = join(cwd, artifact.path);
+            if (existsSync(fullPath)) {
+                const size = getSize(fullPath);
+                found.push({ path: artifact.path, description: artifact.description, size, type: 'dir' });
+                totalSize += size;
+            }
+        }
+        // Scan files
+        for (const artifact of ARTIFACT_FILES) {
+            const fullPath = join(cwd, artifact.path);
+            if (existsSync(fullPath)) {
+                const size = getSize(fullPath);
+                found.push({ path: artifact.path, description: artifact.description, size, type: 'file' });
+                totalSize += size;
+            }
+        }
+        if (found.length === 0) {
+            output.writeln(output.info('No claude-flow artifacts found in the current directory.'));
+            return { success: true, message: 'Nothing to clean' };
+        }
+        // Mark items that would be skipped due to --keep-config
+        if (keepConfig) {
+            for (const item of found) {
+                if (KEEP_CONFIG_PATHS.includes(item.path)) {
+                    item.skipped = true;
+                }
+            }
+        }
+        // Display what was found
+        output.writeln(output.bold('Artifacts found:'));
+        output.writeln();
+        let removedCount = 0;
+        let removedSize = 0;
+        let skippedCount = 0;
+        for (const item of found) {
+            const sizeStr = formatSize(item.size);
+            const typeLabel = item.type === 'dir' ? 'dir ' : 'file';
+            if (item.skipped) {
+                output.writeln(output.dim(`  [skip] ${typeLabel}  ${item.path}  (${sizeStr}) - ${item.description}`));
+                skippedCount++;
+                continue;
+            }
+            if (dryRun) {
+                output.writeln(output.warning(`  [would remove] ${typeLabel}  ${item.path}  (${sizeStr}) - ${item.description}`));
+            }
+            else {
+                // Actually delete
+                try {
+                    const fullPath = join(cwd, item.path);
+                    if (item.type === 'dir') {
+                        rmSync(fullPath, { recursive: true, force: true });
+                    }
+                    else {
+                        rmSync(fullPath, { force: true });
+                    }
+                    output.writeln(output.success(`  [removed] ${typeLabel}  ${item.path}  (${sizeStr}) - ${item.description}`));
+                    removedCount++;
+                    removedSize += item.size;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    output.writeln(output.error(`  [failed] ${typeLabel}  ${item.path}  - ${msg}`));
+                }
+            }
+        }
+        // Summary
+        output.writeln();
+        output.writeln(output.bold('Summary:'));
+        if (dryRun) {
+            const actionable = found.filter(f => !f.skipped);
+            output.writeln(`  Found ${actionable.length} artifact(s) totaling ${formatSize(totalSize)}`);
+            if (skippedCount > 0) {
+                output.writeln(`  ${skippedCount} item(s) would be preserved (--keep-config)`);
+            }
+            output.writeln();
+            output.writeln(output.dim('  This was a dry run. Use --force to actually remove artifacts.'));
+        }
+        else {
+            output.writeln(`  Removed ${removedCount} artifact(s) totaling ${formatSize(removedSize)}`);
+            if (skippedCount > 0) {
+                output.writeln(`  Preserved ${skippedCount} item(s) (--keep-config)`);
+            }
+        }
+        output.writeln();
+        return {
+            success: true,
+            message: dryRun
+                ? `Dry run: ${found.length} artifact(s) found`
+                : `Removed ${removedCount} artifact(s)`,
+            data: { found, removedCount, removedSize, dryRun },
+        };
+    },
+};
+export default cleanupCommand;
+//# sourceMappingURL=cleanup.js.map

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

@@ -29,6 +29,7 @@ export { ruvectorCommand } from './ruvector/index.js';
 export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
+export { cleanupCommand } from './cleanup.js';
 export declare function getConfigCommand(): Promise<Command | undefined>;
 export declare function getMigrateCommand(): Promise<Command | undefined>;
 export declare function getWorkflowCommand(): Promise<Command | undefined>;
@@ -52,6 +53,7 @@ export declare function getIssuesCommand(): Promise<Command | undefined>;
 export declare function getRuvectorCommand(): Promise<Command | undefined>;
 export declare function getGuidanceCommand(): Promise<Command | undefined>;
 export declare function getApplianceCommand(): Promise<Command | undefined>;
+export declare function getCleanupCommand(): Promise<Command | undefined>;
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup

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

@@ -63,6 +63,7 @@ const commandLoaders = {
     appliance: () => import('./appliance.js'),
     'appliance-advanced': () => import('./appliance-advanced.js'),
     'transfer-store': () => import('./transfer-store.js'),
+    cleanup: () => import('./cleanup.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();
@@ -132,6 +133,7 @@ import updateCommand from './update.js';
 import { processCommand } from './process.js';
 import { guidanceCommand } from './guidance.js';
 import { applianceCommand } from './appliance.js';
+import { cleanupCommand } from './cleanup.js';
 // Pre-populate cache with core commands
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
@@ -152,6 +154,7 @@ loadedCommands.set('security', securityCommand);
 loadedCommands.set('ruvector', ruvectorCommand);
 loadedCommands.set('hive-mind', hiveMindCommand);
 loadedCommands.set('guidance', guidanceCommand);
+loadedCommands.set('cleanup', cleanupCommand);
 // =============================================================================
 // Exports (maintain backwards compatibility)
 // =============================================================================
@@ -176,6 +179,7 @@ export { ruvectorCommand } from './ruvector/index.js';
 export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
+export { cleanupCommand } from './cleanup.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
 export async function getConfigCommand() { return loadCommand('config'); }
 export async function getMigrateCommand() { return loadCommand('migrate'); }
@@ -200,6 +204,7 @@ export async function getIssuesCommand() { return loadCommand('issues'); }
 export async function getRuvectorCommand() { return loadCommand('ruvector'); }
 export async function getGuidanceCommand() { return loadCommand('guidance'); }
 export async function getApplianceCommand() { return loadCommand('appliance'); }
+export async function getCleanupCommand() { return loadCommand('cleanup'); }
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup
@@ -225,6 +230,7 @@ export const commands = [
     ruvectorCommand,
     hiveMindCommand,
     guidanceCommand,
+    cleanupCommand,
 ];
 /**
  * Commands organized by category for help display
@@ -273,6 +279,7 @@ export const commandsByCategory = {
         updateCommand,
         processCommand,
         applianceCommand,
+        cleanupCommand,
     ],
 };
 /**

package/v3/@claude-flow/cli/dist/src/mcp-client.js

@@ -34,6 +34,9 @@ import { coordinationTools } from './mcp-tools/coordination-tools.js';
 import { browserTools } from './mcp-tools/browser-tools.js';
 // Phase 6: AgentDB v3 controller tools
 import { agentdbTools } from './mcp-tools/agentdb-tools.js';
+// RuVector WASM tools
+import { ruvllmWasmTools } from './mcp-tools/ruvllm-tools.js';
+import { wasmAgentTools } from './mcp-tools/wasm-agent-tools.js';
 /**
  * MCP Tool Registry
  * Maps tool names to their handler functions
@@ -73,6 +76,9 @@ registerTools([
     ...browserTools,
     // Phase 6: AgentDB v3 controller tools
     ...agentdbTools,
+    // RuVector WASM tools
+    ...ruvllmWasmTools,
+    ...wasmAgentTools,
 ]);
 /**
  * MCP Client Error

package/v3/@claude-flow/cli/dist/src/mcp-tools/hive-mind-tools.js

@@ -268,13 +268,17 @@ export const hiveMindTools = [
                     electedAt: state.queen.electedAt,
                     term: state.queen.term,
                 } : { id: 'N/A', status: 'offline', load: 0, tasksQueued: 0 },
-                workers: state.workers.map(w => ({
-                    id: w,
-                    type: 'worker',
-                    status: 'idle',
-                    currentTask: null,
-                    tasksCompleted: 0,
-                })),
+                workers: state.workers.map(w => {
+                    const agentStore = loadAgentStore();
+                    const agent = agentStore.agents[w];
+                    return {
+                        id: w,
+                        type: agent?.agentType || 'worker',
+                        status: agent?.status || 'unknown',
+                        currentTask: agent?.currentTask || null,
+                        tasksCompleted: agent?.taskCount || 0,
+                    };
+                }),
                 metrics: {
                     totalTasks: state.consensus.history.length + state.consensus.pending.length,
                     completedTasks: state.consensus.history.length,

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

@@ -20,4 +20,6 @@ export { transferTools } from './transfer-tools.js';
 export { securityTools } from './security-tools.js';
 export { embeddingsTools } from './embeddings-tools.js';
 export { claimsTools } from './claims-tools.js';
+export { wasmAgentTools } from './wasm-agent-tools.js';
+export { ruvllmWasmTools } from './ruvllm-tools.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -19,4 +19,6 @@ export { transferTools } from './transfer-tools.js';
 export { securityTools } from './security-tools.js';
 export { embeddingsTools } from './embeddings-tools.js';
 export { claimsTools } from './claims-tools.js';
+export { wasmAgentTools } from './wasm-agent-tools.js';
+export { ruvllmWasmTools } from './ruvllm-tools.js';
 //# sourceMappingURL=index.js.map

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

@@ -1315,6 +1315,42 @@ export async function loadEmbeddingModel(options) {
                 loadTime: Date.now() - startTime
             };
         }
+        // Fallback: Check for ruvector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
+        // v0.2.16: LoRA B=0 fix makes AdaptiveEmbedder safe (identity when untrained)
+        // Note: isReady() returns false until first embed() call (lazy init), so we
+        // skip the isReady() gate and verify with a probe embed instead.
+        const ruvector = await import('ruvector').catch(() => null);
+        if (ruvector?.initOnnxEmbedder) {
+            try {
+                await ruvector.initOnnxEmbedder();
+                // Fallback: OptimizedOnnxEmbedder (raw ONNX, lazy-inits on first embed)
+                const onnxEmb = ruvector.getOptimizedOnnxEmbedder?.();
+                if (onnxEmb?.embed) {
+                    // Probe embed to trigger lazy ONNX init and verify it works
+                    const probe = await onnxEmb.embed('test');
+                    if (probe && probe.length > 0 && (Array.isArray(probe) ? probe.some((v) => v !== 0) : true)) {
+                        if (verbose) {
+                            console.log(`Loading ruvector ONNX embedder (all-MiniLM-L6-v2, ${probe.length}d)...`);
+                        }
+                        embeddingModelState = {
+                            loaded: true,
+                            model: (text) => onnxEmb.embed(text),
+                            tokenizer: null,
+                            dimensions: probe.length || 384
+                        };
+                        return {
+                            success: true,
+                            dimensions: probe.length || 384,
+                            modelName: 'ruvector/onnx',
+                            loadTime: Date.now() - startTime
+                        };
+                    }
+                }
+            }
+            catch {
+                // ruvector ONNX init failed, continue to next fallback
+            }
+        }
         // Legacy fallback: Check for agentic-flow core embeddings
         const agenticFlow = await import('agentic-flow').catch(() => null);
         if (agenticFlow && agenticFlow.embeddings) {
@@ -1378,12 +1414,17 @@ export async function generateEmbedding(text) {
     if (state.model && typeof state.model === 'function') {
         try {
             const output = await state.model(text, { pooling: 'mean', normalize: true });
-            const embedding = Array.from(output.data);
-            return {
-                embedding,
-                dimensions: embedding.length,
-                model: 'onnx'
-            };
+            // Handle both @xenova/transformers (output.data) and ruvector (plain array) formats
+            const embedding = output?.data
+                ? Array.from(output.data)
+                : Array.isArray(output) ? output : null;
+            if (embedding) {
+                return {
+                    embedding,
+                    dimensions: embedding.length,
+                    model: 'onnx'
+                };
+            }
         }
         catch {
             // Fall through to fallback
@@ -1774,13 +1815,18 @@ export async function searchEntries(options) {
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Get entries with embeddings
-        const entries = db.exec(`
-      SELECT id, key, namespace, content, embedding
-      FROM memory_entries
-      WHERE status = 'active'
-        ${namespace !== 'all' ? `AND namespace = '${namespace.replace(/'/g, "''")}'` : ''}
-      LIMIT 1000
-    `);
+        const searchStmt = db.prepare(namespace !== 'all'
+            ? `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' AND namespace = ? LIMIT 1000`
+            : `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' LIMIT 1000`);
+        if (namespace !== 'all') {
+            searchStmt.bind([namespace]);
+        }
+        const searchRows = [];
+        while (searchStmt.step()) {
+            searchRows.push(searchStmt.get());
+        }
+        searchStmt.free();
+        const entries = searchRows.length > 0 ? [{ values: searchRows }] : [];
         const results = [];
         if (entries[0]?.values) {
             for (const row of entries[0].values) {
@@ -1880,21 +1926,37 @@ export async function listEntries(options) {
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Get total count
-        const countQuery = namespace
-            ? `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = '${namespace.replace(/'/g, "''")}'`
-            : `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`;
-        const countResult = db.exec(countQuery);
+        const countStmt = namespace
+            ? db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = ?`)
+            : db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
+        if (namespace) {
+            countStmt.bind([namespace]);
+        }
+        const countRows = [];
+        while (countStmt.step()) {
+            countRows.push(countStmt.get());
+        }
+        countStmt.free();
+        const countResult = countRows.length > 0 ? [{ values: countRows }] : [];
         const total = countResult[0]?.values?.[0]?.[0] || 0;
         // Get entries
-        const listQuery = `
-      SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at
-      FROM memory_entries
-      WHERE status = 'active'
-        ${namespace ? `AND namespace = '${namespace.replace(/'/g, "''")}'` : ''}
-      ORDER BY updated_at DESC
-      LIMIT ${limit} OFFSET ${offset}
-    `;
-        const result = db.exec(listQuery);
+        const safeLimit = parseInt(String(limit), 10) || 100;
+        const safeOffset = parseInt(String(offset), 10) || 0;
+        const listStmt = namespace
+            ? db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' AND namespace = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?`)
+            : db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' ORDER BY updated_at DESC LIMIT ? OFFSET ?`);
+        if (namespace) {
+            listStmt.bind([namespace, safeLimit, safeOffset]);
+        }
+        else {
+            listStmt.bind([safeLimit, safeOffset]);
+        }
+        const listRows = [];
+        while (listStmt.step()) {
+            listRows.push(listStmt.get());
+        }
+        listStmt.free();
+        const result = listRows.length > 0 ? [{ values: listRows }] : [];
         const entries = [];
         if (result[0]?.values) {
             for (const row of result[0].values) {
@@ -1949,14 +2011,21 @@ export async function getEntry(options) {
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Find entry by key
-        const result = db.exec(`
+        const getStmt = db.prepare(`
       SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
       FROM memory_entries
       WHERE status = 'active'
-        AND key = '${key.replace(/'/g, "''")}'
-        AND namespace = '${namespace.replace(/'/g, "''")}'
+        AND key = ?
+        AND namespace = ?
       LIMIT 1
     `);
+        getStmt.bind([key, namespace]);
+        const getRows = [];
+        while (getStmt.step()) {
+            getRows.push(getStmt.get());
+        }
+        getStmt.free();
+        const result = getRows.length > 0 ? [{ values: getRows }] : [];
         if (!result[0]?.values?.[0]) {
             db.close();
             return { success: true, found: false };
@@ -1966,8 +2035,8 @@ export async function getEntry(options) {
         db.run(`
       UPDATE memory_entries
       SET access_count = access_count + 1, last_accessed_at = strftime('%s', 'now') * 1000
-      WHERE id = '${String(id).replace(/'/g, "''")}'
-    `);
+      WHERE id = ?
+    `, [String(id)]);
         // Save updated database
         const data = db.export();
         fs.writeFileSync(dbPath, Buffer.from(data));
@@ -2039,13 +2108,20 @@ export async function deleteEntry(options) {
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Check if entry exists first
-        const checkResult = db.exec(`
+        const checkStmt = db.prepare(`
       SELECT id FROM memory_entries
       WHERE status = 'active'
-        AND key = '${key.replace(/'/g, "''")}'
-        AND namespace = '${namespace.replace(/'/g, "''")}'
+        AND key = ?
+        AND namespace = ?
       LIMIT 1
     `);
+        checkStmt.bind([key, namespace]);
+        const checkRows = [];
+        while (checkStmt.step()) {
+            checkRows.push(checkStmt.get());
+        }
+        checkStmt.free();
+        const checkResult = checkRows.length > 0 ? [{ values: checkRows }] : [];
         if (!checkResult[0]?.values?.[0]) {
             // Get remaining count before closing
             const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
@@ -2069,10 +2145,10 @@ export async function deleteEntry(options) {
       SET status = 'deleted',
           embedding = NULL,
           updated_at = strftime('%s', 'now') * 1000
-      WHERE key = '${key.replace(/'/g, "''")}'
-        AND namespace = '${namespace.replace(/'/g, "''")}'
+      WHERE key = ?
+        AND namespace = ?
         AND status = 'active'
-    `);
+    `, [key, namespace]);
         // Get remaining count
         const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
         const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;

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

@@ -23,6 +23,8 @@ export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttentio
 export { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, type LoRAConfig, type LoRAWeights, type AdaptationResult, type LoRAStats, } from './lora-adapter.js';
 export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, type ClaudeModel, type ModelRouterConfig, type ModelRoutingResult, type ComplexityAnalysis, } from './model-router.js';
 export { SemanticRouter, createSemanticRouter, type Intent, type RouteResult, type RouterConfig, } from './semantic-router.js';
+export { isRuvllmWasmAvailable, initRuvllmWasm, getRuvllmStatus, createHnswRouter, createSonaInstant, createMicroLora, formatChat, createKvCache, createGenerateConfig, createBufferPool, createInferenceArena, HNSW_MAX_SAFE_PATTERNS, type HnswRouterConfig, type HnswPattern, type HnswRouteResult, type SonaConfig, type MicroLoraConfig, type ChatMessage, type GenerateOptions, type RuvllmStatus, } from './ruvllm-wasm.js';
+export { isAgentWasmAvailable, initAgentWasm, createWasmAgent, promptWasmAgent, executeWasmTool, getWasmAgent, listWasmAgents, terminateWasmAgent, getWasmAgentState, getWasmAgentTools, getWasmAgentTodos, exportWasmState, createWasmMcpServer, listGalleryTemplates, getGalleryCount, getGalleryCategories, searchGalleryTemplates, getGalleryTemplate, createAgentFromTemplate, buildRvfContainer, buildRvfFromTemplate, type WasmAgentConfig, type WasmAgentInfo, type GalleryTemplate, type GalleryTemplateDetail, type ToolResult, } from './agent-wasm.js';
 /**
  * Check if ruvector packages are available
  */

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

@@ -33,6 +33,10 @@ export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttentio
 export { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, } from './lora-adapter.js';
 export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, } from './model-router.js';
 export { SemanticRouter, createSemanticRouter, } from './semantic-router.js';
+// ── RuVector LLM WASM (inference utilities) ─────────────────
+export { isRuvllmWasmAvailable, initRuvllmWasm, getRuvllmStatus, createHnswRouter, createSonaInstant, createMicroLora, formatChat, createKvCache, createGenerateConfig, createBufferPool, createInferenceArena, HNSW_MAX_SAFE_PATTERNS, } from './ruvllm-wasm.js';
+// ── Agent WASM (sandboxed agent runtime) ────────────────────
+export { isAgentWasmAvailable, initAgentWasm, createWasmAgent, promptWasmAgent, executeWasmTool, getWasmAgent, listWasmAgents, terminateWasmAgent, getWasmAgentState, getWasmAgentTools, getWasmAgentTodos, exportWasmState, createWasmMcpServer, listGalleryTemplates, getGalleryCount, getGalleryCategories, searchGalleryTemplates, getGalleryTemplate, createAgentFromTemplate, buildRvfContainer, buildRvfFromTemplate, } from './agent-wasm.js';
 /**
  * Check if ruvector packages are available
  */

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.39",
+  "version": "3.5.41",
   "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",
@@ -75,7 +75,6 @@
     "test": "vitest run",
     "test:plugin-store": "npx tsx src/plugins/tests/standalone-test.ts",
     "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
-    "preinstall": "node bin/preinstall.cjs || true",
     "prepublishOnly": "cp ../../../README.md ./README.md",
     "release": "npm version prerelease --preid=alpha && npm run publish:all",
     "publish:all": "./scripts/publish.sh"

package/v3/@claude-flow/cli/bin/preinstall.cjs

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-// Preinstall hook — no-op (cache repair removed in 3.1.0-alpha.53)