@claude-flow/cli 3.54.1 → 3.56.0

package/dist/src/services/memory-backup.d.ts

@@ -20,6 +20,13 @@ export interface BackupResult {
     skipped?: string;
 }
 export declare function defaultMemoryDbPath(cwd?: string): string;
+export interface ProjectBackupResult extends BackupResult {
+    backups: Array<BackupResult & {
+        dbPath: string;
+    }>;
+}
+/** Back up the active project stores; an explicit full-file override stays single-store. */
+export declare function backupProjectMemoryDbs(cwd: string, opts?: Omit<BackupOptions, 'dbPath'>): Promise<ProjectBackupResult>;
 export declare function backupMemoryDb(opts?: BackupOptions): Promise<BackupResult>;
 export interface RestoreResult {
     restored: boolean;

package/dist/src/services/memory-backup.js

@@ -15,9 +15,37 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { readFileMaybeEncrypted } from '../fs-secure.js';
+import { loadBetterSqlite3 } from '../memory/shared-sqlite.js';
+import { resolveMemoryRoot } from '../memory/memory-root.js';
 export function defaultMemoryDbPath(cwd = process.cwd()) {
     return path.join(cwd, '.swarm', 'memory.db');
 }
+/** Back up the active project stores; an explicit full-file override stays single-store. */
+export async function backupProjectMemoryDbs(cwd, opts = {}) {
+    const override = process.env.CLAUDE_FLOW_DB_PATH;
+    let sources;
+    if (override && override.trim().length > 0) {
+        sources = [path.resolve(cwd, override)];
+    }
+    else {
+        const root = resolveMemoryRoot(cwd);
+        sources = [path.join(root, 'memory.db'), path.join(root, 'agentdb-memory.db')];
+    }
+    const backups = [];
+    for (const dbPath of sources) {
+        backups.push({ ...await backupMemoryDb({ ...opts, dbPath }), dbPath });
+    }
+    const successful = backups.filter(result => result.backedUp);
+    const failed = backups.find(result => !result.backedUp && result.skipped !== 'no-db');
+    return {
+        ...successful[0],
+        backedUp: successful.length > 0 && !failed,
+        sizeBytes: successful.reduce((sum, result) => sum + (result.sizeBytes ?? 0), 0),
+        rotatedAway: successful.flatMap(result => result.rotatedAway ?? []),
+        skipped: failed?.skipped ?? (successful.length === 0 ? 'no-db' : undefined),
+        backups,
+    };
+}
 /** ISO timestamp safe for filenames (no ':' or '.'). */
 function fileStamp(ms) {
     return new Date(ms).toISOString().replace(/[:.]/g, '-');
@@ -228,8 +256,7 @@ export async function restoreMemoryDbFromBackup(dbPath, opts = {}) {
     // encrypted snapshots and provides the same checks on WASM-only hosts.
     let Database = null;
     try {
-        const mod = 'better-sqlite3';
-        Database = (await import(mod)).default;
+        Database = await loadBetterSqlite3();
     }
     catch {
         /* use the sql.js verifier */

package/dist/src/services/memory-distillation.js

@@ -27,6 +27,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';
 function emptyReport(dryRun, extra = {}) {
     return {
         processed: 0, episodes: 0, episodeEmbeddings: 0,
@@ -104,8 +105,7 @@ export async function runDistillation(options) {
         return emptyReport(dryRun, { skipped: 'no-db' });
     let Database;
     try {
-        const mod = 'better-sqlite3';
-        Database = (await import(mod)).default;
+        Database = await loadBetterSqlite3();
     }
     catch {
         return emptyReport(dryRun, { skipped: 'better-sqlite3 unavailable' });

package/dist/src/services/policy-ledger-anchor.d.ts

@@ -0,0 +1,42 @@
+import type { PolicyState } from '@claude-flow/security';
+export type AnchorEvent = 'append' | 'migrated-from-state' | 'establish-anchor';
+export interface AnchorEntry {
+    seq: number;
+    length: number;
+    headHash: string | null;
+    prevAnchorHash: string | null;
+    ts: number;
+    event: AnchorEvent;
+    by?: string;
+    hash: string;
+}
+export type AnchorAssessment = {
+    kind: 'absent';
+} | {
+    kind: 'ok';
+    last: AnchorEntry;
+    behind: boolean;
+} | {
+    kind: 'fail';
+    error: string;
+};
+export type AnchorWriter = (file: string, value: unknown) => Promise<void>;
+export declare const anchorLogPath: (projectRoot: string) => string;
+/**
+ * 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 declare function assessAnchors(projectRoot: string, state: PolicyState, rebuild?: boolean): AnchorAssessment;
+/**
+ * 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 declare function recordAnchor(projectRoot: string, state: PolicyState, write: AnchorWriter, event?: AnchorEvent, by?: string): Promise<void>;
+export declare function anchorPosture(projectRoot: string): {
+    log: boolean;
+    mirror: boolean;
+};
+//# sourceMappingURL=policy-ledger-anchor.d.ts.map

package/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/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/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/dist/src/services/worker-daemon.d.ts

@@ -67,7 +67,10 @@ export interface DaemonConfig {
     idleShutdownMs: number;
     aiWorkersEnabled: boolean;
     workers: WorkerConfig[];
+    enabledWorkers?: string[];
 }
+/** Parse only worker types the daemon can actually schedule. */
+export declare function parseEnabledWorkers(value: string): WorkerType[];
 /**
  * Worker Daemon - Manages background workers with Node.js
  */
@@ -367,8 +370,8 @@ export declare class WorkerDaemon extends EventEmitter {
      */
     private runConsolidateWorker;
     /**
-     * Nightly memory-DB backup worker (24h interval). Takes a WAL-safe, consistent
-     * snapshot of .swarm/memory.db with rotation (keep last N). Never throws — a
+     * Nightly memory-DB backup worker (24h interval). Takes WAL-safe, consistent
+     * snapshots of the active CLI and AgentDB stores with rotation (keep last N). Never throws — a
      * worker must not crash the daemon; a skip/error is written to the metrics
      * file. Opt-out by omitting `backup` from `-w`; offsite GCS is opt-in via
      * RUFLO_BACKUP_GCS (a gs:// prefix), retention via RUFLO_BACKUP_KEEP.

package/dist/src/services/worker-daemon.js

@@ -24,7 +24,7 @@ import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-exe
 // 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 { backupMemoryDb } from './memory-backup.js';
+import { backupProjectMemoryDbs } from './memory-backup.js';
 import { resolveGitWorkspaceIdentity } from './git-workspace-identity.js';
 import { getWorkspaceLeaseRegistry } from './workspace-lease.js';
 import { getRepoSupervisorRegistry } from './repo-supervisor.js';
@@ -43,6 +43,14 @@ const DEFAULT_WORKERS = [
     { type: 'predict', intervalMs: 10 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Predictive preloading', enabled: false },
     { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
 ];
+/** Parse only worker types the daemon can actually schedule. */
+export function parseEnabledWorkers(value) {
+    const names = value.split(',');
+    if (!names.length || names.some(name => !DEFAULT_WORKERS.some(worker => worker.type === name))) {
+        throw new Error(`--workers must be a comma-separated list of: ${DEFAULT_WORKERS.map(worker => worker.type).join(',')}`);
+    }
+    return [...new Set(names)];
+}
 // Worker timeout — must exceed the longest per-worker headless timeout (15 min for audit/refactor).
 // Previously 5 min, which caused orphan processes when daemon timeout fired before executor timeout (#1117).
 const DEFAULT_WORKER_TIMEOUT_MS = 16 * 60 * 1000;
@@ -192,7 +200,8 @@ export class WorkerDaemon extends EventEmitter {
             aiWorkersEnabled: config?.aiWorkersEnabled
                 ?? fileConfig.aiWorkersEnabled
                 ?? (process.env.RUFLO_DAEMON_AI_WORKERS === '1'),
-            workers: config?.workers ?? DEFAULT_WORKERS,
+            workers: (config?.workers ?? DEFAULT_WORKERS).map(worker => ({ ...worker })),
+            enabledWorkers: config?.enabledWorkers,
         };
         // #2935 — deferred from readDaemonConfigFromFile(): this.config (and
         // therefore this.config.logDir) doesn't exist until the assignment
@@ -700,6 +709,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)) {
@@ -1615,8 +1635,8 @@ export class WorkerDaemon extends EventEmitter {
         return result;
     }
     /**
-     * Nightly memory-DB backup worker (24h interval). Takes a WAL-safe, consistent
-     * snapshot of .swarm/memory.db with rotation (keep last N). Never throws — a
+     * Nightly memory-DB backup worker (24h interval). Takes WAL-safe, consistent
+     * snapshots of the active CLI and AgentDB stores with rotation (keep last N). Never throws — a
      * worker must not crash the daemon; a skip/error is written to the metrics
      * file. Opt-out by omitting `backup` from `-w`; offsite GCS is opt-in via
      * RUFLO_BACKUP_GCS (a gs:// prefix), retention via RUFLO_BACKUP_KEEP.
@@ -1629,14 +1649,14 @@ export class WorkerDaemon extends EventEmitter {
         let result;
         try {
             const keepEnv = Number(process.env.RUFLO_BACKUP_KEEP);
-            const r = await backupMemoryDb({
-                dbPath: defaultMemoryDbPath(this.projectRoot),
+            const r = await backupProjectMemoryDbs(this.projectRoot, {
                 keep: Number.isFinite(keepEnv) && keepEnv > 0 ? keepEnv : 7,
                 gcs: process.env.RUFLO_BACKUP_GCS || undefined,
             });
             result = {
                 timestamp: new Date().toISOString(),
                 backedUp: r.backedUp,
+                backups: r.backups,
                 path: r.path,
                 sizeBytes: r.sizeBytes ?? 0,
                 rotatedAway: r.rotatedAway?.length ?? 0,

package/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/node_modules/@claude-flow/mcp/dist/connection-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection-pool.d.ts","sourceRoot":"","sources":["../src/connection-pool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EAEpB,eAAe,EACf,OAAO,EACP,aAAa,EACd,MAAM,YAAY,CAAC;AAoDpB,qBAAa,cAAe,SAAQ,YAAa,YAAW,eAAe;IAmBvE,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAnBhC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6C;IACzE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IACtD,OAAO,CAAC,aAAa,CAAC,CAAiB;IACvC,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,cAAc,CAAkB;IAExC,OAAO,CAAC,KAAK,CAOX;gBAGA,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,YAAK,EACzB,MAAM,EAAE,OAAO,EACf,aAAa,GAAE,aAA4B;YAQhD,wBAAwB;YAWxB,gBAAgB;IAaxB,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAiC1C,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAuB3C,OAAO,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAoB3C,QAAQ,IAAI,mBAAmB;IAwBzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,oBAAoB;IAwB5B,OAAO,CAAC,iBAAiB;IAMzB,cAAc,IAAI,gBAAgB,EAAE;IAIpC,SAAS,IAAI,OAAO;CAGrB;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,YAAK,EAC1C,MAAM,EAAE,OAAO,EACf,aAAa,GAAE,aAA4B,GAC1C,cAAc,CAEhB"}
+{"version":3,"file":"connection-pool.d.ts","sourceRoot":"","sources":["../src/connection-pool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EAEpB,eAAe,EACf,OAAO,EACP,aAAa,EACd,MAAM,YAAY,CAAC;AAoDpB,qBAAa,cAAe,SAAQ,YAAa,YAAW,eAAe;IAmBvE,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAnBhC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6C;IACzE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IACtD,OAAO,CAAC,aAAa,CAAC,CAAiB;IACvC,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,cAAc,CAAkB;IAExC,OAAO,CAAC,KAAK,CAOX;gBAGA,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,YAAK,EACzB,MAAM,EAAE,OAAO,EACf,aAAa,GAAE,aAA4B;YAQhD,wBAAwB;YAWxB,gBAAgB;IAexB,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAiC1C,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAuB3C,OAAO,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAoB3C,QAAQ,IAAI,mBAAmB;IAwBzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,oBAAoB;IAwB5B,OAAO,CAAC,iBAAiB;IAMzB,cAAc,IAAI,gBAAgB,EAAE;IAIpC,SAAS,IAAI,OAAO;CAGrB;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,YAAK,EAC1C,MAAM,EAAE,OAAO,EACf,aAAa,GAAE,aAA4B,GAC1C,cAAc,CAEhB"}

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

@@ -80,9 +80,12 @@ export class ConnectionPool extends EventEmitter {
             minConnections: this.config.minConnections,
         });
     }
-    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 });
@@ -105,7 +108,7 @@ export class ConnectionPool extends EventEmitter {
             }
         }
         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);