claude-flow 3.6.4 → 3.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.6.4",
+  "version": "3.6.6",
   "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/mcp-tools/browser-tools.js

@@ -8,47 +8,90 @@ import { validateIdentifier, validateText } from './validate-input.js';
 // Session registry for multi-session support
 const browserSessions = new Map();
 /**
- * Execute agent-browser CLI command
+ * Execute agent-browser CLI command.
+ * Tries global agent-browser first, falls back to npx if ENOENT.
  */
 async function execBrowserCommand(args, session = 'default') {
     const { execFileSync } = await import('child_process');
+    const fullArgs = ['--session', session, '--json', ...args];
+    let result;
     try {
-        const fullArgs = ['--session', session, '--json', ...args];
-        const result = execFileSync('agent-browser', fullArgs, {
+        result = execFileSync('agent-browser', fullArgs, {
             encoding: 'utf-8',
             timeout: 30000,
         });
-        let data;
-        try {
-            data = JSON.parse(result);
-        }
-        catch {
-            data = result.trim();
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            try {
+                result = execFileSync('npx', ['--yes', 'agent-browser', ...fullArgs], {
+                    encoding: 'utf-8',
+                    timeout: 60000,
+                });
+            }
+            catch (npxError) {
+                const npxErr = npxError;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: npxErr.code === 'ENOENT'
+                                    ? 'Neither agent-browser nor npx found. Install with: npm i -g agent-browser'
+                                    : npxErr instanceof Error ? npxErr.message : String(npxError),
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
         }
-        // Update session activity
-        const sessionInfo = browserSessions.get(session);
-        if (sessionInfo) {
-            sessionInfo.lastActivity = new Date().toISOString();
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: err instanceof Error ? err.message : String(error),
+                        }),
+                    }],
+                isError: true,
+            };
         }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(data, null, 2),
-                }],
-        };
     }
-    catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    }),
-                }],
-            isError: true,
-        };
+    let data;
+    try {
+        data = JSON.parse(result);
+    }
+    catch {
+        data = result.trim();
     }
+    const sessionInfo = browserSessions.get(session);
+    if (sessionInfo) {
+        sessionInfo.lastActivity = new Date().toISOString();
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(data, null, 2),
+            }],
+    };
+}
+/**
+ * Detect if Linux needs --no-sandbox for Chrome.
+ */
+function needsNoSandbox() {
+    try {
+        const { readFileSync, existsSync } = require('fs');
+        if (process.platform !== 'linux')
+            return false;
+        const clonePath = '/proc/sys/kernel/unprivileged_userns_clone';
+        if (existsSync(clonePath)) {
+            return readFileSync(clonePath, 'utf-8').trim() === '0';
+        }
+    }
+    catch { /* not Linux or can't read */ }
+    return false;
 }
 /**
  * Browser MCP Tools
@@ -72,6 +115,11 @@ export const browserTools = [
                     enum: ['load', 'domcontentloaded', 'networkidle'],
                     description: 'Wait condition',
                 },
+                args: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Additional Chrome launch args (e.g., ["--no-sandbox", "--disable-dev-shm-usage"])',
+                },
             },
             required: ['url'],
         },
@@ -85,9 +133,15 @@ export const browserTools = [
                     return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: vS.error }) }], isError: true };
             }
             const { url, session, waitUntil } = input;
+            const launchArgs = input.args || [];
+            if (needsNoSandbox() && !launchArgs.includes('--no-sandbox')) {
+                launchArgs.push('--no-sandbox');
+            }
             const args = ['open', url];
             if (waitUntil)
                 args.push('--wait-until', waitUntil);
+            for (const a of launchArgs)
+                args.push('--arg', a);
             // Create session if new
             const sessionId = session || 'default';
             if (!browserSessions.has(sessionId)) {
@@ -369,13 +423,13 @@ export const browserTools = [
     },
     {
         name: 'browser_hover',
-        description: 'Hover over an element',
+        description: 'Hover over an element using ref (@e1) or CSS selector',
         category: 'browser',
         tags: ['interaction'],
         inputSchema: {
             type: 'object',
             properties: {
-                target: { type: 'string', description: 'Element ref or CSS selector' },
+                target: { type: 'string', description: 'Element ref (@e1) or CSS selector' },
                 session: { type: 'string', description: 'Session ID' },
             },
             required: ['target'],

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

@@ -412,7 +412,7 @@ export const embeddingsTools = [
                     query,
                     limit: topK,
                     threshold,
-                    namespace: namespace || 'default'
+                    namespace: namespace || 'all'
                 });
                 const searchTime = (performance.now() - startTime).toFixed(2);
                 return {
@@ -428,7 +428,7 @@ export const embeddingsTools = [
                         model: config.model,
                         topK,
                         threshold,
-                        namespace: namespace || 'default',
+                        namespace: namespace || 'all',
                         searchTime: `${searchTime}ms`,
                         indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
                         resultCount: searchResult.results.length
@@ -446,7 +446,7 @@ export const embeddingsTools = [
                         model: config.model,
                         topK,
                         threshold,
-                        namespace: namespace || 'default',
+                        namespace: namespace || 'all',
                         searchTime: `${searchTime}ms`,
                         indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
                     },
@@ -804,5 +804,74 @@ export const embeddingsTools = [
             };
         },
     },
+    // --- RaBitQ 1-bit quantized vector index ---
+    {
+        name: 'embeddings_rabitq_build',
+        description: 'Build RaBitQ 1-bit quantized index from stored embeddings (32× compression). Pre-filters candidates via Hamming scan before exact rerank.',
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                force: { type: 'boolean', description: 'Force rebuild even if index exists' },
+            },
+        },
+        handler: async (params) => {
+            const { buildRabitqIndex } = await import('../memory/rabitq-index.js');
+            return buildRabitqIndex({ force: params.force });
+        },
+    },
+    {
+        name: 'embeddings_rabitq_search',
+        description: 'Search via RaBitQ quantized index (fast Hamming scan). Returns candidate IDs for reranking.',
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query text' },
+                k: { type: 'number', description: 'Number of results (default: 10)' },
+                namespace: { type: 'string', description: 'Filter by namespace' },
+            },
+            required: ['query'],
+        },
+        handler: async (params) => {
+            const { validateText: vt } = await import('./validate-input.js');
+            const v = vt(params.query, 'query');
+            if (!v.valid)
+                return { success: false, error: v.error };
+            const { searchRabitq } = await import('../memory/rabitq-index.js');
+            const { generateEmbedding } = await import('../memory/memory-initializer.js');
+            const queryEmb = await generateEmbedding(params.query);
+            const results = await searchRabitq(queryEmb.embedding, {
+                k: params.k || 10,
+                namespace: params.namespace,
+            });
+            if (!results) {
+                return { success: false, error: 'RaBitQ index not built. Call embeddings_rabitq_build first.' };
+            }
+            return {
+                success: true,
+                results: results.map(r => ({
+                    id: r.id.substring(0, 12),
+                    key: r.key,
+                    namespace: r.namespace,
+                    distance: Math.round(r.distance * 10000) / 10000,
+                })),
+                count: results.length,
+            };
+        },
+    },
+    {
+        name: 'embeddings_rabitq_status',
+        description: 'Get RaBitQ quantized index status — availability, vector count, compression ratio',
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        handler: async () => {
+            const { getRabitqStatus } = await import('../memory/rabitq-index.js');
+            return { success: true, ...getRabitqStatus() };
+        },
+    },
 ];
 //# sourceMappingURL=embeddings-tools.js.map

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

@@ -2479,20 +2479,25 @@ export const hooksPatternStore = {
         }
         const success = reasoningResult?.success || storeResult.success;
         const controller = reasoningResult?.controller || (storeResult.success ? 'bridge-store' : 'none');
+        const hasEmbedding = !!storeResult.embedding || controller === 'reasoningBank' || controller === 'bridge-fallback';
         return {
             patternId: reasoningResult?.patternId || storeResult.id || patternId,
             pattern,
             type,
             confidence,
             indexed: success,
-            hnswIndexed: success && (!!storeResult.embedding || controller === 'reasoningBank'),
+            hnswIndexed: success && hasEmbedding,
             embedding: storeResult.embedding,
             timestamp,
             controller,
-            implementation: controller === 'reasoningBank' ? 'reasoning-bank-controller' : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
+            implementation: (controller === 'reasoningBank' || controller === 'bridge-fallback')
+                ? 'reasoning-bank-controller'
+                : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
             note: controller === 'reasoningBank'
                 ? 'Pattern stored via ReasoningBank controller with HNSW indexing'
-                : (storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable')),
+                : controller === 'bridge-fallback'
+                    ? 'Pattern stored via bridge with embedding and HNSW indexing'
+                    : (storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable')),
         };
     },
 };

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

@@ -37,6 +37,7 @@ export declare function bridgeStoreEntry(options: {
         dimensions: number;
         model: string;
     };
+    rawEmbedding?: number[];
     guarded?: boolean;
     cached?: boolean;
     attested?: boolean;
@@ -404,4 +405,19 @@ export declare function bridgeContextSynthesize(params: {
 export declare function bridgeSemanticRoute(params: {
     input: string;
 }): Promise<any>;
+/**
+ * Export all embeddings from the bridge's better-sqlite3 connection.
+ * Used by RaBitQ to build its index from the same data that memory_store writes.
+ * Returns null if bridge is unavailable (caller falls back to sql.js).
+ */
+export declare function bridgeGetAllEmbeddings(options?: {
+    dimensions?: number;
+    limit?: number;
+    dbPath?: string;
+}): Promise<Array<{
+    id: string;
+    key: string;
+    namespace: string;
+    embedding: number[];
+}> | null>;
 //# sourceMappingURL=memory-bridge.d.ts.map

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

@@ -381,6 +381,7 @@ export async function bridgeStoreEntry(options) {
             success: true,
             id,
             embedding: embeddingJson ? { dimensions, model } : undefined,
+            rawEmbedding: embeddingJson ? JSON.parse(embeddingJson) : undefined,
             guarded: true,
             cached: true,
             attested: true,
@@ -460,10 +461,11 @@ export async function bridgeSearchEntries(options) {
                 bm25ScoreVal = Math.min(bm25ScoreVal / 10, 1.0);
             }
             // Reciprocal rank fusion: combine semantic and BM25
-            // Weight: 0.7 semantic + 0.3 BM25 (semantic preferred when embeddings available)
-            const score = queryEmbedding
+            // Weight: 0.7 semantic + 0.3 BM25 when both embeddings present
+            // Fall back to BM25-only when either query or row lacks an embedding
+            const score = semanticScore > 0
                 ? (0.7 * semanticScore + 0.3 * bm25ScoreVal)
-                : bm25ScoreVal; // BM25-only when no embeddings
+                : bm25ScoreVal;
             if (score >= threshold) {
                 // Phase 4: ExplainableRecall provenance
                 const provenance = queryEmbedding
@@ -971,15 +973,31 @@ export async function bridgeStorePattern(options) {
             return { success: true, patternId, controller: 'reasoningBank' };
         }
         // Fallback: store via bridge SQL
+        const patternValue = JSON.stringify({ pattern: options.pattern, type: options.type, confidence: options.confidence, metadata: options.metadata });
         const result = await bridgeStoreEntry({
             key: patternId,
-            value: JSON.stringify({ pattern: options.pattern, type: options.type, confidence: options.confidence, metadata: options.metadata }),
+            value: patternValue,
             namespace: 'pattern',
             generateEmbeddingFlag: true,
             tags: [options.type, 'reasoning-pattern'],
             dbPath: options.dbPath,
         });
-        return result ? { success: true, patternId: result.id, controller: 'bridge-fallback' } : null;
+        if (!result)
+            return null;
+        // Add to HNSW index for fast semantic search (bridgeStoreEntry stores SQL only)
+        if (result.rawEmbedding) {
+            try {
+                const { addToHNSWIndex } = await import('./memory-initializer.js');
+                await addToHNSWIndex(result.id, result.rawEmbedding, {
+                    id: result.id,
+                    key: patternId,
+                    namespace: 'pattern',
+                    content: patternValue,
+                });
+            }
+            catch { /* HNSW is best-effort */ }
+        }
+        return { success: true, patternId: result.id, controller: 'bridge-fallback' };
     }
     catch {
         return null;
@@ -1536,6 +1554,51 @@ export async function bridgeSemanticRoute(params) {
         return { route: null, error: e.message };
     }
 }
+// ===== RaBitQ data export =====
+/**
+ * Export all embeddings from the bridge's better-sqlite3 connection.
+ * Used by RaBitQ to build its index from the same data that memory_store writes.
+ * Returns null if bridge is unavailable (caller falls back to sql.js).
+ */
+export async function bridgeGetAllEmbeddings(options) {
+    const registry = await getRegistry(options?.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const dims = options?.dimensions ?? 384;
+        const maxRows = options?.limit ?? 50000;
+        const rows = ctx.db.prepare(`
+      SELECT id, key, namespace, embedding
+      FROM memory_entries
+      WHERE status = 'active' AND embedding IS NOT NULL
+      LIMIT ?
+    `).all(maxRows);
+        const results = [];
+        for (const row of rows) {
+            if (!row.embedding)
+                continue;
+            try {
+                const emb = JSON.parse(row.embedding);
+                if (emb.length !== dims)
+                    continue;
+                results.push({
+                    id: String(row.id),
+                    key: row.key || String(row.id),
+                    namespace: row.namespace || 'default',
+                    embedding: emb,
+                });
+            }
+            catch { /* skip invalid */ }
+        }
+        return results;
+    }
+    catch {
+        return null;
+    }
+}
 // ===== Utility =====
 function cosineSim(a, b) {
     if (!a || !b || a.length === 0 || b.length === 0)

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

@@ -1689,8 +1689,19 @@ export async function storeEntry(options) {
     const bridge = await getBridge();
     if (bridge) {
         const bridgeResult = await bridge.bridgeStoreEntry(options);
-        if (bridgeResult)
+        if (bridgeResult) {
+            // Keep HNSW index in sync with bridge-stored entries
+            if (bridgeResult.rawEmbedding && bridgeResult.success) {
+                const ns = options.namespace || 'default';
+                await addToHNSWIndex(bridgeResult.id, bridgeResult.rawEmbedding, {
+                    id: bridgeResult.id,
+                    key: options.key,
+                    namespace: ns,
+                    content: options.value,
+                }).catch(() => { });
+            }
             return bridgeResult;
+        }
     }
     // Fallback: raw sql.js
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
@@ -1799,7 +1810,51 @@ export async function searchEntries(options) {
         // Generate query embedding
         const queryEmb = await generateEmbedding(query);
         const queryEmbedding = queryEmb.embedding;
-        // Try HNSW search first (150x faster)
+        // Try RaBitQ pre-filter first (32× compressed Hamming scan)
+        try {
+            const { searchRabitq } = await import('./rabitq-index.js');
+            const rabitqCandidates = await searchRabitq(queryEmbedding, { k: limit * 2, namespace: effectiveNamespace });
+            if (rabitqCandidates && rabitqCandidates.length > 0) {
+                // Rerank candidates with exact cosine similarity from SQLite
+                const initSqlJs = (await import('sql.js')).default;
+                const SQL = await initSqlJs();
+                const fileBuffer = fs.readFileSync(dbPath);
+                const db = new SQL.Database(fileBuffer);
+                const reranked = [];
+                for (const candidate of rabitqCandidates) {
+                    const stmt = db.prepare('SELECT content, embedding FROM memory_entries WHERE id = ? AND status = ?');
+                    stmt.bind([candidate.id, 'active']);
+                    if (stmt.step()) {
+                        const [content, embeddingJson] = stmt.get();
+                        let score = 0;
+                        if (embeddingJson) {
+                            try {
+                                const embedding = JSON.parse(embeddingJson);
+                                score = cosineSim(queryEmbedding, embedding);
+                            }
+                            catch { /* skip */ }
+                        }
+                        if (score >= threshold) {
+                            reranked.push({
+                                id: candidate.id.substring(0, 12),
+                                key: candidate.key || candidate.id.substring(0, 15),
+                                content: (content || '').substring(0, 60) + ((content || '').length > 60 ? '...' : ''),
+                                score,
+                                namespace: candidate.namespace,
+                            });
+                        }
+                    }
+                    stmt.free();
+                }
+                db.close();
+                if (reranked.length > 0) {
+                    reranked.sort((a, b) => b.score - a.score);
+                    return { success: true, results: reranked.slice(0, limit), searchTime: Date.now() - startTime };
+                }
+            }
+        }
+        catch { /* RaBitQ unavailable, fall through */ }
+        // Try HNSW search (150x faster than brute-force)
         const hnswResults = await searchHNSWIndex(queryEmbedding, { k: limit, namespace: effectiveNamespace });
         if (hnswResults && hnswResults.length > 0) {
             // Filter by threshold

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

@@ -0,0 +1,60 @@
+/**
+ * RaBitQ Index — 1-bit quantized vector pre-filter (32× compression)
+ *
+ * Wraps @ruvector/rabitq-wasm to provide Hamming-scan pre-filtering
+ * over quantized embeddings. Candidates are reranked with exact cosine
+ * similarity from the full-precision source (HNSW or SQLite).
+ *
+ * Lifecycle:
+ *  1. build() — bulk-load all embeddings from SQLite into the WASM index
+ *  2. search() — fast Hamming scan → candidate ids → caller reranks
+ *  3. rebuild() — called when entry count drifts >20% from last build
+ */
+/**
+ * Build or rebuild the RaBitQ index from SQLite embeddings.
+ * Returns entry count or 0 if RaBitQ is unavailable.
+ */
+export declare function buildRabitqIndex(options?: {
+    dbPath?: string;
+    dimensions?: number;
+    force?: boolean;
+}): Promise<{
+    success: boolean;
+    vectorCount: number;
+    dimensions: number;
+    compressionRatio: number;
+    buildTimeMs: number;
+    wasmVersion?: string;
+    error?: string;
+}>;
+/**
+ * Search the RaBitQ index for candidate IDs.
+ * Returns null if index not built or unavailable.
+ * Caller is responsible for reranking with exact similarity.
+ */
+export declare function searchRabitq(queryEmbedding: number[], options?: {
+    k?: number;
+    namespace?: string;
+}): Promise<Array<{
+    id: string;
+    key: string;
+    namespace: string;
+    distance: number;
+    position: number;
+}> | null>;
+/**
+ * Check if the RaBitQ index needs rebuilding.
+ */
+export declare function shouldRebuildRabitq(currentEntryCount: number): Promise<boolean>;
+/**
+ * Get RaBitQ index status.
+ */
+export declare function getRabitqStatus(): {
+    available: boolean;
+    initialized: boolean;
+    vectorCount: number;
+    dimensions: number;
+    builtAt: number | null;
+    compressionRatio: number;
+};
+//# sourceMappingURL=rabitq-index.d.ts.map

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

@@ -0,0 +1,242 @@
+/**
+ * RaBitQ Index — 1-bit quantized vector pre-filter (32× compression)
+ *
+ * Wraps @ruvector/rabitq-wasm to provide Hamming-scan pre-filtering
+ * over quantized embeddings. Candidates are reranked with exact cosine
+ * similarity from the full-precision source (HNSW or SQLite).
+ *
+ * Lifecycle:
+ *  1. build() — bulk-load all embeddings from SQLite into the WASM index
+ *  2. search() — fast Hamming scan → candidate ids → caller reranks
+ *  3. rebuild() — called when entry count drifts >20% from last build
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const RABITQ_SEED = 42n;
+const RABITQ_RERANK_FACTOR = 20;
+const REBUILD_DRIFT_THRESHOLD = 0.2; // rebuild when count drifts >20%
+let rabitqState = null;
+let rabitqInitializing = false;
+async function loadRabitqModule() {
+    try {
+        const mod = await import('@ruvector/rabitq-wasm');
+        // Node.js: use initSync with the WASM bytes
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        const wasmPath = require.resolve('@ruvector/rabitq-wasm/ruvector_rabitq_wasm_bg.wasm');
+        const wasmBytes = fs.readFileSync(wasmPath);
+        mod.initSync({ module: wasmBytes });
+        return {
+            RabitqIndex: mod.RabitqIndex,
+            initSync: mod.initSync,
+            version: mod.version,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build or rebuild the RaBitQ index from SQLite embeddings.
+ * Returns entry count or 0 if RaBitQ is unavailable.
+ */
+export async function buildRabitqIndex(options) {
+    if (rabitqInitializing) {
+        return { success: false, vectorCount: 0, dimensions: 0, compressionRatio: 0, buildTimeMs: 0, error: 'Build already in progress' };
+    }
+    rabitqInitializing = true;
+    const startTime = Date.now();
+    try {
+        const mod = await loadRabitqModule();
+        if (!mod) {
+            rabitqInitializing = false;
+            return { success: false, vectorCount: 0, dimensions: 0, compressionRatio: 0, buildTimeMs: 0, error: '@ruvector/rabitq-wasm not available' };
+        }
+        const dimensions = options?.dimensions ?? 384;
+        const swarmDir = path.resolve(process.cwd(), '.swarm');
+        const dbPath = options?.dbPath ? path.resolve(options.dbPath) : path.join(swarmDir, 'memory.db');
+        const entries = [];
+        const vectors = [];
+        // Try bridge first (reads via better-sqlite3, sees WAL data)
+        let usedBridge = false;
+        try {
+            const { bridgeGetAllEmbeddings } = await import('./memory-bridge.js');
+            const bridgeRows = await bridgeGetAllEmbeddings({ dimensions, dbPath: options?.dbPath });
+            if (bridgeRows && bridgeRows.length > 0) {
+                for (const row of bridgeRows) {
+                    entries.push({ id: row.id, key: row.key, namespace: row.namespace });
+                    vectors.push(...row.embedding);
+                }
+                usedBridge = true;
+            }
+        }
+        catch { /* bridge unavailable, fall through */ }
+        // Fallback: read .swarm/memory.db via sql.js
+        if (!usedBridge) {
+            if (!fs.existsSync(dbPath)) {
+                rabitqInitializing = false;
+                return { success: false, vectorCount: 0, dimensions, compressionRatio: 0, buildTimeMs: 0, error: 'Database not found' };
+            }
+            const initSqlJs = (await import('sql.js')).default;
+            const SQL = await initSqlJs();
+            const fileBuffer = fs.readFileSync(dbPath);
+            const db = new SQL.Database(fileBuffer);
+            const result = db.exec(`
+        SELECT id, key, namespace, embedding
+        FROM memory_entries
+        WHERE status = 'active' AND embedding IS NOT NULL
+        LIMIT 50000
+      `);
+            if (result[0]?.values) {
+                for (const row of result[0].values) {
+                    const [id, key, ns, embeddingJson] = row;
+                    if (!embeddingJson)
+                        continue;
+                    try {
+                        const embedding = JSON.parse(embeddingJson);
+                        if (embedding.length !== dimensions)
+                            continue;
+                        entries.push({ id: String(id), key: key || String(id), namespace: ns || 'default' });
+                        vectors.push(...embedding);
+                    }
+                    catch {
+                        // skip invalid
+                    }
+                }
+            }
+            db.close();
+        }
+        if (entries.length < 2) {
+            rabitqInitializing = false;
+            return { success: false, vectorCount: entries.length, dimensions, compressionRatio: 0, buildTimeMs: Date.now() - startTime, error: 'Need at least 2 vectors to build RaBitQ index' };
+        }
+        // Build the RaBitQ index
+        const flatVectors = new Float32Array(vectors);
+        const index = mod.RabitqIndex.build(flatVectors, dimensions, RABITQ_SEED, RABITQ_RERANK_FACTOR);
+        // Free old index if exists
+        if (rabitqState?.index) {
+            try {
+                rabitqState.index.free();
+            }
+            catch { /* already freed */ }
+        }
+        rabitqState = {
+            index,
+            entries,
+            dimensions,
+            builtAt: Date.now(),
+            vectorCount: entries.length,
+        };
+        // Persist metadata for fast reload hint
+        try {
+            const metaPath = path.join(swarmDir, 'rabitq.meta.json');
+            fs.writeFileSync(metaPath, JSON.stringify({
+                vectorCount: entries.length,
+                dimensions,
+                builtAt: rabitqState.builtAt,
+                wasmVersion: mod.version(),
+            }));
+        }
+        catch { /* best-effort */ }
+        const rawBytes = entries.length * dimensions * 4; // f32 = 4 bytes
+        const quantizedBytes = entries.length * Math.ceil(dimensions / 8); // 1 bit per dim
+        const compressionRatio = rawBytes / Math.max(quantizedBytes, 1);
+        rabitqInitializing = false;
+        return {
+            success: true,
+            vectorCount: entries.length,
+            dimensions,
+            compressionRatio: Math.round(compressionRatio * 10) / 10,
+            buildTimeMs: Date.now() - startTime,
+            wasmVersion: mod.version(),
+        };
+    }
+    catch (error) {
+        rabitqInitializing = false;
+        return {
+            success: false,
+            vectorCount: 0,
+            dimensions: 0,
+            compressionRatio: 0,
+            buildTimeMs: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Search the RaBitQ index for candidate IDs.
+ * Returns null if index not built or unavailable.
+ * Caller is responsible for reranking with exact similarity.
+ */
+export async function searchRabitq(queryEmbedding, options) {
+    if (!rabitqState?.index)
+        return null;
+    try {
+        const query = new Float32Array(queryEmbedding);
+        if (query.length !== rabitqState.dimensions)
+            return null;
+        const k = options?.k ?? 10;
+        // Get more candidates than needed for namespace filtering + rerank
+        const expandedK = Math.min(k * 3, rabitqState.vectorCount);
+        const rawResults = rabitqState.index.search(query, expandedK);
+        const results = [];
+        for (const hit of rawResults) {
+            const pos = hit.id; // row index from build()
+            const entry = rabitqState.entries[pos];
+            if (!entry)
+                continue;
+            // Namespace filter
+            if (options?.namespace && options.namespace !== 'all' && entry.namespace !== options.namespace) {
+                continue;
+            }
+            results.push({
+                id: entry.id,
+                key: entry.key,
+                namespace: entry.namespace,
+                distance: hit.distance,
+                position: pos,
+            });
+            // Free WASM SearchResult to prevent leak
+            try {
+                hit.free();
+            }
+            catch { /* already freed */ }
+            if (results.length >= k)
+                break;
+        }
+        // Free remaining SearchResults
+        for (const hit of rawResults) {
+            try {
+                hit.free();
+            }
+            catch { /* already freed or used */ }
+        }
+        return results;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if the RaBitQ index needs rebuilding.
+ */
+export async function shouldRebuildRabitq(currentEntryCount) {
+    if (!rabitqState)
+        return currentEntryCount >= 10; // Build if we have enough vectors
+    const drift = Math.abs(currentEntryCount - rabitqState.vectorCount) / Math.max(rabitqState.vectorCount, 1);
+    return drift > REBUILD_DRIFT_THRESHOLD;
+}
+/**
+ * Get RaBitQ index status.
+ */
+export function getRabitqStatus() {
+    return {
+        available: rabitqState !== null,
+        initialized: rabitqState !== null,
+        vectorCount: rabitqState?.vectorCount ?? 0,
+        dimensions: rabitqState?.dimensions ?? 384,
+        builtAt: rabitqState?.builtAt ?? null,
+        compressionRatio: rabitqState ? Math.round((rabitqState.dimensions * 4) / Math.ceil(rabitqState.dimensions / 8) * 10) / 10 : 0,
+    };
+}
+//# sourceMappingURL=rabitq-index.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.6.4",
+  "version": "3.6.6",
   "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",
@@ -97,23 +97,24 @@
     "@claude-flow/mcp": "^3.0.0-alpha.8",
     "@claude-flow/shared": "^3.0.0-alpha.7",
     "@noble/ed25519": "^2.1.0",
+    "@ruvector/rabitq-wasm": "^0.1.0",
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
     "@claude-flow/aidefence": "^3.0.2",
-    "@claude-flow/security": "^3.0.0-alpha.1",
     "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/embeddings": "^3.0.0-alpha.12",
     "@claude-flow/guidance": "^3.0.0-alpha.1",
     "@claude-flow/memory": "^3.0.0-alpha.12",
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
+    "@claude-flow/security": "^3.0.0-alpha.1",
     "@ruvector/attention": "^0.1.32",
     "@ruvector/attention-darwin-arm64": "0.1.32",
+    "@ruvector/diskann": "^0.1.0",
     "@ruvector/learning-wasm": "^0.1.29",
     "@ruvector/router": "^0.1.30",
     "@ruvector/ruvllm-wasm": "^2.0.2",
     "@ruvector/rvagent-wasm": "^0.1.0",
-    "@ruvector/diskann": "^0.1.0",
     "@ruvector/sona": "^0.1.5",
     "agentdb": "^3.0.0-alpha.11",
     "agentic-flow": "^3.0.0-alpha.1"