claude-flow 3.59.3 → 3.59.5

package/.claude/proven-config.json

@@ -1,5 +1,5 @@
 {
-  "adoptedAt": 1792547603690,
+  "adoptedAt": 1792556117950,
   "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
   "manifest": {
     "schema": "ruflo.proven-config/v1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.59.3",
+  "version": "3.59.5",
   "workspaces": [
     "v3/@claude-flow/codex",
     "v3/@claude-flow/mcp",

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

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-21T01:53:55.354Z",
-  "gitSha": "eb808c24",
+  "generatedAt": "2026-10-21T04:15:49.428Z",
+  "gitSha": "5f5f5941",
   "catalog": {
     "agents": 176,
     "tools": 432,

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

@@ -27,7 +27,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { output } from '../output.js';
-import { runDistillation, defaultMemoryDbPath, } from '../services/memory-distillation.js';
+import { runDistillationForStores, projectMemoryDbPaths, defaultMemoryDbPath, } from '../services/memory-distillation.js';
 const DEFAULT_CONFIG = {
     dryRun: false,
     batchSize: 200,
@@ -139,7 +139,15 @@ const runCommand = {
                 'Refusing to run the LLM judge against a $0 budget.');
             return { success: false, exitCode: 1 };
         }
-        const dbPath = resolveDbPath(ctx);
+        // An explicit --db remains a single-store operation. Without it, cover
+        // both stores the CLI/MCP surfaces can write (#3446): memory.db and the
+        // native AgentDB sibling. An MCP-only project often has only the latter,
+        // which is why the worker used to skip with "target table ... missing".
+        const explicitDb = typeof ctx.flags.db === 'string' && ctx.flags.db.trim()
+            ? path.resolve(ctx.flags.db)
+            : undefined;
+        const dbPaths = explicitDb ? [explicitDb] : projectMemoryDbPaths(ctx.cwd || process.cwd());
+        const dbPath = explicitDb ?? dbPaths[0];
         output.writeln();
         output.writeln(output.bold('Memory Distillation (ADR-174)'));
         output.writeln(output.dim('─'.repeat(55)));
@@ -148,7 +156,6 @@ const runCommand = {
         const spinner = output.createSpinner({ text: 'Distilling memory_entries...', spinner: 'dots' });
         spinner.start();
         const distillOptions = {
-            dbPath,
             namespaces: config.namespaces,
             batchSize: config.batchSize,
             maxEntries: config.maxEntries,
@@ -158,22 +165,31 @@ const runCommand = {
             sinceRowid: config.sinceRowid,
             verbose: ctx.flags.verbose === true,
         };
-        let report;
+        let outcome;
         try {
-            report = await runDistillation(distillOptions);
+            outcome = await runDistillationForStores(dbPaths, distillOptions);
         }
         catch (error) {
             spinner.fail('Distillation failed');
             output.printError(error instanceof Error ? error.message : String(error));
             return { success: false, exitCode: 1 };
         }
+        const report = outcome.report;
         if (report.skipped) {
             spinner.succeed('Distillation skipped');
             output.writeln(output.warning(`skipped: ${report.skipped}`));
-            return { success: true, data: { dbPath, config, report } };
+            return { success: true, data: { dbPath, dbPaths, stores: outcome.stores, config, report } };
         }
         spinner.succeed(config.dryRun ? 'Dry-run complete' : 'Distillation complete');
         output.writeln();
+        for (const store of outcome.stores) {
+            if (store.report.skipped) {
+                output.writeln(output.warning(`${store.dbPath}: ${store.report.skipped}`));
+            }
+        }
+        if (outcome.stores.length > 1) {
+            output.writeln(output.dim(`Stores covered: ${outcome.stores.length}`));
+        }
         output.printTable({
             columns: [
                 { key: 'metric', header: 'Metric', width: 24 },
@@ -198,7 +214,7 @@ const runCommand = {
             output.writeln(output.bold('By Provenance'));
             output.printList(provenanceEntries.map(([tier, count]) => `${output.highlight(tier)}: ${count}`));
         }
-        return { success: true, data: { dbPath, config, report } };
+        return { success: true, data: { dbPath, dbPaths, stores: outcome.stores, config, report } };
     },
 };
 // ============================================================================

package/v3/@claude-flow/cli/dist/src/mcp-tools/hive-mind-tools.js

@@ -361,6 +361,24 @@ export const hiveMindTools = [
                     description: 'Consensus strategy. Default: raft (anti-drift). Use byzantine for f<n/3 fault tolerance.',
                 },
                 queenId: { type: 'string', description: 'Initial queen agent ID' },
+                maxAgents: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 1000,
+                    default: 15,
+                    description: 'Maximum number of agents the hive may contain (default: 15)',
+                },
+                memoryBackend: {
+                    type: 'string',
+                    enum: ['agentdb', 'sqlite', 'hybrid'],
+                    default: 'hybrid',
+                    description: 'Memory backend requested for this hive (default: hybrid)',
+                },
+                persist: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Persist hive state to .claude-flow/hive-mind/state.json. Set false for an ephemeral init that writes no durable state.',
+                },
                 bootstrapSecret: { type: 'string', description: 'Operator secret (RUFLO_HIVE_BOOTSTRAP_SECRET or .claude-flow/hive-mind/bootstrap.secret). Only needed by remote/HTTP callers; local stdio/CLI callers omit it. See ADR-476.' },
             },
         },
@@ -372,16 +390,32 @@ export const hiveMindTools = [
             if (bootstrapError) {
                 return { success: false, error: bootstrapError };
             }
-            // Local first init materialises the 0600 operator secret so a later
-            // remote/HTTP deployment has something to be told out of band. The
-            // value is never returned.
-            if (classifyCaller(context) === 'local')
-                ensureBootstrapSecret();
+            // Validate the advertised init contract before creating any durable
+            // state (the operator secret is a filesystem write, so it must come
+            // after every input check).
+            if (input.persist !== undefined && typeof input.persist !== 'boolean') {
+                return { success: false, error: 'persist must be a boolean' };
+            }
+            const persist = input.persist !== false;
+            const maxAgents = input.maxAgents === undefined ? 15 : Number(input.maxAgents);
+            if (!Number.isInteger(maxAgents) || maxAgents < 1 || maxAgents > 1000) {
+                return { success: false, error: 'maxAgents must be an integer between 1 and 1000' };
+            }
+            const memoryBackend = input.memoryBackend === undefined ? 'hybrid' : String(input.memoryBackend);
+            if (memoryBackend !== 'agentdb' && memoryBackend !== 'sqlite' && memoryBackend !== 'hybrid') {
+                return { success: false, error: 'memoryBackend must be one of: agentdb, sqlite, hybrid' };
+            }
             if (input.queenId) {
                 const v = validateIdentifier(input.queenId, 'queenId');
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
+            // Local first init materialises the 0600 operator secret so a later
+            // remote/HTTP deployment has something to be told out of band. The
+            // value is never returned. An ephemeral init (persist:false) must not
+            // write it either.
+            if (persist && classifyCaller(context) === 'local')
+                ensureBootstrapSecret();
             const state = loadHiveState();
             const hiveId = `hive-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
             const queenId = input.queenId || `queen-${Date.now()}`;
@@ -389,6 +423,9 @@ export const hiveMindTools = [
             state.initialized = true;
             state.topology = input.topology || 'mesh';
             state.consensusStrategy = requestedConsensus;
+            state.maxAgents = maxAgents;
+            state.memoryBackend = memoryBackend;
+            state.persist = persist;
             state.createdAt = new Date().toISOString();
             state.queen = {
                 agentId: queenId,
@@ -403,7 +440,8 @@ export const hiveMindTools = [
             if (!state.hiveToken) {
                 state.hiveToken = randomBytes(32).toString('hex');
             }
-            saveHiveState(state);
+            if (persist)
+                saveHiveState(state);
             return {
                 success: true,
                 hiveId,
@@ -411,6 +449,7 @@ export const hiveMindTools = [
                 consensus: state.consensusStrategy,
                 queenId,
                 status: 'initialized',
+                persisted: persist,
                 // Deliberately NOT echoing state.hiveToken here (even though this
                 // call is itself now bootstrap-secret-gated): the CLI never reads
                 // it off this response (it uses getHiveTokenForCli()'s direct
@@ -419,9 +458,9 @@ export const hiveMindTools = [
                 config: {
                     topology: state.topology,
                     consensus: state.consensusStrategy,
-                    maxAgents: input.maxAgents || 15,
-                    persist: input.persist !== false,
-                    memoryBackend: input.memoryBackend || 'hybrid',
+                    maxAgents,
+                    persist,
+                    memoryBackend,
                 },
                 createdAt: state.createdAt,
             };
@@ -468,8 +507,10 @@ export const hiveMindTools = [
                 hiveId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
                 status: state.initialized ? 'active' : 'offline',
                 topology: state.topology,
-                // ADR-093 F3: surface the persisted strategy instead of a hardcoded "byzantine".
-                consensus: state.consensusStrategy ?? 'byzantine',
+                // ADR-093 F3: surface the persisted strategy instead of a hardcoded
+                // "byzantine". Init's documented default is raft, so legacy state
+                // without the field must not drift to a different protocol.
+                consensus: state.consensusStrategy ?? 'raft',
                 queen: state.queen ? {
                     id: state.queen.agentId,
                     agentId: state.queen.agentId,
@@ -508,6 +549,8 @@ export const hiveMindTools = [
                 // Additional fields
                 id: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
                 initialized: state.initialized,
+                maxAgents: state.maxAgents ?? 15,
+                memoryBackend: state.memoryBackend ?? 'hybrid',
                 workerCount: state.workers.length,
                 pendingConsensus: state.consensus.pending.length,
                 sharedMemoryKeys: Object.keys(state.sharedMemory).length,

package/v3/@claude-flow/cli/dist/src/services/memory-distillation.d.ts

@@ -37,6 +37,42 @@ export interface DistillReport {
  * Incremental, $0, transactional, provenance-tagged.
  */
 export declare function runDistillation(options: DistillOptions): Promise<DistillReport>;
-/** Where the memory DB lives, for daemon/CLI callers. */
+/**
+ * The two stores the CLI/MCP surface can write:
+ *  - memory.db is the sql.js/CLI store (also used with encryption at rest);
+ *  - agentdb-memory.db is the native AgentDB store the MCP bridge writes to.
+ *
+ * #3446: distillation used to default to memory.db only. In an MCP-only
+ * project that file often has no AgentDB target tables, so the daemon's
+ * consolidate worker skipped every tick while the rows accumulated in the
+ * sibling store. Keep both paths here (same root resolution as backup) so
+ * callers can cover every store without guessing which surface wrote.
+ */
+export declare function projectMemoryDbPaths(cwd?: string): string[];
+/** Where the primary memory DB lives, for callers that still need one path. */
 export declare function defaultMemoryDbPath(cwd?: string): string;
+export interface StoreDistillResult {
+    dbPath: string;
+    report: DistillReport;
+}
+export interface MultiStoreDistillResult {
+    stores: StoreDistillResult[];
+    report: DistillReport;
+}
+/**
+ * Merge per-store reports without hiding a store's outcome. A run over both
+ * stores is only `skipped` when every store skipped; if one store distilled
+ * and the other had no schema/DB, the successful counts remain authoritative
+ * and the per-store skip stays available in `stores`.
+ */
+export declare function aggregateDistillReports(stores: StoreDistillResult[], dryRun?: boolean): DistillReport;
+/**
+ * Run one distillation pass against each provided store.
+ *
+ * `runner` is injectable so callers/tests can exercise the multi-store
+ * orchestration without a native SQLite build; the default is the real
+ * service. A runner failure is converted to a per-store skip so one bad store
+ * cannot prevent the other from being distilled.
+ */
+export declare function runDistillationForStores(dbPaths: string[], options?: Omit<DistillOptions, 'dbPath'>, runner?: (options: DistillOptions) => Promise<DistillReport>): Promise<MultiStoreDistillResult>;
 //# sourceMappingURL=memory-distillation.d.ts.map

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

@@ -28,6 +28,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { distillTrajectoryContent, serialiseDistilled } from '../memory/structured-distill.js';
 import { loadBetterSqlite3 } from '../memory/shared-sqlite.js';
+import { resolveMemoryRoot } from '../memory/memory-root.js';
 function emptyReport(dryRun, extra = {}) {
     return {
         processed: 0, episodes: 0, episodeEmbeddings: 0,
@@ -346,8 +347,87 @@ export async function runDistillation(options) {
     }
     return report;
 }
-/** Where the memory DB lives, for daemon/CLI callers. */
+/**
+ * The two stores the CLI/MCP surface can write:
+ *  - memory.db is the sql.js/CLI store (also used with encryption at rest);
+ *  - agentdb-memory.db is the native AgentDB store the MCP bridge writes to.
+ *
+ * #3446: distillation used to default to memory.db only. In an MCP-only
+ * project that file often has no AgentDB target tables, so the daemon's
+ * consolidate worker skipped every tick while the rows accumulated in the
+ * sibling store. Keep both paths here (same root resolution as backup) so
+ * callers can cover every store without guessing which surface wrote.
+ */
+export function projectMemoryDbPaths(cwd = process.cwd()) {
+    // An explicit project DB pin stays a single-store operation, matching
+    // memory-backup's precedence.
+    const override = process.env.CLAUDE_FLOW_DB_PATH;
+    if (override && override.trim().length > 0)
+        return [path.resolve(cwd, override)];
+    const root = resolveMemoryRoot(cwd);
+    return [path.join(root, 'memory.db'), path.join(root, 'agentdb-memory.db')];
+}
+/** Where the primary memory DB lives, for callers that still need one path. */
 export function defaultMemoryDbPath(cwd = process.cwd()) {
-    return path.join(cwd, '.swarm', 'memory.db');
+    return projectMemoryDbPaths(cwd)[0];
+}
+/**
+ * Merge per-store reports without hiding a store's outcome. A run over both
+ * stores is only `skipped` when every store skipped; if one store distilled
+ * and the other had no schema/DB, the successful counts remain authoritative
+ * and the per-store skip stays available in `stores`.
+ */
+export function aggregateDistillReports(stores, dryRun = false) {
+    const report = emptyReport(dryRun);
+    const skipped = [];
+    for (const { report: part } of stores) {
+        report.processed += part.processed;
+        report.episodes += part.episodes;
+        report.episodeEmbeddings += part.episodeEmbeddings;
+        report.patterns += part.patterns;
+        report.patternEmbeddings += part.patternEmbeddings;
+        report.causalEdges += part.causalEdges;
+        report.promoted += part.promoted;
+        report.spendUsd += part.spendUsd;
+        report.namespaces = [...new Set([...report.namespaces, ...part.namespaces])];
+        for (const [tier, count] of Object.entries(part.byProvenance)) {
+            report.byProvenance[tier] = (report.byProvenance[tier] ?? 0) + count;
+        }
+        if (part.corrupt)
+            report.corrupt = true;
+        if (part.skipped)
+            skipped.push(part.skipped);
+    }
+    if (stores.length > 0 && stores.every(store => store.report.skipped)) {
+        report.skipped = [...new Set(skipped)].join('; ');
+    }
+    return report;
+}
+/**
+ * Run one distillation pass against each provided store.
+ *
+ * `runner` is injectable so callers/tests can exercise the multi-store
+ * orchestration without a native SQLite build; the default is the real
+ * service. A runner failure is converted to a per-store skip so one bad store
+ * cannot prevent the other from being distilled.
+ */
+export async function runDistillationForStores(dbPaths, options = {}, runner = runDistillation) {
+    const stores = [];
+    for (const dbPath of [...new Set(dbPaths.map(p => path.resolve(p)))]) {
+        let report;
+        try {
+            report = await runner({ ...options, dbPath });
+        }
+        catch (error) {
+            report = emptyReport(options.dryRun === true, {
+                skipped: `error: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        stores.push({ dbPath, report });
+    }
+    if (stores.length === 0) {
+        return { stores, report: emptyReport(options.dryRun === true, { skipped: 'no-db' }) };
+    }
+    return { stores, report: aggregateDistillReports(stores, options.dryRun === true) };
 }
 //# sourceMappingURL=memory-distillation.js.map

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -23,7 +23,7 @@ import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-exe
 // service itself is owned/frozen elsewhere (memory-distillation.ts) — it is
 // incremental (rowid cursor), non-destructive, transactional, and
 // quick_check-gated, so it's safe to call unconditionally on every tick.
-import { runDistillation, defaultMemoryDbPath } from './memory-distillation.js';
+import { runDistillationForStores, projectMemoryDbPaths, } from './memory-distillation.js';
 import { backupProjectMemoryDbs } from './memory-backup.js';
 import { resolveGitWorkspaceIdentity } from './git-workspace-identity.js';
 import { getWorkspaceLeaseRegistry } from './workspace-lease.js';
@@ -1614,13 +1614,15 @@ export class WorkerDaemon extends EventEmitter {
             return disabledResult;
         }
         let report;
+        let stores = [];
         try {
-            report = await runDistillation({
-                dbPath: defaultMemoryDbPath(this.projectRoot),
+            const outcome = await runDistillationForStores(projectMemoryDbPaths(this.projectRoot), {
                 maxEntries: CONSOLIDATE_MAX_ENTRIES_PER_TICK,
                 batchSize: CONSOLIDATE_BATCH_SIZE,
                 dedupDistance: CONSOLIDATE_DEDUP_DISTANCE,
             });
+            report = outcome.report;
+            stores = outcome.stores;
         }
         catch (error) {
             // Defensive only — runDistillation() is internally try/catch'd and
@@ -1638,6 +1640,11 @@ export class WorkerDaemon extends EventEmitter {
             writeFileSync(consolidateFile, JSON.stringify(errorResult, null, 2));
             return errorResult;
         }
+        for (const store of stores) {
+            if (store.report.skipped) {
+                this.log('info', `Consolidate worker: ${store.dbPath} skipped (${store.report.skipped})`);
+            }
+        }
         if (report.corrupt) {
             this.log('warn', `Consolidate worker: memory DB reports corruption — ${report.skipped ?? 'skipped'}`);
         }
@@ -1667,6 +1674,12 @@ export class WorkerDaemon extends EventEmitter {
             dryRun: report.dryRun,
             corrupt: report.corrupt ?? false,
             skipped: report.skipped,
+            stores: stores.map(({ dbPath, report: part }) => ({
+                dbPath,
+                processed: part.processed,
+                patterns: part.patterns,
+                skipped: part.skipped,
+            })),
         };
         writeFileSync(consolidateFile, JSON.stringify(result, null, 2));
         return result;

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

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