claude-flow 3.59.2 → 3.59.4

package/.claude/proven-config.json

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

package/package.json

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

package/v3/@claude-flow/cli/bin/cli.js

@@ -369,11 +369,23 @@ if (isHarness) {
   const { CLI } = await import('../dist/src/index.js');
   const cli = new CLI();
   cli.run()
-    .then(() => {
-      // #1552: Exit cleanly after one-shot commands.
-      // Long-running commands (daemon foreground, mcp, status --watch) never resolve,
-      // so this only fires for normal CLI commands.
-      process.exit(0);
+    .then(async () => {
+      // #1552: one-shot commands can leave the memory ControllerRegistry's
+      // database handles and timers alive. Close them before relying on the
+      // event loop to drain.
+      //
+      // #3226: calling process.exit(0) here used to race that teardown and
+      // intermittently abort on Windows with a libuv UV_HANDLE_CLOSING
+      // assertion *after* the command had printed a successful result. Set
+      // the exit status and let the loop drain instead.
+      if (process.exitCode === undefined) process.exitCode = 0;
+      try {
+        const { shutdownBridge } = await import('../dist/src/memory/memory-bridge.js');
+        if (typeof shutdownBridge === 'function') await shutdownBridge();
+      } catch {
+        // Cleanup is best-effort: it must never turn a successful command into
+        // a failure. Commands that do not use memory simply have nothing to do.
+      }
     })
     .catch((error) => {
       console.error('Fatal error:', error.message);

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

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-21T01:00:21.045Z",
-  "gitSha": "2276232b",
+  "generatedAt": "2026-10-21T02:25:59.482Z",
+  "gitSha": "a4b8162c",
   "catalog": {
     "agents": 176,
     "tools": 432,

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/package.json

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