@claude-flow/cli 3.38.6 → 3.38.8

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

@@ -1,13 +1,13 @@
 {
   "manifest": {
-    "version": "3.38.6",
+    "version": "3.38.8",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "dae295fb9ae2626b89899c19a20cc911541af82b52d2eeb9b214d618b96e9a86",
-      "intelligence.cjs": "66d63fdeab5f2ce0546bff80e69144911508fa2bf88f7b167ba0905762ecb314",
+      "intelligence.cjs": "30e42ed7ec4ca5a94ac54fdb1330d2d47ac5f3fdeeef207753574723a9e77b5c",
       "statusline.cjs": "0457fe53f8cd2c56458ff178392536a5868efd1a573665fa43bc01d2d95ca677"
     }
   },
-  "signature": "0u8qz9OxORssiGc4kWWJR9fL9OPo7GZj6K7Zhkq+40XkKCP7nxLHx8LPcUwxhRHzVnnBtnE34TvsoTueM2VIBA==",
+  "signature": "EoEEuSnNwaVCAmnwd7Evq+V2sD0Zz5cOqqZO4PecBOchzrcimyqFqkz4eOyhYF6iIhEtQ8+XsOvZKFKMbtKIDg==",
   "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-12T22:31:25.682Z",
+  "gitSha": "5efd5937",
   "catalog": {
     "agents": 164,
     "tools": 397,

package/dist/src/mcp-tools/agent-execute-core.d.ts

@@ -27,8 +27,8 @@ export interface AgentRecord {
      * falling back to MODEL_MAP[tier].
      */
     modelId?: string;
-    /** ADR-148 phase 2 — execution provider hint. */
-    provider?: 'anthropic' | 'openrouter';
+    /** ADR-148 phase 2 — execution provider hint. #2962 widened to include 'ollama'. */
+    provider?: 'anthropic' | 'openrouter' | 'ollama';
     /** ADR-148 phase 2 — concrete OpenRouter slug when provider='openrouter'. */
     openrouterModel?: string;
     lastResult?: Record<string, unknown>;
@@ -42,6 +42,14 @@ export interface AnthropicCallInput {
     maxTokens?: number;
     temperature?: number;
     timeoutMs?: number;
+    /**
+     * #2962 — explicit provider carried from the agent record (agent.provider,
+     * itself populated from a user's `--provider` flag or persisted
+     * `providers configure`). When set, this outranks the env-var-only
+     * inference callAnthropicMessages otherwise does — see the precedence
+     * comment on that function.
+     */
+    provider?: 'anthropic' | 'openrouter' | 'ollama';
 }
 export interface AnthropicCallResult {
     success: boolean;

package/dist/src/mcp-tools/agent-execute-core.js

@@ -10,6 +10,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
+import { configManager } from '../services/config-file-manager.js';
 const STORAGE_DIR = '.claude-flow';
 const AGENT_DIR = 'agents';
 const AGENT_FILE = 'store.json';
@@ -57,6 +58,29 @@ const MODEL_MAP = {
 export function modelRejectsSamplingParams(model) {
     return /^claude-(fable-5|opus-4-8|opus-4-7|sonnet-5)/.test(model);
 }
+/**
+ * #2962 — read the enabled `agents.providers` entry matching `name` from
+ * cwd-scoped `claude-flow.config.json` (written by `providers configure`,
+ * `commands/providers.ts`). Best-effort: any failure (no config file, wrong
+ * shape, etc.) returns undefined rather than throwing — this must never
+ * break execution, and env vars remain a fully-supported override that
+ * doesn't require this file to exist.
+ */
+function getPersistedProviderConfig(name) {
+    try {
+        const providers = configManager.get(getProjectCwd(), 'agents.providers');
+        if (!Array.isArray(providers))
+            return undefined;
+        const entry = providers.find((p) => !!p && typeof p === 'object' && typeof p.name === 'string' &&
+            p.name.toLowerCase() === name.toLowerCase());
+        if (!entry || entry.enabled === false)
+            return undefined;
+        return entry;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Generic Anthropic Messages API call. No agent registry coupling — used
  * by agent_execute (with the agent's configured model) and by the WASM
@@ -69,7 +93,13 @@ export function modelRejectsSamplingParams(model) {
  * don't need to know which provider answered.
  */
 export async function callAnthropicMessages(input) {
-    const explicitProvider = (process.env.RUFLO_PROVIDER || '').toLowerCase();
+    // #2962 — precedence: explicit per-agent flag (input.provider, forwarded
+    // from agent.provider by executeAgentTask, itself populated from a
+    // user's `agent spawn --provider` flag) → env vars (RUFLO_PROVIDER + the
+    // *_API_KEY family — unchanged back-compat surface) → persisted
+    // `agents.providers` config (`providers configure`) → the original
+    // key-presence inference, kept below as the last-resort fallback.
+    const explicitProvider = (input.provider || process.env.RUFLO_PROVIDER || '').toLowerCase();
     const ollamaKey = process.env.OLLAMA_API_KEY;
     const anthropicKey = process.env.ANTHROPIC_API_KEY;
     // #2042 — OpenRouter is an OpenAI-compat endpoint that fronts dozens of
@@ -80,22 +110,47 @@ export async function callAnthropicMessages(input) {
     // branch above).
     const openrouterKey = process.env.OPENROUTER_API_KEY;
     const useOpenRouter = explicitProvider === 'openrouter' || (!anthropicKey && !!openrouterKey);
-    const useOllama = explicitProvider === 'ollama' || (!anthropicKey && !!ollamaKey && !openrouterKey);
-    if (useOpenRouter && openrouterKey) {
-        return callOpenAICompat({
-            ...input,
-            apiKey: openrouterKey,
-            baseUrl: process.env.OPENROUTER_BASE_URL || 'https://openrouter.ai/api',
-            providerLabel: 'openrouter',
-            // #2357 Finding C: anthropic/claude-3.5-sonnet was retired Oct 2025.
-            // Default to the same canonical family the rest of the resolver uses
-            // (MODEL_MAP). `OPENROUTER_DEFAULT_MODEL` still wins for callers who
-            // want to pin a specific OpenRouter slug.
-            defaultModel: process.env.OPENROUTER_DEFAULT_MODEL || 'anthropic/claude-sonnet-4-6',
-        });
+    // #2962 — only consult the persisted config when a candidate is actually
+    // relevant (explicit choice, or no env key found anywhere), so a normal
+    // ANTHROPIC_API_KEY-only setup never pays a config-file read.
+    const persistedOllama = explicitProvider === 'ollama' || (!anthropicKey && !openrouterKey && !ollamaKey)
+        ? getPersistedProviderConfig('ollama')
+        : undefined;
+    const persistedOpenRouter = explicitProvider === 'openrouter' && !openrouterKey ? getPersistedProviderConfig('openrouter') : undefined;
+    const useOllama = explicitProvider === 'ollama' || (!anthropicKey && !openrouterKey && (!!ollamaKey || !!persistedOllama));
+    if (useOpenRouter) {
+        const apiKey = openrouterKey || persistedOpenRouter?.apiKey;
+        if (apiKey) {
+            return callOpenAICompat({
+                ...input,
+                apiKey,
+                baseUrl: process.env.OPENROUTER_BASE_URL || persistedOpenRouter?.baseUrl || 'https://openrouter.ai/api',
+                providerLabel: 'openrouter',
+                // #2357 Finding C: anthropic/claude-3.5-sonnet was retired Oct 2025.
+                // Default to the same canonical family the rest of the resolver uses
+                // (MODEL_MAP). `OPENROUTER_DEFAULT_MODEL` still wins for callers who
+                // want to pin a specific OpenRouter slug.
+                defaultModel: process.env.OPENROUTER_DEFAULT_MODEL || persistedOpenRouter?.model || 'anthropic/claude-sonnet-4-6',
+            });
+        }
     }
-    if (useOllama && ollamaKey) {
-        return callOllamaCompat({ ...input, apiKey: ollamaKey });
+    if (useOllama) {
+        // #2962 — retire the undocumented OLLAMA_API_KEY=local sentinel
+        // requirement. A self-hosted, unauthenticated Ollama daemon shouldn't
+        // need a fake credential to become reachable; "self-hosted" is any
+        // resolved base URL that isn't the public Ollama Cloud endpoint
+        // (persisted `providers configure -e` baseUrl, or OLLAMA_BASE_URL,
+        // checked in that order — matching callOllamaCompat's own precedence).
+        const resolvedBaseUrl = process.env.OLLAMA_BASE_URL || persistedOllama?.baseUrl;
+        const isSelfHosted = !!resolvedBaseUrl && !/^https:\/\/ollama\.com\/?$/i.test(resolvedBaseUrl);
+        if (ollamaKey || persistedOllama?.apiKey || isSelfHosted) {
+            return callOllamaCompat({
+                ...input,
+                apiKey: ollamaKey || persistedOllama?.apiKey || 'local',
+                baseUrl: resolvedBaseUrl,
+                model: input.model || persistedOllama?.model,
+            });
+        }
     }
     if (!anthropicKey) {
         return {
@@ -185,15 +240,18 @@ export async function callAnthropicMessages(input) {
 async function callOllamaCompat(input) {
     const model = resolveOllamaModel(input.model);
     const startedAt = Date.now();
-    // OLLAMA_BASE_URL lets users point at local/self-hosted endpoints
-    // (e.g. http://ruvultra:11434, http://localhost:11434) instead of
-    // Ollama Cloud. Default is the public cloud endpoint.
-    const base = (process.env.OLLAMA_BASE_URL || 'https://ollama.com').replace(/\/+$/, '');
+    // #2962 — input.baseUrl (resolved by the caller from persisted
+    // `providers configure` config, then OLLAMA_BASE_URL) takes precedence
+    // over re-reading OLLAMA_BASE_URL here, so a persisted-config-only setup
+    // (no env vars) still reaches a self-hosted endpoint instead of Ollama
+    // Cloud. Falls back to the original OLLAMA_BASE_URL-or-cloud behavior
+    // for any direct caller that doesn't pass baseUrl.
+    const base = (input.baseUrl || process.env.OLLAMA_BASE_URL || 'https://ollama.com').replace(/\/+$/, '');
     const url = `${base}/v1/chat/completions`;
     // Self-hosted endpoints typically don't need an Authorization header
     // (the daemon binds to 11434 with no auth by default), but Ollama Cloud
     // does. Send the bearer when the key is non-empty AND looks cloud-shaped.
-    const sendAuth = input.apiKey && input.apiKey !== 'local';
+    const sendAuth = !!input.apiKey && input.apiKey !== 'local';
     try {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
@@ -406,6 +464,11 @@ export async function executeAgentTask(input) {
     const startedAt = Date.now();
     // #2042 — delegate to callAnthropicMessages so the v3 provider router
     // (Anthropic / Ollama / OpenRouter) governs which backend is hit.
+    // #2962 — forward the agent's own explicit provider (set at spawn time
+    // from --provider / persisted config) so it outranks env-var inference.
+    // Only the first-attempt call; the ADR-149 fallback-retry call below is
+    // driven by the cost-optimal neural router picking model-id alternatives,
+    // an orthogonal mechanism left as-is to avoid unintended interaction.
     let result = await callAnthropicMessages({
         model: anthropicModel,
         prompt: input.prompt,
@@ -413,6 +476,7 @@ export async function executeAgentTask(input) {
         maxTokens: input.maxTokens,
         temperature: input.temperature,
         timeoutMs: input.timeoutMs,
+        provider: agent.provider,
     });
     // ADR-149 iter 7 — fallback chain on retryable failures (429, 5xx,
     // timeout). When the cost-optimal neural backend picked a specific

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

@@ -126,8 +126,19 @@ async function embedTaskSafe(task) {
  */
 async function determineAgentModel(agentType, config, task) {
     // 1. Explicit model in config
-    if (config.model && ['haiku', 'sonnet', 'opus', 'opus-4.7', 'inherit'].includes(config.model)) {
-        return { model: config.model, routedBy: 'explicit' };
+    if (config.model) {
+        const explicitModel = config.model;
+        if (['haiku', 'sonnet', 'opus', 'opus-4.7', 'inherit'].includes(explicitModel)) {
+            return { model: explicitModel, routedBy: 'explicit' };
+        }
+        // #2962 — a non-alias model string (e.g. an Ollama tag like
+        // 'qwen3.6:27b', or any other provider-native model id) is still an
+        // explicit user selection. Route it through the modelId fast-path
+        // (executeAgentTask already prefers agent.modelId over
+        // MODEL_MAP[agent.model] — ADR-149 iter 13) instead of falling through
+        // to task-based routing / agent-type defaults, which silently
+        // substituted 'sonnet' and discarded the user's request.
+        return { model: 'sonnet', routedBy: 'explicit', modelId: explicitModel };
     }
     // 2. Enhanced task-based routing with deterministic Tier-1 codemods
     if (task) {
@@ -248,6 +259,15 @@ export const agentTools = [
             const task = input.task || config.task || undefined;
             // Determine model using ADR-026 3-tier routing logic
             const routingResult = await determineAgentModel(agentType, config, task);
+            // #2962 — an explicit, unambiguous provider choice in config wins over
+            // the router's own pick. 'anthropic' is deliberately excluded: the CLI's
+            // `agent spawn` action always sets config.provider (defaulting to
+            // 'anthropic' when --provider isn't passed — commands/agent.ts), so
+            // 'anthropic' here is indistinguishable from that silent default.
+            // 'ollama'/'openrouter' are never silently defaulted and are unambiguous.
+            const explicitConfigProvider = config.provider === 'ollama' || config.provider === 'openrouter'
+                ? config.provider
+                : undefined;
             const agent = {
                 agentId,
                 agentType,
@@ -260,7 +280,9 @@ export const agentTools = [
                 model: routingResult.model,
                 modelRoutedBy: routingResult.routedBy,
                 ...(routingResult.modelId ? { modelId: routingResult.modelId } : {}),
-                ...(routingResult.provider ? { provider: routingResult.provider } : {}),
+                ...(explicitConfigProvider
+                    ? { provider: explicitConfigProvider }
+                    : routingResult.provider ? { provider: routingResult.provider } : {}),
                 ...(routingResult.openrouterModel ? { openrouterModel: routingResult.openrouterModel } : {}),
             };
             store.agents[agentId] = agent;
@@ -331,7 +353,11 @@ export const agentTools = [
                 model: agent.model,
                 modelRoutedBy: routingResult.routedBy,
                 ...(routingResult.modelId ? { modelId: routingResult.modelId } : {}),
-                ...(routingResult.provider ? { provider: routingResult.provider } : {}),
+                // #2962 — mirror the same precedence used for the stored agent
+                // record, so the response a caller sees matches what was actually
+                // persisted (previously this always reported the router's own
+                // pick, silently dropping an explicit config.provider override).
+                ...(agent.provider ? { provider: agent.provider } : {}),
                 ...(routingResult.openrouterModel ? { openrouterModel: routingResult.openrouterModel } : {}),
                 status: 'registered',
                 createdAt: agent.createdAt,

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.8",
   "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",