@claude-flow/cli 3.32.19 → 3.32.21

package/.claude/helpers/.helpers-version

@@ -1 +1 @@
-3.32.18
+3.32.19

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

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.32.19",
+    "version": "3.32.21",
     "files": {
       "auto-memory-hook.mjs": "e3e1033b24704992ddef6b31c7fa9dd7fcd9e1af7935dd77ef73402b916b31e6",
       "hook-handler.cjs": "f87ec28684bfc5fd0a54c46bd2a53a3fb037defe71d0ea4b8a5cb88a2cd87a3f",
@@ -8,6 +8,6 @@
       "statusline.cjs": "10f74a1aa9af217d0623c0a9839d82825b0eed31a4707a7531a85c6116869a6c"
     }
   },
-  "signature": "zNv+zmXpSZI/3JYym+FY2sEhWuFeR7k2L4pKiQGIcjFUQ/hcd3p5VVkqdO1+EsX9/JSDP6TVLIjrW6IqQq1vAg==",
+  "signature": "/u6cu5Rvxtw6aRDpqL1ZUGcCxrzoRUfDRtDI13Yd8RQres08uHFd1tSWJgDDw+fYYNHvmR/yfJS3Hb9KCccTAQ==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 1,
-  "generatedAt": "2026-07-27T03:04:01.949Z",
-  "gitSha": "7e76906f",
+  "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/dist/src/commands/swarm.js

@@ -843,10 +843,68 @@ const coordinateCommand = {
     }
 };
 // Main swarm command
+// #2727 dream-cycle — inter-agent message compressor (IB+VQ-inspired
+// MVP). Advisory tool: takes a message + token budget, returns a
+// compressed variant that preserves must-see spans (code, URLs, paths)
+// and keeps the top-scored sentences by TF-IDF-ish keyword density.
+// v2 wires a real VQ codec once a training pipeline exists.
+const compressMessageCommand = {
+    name: 'compress-message',
+    description: 'Compress an inter-agent message to a token budget (IB+VQ-inspired, dream-cycle #2727)',
+    options: [
+        { name: 'message', short: 'm', type: 'string', description: 'Message text (or use --message-file)' },
+        { name: 'message-file', type: 'string', description: 'Path to a file whose contents will be compressed' },
+        { name: 'budget-tokens', short: 'b', type: 'number', default: 200, description: 'Target token budget (approximate, ~4 chars per token)' },
+        { name: 'mode', type: 'string', choices: ['keyword', 'sentence', 'hybrid'], default: 'hybrid', description: 'Scoring mode' },
+    ],
+    examples: [
+        { command: 'claude-flow swarm compress-message -m "…" --budget-tokens 100', description: 'Compress inline message to 100 tokens' },
+        { command: 'claude-flow swarm compress-message --message-file ./msg.md -b 300 --format json', description: 'JSON for pipelines' },
+    ],
+    action: async (ctx) => {
+        const inlineMsg = ctx.flags.message;
+        const msgFile = ctx.flags.messageFile;
+        const budgetTokens = ctx.flags.budgetTokens || 200;
+        const mode = ctx.flags.mode || 'hybrid';
+        let message = inlineMsg ?? '';
+        if (msgFile) {
+            try {
+                const fsMod = await import('node:fs');
+                const pathMod = await import('node:path');
+                message = fsMod.readFileSync(pathMod.resolve(msgFile), 'utf-8');
+            }
+            catch (err) {
+                output.printError(`Failed to read ${msgFile}: ${err instanceof Error ? err.message : String(err)}`);
+                return { success: false, exitCode: 1 };
+            }
+        }
+        if (!message) {
+            output.printError('No message provided. Use --message "..." or --message-file <path>.');
+            return { success: false, exitCode: 1 };
+        }
+        const { compressMessage } = await import('../swarm/message-compressor.js');
+        const result = compressMessage(message, { budgetTokens, mode: mode });
+        if (ctx.flags.format === 'json') {
+            output.printJson(result);
+            return { success: true, data: result };
+        }
+        output.writeln();
+        output.printBox(`Original: ${result.stats.originalTokens} tokens · Compressed: ${result.stats.compressedTokens} tokens\n` +
+            `Ratio: ${(result.stats.compressionRatio * 100).toFixed(1)}%\n` +
+            `Sentences kept: ${result.stats.sentencesKept}/${result.stats.sentencesTotal} · Preserved spans: ${result.stats.preservedSpans}\n` +
+            `Info retained (top-quartile): ${(result.stats.infoRetainedEstimate * 100).toFixed(1)}%`, 'Message Compressor (#2727 IB+VQ MVP)');
+        output.writeln();
+        output.writeln(output.bold('Compressed message'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.writeln(result.compressed);
+        output.writeln(output.dim('─'.repeat(60)));
+        return { success: true, data: result };
+    },
+};
 export const swarmCommand = {
     name: 'swarm',
     description: 'Swarm coordination commands',
-    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand],
+    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand, compressMessageCommand],
     options: [],
     examples: [
         { command: 'claude-flow swarm init --v3-mode', description: 'Initialize V3 swarm' },

package/dist/src/swarm/message-compressor.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Inter-agent message compressor (#2727 dream-cycle, IB+VQ inspired).
+ *
+ * Dream-cycle #2727 (IB+VQ messaging 181.8% task gain): variable-
+ * bandwidth compression at the inter-agent message boundary breaks the
+ * performance/bandwidth tradeoff. Real VQ needs a codebook trained on
+ * actual agent-to-agent traffic (own PR, own dataset). This v1 MVP
+ * delivers the SPIRIT of the finding with a deterministic pipeline:
+ *
+ *   1. Extract structured "must-preserve" spans (code fences, inline
+ *      code, URLs, file paths, tool-call directives) — never compress
+ *      those; they're load-bearing.
+ *   2. Score sentences by keyword density (TF-IDF against a domain
+ *      stop-list) and keep the top-K sentences that fit `budgetTokens`.
+ *   3. Reassemble: preserved spans in original order + top scored
+ *      sentences.
+ *
+ * v2 wires a real VQ codec once the training pipeline lands.
+ *
+ * SCOPE: advisory tool + library. Callers decide whether to use the
+ * compressed form. No auto-wire into SendMessage / hooks in v1.
+ */
+/** Result of a compression pass. */
+export interface CompressionResult {
+    original: string;
+    compressed: string;
+    stats: {
+        originalTokens: number;
+        compressedTokens: number;
+        compressionRatio: number;
+        preservedSpans: number;
+        sentencesKept: number;
+        sentencesTotal: number;
+        /** Rough info-retention proxy: fraction of top-quartile-scored sentences kept. */
+        infoRetainedEstimate: number;
+    };
+}
+export interface CompressOptions {
+    /**
+     * Target token budget. The compressor keeps preserved spans first
+     * (they're mandatory) and then fills the remaining budget with the
+     * highest-scored sentences. Approximate — actual output may exceed
+     * budget by up to one sentence if a preserved span is very large.
+     */
+    budgetTokens?: number;
+    /**
+     * Mode:
+     *   'keyword'  → sentence score = sum(TF-IDF-approx) of unique keywords
+     *   'sentence' → sentence score = length + position penalty (favor lead)
+     *   'hybrid'   → 0.7·keyword + 0.3·sentence (default)
+     */
+    mode?: 'keyword' | 'sentence' | 'hybrid';
+}
+/** ~1 token per 4 chars — matches the OpenAI/Anthropic rule-of-thumb. */
+export declare function estimateTokens(text: string): number;
+export declare function compressMessage(message: string, options?: CompressOptions): CompressionResult;
+//# sourceMappingURL=message-compressor.d.ts.map

package/package.json

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