claude-flow 3.32.18 → 3.32.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.32.18",
+  "version": "3.32.20",
   "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/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 1,
-  "generatedAt": "2026-07-27T02:55:18.250Z",
-  "gitSha": "684ca3bf",
+  "generatedAt": "2026-07-27T03:15:06.269Z",
+  "gitSha": "353d0663",
   "catalog": {
     "agents": 164,
     "tools": 387,

package/v3/@claude-flow/cli/dist/src/commands/memory.js

@@ -1632,6 +1632,64 @@ const initMemoryCommand = {
         }
     }
 };
+// #2763 dream-cycle — OAS memory-operator selector. Standalone
+// subcommand that returns the highest-value consolidation operator
+// that fits the given budget for the given entry count. Advisory —
+// the caller decides whether to invoke that operator.
+const selectOperatorCommand = {
+    name: 'select-operator',
+    description: 'Pick the highest-value consolidation operator that fits a budget (OAS, dream-cycle #2763)',
+    options: [
+        { name: 'budget', short: 'b', type: 'number', required: true, description: 'Budget in abstract operator points (1 point ≈ 1 Haiku call)' },
+        { name: 'entries', short: 'e', type: 'number', required: true, description: 'Number of entries to consolidate' },
+        { name: 'hint', type: 'string', choices: ['duplicates', 'verbose', 'patterns', 'general'], default: 'general', description: 'Entry-shape hint' },
+    ],
+    examples: [
+        { command: 'claude-flow memory select-operator -b 50 -e 200', description: 'Pick operator for 200 entries within 50 points' },
+        { command: 'claude-flow memory select-operator -b 5 -e 100 --hint duplicates --format json', description: 'JSON for pipelines' },
+    ],
+    action: async (ctx) => {
+        const budget = ctx.flags.budget;
+        const entries = ctx.flags.entries;
+        const hint = ctx.flags.hint || 'general';
+        if (budget === undefined || entries === undefined) {
+            output.printError('Both --budget and --entries are required.');
+            return { success: false, exitCode: 1 };
+        }
+        if (budget < 0 || entries < 0) {
+            output.printError('Budget and entries must be non-negative.');
+            return { success: false, exitCode: 1 };
+        }
+        const { selectOperator, OPERATORS } = await import('../memory/oas-operator-selector.js');
+        const selection = selectOperator({ budget, entries, hint: hint });
+        if (ctx.flags.format === 'json') {
+            output.printJson(selection);
+            return { success: true, data: selection };
+        }
+        const chosen = OPERATORS[selection.operator];
+        output.writeln();
+        output.printBox(`Budget: ${budget} points · Entries: ${entries}\n` +
+            `Operator: ${selection.operator}\n` +
+            `Description: ${chosen.description}\n` +
+            `Estimated cost: ${selection.estimatedCost.toFixed(2)} points\n` +
+            `Needs split: ${selection.needsSplit ? `YES — batch size ${selection.suggestedBatchSize}` : 'no'}`, 'OAS Operator Selection (#2763)');
+        output.writeln();
+        output.writeln(output.dim(selection.reason));
+        if (selection.considered.length > 0) {
+            output.writeln();
+            output.writeln(output.bold('All operators considered'));
+            output.printTable({
+                columns: [
+                    { key: 'id', header: 'Operator', width: 15 },
+                    { key: 'cost', header: 'Est. Cost', width: 12, align: 'right', format: (v) => Number(v).toFixed(2) },
+                    { key: 'fits', header: 'Fits Budget', width: 12, align: 'center', format: (v) => v ? '✓' : '—' },
+                ],
+                data: selection.considered,
+            });
+        }
+        return { success: true, data: selection };
+    },
+};
 // #2760 dream-cycle — SCM query classifier. Standalone subcommand so
 // users can inspect what intent a query maps to and pipe the mapped
 // namespaces into other tools (e.g. `memory search --namespace ...`).
@@ -1673,7 +1731,7 @@ const classifyCommand = {
 export const memoryCommand = {
     name: 'memory',
     description: 'Memory management commands',
-    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, purgeCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, distillCommand, backupCommand, classifyCommand],
+    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, purgeCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, distillCommand, backupCommand, classifyCommand, selectOperatorCommand],
     options: [],
     examples: [
         { command: 'claude-flow memory store -k "key" -v "value"', description: 'Store data' },

package/v3/@claude-flow/cli/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/v3/@claude-flow/cli/dist/src/memory/oas-operator-selector.d.ts

@@ -0,0 +1,74 @@
+/**
+ * OAS (Operator-Aware Selection) memory-consolidation operator picker
+ * (#2763 dream-cycle).
+ *
+ * Findings from the OAS paper referenced in dream-cycle #2763: memory-
+ * consolidation performance improves by +48% when the caller picks the
+ * RIGHT operator for the current budget + workload, instead of always
+ * applying the most-expensive one. Ruflo already has multiple
+ * consolidation operators (merge / summarize / compress / distill),
+ * but has no cost-aware selector — every `memory consolidate` call
+ * uses the same path.
+ *
+ * v1 MVP: rule-based selector. Cost-per-entry estimates are informed
+ * by ruflo's own measured performance targets in v3/@claude-flow/cli/
+ * CLAUDE.md — no external benchmark call needed. v2 will refine costs
+ * from routing-outcomes trajectories.
+ */
+/** The four consolidation operators ruflo can apply. */
+export type OperatorId = 'merge' | 'summarize' | 'compress' | 'distill';
+export interface OperatorSpec {
+    id: OperatorId;
+    /** Estimated cost per entry, in abstract "operator points" (1 point ≈ 1 Haiku call). */
+    costPerEntry: number;
+    /** Maximum recommended entry count per invocation (higher counts split). */
+    maxEntries: number;
+    /** What the operator does — human-readable. */
+    description: string;
+    /** Best when the entry set has this shape. */
+    bestWhen: string;
+}
+export declare const OPERATORS: Record<OperatorId, OperatorSpec>;
+export interface OperatorSelection {
+    operator: OperatorId;
+    reason: string;
+    /** Estimated cost = costPerEntry × min(entries, maxEntries). */
+    estimatedCost: number;
+    /** True if entries > operator.maxEntries and caller should split into multiple invocations. */
+    needsSplit: boolean;
+    suggestedBatchSize: number;
+    /** All operators considered, in ranked order (best first). */
+    considered: Array<{
+        id: OperatorId;
+        cost: number;
+        fits: boolean;
+    }>;
+}
+export interface SelectOptions {
+    /** Budget in abstract operator points. */
+    budget: number;
+    /** Number of entries to consolidate. */
+    entries: number;
+    /**
+     * Optional hint about entry shape:
+     *   'duplicates' → strongly prefer merge (cheap wins first)
+     *   'verbose'    → prefer summarize
+     *   'patterns'   → prefer distill (small, high-signal)
+     *   'general'    → let cost-fit decide (default)
+     */
+    hint?: 'duplicates' | 'verbose' | 'patterns' | 'general';
+}
+/**
+ * Select the highest-value operator that fits the budget.
+ *
+ * Selection rule (v1):
+ *   1. If a hint is provided AND the hinted operator fits the budget,
+ *      pick it (hint is a strong signal about entry shape).
+ *   2. Else, rank operators by cost ascending; pick the most expensive
+ *      operator that still fits budget × 1.0 (no over-spend). Idea:
+ *      spend the whole budget on the most-fidelity operator we can afford.
+ *   3. If nothing fits, return merge (guaranteed cheapest) with
+ *      needsSplit=true so caller batches.
+ */
+export declare function selectOperator(opts: SelectOptions): OperatorSelection;
+//# sourceMappingURL=oas-operator-selector.d.ts.map

package/v3/@claude-flow/cli/dist/src/memory/oas-operator-selector.js

@@ -0,0 +1,117 @@
+/**
+ * OAS (Operator-Aware Selection) memory-consolidation operator picker
+ * (#2763 dream-cycle).
+ *
+ * Findings from the OAS paper referenced in dream-cycle #2763: memory-
+ * consolidation performance improves by +48% when the caller picks the
+ * RIGHT operator for the current budget + workload, instead of always
+ * applying the most-expensive one. Ruflo already has multiple
+ * consolidation operators (merge / summarize / compress / distill),
+ * but has no cost-aware selector — every `memory consolidate` call
+ * uses the same path.
+ *
+ * v1 MVP: rule-based selector. Cost-per-entry estimates are informed
+ * by ruflo's own measured performance targets in v3/@claude-flow/cli/
+ * CLAUDE.md — no external benchmark call needed. v2 will refine costs
+ * from routing-outcomes trajectories.
+ */
+export const OPERATORS = {
+    merge: {
+        id: 'merge',
+        costPerEntry: 0.02, // near-free — deterministic near-duplicate merge
+        maxEntries: 5000,
+        description: 'Near-duplicate merge (deterministic, cosine ≥ 0.95)',
+        bestWhen: 'Many near-identical entries (e.g. duplicated command traces)',
+    },
+    summarize: {
+        id: 'summarize',
+        costPerEntry: 0.5, // one Haiku call per ~2 entries
+        maxEntries: 500,
+        description: 'Short-to-long consolidation via Haiku (1 call per ~2 entries)',
+        bestWhen: 'Verbose logs / trajectory steps that share a theme',
+    },
+    compress: {
+        id: 'compress',
+        costPerEntry: 1.5, // LoRA-style compression pass — heavier
+        maxEntries: 200,
+        description: 'LoRA/EWC-style compression preserving semantic embeddings',
+        bestWhen: 'High-fidelity pattern preservation across many entries',
+    },
+    distill: {
+        id: 'distill',
+        costPerEntry: 3, // full distillation — heaviest
+        maxEntries: 100,
+        description: 'Full pattern distillation (extracts high-value patterns for ReasoningBank)',
+        bestWhen: 'Extracting durable learnings from a small high-signal set',
+    },
+};
+/**
+ * Select the highest-value operator that fits the budget.
+ *
+ * Selection rule (v1):
+ *   1. If a hint is provided AND the hinted operator fits the budget,
+ *      pick it (hint is a strong signal about entry shape).
+ *   2. Else, rank operators by cost ascending; pick the most expensive
+ *      operator that still fits budget × 1.0 (no over-spend). Idea:
+ *      spend the whole budget on the most-fidelity operator we can afford.
+ *   3. If nothing fits, return merge (guaranteed cheapest) with
+ *      needsSplit=true so caller batches.
+ */
+export function selectOperator(opts) {
+    const { budget, entries, hint } = opts;
+    const considered = Object.keys(OPERATORS).map((id) => {
+        const spec = OPERATORS[id];
+        const effectiveEntries = Math.min(entries, spec.maxEntries);
+        const cost = spec.costPerEntry * effectiveEntries;
+        return { id, cost, fits: cost <= budget };
+    }).sort((a, b) => a.cost - b.cost);
+    // Rule 1: honor a shape hint if the hinted operator fits.
+    const hintMap = {
+        duplicates: 'merge',
+        verbose: 'summarize',
+        patterns: 'distill',
+        general: 'compress',
+    };
+    if (hint && hint !== 'general') {
+        const preferred = hintMap[hint];
+        const match = considered.find((c) => c.id === preferred);
+        if (match?.fits) {
+            const spec = OPERATORS[match.id];
+            return {
+                operator: match.id,
+                reason: `Hint "${hint}" → ${match.id} (cost ${match.cost.toFixed(2)} ≤ budget ${budget})`,
+                estimatedCost: match.cost,
+                needsSplit: entries > spec.maxEntries,
+                suggestedBatchSize: spec.maxEntries,
+                considered,
+            };
+        }
+    }
+    // Rule 2: pick the most-expensive operator that still fits.
+    const fitting = considered.filter((c) => c.fits);
+    if (fitting.length > 0) {
+        const best = fitting[fitting.length - 1]; // most expensive fitting
+        const spec = OPERATORS[best.id];
+        return {
+            operator: best.id,
+            reason: `Best-fit within budget: ${best.id} at cost ${best.cost.toFixed(2)} (budget ${budget}, entries ${entries})`,
+            estimatedCost: best.cost,
+            needsSplit: entries > spec.maxEntries,
+            suggestedBatchSize: spec.maxEntries,
+            considered,
+        };
+    }
+    // Rule 3: budget too small for any operator on the full entry set.
+    // Split via merge (cheapest) with the merge batch size.
+    const mergeSpec = OPERATORS.merge;
+    const batchSize = Math.max(1, Math.floor(budget / mergeSpec.costPerEntry));
+    return {
+        operator: 'merge',
+        reason: `Budget ${budget} too small for any operator across ${entries} entries — split via merge in batches of ${batchSize}`,
+        estimatedCost: budget,
+        needsSplit: true,
+        suggestedBatchSize: batchSize,
+        considered,
+    };
+}
+//# sourceMappingURL=oas-operator-selector.js.map

package/v3/@claude-flow/cli/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/v3/@claude-flow/cli/package.json

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