@claude-flow/cli 3.32.20 → 3.32.21

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

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.32.20",
+    "version": "3.32.21",
     "files": {
       "auto-memory-hook.mjs": "e3e1033b24704992ddef6b31c7fa9dd7fcd9e1af7935dd77ef73402b916b31e6",
       "hook-handler.cjs": "f87ec28684bfc5fd0a54c46bd2a53a3fb037defe71d0ea4b8a5cb88a2cd87a3f",
@@ -8,6 +8,6 @@
       "statusline.cjs": "10f74a1aa9af217d0623c0a9839d82825b0eed31a4707a7531a85c6116869a6c"
     }
   },
-  "signature": "bY9ZP2Fd6NCPqd/ECMOGZ1yhiR2yIlRP/anY6HcLPuIKFiR1upJK07TUWQUMS7Eac2Ys+CjxCr2KEvkb4iJsDA==",
+  "signature": "/u6cu5Rvxtw6aRDpqL1ZUGcCxrzoRUfDRtDI13Yd8RQres08uHFd1tSWJgDDw+fYYNHvmR/yfJS3Hb9KCccTAQ==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 1,
-  "generatedAt": "2026-07-27T03:15:06.269Z",
-  "gitSha": "353d0663",
+  "generatedAt": "2026-07-27T03:27:12.952Z",
+  "gitSha": "6b6eef90",
   "catalog": {
     "agents": 164,
     "tools": 387,

package/dist/src/commands/embeddings.js

@@ -111,8 +111,16 @@ const searchCommand = {
     action: async (ctx) => {
         const query = ctx.flags.query;
         const namespace = ctx.flags.collection || 'default';
-        const limit = parseInt(ctx.flags.limit || '10', 10);
-        const threshold = parseFloat(ctx.flags.threshold || '0.5');
+        // #2790 fix — `||` on a numeric-0 argument returns the fallback,
+        // so `--threshold 0` was unreachable. `??` preserves an explicit zero.
+        // The flag arrives as a string here (parser produces string for typed
+        // options passed via CLI without type coercion in some paths), so we
+        // check for undefined explicitly rather than falsy.
+        const limit = parseInt(ctx.flags.limit ?? '10', 10);
+        const rawThreshold = ctx.flags.threshold;
+        const threshold = rawThreshold === undefined || rawThreshold === null
+            ? 0.5
+            : parseFloat(String(rawThreshold));
         const dbPath = ctx.flags['db-path'] || '.swarm/memory.db';
         if (!query) {
             output.printError('Query is required');
@@ -1006,7 +1014,12 @@ const neuralCommand = {
     action: async (ctx) => {
         const feature = ctx.flags.feature || 'all';
         const init = ctx.flags.init;
-        const driftThreshold = parseFloat((ctx.flags['drift-threshold'] || ctx.flags.driftThreshold || '0.3'));
+        // #2790 fix — same `0 || fallback` bug: `--drift-threshold 0` was
+        // silently replaced by 0.3. Use nullish coalescing.
+        const rawDriftThreshold = ctx.flags['drift-threshold'] ?? ctx.flags.driftThreshold;
+        const driftThreshold = rawDriftThreshold === undefined || rawDriftThreshold === null
+            ? 0.3
+            : parseFloat(String(rawDriftThreshold));
         const decayRate = parseFloat((ctx.flags['decay-rate'] || ctx.flags.decayRate || '0.01'));
         const consolidationInterval = parseInt((ctx.flags['consolidation-interval'] || ctx.flags.consolidationInterval || '60000'), 10);
         output.writeln();

package/dist/src/commands/hooks.js

@@ -1336,7 +1336,7 @@ const transferFromProjectCommand = {
     ],
     action: async (ctx) => {
         const sourcePath = ctx.flags.source || ctx.args[0];
-        const minConfidence = ctx.flags.minConfidence || 0.7;
+        const minConfidence = ctx.flags.minConfidence ?? 0.7;
         if (!sourcePath) {
             output.printError('Source project path is required. Use --source or -s flag.');
             return { success: false, exitCode: 1 };
@@ -2671,7 +2671,7 @@ const coverageRouteCommand = {
     ],
     action: async (ctx) => {
         const task = ctx.flags.task || ctx.args[0];
-        const threshold = ctx.flags.threshold || 80;
+        const threshold = ctx.flags.threshold ?? 80;
         const useRuvector = !ctx.flags['no-ruvector'];
         if (!task) {
             output.printError('Task description is required. Use --task or -t flag.');
@@ -2891,7 +2891,7 @@ const coverageSuggestCommand = {
     ],
     action: async (ctx) => {
         const targetPath = ctx.flags.path || ctx.args[0];
-        const threshold = ctx.flags.threshold || 80;
+        const threshold = ctx.flags.threshold ?? 80;
         const limit = ctx.flags.limit || 20;
         if (!targetPath) {
             output.printError('Path is required. Use --path or -p flag.');
@@ -3080,7 +3080,7 @@ const coverageGapsCommand = {
         { command: 'claude-flow hooks coverage-gaps --threshold 90', description: 'Stricter threshold' }
     ],
     action: async (ctx) => {
-        const threshold = ctx.flags.threshold || 80;
+        const threshold = ctx.flags.threshold ?? 80;
         const groupByAgent = ctx.flags['group-by-agent'] !== false;
         const criticalOnly = ctx.flags['critical-only'] || false;
         const spinner = output.createSpinner({ text: 'Analyzing project coverage gaps...' });

package/dist/src/commands/memory.js

@@ -369,7 +369,13 @@ const searchCommand = {
         const query = ctx.flags.query || ctx.args[0];
         let namespace = ctx.flags.namespace || 'all';
         const limit = ctx.flags.limit || 10;
-        const threshold = ctx.flags.threshold || 0.3;
+        // #2790 fix — `||` discards an explicit `--threshold 0` (falsy) and
+        // silently uses the fallback; that made `--threshold 0` return
+        // FEWER results than `--threshold 0.01` (non-monotonic). Nullish
+        // coalescing preserves an explicit zero. Fallback aligned with the
+        // option's declared `default: 0.7` (was `0.3` — the two disagreed
+        // and --help advertised a default the code did not honor).
+        const threshold = ctx.flags.threshold ?? 0.7;
         const searchType = ctx.flags.type || 'semantic';
         const buildHnsw = (ctx.flags['build-hnsw'] || ctx.flags.buildHnsw);
         const requestedIntent = ctx.flags.intent || 'mixed';
@@ -430,9 +436,58 @@ const searchCommand = {
         output.writeln();
         // Use direct sql.js search with vector similarity
         try {
-            const { searchEntries, resolveDbPath: _rdbSearch } = await import('../memory/memory-initializer.js');
+            const { searchEntries, listEntries, resolveDbPath: _rdbSearch } = await import('../memory/memory-initializer.js');
             const dbPathSearch = _rdbSearch(ctx.flags.path);
             const useSmart = (ctx.flags.smart || ctx.flags.s);
+            // #2790 fix — keyword mode was declared, echoed, and IGNORED (every
+            // search ran semantic regardless). Wire it here: list entries in
+            // the requested namespace (or all) and substring-match against key
+            // + content. Hybrid unions the keyword hits with the semantic hits
+            // and dedups by key + namespace.
+            let keywordResults = [];
+            if (searchType === 'keyword' || searchType === 'hybrid') {
+                const list = await listEntries({
+                    namespace: namespace === 'all' ? undefined : namespace,
+                    limit: 5000,
+                    includeContent: true,
+                    dbPath: dbPathSearch,
+                });
+                if (list.success) {
+                    const q = query.toLowerCase();
+                    keywordResults = list.entries
+                        .filter((e) => {
+                        const c = e.content ?? '';
+                        return e.key.toLowerCase().includes(q) || c.toLowerCase().includes(q);
+                    })
+                        .map((e) => {
+                        const c = e.content ?? '';
+                        const inKey = e.key.toLowerCase().includes(q);
+                        // Keyword scoring: 1.0 for key hit, 0.7 for content hit
+                        return {
+                            key: e.key,
+                            score: inKey ? 1.0 : 0.7,
+                            namespace: e.namespace,
+                            preview: c.slice(0, 200),
+                        };
+                    })
+                        .sort((a, b) => b.score - a.score)
+                        .slice(0, limit);
+                }
+                if (searchType === 'keyword') {
+                    // Pure-keyword mode returns directly; skip the semantic path entirely.
+                    if (ctx.flags.format === 'json') {
+                        output.printJson({ query, searchType, results: keywordResults, searchTime: '0ms' });
+                        return { success: true, data: keywordResults };
+                    }
+                    output.writeln();
+                    output.printSuccess(`Found ${keywordResults.length} result(s) via keyword substring match`);
+                    for (const r of keywordResults) {
+                        output.writeln(`  ${r.key} (${r.namespace}, score=${r.score.toFixed(2)}) — ${r.preview.slice(0, 80)}${r.preview.length > 80 ? '…' : ''}`);
+                    }
+                    return { success: true, data: keywordResults };
+                }
+                // Hybrid mode: keyword hits will be MERGED after semantic runs below.
+            }
             let results;
             let searchTimeMs;
             let smartStats;
@@ -513,6 +568,22 @@ const searchCommand = {
                 }));
                 searchTimeMs = searchResult.searchTime;
             }
+            // #2790 fix (hybrid mode): union keyword results with semantic
+            // results, dedup by (key, namespace), then take top `limit`.
+            if (searchType === 'hybrid' && keywordResults.length > 0) {
+                const seen = new Set(results.map((r) => `${r.namespace}::${r.key}`));
+                for (const k of keywordResults) {
+                    const id = `${k.namespace}::${k.key}`;
+                    if (!seen.has(id)) {
+                        results.push(k);
+                        seen.add(id);
+                    }
+                }
+                // Rerank by score
+                results.sort((a, b) => b.score - a.score);
+                results = results.slice(0, limit);
+                backendLabel = `${backendLabel} + keyword union (#2790)`;
+            }
             if (ctx.flags.format === 'json') {
                 output.printJson({ query, searchType, results, searchTime: `${searchTimeMs}ms`, ...(smartStats ? { stats: smartStats } : {}) });
                 return { success: true, data: results };

package/package.json

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