claude-flow 3.7.0-alpha.62 → 3.7.0-alpha.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.62",
+  "version": "3.7.0-alpha.63",
   "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/memory-tools.js

@@ -917,16 +917,16 @@ export const memoryTools = [
                 const claudeEntries = await listEntries({ namespace: 'claude-memories' });
                 claudeMemoryEntries = claudeEntries?.total
                     ?? claudeEntries?.entries?.length ?? 0;
-                // Per-namespace counts for the namespaces the reporter referenced
-                // (#1940). Best-effort — a namespace with 0 entries is omitted.
-                for (const ns of ['default', 'patterns', 'claude-memories', 'auto-memory', 'tasks', 'feedback', 'pretrain']) {
-                    try {
-                        const r = await listEntries({ namespace: ns });
-                        const t = r?.total ?? r?.entries?.length ?? 0;
-                        if (t > 0)
-                            namespaceCounts[ns] = t;
+                // #2037 + #1940: per-namespace counts via dynamic enumeration
+                // from the already-fetched `allEntries`. The old hardcoded
+                // 7-namespace whitelist silently dropped custom namespaces
+                // (team prefixes, plugin namespaces, etc.) from the bridge
+                // status — exactly the bug #2037 reported on the sibling
+                // memory_search_unified tool.
+                for (const e of allEntries?.entries ?? []) {
+                    if (typeof e.namespace === 'string' && e.namespace.length > 0) {
+                        namespaceCounts[e.namespace] = (namespaceCounts[e.namespace] ?? 0) + 1;
                     }
-                    catch { /* skip per-namespace failure */ }
                 }
             }
             catch { /* ignore */ }
@@ -952,31 +952,71 @@ export const memoryTools = [
     },
     {
         name: 'memory_search_unified',
-        description: 'Search across both Claude Code memories and AgentDB entries using semantic vector similarity. Returns merged, deduplicated results from all namespaces. Use when native Read/Write is wrong because you need (a) cross-session retrieval by semantic similarity (vector embeddings) not by file path, (b) namespacing across projects without managing directory layout, or (c) the .swarm/memory.db audit trail. For one-shot file I/O, native Read/Write is fine.',
+        description: 'Search across Claude Code memories and AgentDB entries using semantic vector similarity. By default DYNAMICALLY ENUMERATES all namespaces in the store via listEntries — no longer hardcoded — so custom namespaces (e.g. team/project-prefixed) are included. Use `namespace` to filter to one, or `namespaces` to target an explicit set. Returns merged, deduplicated results sorted by score. Native Read/Write is fine for one-shot file I/O; use this when you need (a) cross-session retrieval by semantic similarity, (b) cross-namespace search without managing the namespace list, or (c) the .swarm/memory.db audit trail.',
         category: 'memory',
         inputSchema: {
             type: 'object',
             properties: {
                 query: { type: 'string', description: 'Search query (natural language)' },
                 limit: { type: 'number', description: 'Max results (default: 10)' },
-                namespace: { type: 'string', description: 'Filter to namespace (omit for all)' },
+                namespace: { type: 'string', description: 'Filter to a single namespace. Omit for all.' },
+                namespaces: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Explicit list of namespaces to search. Overrides the auto-enumeration. Use when you know exactly which namespaces are relevant (e.g. team prefixes). Ignored when `namespace` is set.',
+                },
             },
             required: ['query'],
         },
         handler: async (input) => {
             await ensureInitialized();
-            const { searchEntries } = await getMemoryFunctions();
+            const { searchEntries, listEntries } = await getMemoryFunctions();
             validateMemoryInput(undefined, undefined, input.query);
             const query = input.query;
             const limit = input.limit ?? 10;
             const ns = input.namespace;
+            const explicitNamespaces = Array.isArray(input.namespaces) ? input.namespaces : undefined;
             if (ns) {
                 const vNs = validateIdentifier(ns, 'namespace');
                 if (!vNs.valid)
                     return { success: false, query, results: [], total: 0, error: vNs.error };
             }
-            // Search all namespaces unless filtered
-            const namespaces = ns ? [ns] : ['default', 'claude-memories', 'auto-memory', 'patterns', 'tasks', 'feedback'];
+            if (explicitNamespaces) {
+                for (const n of explicitNamespaces) {
+                    const v = validateIdentifier(n, 'namespace');
+                    if (!v.valid)
+                        return { success: false, query, results: [], total: 0, error: v.error };
+                }
+            }
+            // #2037: enumerate namespaces dynamically. Resolution order:
+            //   1. `namespace` (single string) → that one only
+            //   2. `namespaces` (explicit array) → that list
+            //   3. Auto-discover every namespace present in the store via
+            //      listEntries — replaces the old hardcoded 6-namespace
+            //      whitelist that silently dropped custom namespaces.
+            let namespaces;
+            if (ns) {
+                namespaces = [ns];
+            }
+            else if (explicitNamespaces && explicitNamespaces.length > 0) {
+                namespaces = explicitNamespaces;
+            }
+            else {
+                try {
+                    const all = await listEntries({ limit: 100000 });
+                    const seen = new Set();
+                    for (const e of all.entries ?? []) {
+                        if (typeof e.namespace === 'string' && e.namespace.length > 0)
+                            seen.add(e.namespace);
+                    }
+                    namespaces = seen.size > 0 ? Array.from(seen).sort() : ['default'];
+                }
+                catch {
+                    // Listing failed (store empty or backend hiccup) — fall back
+                    // to 'default' so the tool always returns something coherent.
+                    namespaces = ['default'];
+                }
+            }
             const allResults = [];
             for (const searchNs of namespaces) {
                 try {
@@ -988,12 +1028,14 @@ export const memoryTools = [
                                 content: (entry.content || entry.value || '').toString().slice(0, 200),
                                 score: entry.score || 0,
                                 namespace: searchNs,
-                                source: searchNs === 'claude-memories' ? 'claude-code' : searchNs === 'auto-memory' ? 'auto-memory' : 'agentdb',
+                                source: searchNs === 'claude-memories' ? 'claude-code'
+                                    : searchNs === 'auto-memory' ? 'auto-memory'
+                                        : 'agentdb',
                             });
                         }
                     }
                 }
-                catch { /* namespace may not exist */ }
+                catch { /* namespace search failure — keep going */ }
             }
             // Sort by score, deduplicate by key, take top N
             allResults.sort((a, b) => b.score - a.score);

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.62",
+  "version": "3.7.0-alpha.63",
   "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",