claude-flow 3.5.25 → 3.5.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.25",
+  "version": "3.5.27",
   "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",
@@ -54,6 +54,7 @@
     "v3:security": "npm run security:audit && npm run security:test"
   },
   "dependencies": {
+    "@ruvector/ruvllm-wasm": "^2.0.0",
     "semver": "^7.6.0",
     "zod": "^3.22.4"
   },

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/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/mcp-tools/ruvllm-tools.d.ts

@@ -0,0 +1,9 @@
+/**
+ * RuVector LLM WASM MCP Tools
+ *
+ * Exposes @ruvector/ruvllm-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+import type { MCPTool } from './types.js';
+export declare const ruvllmWasmTools: MCPTool[];
+//# sourceMappingURL=ruvllm-tools.d.ts.map

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

@@ -0,0 +1,283 @@
+/**
+ * RuVector LLM WASM MCP Tools
+ *
+ * Exposes @ruvector/ruvllm-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+async function loadRuvllmWasm() {
+    return import('../ruvector/ruvllm-wasm.js');
+}
+export const ruvllmWasmTools = [
+    {
+        name: 'ruvllm_status',
+        description: 'Get ruvllm-wasm availability and initialization status.',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const mod = await loadRuvllmWasm();
+                const status = await mod.getRuvllmStatus();
+                return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_hnsw_create',
+        description: 'Create a WASM HNSW router for semantic pattern routing. Max ~11 patterns (v2.0.1 limit).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dimensions: { type: 'number', description: 'Embedding dimensions (e.g., 64, 128, 384)' },
+                maxPatterns: { type: 'number', description: 'Max patterns capacity (limit ~11 in v2.0.1)' },
+                efSearch: { type: 'number', description: 'HNSW ef search parameter (higher = more accurate, slower)' },
+            },
+            required: ['dimensions', 'maxPatterns'],
+        },
+        handler: async (args) => {
+            try {
+                const mod = await loadRuvllmWasm();
+                const router = await mod.createHnswRouter({
+                    dimensions: args.dimensions,
+                    maxPatterns: args.maxPatterns,
+                    efSearch: args.efSearch,
+                });
+                // Store router in module-level registry
+                const id = `hnsw-${Date.now().toString(36)}`;
+                hnswRouters.set(id, router);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, routerId: id, dimensions: args.dimensions, maxPatterns: args.maxPatterns }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_hnsw_add',
+        description: 'Add a pattern to an HNSW router. Embedding must match router dimensions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                routerId: { type: 'string', description: 'HNSW router ID from ruvllm_hnsw_create' },
+                name: { type: 'string', description: 'Pattern name/label' },
+                embedding: { type: 'array', description: 'Float array embedding vector' },
+                metadata: { type: 'object', description: 'Optional metadata object' },
+            },
+            required: ['routerId', 'name', 'embedding'],
+        },
+        handler: async (args) => {
+            try {
+                const router = hnswRouters.get(args.routerId);
+                if (!router)
+                    return { content: [{ type: 'text', text: JSON.stringify({ error: `Router not found: ${args.routerId}` }) }], isError: true };
+                const embedding = new Float32Array(args.embedding);
+                const ok = router.addPattern({
+                    name: args.name,
+                    embedding,
+                    metadata: args.metadata,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: ok, patternCount: router.patternCount() }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_hnsw_route',
+        description: 'Route a query embedding to nearest patterns in HNSW index.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                routerId: { type: 'string', description: 'HNSW router ID' },
+                query: { type: 'array', description: 'Query embedding vector' },
+                k: { type: 'number', description: 'Number of nearest neighbors (default: 3)' },
+            },
+            required: ['routerId', 'query'],
+        },
+        handler: async (args) => {
+            try {
+                const router = hnswRouters.get(args.routerId);
+                if (!router)
+                    return { content: [{ type: 'text', text: JSON.stringify({ error: `Router not found: ${args.routerId}` }) }], isError: true };
+                const query = new Float32Array(args.query);
+                const results = router.route(query, args.k ?? 3);
+                return { content: [{ type: 'text', text: JSON.stringify({ results }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_sona_create',
+        description: 'Create a SONA instant adaptation loop (<1ms adaptation cycles).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                hiddenDim: { type: 'number', description: 'Hidden dimension (default: 64)' },
+                learningRate: { type: 'number', description: 'Learning rate (default: 0.01)' },
+                patternCapacity: { type: 'number', description: 'Max stored patterns' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const mod = await loadRuvllmWasm();
+                const sona = await mod.createSonaInstant({
+                    hiddenDim: args.hiddenDim,
+                    learningRate: args.learningRate,
+                    patternCapacity: args.patternCapacity,
+                });
+                const id = `sona-${Date.now().toString(36)}`;
+                sonaInstances.set(id, sona);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, sonaId: id }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_sona_adapt',
+        description: 'Run SONA instant adaptation with a quality signal.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sonaId: { type: 'string', description: 'SONA instance ID' },
+                quality: { type: 'number', description: 'Quality signal (0.0-1.0)' },
+            },
+            required: ['sonaId', 'quality'],
+        },
+        handler: async (args) => {
+            try {
+                const sona = sonaInstances.get(args.sonaId);
+                if (!sona)
+                    return { content: [{ type: 'text', text: JSON.stringify({ error: `SONA not found: ${args.sonaId}` }) }], isError: true };
+                sona.adapt(args.quality);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, stats: sona.stats() }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_microlora_create',
+        description: 'Create a MicroLoRA adapter (ultra-lightweight LoRA, ranks 1-4).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                inputDim: { type: 'number', description: 'Input dimension' },
+                outputDim: { type: 'number', description: 'Output dimension' },
+                rank: { type: 'number', description: 'LoRA rank (1-4, default: 2)' },
+                alpha: { type: 'number', description: 'LoRA alpha scaling (default: 1.0)' },
+            },
+            required: ['inputDim', 'outputDim'],
+        },
+        handler: async (args) => {
+            try {
+                const mod = await loadRuvllmWasm();
+                const lora = await mod.createMicroLora({
+                    inputDim: args.inputDim,
+                    outputDim: args.outputDim,
+                    rank: args.rank,
+                    alpha: args.alpha,
+                });
+                const id = `lora-${Date.now().toString(36)}`;
+                loraInstances.set(id, lora);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, loraId: id }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_microlora_adapt',
+        description: 'Adapt MicroLoRA weights with quality feedback.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                loraId: { type: 'string', description: 'MicroLoRA instance ID' },
+                quality: { type: 'number', description: 'Quality signal (0.0-1.0)' },
+                learningRate: { type: 'number', description: 'Learning rate (default: 0.01)' },
+                success: { type: 'boolean', description: 'Whether the adaptation was successful (default: true)' },
+            },
+            required: ['loraId', 'quality'],
+        },
+        handler: async (args) => {
+            try {
+                const lora = loraInstances.get(args.loraId);
+                if (!lora)
+                    return { content: [{ type: 'text', text: JSON.stringify({ error: `MicroLoRA not found: ${args.loraId}` }) }], isError: true };
+                lora.adapt(args.quality, args.learningRate, args.success);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, stats: lora.stats() }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_chat_format',
+        description: 'Format chat messages using a template (llama3, mistral, chatml, phi, gemma, or auto-detect).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                messages: {
+                    type: 'array',
+                    description: 'Array of {role, content} message objects',
+                },
+                template: { type: 'string', description: 'Template preset (llama3, mistral, chatml, phi, gemma) or model ID for auto-detection' },
+            },
+            required: ['messages', 'template'],
+        },
+        handler: async (args) => {
+            try {
+                const mod = await loadRuvllmWasm();
+                const messages = args.messages;
+                const templateStr = args.template;
+                const presets = ['llama3', 'mistral', 'chatml', 'phi', 'gemma'];
+                const template = presets.includes(templateStr)
+                    ? templateStr
+                    : { modelId: templateStr };
+                const formatted = await mod.formatChat(messages, template);
+                return { content: [{ type: 'text', text: formatted }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'ruvllm_generate_config',
+        description: 'Create a generation config (maxTokens, temperature, topP, etc.) as JSON.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                maxTokens: { type: 'number', description: 'Max tokens to generate' },
+                temperature: { type: 'number', description: 'Sampling temperature (note: f32 precision)' },
+                topP: { type: 'number', description: 'Top-p sampling' },
+                topK: { type: 'number', description: 'Top-k sampling' },
+                repetitionPenalty: { type: 'number', description: 'Repetition penalty' },
+                stopSequences: { type: 'array', description: 'Stop sequences' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const mod = await loadRuvllmWasm();
+                const config = await mod.createGenerateConfig(args);
+                return { content: [{ type: 'text', text: config }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+];
+// ── Instance Registries ──────────────────────────────────────
+const hnswRouters = new Map();
+const sonaInstances = new Map();
+const loraInstances = new Map();
+//# sourceMappingURL=ruvllm-tools.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * WASM Agent MCP Tools
+ *
+ * Exposes @ruvector/rvagent-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+import type { MCPTool } from './types.js';
+export declare const wasmAgentTools: MCPTool[];
+//# sourceMappingURL=wasm-agent-tools.d.ts.map

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

@@ -0,0 +1,230 @@
+/**
+ * WASM Agent MCP Tools
+ *
+ * Exposes @ruvector/rvagent-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+async function loadAgentWasm() {
+    const mod = await import('../ruvector/agent-wasm.js');
+    return mod;
+}
+export const wasmAgentTools = [
+    {
+        name: 'wasm_agent_create',
+        description: 'Create a sandboxed WASM agent with virtual filesystem (no OS access). Optionally use a gallery template.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Gallery template name (coder, researcher, tester, reviewer, security, swarm)' },
+                model: { type: 'string', description: 'Model identifier (default: anthropic:claude-sonnet-4-20250514)' },
+                instructions: { type: 'string', description: 'System instructions for the agent' },
+                maxTurns: { type: 'number', description: 'Max conversation turns (default: 50)' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                if (args.template) {
+                    const info = await wasm.createAgentFromTemplate(args.template);
+                    return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, source: 'gallery' }, null, 2) }] };
+                }
+                const info = await wasm.createWasmAgent({
+                    model: args.model,
+                    instructions: args.instructions,
+                    maxTurns: args.maxTurns,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_prompt',
+        description: 'Send a prompt to a WASM agent and get a response.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+                input: { type: 'string', description: 'User prompt to send' },
+            },
+            required: ['agentId', 'input'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const result = await wasm.promptWasmAgent(args.agentId, args.input);
+                return { content: [{ type: 'text', text: result }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_tool',
+        description: 'Execute a tool on a WASM agent sandbox. Tools: read_file, write_file, edit_file, write_todos, list_files. Use flat format: {tool, path, content, ...}.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+                toolName: { type: 'string', description: 'Tool name (read_file, write_file, edit_file, write_todos, list_files)' },
+                toolInput: { type: 'object', description: 'Tool parameters (flat: {path, content, old_string, new_string, todos})' },
+            },
+            required: ['agentId', 'toolName'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                // Flat format: {tool: 'write_file', path: '...', content: '...'}
+                const toolCall = {
+                    tool: args.toolName,
+                    ...(args.toolInput ?? {}),
+                };
+                const result = await wasm.executeWasmTool(args.agentId, toolCall);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_list',
+        description: 'List all active WASM agents.',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wasm = await loadAgentWasm();
+                const agents = wasm.listWasmAgents();
+                return { content: [{ type: 'text', text: JSON.stringify({ agents, count: agents.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_terminate',
+        description: 'Terminate a WASM agent and free resources.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const ok = wasm.terminateWasmAgent(args.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: ok }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_files',
+        description: 'Get a WASM agent\'s available tools and info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const tools = wasm.getWasmAgentTools(args.agentId);
+                const info = wasm.getWasmAgent(args.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify({ tools, fileCount: info?.fileCount ?? 0, turnCount: info?.turnCount ?? 0 }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_export',
+        description: 'Export a WASM agent\'s full state (config, filesystem, conversation) as JSON.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const state = wasm.exportWasmState(args.agentId);
+                return { content: [{ type: 'text', text: state }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_list',
+        description: 'List all available WASM agent gallery templates (Coder, Researcher, Tester, Reviewer, Security, Swarm).',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wasm = await loadAgentWasm();
+                const templates = await wasm.listGalleryTemplates();
+                return { content: [{ type: 'text', text: JSON.stringify({ templates, count: templates.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_search',
+        description: 'Search WASM agent gallery templates by query.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+            },
+            required: ['query'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const results = await wasm.searchGalleryTemplates(args.query);
+                return { content: [{ type: 'text', text: JSON.stringify({ results, count: results.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_create',
+        description: 'Create a WASM agent from a gallery template.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Template name (coder, researcher, tester, reviewer, security, swarm)' },
+            },
+            required: ['template'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const info = await wasm.createAgentFromTemplate(args.template);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, template: args.template }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+];
+//# sourceMappingURL=wasm-agent-tools.js.map

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

@@ -1315,6 +1315,60 @@ 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)
+        const ruvector = await import('ruvector').catch(() => null);
+        if (ruvector?.initOnnxEmbedder) {
+            try {
+                await ruvector.initOnnxEmbedder();
+                // Prefer AdaptiveEmbedder (LoRA adaptation capability, identity when untrained)
+                if (ruvector.AdaptiveEmbedder) {
+                    try {
+                        const adaptive = new ruvector.AdaptiveEmbedder({ useEpisodic: false });
+                        if (adaptive?.embed && adaptive.isReady?.()) {
+                            if (verbose) {
+                                console.log('Loading ruvector AdaptiveEmbedder (all-MiniLM-L6-v2 + LoRA)...');
+                            }
+                            embeddingModelState = {
+                                loaded: true,
+                                model: (text) => adaptive.embed(text),
+                                tokenizer: null,
+                                dimensions: adaptive.getDimension?.() || 384
+                            };
+                            return {
+                                success: true,
+                                dimensions: adaptive.getDimension?.() || 384,
+                                modelName: 'ruvector/adaptive',
+                                loadTime: Date.now() - startTime
+                            };
+                        }
+                    }
+                    catch { /* fall through to OptimizedOnnxEmbedder */ }
+                }
+                // Fallback: OptimizedOnnxEmbedder (raw ONNX without LoRA)
+                const onnxEmb = ruvector.getOptimizedOnnxEmbedder?.();
+                if (onnxEmb?.embed && onnxEmb.isReady?.()) {
+                    if (verbose) {
+                        console.log('Loading ruvector ONNX embedder (all-MiniLM-L6-v2)...');
+                    }
+                    embeddingModelState = {
+                        loaded: true,
+                        model: (text) => onnxEmb.embed(text),
+                        tokenizer: null,
+                        dimensions: onnxEmb.getDimension?.() || 384
+                    };
+                    return {
+                        success: true,
+                        dimensions: onnxEmb.getDimension?.() || 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 +1432,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