claude-flow 3.57.0 → 3.57.2

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

@@ -227,15 +227,31 @@ function loadLegacyStore() {
 /**
  * Mark migration as complete
  */
-function markMigrationComplete() {
+function markMigrationComplete(counts) {
     const legacyDir = resolve(LEGACY_MEMORY_DIR);
     if (!existsSync(legacyDir))
         mkdirSync(legacyDir, { recursive: true });
     writeFileSync(resolve(join(LEGACY_MEMORY_DIR, MIGRATION_MARKER)), JSON.stringify({
         migratedAt: new Date().toISOString(),
         version: '3.0.0',
+        ...(counts ?? {}),
     }), 'utf-8');
 }
+/**
+ * Counts recorded by the migration that wrote the marker, or null when no
+ * marker (or an older marker without counts) is present.
+ */
+function readMigrationCounts() {
+    try {
+        const marker = JSON.parse(readFileSync(resolve(join(LEGACY_MEMORY_DIR, MIGRATION_MARKER)), 'utf-8'));
+        return typeof marker?.migrated === 'number' && typeof marker?.total === 'number'
+            ? { migrated: marker.migrated, total: marker.total }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Lazy-load memory initializer functions to avoid circular deps
  */
@@ -391,7 +407,7 @@ async function ensureInitialized(dbPath) {
                         }
                     }
                     console.error(`[MCP Memory] Migrated ${migrated}/${Object.keys(legacyStore.entries).length} entries`);
-                    markMigrationComplete();
+                    markMigrationComplete({ migrated, total: Object.keys(legacyStore.entries).length });
                 }
             }
         }
@@ -636,7 +652,11 @@ export const memoryTools = [
                             });
                             return {
                                 results: r.results.map(e => ({
-                                    id: e.id,
+                                    // #2271: searchEntries() truncates ids to 12 chars ("entry_" +
+                                    // the leading digits of Date.now()), so entries written within
+                                    // ~2.8h share one id and RRF fused them into a single result.
+                                    // SmartRetrieval dedupes on id: give it the (namespace, key) tuple.
+                                    id: JSON.stringify([e.namespace, e.key]),
                                     key: e.key,
                                     content: e.content,
                                     score: e.score,
@@ -966,11 +986,17 @@ export const memoryTools = [
         },
         handler: async (input) => {
             const force = input.force;
-            // Remove migration marker if forcing
+            // Remove the migration marker if forcing. hasLegacyStore() checks the marker
+            // beside the legacy store, so that is the one force must clear (#4194);
+            // the old .swarm marker path is cleared too for compatibility.
             if (force) {
-                const markerPath = getMigrationMarkerPath();
-                if (existsSync(markerPath)) {
-                    unlinkSync(markerPath);
+                for (const markerPath of [
+                    resolve(join(LEGACY_MEMORY_DIR, MIGRATION_MARKER)),
+                    getMigrationMarkerPath(),
+                ]) {
+                    if (existsSync(markerPath)) {
+                        unlinkSync(markerPath);
+                    }
                 }
             }
             // Check for legacy data
@@ -982,12 +1008,35 @@ export const memoryTools = [
                     migrated: 0,
                 };
             }
+            // A marker beside the store means a migration already ran; ensureInitialized
+            // would move nothing, so say so instead of reporting the store's size.
+            if (!hasLegacyStore()) {
+                return {
+                    success: true,
+                    message: 'Legacy store already migrated (marker present); nothing was moved. Pass force: true to re-run.',
+                    migrated: 0,
+                    total: Object.keys(legacyStore.entries).length,
+                };
+            }
             // Run migration via ensureInitialized
             await ensureInitialized();
+            // ensureInitialized swallows errors and records what it moved in the marker.
+            const counts = readMigrationCounts();
+            if (!counts) {
+                return {
+                    success: false,
+                    message: 'Migration did not complete; no entries were recorded as migrated. See the MCP server log.',
+                    migrated: 0,
+                    total: Object.keys(legacyStore.entries).length,
+                };
+            }
             return {
                 success: true,
-                message: 'Migration completed',
-                migrated: Object.keys(legacyStore.entries).length,
+                message: counts.migrated === counts.total
+                    ? 'Migration completed'
+                    : `Migration completed with failures: ${counts.migrated} of ${counts.total} entries migrated`,
+                migrated: counts.migrated,
+                total: counts.total,
                 backend: await describeBackend(),
             };
         },

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

@@ -577,7 +577,8 @@ export const workflowTools = [
             const store = loadWorkflowStore();
             let workflows = Object.values(store.workflows);
             // Apply filters
-            if (input.status) {
+            // 'all' is the CLI's explicit "no filter" value (`workflow list` sends it by default).
+            if (input.status && input.status !== 'all') {
                 workflows = workflows.filter(w => w.status === input.status);
             }
             // Sort by creation date (newest first)

package/v3/@claude-flow/cli/dist/src/memory/graph-edge-writer.d.ts

@@ -30,10 +30,12 @@
  * @module v3/cli/memory/graph-edge-writer
  */
 /**
- * True iff the memory.db bridge at `customDbPath` (or the default location)
- * is currently RFE1-encrypted-at-rest. Callers that receive `null` from
- * getBridgeDb()/insertGraphEdge() can use this to avoid recommending the
- * destructive `memory init` command for this specific, non-corrupt case.
+ * True iff the memory.db bridge at `customDbPath` — or, when omitted, the
+ * path `resolveDbPath()` resolves from the `CLAUDE_FLOW_DB_PATH` env binding
+ * / memory root default (#4291) — is currently RFE1-encrypted-at-rest.
+ * Callers that receive `null` from getBridgeDb()/insertGraphEdge() can use
+ * this to avoid recommending the destructive `memory init` command for this
+ * specific, non-corrupt case.
  */
 export declare function isBridgeDbEncryptedAtRest(customDbPath?: string): boolean;
 /** Test-only: clear the once-per-path warning dedup set. */
@@ -60,6 +62,16 @@ export declare function releaseBridgeDb(dbPath?: string): boolean;
  * #2431 fix: better-sqlite3 + WAL mode replaces sql.js + whole-file
  * writeFileSync. Eliminates the dual-write race that corrupted memory.db
  * when called alongside the memory bridge's better-sqlite3 writer.
+ *
+ * #4291 fix: the file is resolved via `resolveDbPath()` — the project's one
+ * documented path-priority rule (explicit `customDbPath` argument wins, then
+ * the `CLAUDE_FLOW_DB_PATH` env binding, then the plain `memory.db` default
+ * under the memory root) — instead of a local `customDbPath ?? <default>`
+ * expression that silently ignored `CLAUDE_FLOW_DB_PATH`. A caller that
+ * explicitly selected a store via that env var no longer gets answers read
+ * from a different, unselected database file. When the resolved file is
+ * missing (and `createIfMissing` is false) or encrypted at rest, this
+ * refuses (returns null) rather than falling back to any other store.
  */
 export declare function getBridgeDb(customDbPath?: string, opts?: {
     createIfMissing?: boolean;

package/v3/@claude-flow/cli/dist/src/memory/graph-edge-writer.js

@@ -33,7 +33,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as crypto from 'crypto';
 import { execFileSync } from 'child_process';
-import { getMemoryRoot } from './memory-initializer.js';
+import { resolveDbPath } from './memory-initializer.js';
 import { encodeEmbedding } from './embedding-quantization.js';
 import { loadBetterSqlite3 } from './shared-sqlite.js';
 import { isEncryptedBlob } from '../encryption/vault.js';
@@ -125,13 +125,15 @@ function warnRfe1EncryptedOnce(dbPath) {
         'See #2889 (https://github.com/ruvnet/ruflo/issues/2889) for details and recovery options.');
 }
 /**
- * True iff the memory.db bridge at `customDbPath` (or the default location)
- * is currently RFE1-encrypted-at-rest. Callers that receive `null` from
- * getBridgeDb()/insertGraphEdge() can use this to avoid recommending the
- * destructive `memory init` command for this specific, non-corrupt case.
+ * True iff the memory.db bridge at `customDbPath` — or, when omitted, the
+ * path `resolveDbPath()` resolves from the `CLAUDE_FLOW_DB_PATH` env binding
+ * / memory root default (#4291) — is currently RFE1-encrypted-at-rest.
+ * Callers that receive `null` from getBridgeDb()/insertGraphEdge() can use
+ * this to avoid recommending the destructive `memory init` command for this
+ * specific, non-corrupt case.
  */
 export function isBridgeDbEncryptedAtRest(customDbPath) {
-    const dbPath = customDbPath ?? path.join(getMemoryRoot(), 'memory.db');
+    const dbPath = resolveDbPath(customDbPath);
     return fs.existsSync(dbPath) && isRfe1EncryptedAtRest(dbPath);
 }
 /** Test-only: clear the once-per-path warning dedup set. */
@@ -222,9 +224,19 @@ export function releaseBridgeDb(dbPath) {
  * #2431 fix: better-sqlite3 + WAL mode replaces sql.js + whole-file
  * writeFileSync. Eliminates the dual-write race that corrupted memory.db
  * when called alongside the memory bridge's better-sqlite3 writer.
+ *
+ * #4291 fix: the file is resolved via `resolveDbPath()` — the project's one
+ * documented path-priority rule (explicit `customDbPath` argument wins, then
+ * the `CLAUDE_FLOW_DB_PATH` env binding, then the plain `memory.db` default
+ * under the memory root) — instead of a local `customDbPath ?? <default>`
+ * expression that silently ignored `CLAUDE_FLOW_DB_PATH`. A caller that
+ * explicitly selected a store via that env var no longer gets answers read
+ * from a different, unselected database file. When the resolved file is
+ * missing (and `createIfMissing` is false) or encrypted at rest, this
+ * refuses (returns null) rather than falling back to any other store.
  */
 export async function getBridgeDb(customDbPath, opts) {
-    const dbPath = customDbPath ?? path.join(getMemoryRoot(), 'memory.db');
+    const dbPath = resolveDbPath(customDbPath);
     const createIfMissing = opts?.createIfMissing === true;
     if (_db && _dbPath === dbPath) {
         armIdleRelease();

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

@@ -1077,6 +1077,10 @@ export async function recordTrajectory(steps, verdict) {
         }
         bumpStat('trajectoriesRecorded');
         globalStats.lastAdaptation = Date.now();
+        // #4283: the bank's own save is debounced, and the one-shot bins exit as
+        // soon as the command resolves, so write the patterns now. Otherwise
+        // stats.json counts patterns that never reach patterns.json.
+        reasoningBank?.flushToDisk();
         savePersistedStats();
         return true;
     }

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

@@ -2131,15 +2131,19 @@ async function loadLocalEmbeddingChain(verbose = false, startTime = Date.now())
             if (verbose) {
                 console.log('Loading agentic-flow ReasoningBank embedding model...');
             }
+            // #3113: register a callable, like the ruvector branch below —
+            // generateLocalEmbedding() only invokes function models. The bundled
+            // model is all-MiniLM-L6-v2 (384-dim, per agentic-flow's
+            // getEmbeddingDimensions()).
             embeddingModelState = {
                 loaded: true,
-                model: { embed: reasoningBank.computeEmbedding },
+                model: (text) => reasoningBank.computeEmbedding(text),
                 tokenizer: null,
-                dimensions: 768
+                dimensions: 384
             };
             return {
                 success: true,
-                dimensions: 768,
+                dimensions: 384,
                 modelName: 'agentic-flow/reasoningbank',
                 loadTime: Date.now() - startTime
             };
@@ -2272,10 +2276,13 @@ export async function generateLocalEmbedding(text) {
     if (state.model && typeof state.model === 'function') {
         try {
             const output = await state.model(text, { pooling: 'mean', normalize: true });
-            // Handle both @xenova/transformers (output.data) and ruvector (plain array) formats
+            // Handle @xenova/transformers (output.data), ruvector (plain array) and
+            // typed-array (ReasoningBank Float32Array, #3114) formats. DataView is an
+            // ArrayBuffer view without an iterator (Array.from gives []), so exclude it.
             const embedding = output?.data
                 ? Array.from(output.data)
-                : Array.isArray(output) ? output : null;
+                : Array.isArray(output) ? output
+                    : ArrayBuffer.isView(output) && !(output instanceof DataView) ? Array.from(output) : null;
             if (embedding) {
                 return {
                     embedding,