claude-flow 3.54.1 → 3.55.0

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

@@ -193,6 +193,7 @@ export class WorkerDaemon extends EventEmitter {
                 ?? fileConfig.aiWorkersEnabled
                 ?? (process.env.RUFLO_DAEMON_AI_WORKERS === '1'),
             workers: config?.workers ?? DEFAULT_WORKERS,
+            enabledWorkers: config?.enabledWorkers,
         };
         // #2935 — deferred from readDaemonConfigFromFile(): this.config (and
         // therefore this.config.logDir) doesn't exist until the assignment
@@ -700,6 +701,17 @@ export class WorkerDaemon extends EventEmitter {
                 // Ignore parse errors, start fresh
             }
         }
+        // #3547 (#1968 follow-up): an explicit `--workers` selection wins over
+        // both DEFAULT_WORKERS and whatever daemon-state.json just restored
+        // above — otherwise `daemon start --workers map,audit` always ran the
+        // full default set (or a stale saved selection) because nothing ever
+        // applied the requested list to `enabled`.
+        if (this.config.enabledWorkers) {
+            const selected = new Set(this.config.enabledWorkers);
+            for (const workerConfig of this.config.workers) {
+                workerConfig.enabled = selected.has(workerConfig.type);
+            }
+        }
         // Initialize any missing workers
         for (const workerConfig of this.config.workers) {
             if (!this.workers.has(workerConfig.type)) {

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

@@ -233,8 +233,9 @@ export class WorkerQueue extends EventEmitter {
         // Check queues in priority order
         for (const workerType of workerTypes) {
             const queueName = this.getQueueName(workerType);
-            const taskId = this.store.popFromQueue(queueName);
-            if (taskId) {
+            let taskId;
+            // Cancelled or otherwise stale entries do not exhaust this worker type.
+            while ((taskId = this.store.popFromQueue(queueName)) !== null) {
                 const task = this.store.getTask(taskId);
                 if (task && task.status === 'pending') {
                     task.status = 'processing';
@@ -258,6 +259,10 @@ export class WorkerQueue extends EventEmitter {
             this.emit('warning', { message: `Task ${taskId} not found for completion` });
             return;
         }
+        // Late or duplicate outcomes must not rewrite a settled task.
+        if (['completed', 'failed', 'timeout', 'cancelled'].includes(task.status)) {
+            return;
+        }
         task.status = 'completed';
         task.completedAt = new Date();
         task.result = result;
@@ -276,6 +281,10 @@ export class WorkerQueue extends EventEmitter {
             this.emit('warning', { message: `Task ${taskId} not found for failure` });
             return;
         }
+        // Late or duplicate outcomes must not rewrite a settled task.
+        if (['completed', 'failed', 'timeout', 'cancelled'].includes(task.status)) {
+            return;
+        }
         this.processingTasks.delete(taskId);
         // Check if we should retry
         if (retryable && task.retryCount < task.maxRetries) {

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.54.1",
+  "version": "3.55.0",
   "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",
@@ -100,11 +100,11 @@
   "dependencies": {
     "@claude-flow/cli-core": "3.7.0",
     "@claude-flow/codex": "3.0.3",
-    "@claude-flow/mcp": "3.0.0",
+    "@claude-flow/mcp": "3.1.0",
     "@claude-flow/neural": "3.0.0",
-    "@claude-flow/plugin-agent-federation": "1.0.0",
-    "@claude-flow/security": "3.0.1",
-    "@claude-flow/shared": "3.0.1",
+    "@claude-flow/plugin-agent-federation": "1.0.1",
+    "@claude-flow/security": "3.0.2",
+    "@claude-flow/shared": "3.0.2",
     "@iarna/toml": "^2.2.5",
     "@noble/ed25519": "2.3.0",
     "@ruvector/rabitq-wasm": "0.1.0",
@@ -125,11 +125,11 @@
     "ws": "^8.21.0",
     "yaml": "^2.8.0",
     "zod": "^3.22.0",
-    "@claude-flow/memory": "3.0.0"
+    "@claude-flow/memory": "3.0.1"
   },
   "optionalDependencies": {
     "@agntcy/slim-bindings": "2.0.0-alpha.5",
-    "@claude-flow/memory": "3.0.0",
+    "@claude-flow/memory": "3.0.1",
     "@metaharness/darwin": "~0.10.2",
     "@metaharness/flywheel": "~0.1.10",
     "@metaharness/radio": "~0.1.0",

package/v3/@claude-flow/shared/dist/events/event-store-pagination.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-store-pagination.test.d.ts.map

package/v3/@claude-flow/shared/dist/events/event-store-pagination.test.js

@@ -0,0 +1,32 @@
+import { beforeEach, afterEach, describe, it, expect } from 'vitest';
+import { EventStore } from './event-store.js';
+import { createAgentSpawnedEvent } from './domain-events.js';
+describe('SQLite event query pagination', () => {
+    let store;
+    beforeEach(async () => {
+        store = new EventStore({
+            databasePath: ':memory:',
+            autoPersistInterval: 0,
+        });
+        await store.initialize();
+        for (let i = 0; i < 3; i++) {
+            const event = createAgentSpawnedEvent(`agent-${i}`, 'coder', 'core', []);
+            event.timestamp = 100 + i;
+            await store.append(event);
+        }
+    });
+    afterEach(async () => {
+        await store.shutdown();
+    });
+    it('supports offsets without a caller-specified limit', async () => {
+        expect((await store.query({ offset: 1 })).map((event) => event.aggregateId)).toEqual(['agent-1', 'agent-2']);
+    });
+    it('returns no rows for an explicit zero limit', async () => {
+        expect(await store.query({ limit: 0 })).toEqual([]);
+        expect(await store.query({ limit: 0, offset: 1 })).toEqual([]);
+    });
+    it('retains bounded page ordering', async () => {
+        expect((await store.query({ limit: 1, offset: 1 })).map((event) => event.aggregateId)).toEqual(['agent-1']);
+    });
+});
+//# sourceMappingURL=event-store-pagination.test.js.map

package/v3/@claude-flow/shared/dist/events/event-store.js

@@ -225,11 +225,15 @@ export class EventStore extends EventEmitter {
         // Order by timestamp
         sql += ' ORDER BY timestamp ASC';
         // Pagination
-        if (filter.limit) {
+        if (filter.limit !== undefined) {
             sql += ' LIMIT ?';
             params.push(filter.limit);
         }
-        if (filter.offset) {
+        else if (filter.offset !== undefined) {
+            // SQLite requires LIMIT before OFFSET; -1 means no upper bound.
+            sql += ' LIMIT -1';
+        }
+        if (filter.offset !== undefined) {
             sql += ' OFFSET ?';
             params.push(filter.offset);
         }

package/v3/@claude-flow/shared/dist/mcp/connection-pool.js

@@ -119,9 +119,12 @@ export class ConnectionPool extends EventEmitter {
     /**
      * Create a new connection
      */
-    async createConnection() {
+    async createConnection(reserved = false) {
         const id = `conn-${++this.connectionCounter}-${Date.now()}`;
         const connection = new ManagedConnection(id, this.transportType);
+        // Reserve before exposing it in the map or yielding to another acquirer.
+        if (reserved)
+            connection.state = 'busy';
         this.connections.set(id, connection);
         this.stats.totalCreated++;
         this.emit('pool:connection:created', { connectionId: id });
@@ -149,7 +152,7 @@ export class ConnectionPool extends EventEmitter {
         }
         // Create new connection if under limit
         if (this.connections.size < this.config.maxConnections) {
-            const connection = await this.createConnection();
+            const connection = await this.createConnection(true);
             connection.acquire();
             this.stats.totalAcquired++;
             this.recordAcquireTime(startTime);

package/v3/@claude-flow/shared/dist/resilience/bulkhead-sync-throw.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bulkhead-sync-throw.test.d.ts.map

package/v3/@claude-flow/shared/dist/resilience/bulkhead-sync-throw.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { Bulkhead } from './bulkhead.js';
+describe('queued bulkhead failures', () => {
+    it('rejects the throwing task and preserves the previous result and remaining capacity', async () => {
+        const bulkhead = new Bulkhead({
+            name: 'test',
+            maxConcurrent: 1,
+            maxQueue: 2,
+            queueTimeout: 100,
+        });
+        let release;
+        const first = bulkhead.execute(() => new Promise((resolve) => {
+            release = resolve;
+        }));
+        const failure = new Error('synchronous callback failure');
+        const second = bulkhead.execute(() => {
+            throw failure;
+        });
+        const secondResult = second.catch((error) => error);
+        const third = bulkhead.execute(async () => 'third');
+        release('first');
+        await expect(first).resolves.toBe('first');
+        expect(await secondResult).toBe(failure);
+        await expect(third).resolves.toBe('third');
+        await Promise.resolve();
+        expect(bulkhead.getStats()).toMatchObject({
+            active: 0,
+            queued: 0,
+            completed: 2,
+        });
+    });
+});
+//# sourceMappingURL=bulkhead-sync-throw.test.js.map

package/v3/@claude-flow/shared/dist/resilience/bulkhead.js

@@ -158,7 +158,8 @@ export class Bulkhead extends EventEmitter {
         // Execute the queued function
         this.active++;
         this.emit('acquire');
-        item.fn()
+        Promise.resolve()
+            .then(() => item.fn())
             .then((result) => {
             this.completed++;
             item.resolve(result);

package/v3/@claude-flow/shared/dist/resilience/retry-timeout-cleanup.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=retry-timeout-cleanup.test.d.ts.map

package/v3/@claude-flow/shared/dist/resilience/retry-timeout-cleanup.test.js

@@ -0,0 +1,38 @@
+import { afterEach, describe, it, expect, vi } from 'vitest';
+import { retry } from './retry.js';
+afterEach(() => vi.useRealTimers());
+describe('retry timeout lifetime', () => {
+    it('does not keep a success timer alive after an attempt settles', async () => {
+        vi.useFakeTimers();
+        const result = await retry(async () => 42, {
+            maxAttempts: 1,
+            timeout: 30000,
+        });
+        expect(result.success).toBe(true);
+        expect(result.result).toBe(42);
+        expect(vi.getTimerCount()).toBe(0);
+    });
+    it('releases timers for rejected attempts without suppressing their errors', async () => {
+        vi.useFakeTimers();
+        const err = new Error('no');
+        const result = await retry(async () => {
+            throw err;
+        }, { maxAttempts: 1 });
+        expect(result.success).toBe(false);
+        expect(result.errors).toEqual([err]);
+        expect(vi.getTimerCount()).toBe(0);
+    });
+    it('still bounds a pending operation and reports the timeout', async () => {
+        vi.useFakeTimers();
+        const promise = retry(() => new Promise(() => { }), {
+            maxAttempts: 1,
+            timeout: 10,
+        });
+        await vi.advanceTimersByTimeAsync(10);
+        const result = await promise;
+        expect(result.success).toBe(false);
+        expect(result.errors[0].message).toContain('timed out');
+        expect(vi.getTimerCount()).toBe(0);
+    });
+});
+//# sourceMappingURL=retry-timeout-cleanup.test.js.map

package/v3/@claude-flow/shared/dist/resilience/retry.js

@@ -117,12 +117,19 @@ export function withRetry(fn, options = {}) {
  * Execute with timeout
  */
 async function withTimeout(promise, timeout, attempt) {
+    let timer;
     const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
+        timer = setTimeout(() => {
             reject(new Error(`Attempt ${attempt} timed out after ${timeout}ms`));
         }, timeout);
     });
-    return Promise.race([promise, timeoutPromise]);
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
 }
 /**
  * Sleep for specified milliseconds

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/shared",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "type": "module",
   "description": "Shared module - common types, events, utilities, core interfaces",
   "main": "dist/index.js",