claude-flow 3.54.0 → 3.55.0

package/v3/@claude-flow/cli/dist/src/services/policy-ledger-anchor.js

@@ -0,0 +1,163 @@
+/**
+ * Second, hash-chained copy of the policy ledger anchor (#3602, ADR-475).
+ *
+ * The primary anchor (`ledgerLength` / `ledgerHead`) lives inside state.json,
+ * the same file it protects, so deleting it together with receipts used to
+ * make `verify` bless the truncated chain. This module keeps an append-only
+ * chain of anchor entries in a SEPARATE file plus a mirror of the newest entry
+ * outside the project directory (~/.config/ruflo/policy-trust/<project>/).
+ *
+ * Threat model: this detects any tampering confined to state.json, and any
+ * tampering confined to the project directory. It does NOT stop an attacker
+ * who can rewrite both the project directory and the user's home directory.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { userInfo } from 'node:os';
+const LOG_FILE = 'ledger-anchors.json';
+const MIRROR_FILE = 'ledger-anchor-head.json';
+export const anchorLogPath = (projectRoot) => join(resolve(projectRoot), '.claude-flow', 'policy', LOG_FILE);
+function mirrorPath(projectRoot) {
+    const id = createHash('sha256').update(realpathSync(projectRoot)).digest('hex');
+    return join(userInfo().homedir, '.config', 'ruflo', 'policy-trust', id, MIRROR_FILE);
+}
+function entryHash(entry) {
+    return createHash('sha256').update(JSON.stringify([
+        entry.seq, entry.length, entry.headHash, entry.prevAnchorHash, entry.ts, entry.event, entry.by ?? null,
+    ])).digest('hex');
+}
+function validEntry(value, seq, prev) {
+    const e = value;
+    return !!e && typeof e === 'object'
+        && e.seq === seq
+        && Number.isInteger(e.length) && e.length >= 0
+        && (e.headHash === null || typeof e.headHash === 'string')
+        && e.prevAnchorHash === prev
+        && typeof e.ts === 'number'
+        && ['append', 'migrated-from-state', 'establish-anchor'].includes(e.event)
+        && typeof e.hash === 'string'
+        && e.hash === entryHash({ ...e, hash: undefined });
+}
+function readLog(projectRoot) {
+    const file = anchorLogPath(projectRoot);
+    if (!existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (parsed.version !== 1 || !Array.isArray(parsed.entries))
+            return 'corrupt';
+        let prev = null;
+        for (let i = 0; i < parsed.entries.length; i++) {
+            if (!validEntry(parsed.entries[i], i, prev))
+                return 'corrupt';
+            prev = parsed.entries[i].hash;
+        }
+        return parsed.entries;
+    }
+    catch {
+        return 'corrupt';
+    }
+}
+function readMirror(projectRoot) {
+    const file = mirrorPath(projectRoot);
+    if (!existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        return typeof parsed?.hash === 'string' && parsed.hash === entryHash({ ...parsed, hash: undefined })
+            ? parsed
+            : 'corrupt';
+    }
+    catch {
+        return 'corrupt';
+    }
+}
+/**
+ * How the stored anchors relate to `state`; read-only. `rebuild` is the
+ * explicit-establish path: an unreadable log or mirror is treated as absent, but
+ * whatever readable anchor remains must still agree with the chain, so it can
+ * never bless a truncation the anchors still remember.
+ */
+export function assessAnchors(projectRoot, state, rebuild = false) {
+    let entries = readLog(projectRoot);
+    if (entries === 'corrupt') {
+        if (!rebuild)
+            return { kind: 'fail', error: 'policy-anchor-log-corrupt' };
+        entries = [];
+    }
+    let mirror = readMirror(projectRoot);
+    if (mirror === 'corrupt') {
+        if (!rebuild)
+            return { kind: 'fail', error: 'policy-anchor-mirror-corrupt' };
+        mirror = null;
+    }
+    if (entries.length === 0) {
+        if (!mirror)
+            return { kind: 'absent' };
+        if (!rebuild)
+            return { kind: 'fail', error: 'policy-anchor-log-missing' };
+        if (state.receipts.length < mirror.length)
+            return { kind: 'fail', error: 'policy-ledger-truncated' };
+        if (mirror.length > 0 && state.receipts[mirror.length - 1].hash !== mirror.headHash) {
+            return { kind: 'fail', error: 'policy-ledger-anchor-mismatch' };
+        }
+        return { kind: 'absent' };
+    }
+    if (mirror && !entries.some((entry) => entry.hash === mirror.hash)) {
+        return { kind: 'fail', error: 'policy-anchor-log-rolled-back' };
+    }
+    const last = entries[entries.length - 1];
+    for (const anchor of mirror ? [last, mirror] : [last]) {
+        if (state.receipts.length < anchor.length)
+            return { kind: 'fail', error: 'policy-ledger-truncated' };
+        if (anchor.length > 0 && state.receipts[anchor.length - 1].hash !== anchor.headHash) {
+            return { kind: 'fail', error: 'policy-ledger-anchor-mismatch' };
+        }
+    }
+    return { kind: 'ok', last, behind: state.receipts.length > last.length };
+}
+/**
+ * Append an entry for the current state if the newest entry does not already
+ * describe it. Must run under the policy lock. Throws if the log is corrupt:
+ * only an explicit establish may replace a corrupt log.
+ */
+export async function recordAnchor(projectRoot, state, write, event = 'append', by) {
+    if (state.receipts.length === 0)
+        return;
+    const loaded = readLog(projectRoot);
+    const entries = loaded === 'corrupt' ? [] : loaded;
+    if (loaded === 'corrupt' && event !== 'establish-anchor')
+        throw new Error('policy-anchor-log-corrupt');
+    const last = entries[entries.length - 1];
+    const length = state.receipts.length;
+    const headHash = state.receipts[length - 1].hash;
+    let tip = last;
+    if (!last || last.length !== length || last.headHash !== headHash) {
+        const base = {
+            seq: entries.length,
+            length,
+            headHash,
+            prevAnchorHash: last?.hash ?? null,
+            ts: Date.now(),
+            event,
+            ...(by ? { by } : {}),
+        };
+        tip = { ...base, hash: entryHash(base) };
+        await write(anchorLogPath(projectRoot), { version: 1, entries: [...entries, tip] });
+    }
+    try {
+        const mirror = mirrorPath(projectRoot);
+        mkdirSync(dirname(mirror), { recursive: true, mode: 0o700 });
+        await write(mirror, tip);
+    }
+    catch (error) {
+        // A read-only home must not stop the ledger; verify reports the weaker
+        // posture (no mirror) rather than failing closed on every decision.
+        process.stderr.write(`[policy] anchor mirror not written: ${error.message}\n`);
+    }
+}
+export function anchorPosture(projectRoot) {
+    return { log: existsSync(anchorLogPath(projectRoot)), mirror: existsSync(mirrorPath(projectRoot)) };
+}
+//# sourceMappingURL=policy-ledger-anchor.js.map

package/v3/@claude-flow/cli/dist/src/services/policy-runtime.d.ts

@@ -22,13 +22,19 @@ export declare function issuePolicyApproval(approval: Omit<PolicyApproval, 'uses
     issuedAt?: number;
 }, projectRoot?: string, approvalIssuerVerifier?: (issuer: string) => boolean): Promise<PolicyApproval>;
 export declare function revokePolicyApproval(id: string, projectRoot?: string): Promise<boolean>;
+export type PolicyLedgerVerification = ReturnType<AgenticPolicyEngine['verifyLedger']> & {
+    /** How the second anchor was brought in line during this call. */
+    secondaryAnchor?: 'recorded-from-state' | 'restored-primary' | 'established-explicitly';
+};
 /**
- * Read-only verification (#3568). It must not run inside
- * `withPolicyTransaction`, whose own post-operation check throws a generic
- * `policy-ledger-verification-failed` and hides which check failed. The only
- * write is persisting an anchor established for a pre-anchor ledger.
+ * Verification (#3568, #3602). It must not run inside `withPolicyTransaction`,
+ * whose own post-operation check throws a generic
+ * `policy-ledger-verification-failed` and hides which check failed. It writes
+ * only to bring the second anchor in line, or on an explicit `establishAnchor`.
  */
-export declare function verifyPolicyLedger(projectRoot?: string): Promise<ReturnType<AgenticPolicyEngine['verifyLedger']>>;
+export declare function verifyPolicyLedger(projectRoot?: string, options?: {
+    establishAnchor?: boolean;
+}): Promise<PolicyLedgerVerification>;
 export declare function authorizeMcpTool(toolName: string, input: Record<string, unknown>, context?: Record<string, unknown>, attributes?: Readonly<{
     actionType?: string;
     network?: boolean;

package/v3/@claude-flow/cli/dist/src/services/policy-runtime.js

@@ -5,6 +5,7 @@ import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync,
 import { dirname, join, resolve } from 'node:path';
 import { hostname, userInfo } from 'node:os';
 import { syncPolicyProjection } from '../mods/policy-projection.js';
+import { assessAnchors, recordAnchor } from './policy-ledger-anchor.js';
 const POLICY_DIR = join('.claude-flow', 'policy');
 const POLICY_FILE = 'state.json';
 const LOCK_FILE = 'state.lock';
@@ -231,8 +232,11 @@ function verifyStateAnchor(projectRoot, state) {
         throw new Error('policy-state-authentication-failed');
     }
 }
-async function writePolicyState(projectRoot, statePath, state) {
+async function writePolicyState(projectRoot, statePath, state, anchorEvent = 'append', by) {
     await writePolicyStateFiles(projectRoot, statePath, state);
+    // #3602: the second anchor is written after the state, so a crash leaves the
+    // state AHEAD of the log (caught up on the next write), never behind it.
+    await recordAnchor(projectRoot, state, writeJsonAtomic, anchorEvent, by);
     // ADR-404: the ruflo mod reads Claude Code tool rules from a small
     // projection, never from state.json. Written only after the state and its
     // anchor are safely down; a failure here never fails the state write. A
@@ -350,20 +354,26 @@ export async function withPolicyTransaction(projectRoot, operation, options = {}
     mkdirSync(target.dir, { recursive: true, mode: 0o700 });
     const release = await acquireLock(target.lock);
     try {
-        const engine = AgenticPolicyEngine.fromState(loadPolicyState(projectRoot), {
+        const loaded = loadPolicyState(projectRoot);
+        const engine = AgenticPolicyEngine.fromState(loaded, {
             signingKey: process.env.CLAUDE_FLOW_POLICY_SIGNING_KEY,
             keyId: process.env.CLAUDE_FLOW_POLICY_KEY_ID,
             evidenceVerifier: verifyPolicyEvidence,
             approvalIssuerVerifier: options.approvalIssuerVerifier,
         });
+        // #3602: refuse to operate on a ledger whose anchors are missing or
+        // disagree; a restored primary anchor is persisted by the write below.
+        const gate = reconcileLedger(projectRoot, engine, {});
+        if (!gate.result.valid) {
+            throw new Error(gate.result.error === 'anchor-missing'
+                ? `policy-ledger-anchor-missing: receipts exist but no ledger anchor was found. If this ledger predates anchors, run \`ruflo policy verify --establish-anchor\`; otherwise treat it as tampering.`
+                : gate.result.error ?? 'policy-ledger-verification-failed');
+        }
         const result = await operation(engine);
-        // Verify before exporting: verification establishes the ledger anchor
-        // (#3568) on state written before the anchor existed, and that anchor
-        // must be part of what is persisted.
         if (!engine.verifyLedger().valid)
             throw new Error('policy-ledger-verification-failed');
         const nextState = engine.exportState();
-        await writePolicyState(projectRoot, target.state, nextState);
+        await writePolicyState(projectRoot, target.state, nextState, gate.event);
         return result;
     }
     finally {
@@ -416,12 +426,56 @@ export async function revokePolicyApproval(id, projectRoot = process.cwd()) {
     return withPolicyTransaction(projectRoot, (engine) => engine.revokeApproval(id));
 }
 /**
- * Read-only verification (#3568). It must not run inside
- * `withPolicyTransaction`, whose own post-operation check throws a generic
- * `policy-ledger-verification-failed` and hides which check failed. The only
- * write is persisting an anchor established for a pre-anchor ledger.
+ * Decide whether the ledger may be trusted, using the chain, the primary anchor
+ * in state.json and the second anchor (#3602). It never creates an anchor over
+ * existing receipts on its own: only an authentic second anchor (restoring a
+ * deleted primary) or an explicit `establishAnchor` does.
+ */
+function reconcileLedger(projectRoot, engine, options) {
+    const state = engine.exportState();
+    const length = state.receipts.length;
+    const primary = typeof state.ledgerLength === 'number';
+    const base = engine.verifyLedger();
+    const fail = (error) => ({ result: { valid: false, length, error }, persist: false });
+    if (!base.valid && base.error !== 'anchor-missing')
+        return { result: base, persist: false };
+    const assessed = assessAnchors(projectRoot, state, options.establishAnchor === true);
+    if (assessed.kind === 'fail')
+        return fail(assessed.error);
+    if (primary) {
+        if (assessed.kind === 'absent' && length > 0) {
+            return options.establishAnchor
+                ? { result: { ...base, secondaryAnchor: 'established-explicitly' }, persist: true, event: 'establish-anchor' }
+                : { result: { ...base, secondaryAnchor: 'recorded-from-state' }, persist: true, event: 'migrated-from-state' };
+        }
+        return { result: base, persist: assessed.kind === 'ok' && assessed.behind, event: 'append' };
+    }
+    // No primary anchor.
+    if (length === 0)
+        return { result: { valid: true, length, state: 'empty' }, persist: false };
+    if (assessed.kind === 'ok') {
+        // The second anchor is authentic and agrees with the chain: the deleted
+        // primary can be restored from it. Truncation was already rejected above.
+        engine.verifyLedger({ establishAnchor: true });
+        return { result: { valid: true, length, secondaryAnchor: 'restored-primary' }, persist: true, event: 'append' };
+    }
+    if (options.establishAnchor) {
+        const established = engine.verifyLedger({ establishAnchor: true });
+        return {
+            result: { ...established, secondaryAnchor: 'established-explicitly' },
+            persist: true,
+            event: 'establish-anchor',
+        };
+    }
+    return fail('anchor-missing');
+}
+/**
+ * Verification (#3568, #3602). It must not run inside `withPolicyTransaction`,
+ * whose own post-operation check throws a generic
+ * `policy-ledger-verification-failed` and hides which check failed. It writes
+ * only to bring the second anchor in line, or on an explicit `establishAnchor`.
  */
-export async function verifyPolicyLedger(projectRoot = process.cwd()) {
+export async function verifyPolicyLedger(projectRoot = process.cwd(), options = {}) {
     const target = paths(projectRoot);
     mkdirSync(target.dir, { recursive: true, mode: 0o700 });
     const release = await acquireLock(target.lock);
@@ -430,11 +484,12 @@ export async function verifyPolicyLedger(projectRoot = process.cwd()) {
             signingKey: process.env.CLAUDE_FLOW_POLICY_SIGNING_KEY,
             keyId: process.env.CLAUDE_FLOW_POLICY_KEY_ID,
         });
-        const result = engine.verifyLedger();
-        if (result.anchor === 'established-now') {
-            await writePolicyState(projectRoot, target.state, engine.exportState());
+        const outcome = reconcileLedger(projectRoot, engine, options);
+        if (outcome.persist) {
+            const by = outcome.event === 'establish-anchor' ? userInfo().username : undefined;
+            await writePolicyState(projectRoot, target.state, engine.exportState(), outcome.event, by);
         }
-        return result;
+        return outcome.result;
     }
     finally {
         release();

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

@@ -67,6 +67,7 @@ export interface DaemonConfig {
     idleShutdownMs: number;
     aiWorkersEnabled: boolean;
     workers: WorkerConfig[];
+    enabledWorkers?: string[];
 }
 /**
  * Worker Daemon - Manages background workers with Node.js

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.d.ts

@@ -103,6 +103,7 @@ export declare class WorkerQueue extends EventEmitter {
     private workerId;
     private heartbeatTimer?;
     private processingTasks;
+    private retryTimers;
     private isShuttingDown;
     private maxConcurrent;
     private initialized;

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

@@ -162,6 +162,7 @@ export class WorkerQueue extends EventEmitter {
     workerId;
     heartbeatTimer;
     processingTasks = new Set();
+    retryTimers = new Set();
     isShuttingDown = false;
     maxConcurrent = 1;
     initialized = false;
@@ -232,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';
@@ -257,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;
@@ -275,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) {
@@ -286,10 +296,13 @@ export class WorkerQueue extends EventEmitter {
             this.store.setTask(taskId, task);
             // Re-queue with delay (exponential backoff)
             const delay = Math.min(30000, 1000 * Math.pow(2, task.retryCount));
-            setTimeout(() => {
+            // Tracked so shutdown() can release it
+            const timer = setTimeout(() => {
+                this.retryTimers.delete(timer);
                 const queueName = this.getQueueName(task.workerType);
                 this.store.pushToQueue(queueName, taskId, PRIORITY_SCORES[task.priority]);
             }, delay);
+            this.retryTimers.add(timer);
             this.emit('taskRetrying', { taskId, retryCount: task.retryCount, delay });
         }
         else {
@@ -469,6 +482,10 @@ export class WorkerQueue extends EventEmitter {
         for (const taskId of this.processingTasks) {
             await this.fail(taskId, 'Worker shutdown', false);
         }
+        // Release scheduled retry timers (they would hold the process open)
+        for (const timer of this.retryTimers)
+            clearTimeout(timer);
+        this.retryTimers.clear();
         // Stop store cleanup
         this.store.stopCleanup();
         await this.unregisterWorker();

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.54.0",
+  "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.0",
+    "@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);
         }
@@ -281,9 +285,12 @@ export class EventStore extends EventEmitter {
     async getSnapshot(aggregateId) {
         this.ensureInitialized();
         const stmt = this.db.prepare('SELECT * FROM snapshots WHERE aggregate_id = ? ORDER BY version DESC LIMIT 1');
-        const row = stmt.getAsObject([aggregateId]);
+        stmt.bind([aggregateId]);
+        // sql.js getAsObject() yields undefined-valued column keys when no row matched,
+        // so step first and treat absence explicitly.
+        const row = stmt.step() ? stmt.getAsObject() : null;
         stmt.free();
-        if (!row || Object.keys(row).length === 0) {
+        if (!row) {
             return null;
         }
         return {

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

@@ -6,6 +6,7 @@
  */
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { EventStore } from './event-store.js';
+import { StateReconstructor, TaskAggregate } from './state-reconstructor.js';
 import { AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection } from './projections.js';
 import { createAgentSpawnedEvent, createAgentStartedEvent, createAgentTaskAssignedEvent, createAgentTaskCompletedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, } from './domain-events.js';
 describe('EventStore', () => {
@@ -157,6 +158,25 @@ describe('EventStore', () => {
             const retrieved = await eventStore.getSnapshot('agent-1');
             expect(retrieved?.version).toBe(10);
         });
+        it('should return null when no snapshot exists for the aggregate', async () => {
+            await expect(eventStore.getSnapshot('missing')).resolves.toBeNull();
+        });
+        it('should return null for an unknown aggregate when other snapshots exist', async () => {
+            await eventStore.saveSnapshot({
+                aggregateId: 'agent-1',
+                aggregateType: 'agent',
+                version: 1,
+                state: {},
+                timestamp: Date.now(),
+            });
+            await expect(eventStore.getSnapshot('other')).resolves.toBeNull();
+        });
+        it('should reconstruct from the event log when no snapshot exists', async () => {
+            await eventStore.append(createTaskCreatedEvent('task-1', 'impl', 'Write code', 'desc', 'normal', []));
+            const reconstructor = new StateReconstructor(eventStore);
+            const task = await reconstructor.reconstruct('task-1', (id) => new TaskAggregate(id));
+            expect(task.version).toBe(1);
+        });
     });
     describe('Statistics', () => {
         it('should provide event store statistics', async () => {

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