@claude-flow/cli 3.38.6 → 3.38.7

package/.claude/helpers/helpers.manifest.json

@@ -1,13 +1,13 @@
 {
   "manifest": {
-    "version": "3.38.6",
+    "version": "3.38.7",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "dae295fb9ae2626b89899c19a20cc911541af82b52d2eeb9b214d618b96e9a86",
-      "intelligence.cjs": "66d63fdeab5f2ce0546bff80e69144911508fa2bf88f7b167ba0905762ecb314",
+      "intelligence.cjs": "30e42ed7ec4ca5a94ac54fdb1330d2d47ac5f3fdeeef207753574723a9e77b5c",
       "statusline.cjs": "0457fe53f8cd2c56458ff178392536a5868efd1a573665fa43bc01d2d95ca677"
     }
   },
-  "signature": "0u8qz9OxORssiGc4kWWJR9fL9OPo7GZj6K7Zhkq+40XkKCP7nxLHx8LPcUwxhRHzVnnBtnE34TvsoTueM2VIBA==",
+  "signature": "FgH/N1oH9kP+lac4BmyUWUmAamnyfQzYgIt3b/xGeL2PJgOLGvPbuKF1DTpnzRHONcsAViViVt0dWKF6Q3LqAw==",
   "algorithm": "ed25519"
 }

package/.claude/helpers/intelligence.cjs

@@ -830,11 +830,16 @@ function consolidate() {
     pageRanks = computePageRank(nodes, edges, 0.85, 30);
   }
 
-  // 6. Write updated graph
+  // 6. Write updated graph. #2920 follow-up: include contentFingerprint so
+  // init()'s cache-hit gate (line ~511) doesn't unconditionally miss on the
+  // very next init after a consolidate — without this, nodeCount alone
+  // matched but contentFingerprint was undefined here vs a real hash in
+  // init()'s own write, forcing a full rebuild every time.
   writeJSON(GRAPH_PATH, {
     version: 1,
     updatedAt: Date.now(),
     nodeCount: Object.keys(nodes).length,
+    contentFingerprint: storeFingerprint(store),
     nodes,
     edges,
     pageRanks,

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 4,
-  "generatedAt": "2026-08-12T20:46:09.024Z",
-  "gitSha": "f7672a10",
+  "generatedAt": "2026-08-12T21:44:13.365Z",
+  "gitSha": "57c0fcba",
   "catalog": {
     "agents": 164,
     "tools": 397,

package/dist/src/mcp-tools/memory-tools.js

@@ -203,6 +203,23 @@ async function getMemoryFunctions() {
         checkMemoryInitialization,
     };
 }
+/**
+ * #2922: every `backend:` field in this file's tool responses used to be the
+ * hardcoded literal `'sql.js + HNSW'` regardless of which search path was
+ * actually active — most of the time that's the bridge doing a brute-force
+ * cosine scan, not HNSW. This reports the real algorithm via the same
+ * capability probe `getHNSWStatus()` already exposes.
+ */
+async function describeBackend() {
+    try {
+        const { getHNSWStatus } = await import('../memory/memory-initializer.js');
+        const status = getHNSWStatus();
+        return status.algorithm === 'hnsw' ? 'sql.js + HNSW' : 'sqlite (bridge, brute-force cosine)';
+    }
+    catch {
+        return 'sqlite';
+    }
+}
 /**
  * Ensure memory database is initialized and migrate legacy data if needed.
  * #1606: Wrapped in try/catch to prevent process-level crashes that kill
@@ -318,7 +335,7 @@ export const memoryTools = [
                     hasEmbedding: !!result.embedding,
                     embeddingDimensions: result.embedding?.dimensions || null,
                     provenanceType: provenanceType || 'unknown',
-                    backend: 'sql.js + HNSW',
+                    backend: await describeBackend(),
                     storeTime: `${duration.toFixed(2)}ms`,
                     error: result.error,
                 };
@@ -371,7 +388,7 @@ export const memoryTools = [
                         accessCount: result.entry.accessCount,
                         hasEmbedding: result.entry.hasEmbedding,
                         found: true,
-                        backend: 'sql.js + HNSW',
+                        backend: await describeBackend(),
                     };
                 }
                 return {
@@ -584,7 +601,7 @@ export const memoryTools = [
                     namespace,
                     deleted: result.deleted,
                     hnswIndexInvalidated: result.deleted,
-                    backend: 'sql.js + HNSW',
+                    backend: await describeBackend(),
                 };
             }
             catch (error) {
@@ -641,7 +658,7 @@ export const memoryTools = [
                     total: result.total,
                     limit,
                     offset,
-                    backend: 'sql.js + HNSW',
+                    backend: await describeBackend(),
                 };
             }
             catch (error) {
@@ -685,7 +702,7 @@ export const memoryTools = [
                         ? `${((withEmbeddings / allEntries.total) * 100).toFixed(1)}%`
                         : '0%',
                     namespaces,
-                    backend: 'sql.js + HNSW',
+                    backend: await describeBackend(),
                     version: status.version || '3.0.0',
                     features: status.features || {
                         vectorEmbeddings: true,
@@ -736,7 +753,7 @@ export const memoryTools = [
                 success: true,
                 message: 'Migration completed',
                 migrated: Object.keys(legacyStore.entries).length,
-                backend: 'sql.js + HNSW',
+                backend: await describeBackend(),
             };
         },
     },
@@ -1149,7 +1166,7 @@ export const memoryTools = [
                 bytes += e.size || 0;
             }
             return {
-                backend: 'sql.js + HNSW',
+                backend: await describeBackend(),
                 entries: all.total ?? all.entries.length,
                 size: bytes,
                 namespaces: Object.entries(nsCounts).map(([name, entries]) => ({ name, entries })),

package/dist/src/memory/memory-bridge.d.ts

@@ -209,21 +209,29 @@ export declare function bridgeLoadEmbeddingModel(dbPath?: string): Promise<{
     loadTime?: number;
 } | null>;
 /**
- * Get HNSW status from AgentDB v3's vector backend or HNSW index.
+ * Get vector search status from AgentDB v3's SQLite-backed store.
  * Returns null if unavailable.
- */
-export declare function bridgeGetHNSWStatus(dbPath?: string): Promise<{
+ *
+ * #2922: previously named `bridgeGetHNSWStatus` and unconditionally returned
+ * `available: true` whenever a DB connection succeeded — but the search this
+ * status describes (`bridgeSearchBruteForceCosine`, below) is a full-table
+ * SELECT + brute-force cosine scan, not an HNSW index lookup. Renamed and
+ * given an explicit `algorithm` field so callers can't mistake "vector
+ * search works" for "vector search is HNSW-accelerated".
+ */
+export declare function bridgeGetVectorSearchStatus(dbPath?: string): Promise<{
     available: boolean;
     initialized: boolean;
     entryCount: number;
     dimensions: number;
+    algorithm: 'brute-force-cosine';
 } | null>;
 /**
- * Search using AgentDB v3's embedder + SQLite entries.
- * This is the HNSW-equivalent search through the bridge.
- * Returns null if unavailable.
+ * Search AgentDB v3's embedder + SQLite entries via a full-table scan and
+ * brute-force cosine similarity. NOT HNSW-accelerated — see #2922. Returns
+ * null if unavailable.
  */
-export declare function bridgeSearchHNSW(queryEmbedding: number[], options?: {
+export declare function bridgeSearchBruteForceCosine(queryEmbedding: number[], options?: {
     k?: number;
     namespace?: string;
     threshold?: number;
@@ -235,10 +243,11 @@ export declare function bridgeSearchHNSW(queryEmbedding: number[], options?: {
     namespace: string;
 }> | null>;
 /**
- * Add entry to the bridge's database with embedding.
- * Returns null if unavailable.
+ * Add entry to the bridge's database with embedding. No HNSW index is built
+ * or updated here — see #2922; the embedding is only stored for a later
+ * brute-force scan. Returns null if unavailable.
  */
-export declare function bridgeAddToHNSW(id: string, embedding: number[], entry: {
+export declare function bridgeAddEmbedding(id: string, embedding: number[], entry: {
     id: string;
     key: string;
     namespace: string;

package/dist/src/memory/memory-bridge.js

@@ -1478,10 +1478,17 @@ export async function bridgeLoadEmbeddingModel(dbPath) {
 }
 // ===== Phase 3: HNSW bridge =====
 /**
- * Get HNSW status from AgentDB v3's vector backend or HNSW index.
+ * Get vector search status from AgentDB v3's SQLite-backed store.
  * Returns null if unavailable.
+ *
+ * #2922: previously named `bridgeGetHNSWStatus` and unconditionally returned
+ * `available: true` whenever a DB connection succeeded — but the search this
+ * status describes (`bridgeSearchBruteForceCosine`, below) is a full-table
+ * SELECT + brute-force cosine scan, not an HNSW index lookup. Renamed and
+ * given an explicit `algorithm` field so callers can't mistake "vector
+ * search works" for "vector search is HNSW-accelerated".
  */
-export async function bridgeGetHNSWStatus(dbPath) {
+export async function bridgeGetVectorSearchStatus(dbPath) {
     const registry = await getRegistry(dbPath);
     if (!registry)
         return null;
@@ -1503,6 +1510,7 @@ export async function bridgeGetHNSWStatus(dbPath) {
             initialized: true,
             entryCount,
             dimensions: 384,
+            algorithm: 'brute-force-cosine',
         };
     }
     catch {
@@ -1510,11 +1518,11 @@ export async function bridgeGetHNSWStatus(dbPath) {
     }
 }
 /**
- * Search using AgentDB v3's embedder + SQLite entries.
- * This is the HNSW-equivalent search through the bridge.
- * Returns null if unavailable.
+ * Search AgentDB v3's embedder + SQLite entries via a full-table scan and
+ * brute-force cosine similarity. NOT HNSW-accelerated — see #2922. Returns
+ * null if unavailable.
  */
-export async function bridgeSearchHNSW(queryEmbedding, options, dbPath) {
+export async function bridgeSearchBruteForceCosine(queryEmbedding, options, dbPath) {
     const registry = await getRegistry(dbPath);
     if (!registry)
         return null;
@@ -1576,10 +1584,11 @@ export async function bridgeSearchHNSW(queryEmbedding, options, dbPath) {
     }
 }
 /**
- * Add entry to the bridge's database with embedding.
- * Returns null if unavailable.
+ * Add entry to the bridge's database with embedding. No HNSW index is built
+ * or updated here — see #2922; the embedding is only stored for a later
+ * brute-force scan. Returns null if unavailable.
  */
-export async function bridgeAddToHNSW(id, embedding, entry, dbPath) {
+export async function bridgeAddEmbedding(id, embedding, entry, dbPath) {
     const registry = await getRegistry(dbPath);
     if (!registry)
         return null;

package/dist/src/memory/memory-initializer.d.ts

@@ -91,6 +91,7 @@ export declare function getHNSWStatus(): {
     initialized: boolean;
     entryCount: number;
     dimensions: number;
+    algorithm: 'hnsw' | 'brute-force-cosine';
 };
 /**
  * Clear the HNSW index (for rebuilding)

package/dist/src/memory/memory-initializer.js

@@ -750,7 +750,7 @@ export async function addToHNSWIndex(id, embedding, entry) {
     // ADR-053: Try AgentDB v3 bridge first
     const bridge = await getBridge();
     if (bridge) {
-        const bridgeResult = await bridge.bridgeAddToHNSW(id, embedding, entry);
+        const bridgeResult = await bridge.bridgeAddEmbedding(id, embedding, entry);
         if (bridgeResult === true)
             return true;
     }
@@ -780,7 +780,7 @@ export async function searchHNSWIndex(queryEmbedding, options) {
     // ADR-053: Try AgentDB v3 bridge first
     const bridge = await getBridge();
     if (bridge) {
-        const bridgeResult = await bridge.bridgeSearchHNSW(queryEmbedding, options);
+        const bridgeResult = await bridge.bridgeSearchBruteForceCosine(queryEmbedding, options);
         if (bridgeResult)
             return bridgeResult;
     }
@@ -826,14 +826,23 @@ export async function searchHNSWIndex(queryEmbedding, options) {
  * Get HNSW index status
  */
 export function getHNSWStatus() {
-    // ADR-053: If bridge was previously loaded, report availability
+    // #2922: this branch previously reported `available: true` whenever the
+    // bridge was loaded, on the theory that "AgentDB v3 is HNSW-equivalent" —
+    // but the bridge's actual search path (bridgeSearchBruteForceCosine, see
+    // memory-bridge.ts) does a full-table SELECT + brute-force cosine loop and
+    // never touches @ruvector/core or an HNSW index, regardless of whether
+    // ruvector-core itself is installed. `available` here means "an HNSW
+    // index is the one actually searched", matching what this function's own
+    // name promises — that's false while the bridge is the active path, so
+    // this no longer claims otherwise. Vector search itself still works via
+    // the bridge; `algorithm` tells callers it's brute-force, not HNSW.
     if (_bridge && _bridge !== null) {
-        // Bridge is loaded — HNSW-equivalent is available via AgentDB v3
         return {
-            available: true,
-            initialized: true,
+            available: false,
+            initialized: false,
             entryCount: hnswIndex?.entries.size ?? 0,
-            dimensions: hnswIndex?.dimensions ?? 384
+            dimensions: hnswIndex?.dimensions ?? 384,
+            algorithm: 'brute-force-cosine',
         };
     }
     // #2356: `available` now reflects real capability (index already loaded OR
@@ -845,7 +854,8 @@ export function getHNSWStatus() {
         available: hnswIndex !== null || isRuvectorCoreResolvable(),
         initialized: hnswIndex?.initialized ?? false,
         entryCount: hnswIndex?.entries.size ?? 0,
-        dimensions: hnswIndex?.dimensions ?? 384
+        dimensions: hnswIndex?.dimensions ?? 384,
+        algorithm: 'hnsw',
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.38.6",
+  "version": "3.38.7",
   "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",