@claude-flow/cli 3.57.0 → 3.57.2

package/.claude/helpers/.helpers-version

@@ -1 +1 @@
-3.57.0
+3.57.1

package/.claude/helpers/helpers.manifest.json

@@ -1,14 +1,14 @@
 {
   "manifest": {
-    "version": "3.57.0",
+    "version": "3.57.2",
     "files": {
       "auto-memory-hook.mjs": "631fac9d518835e2852a406888316bbbddddb49e7ed8e406d2e971f46833df9a",
       "hook-handler.cjs": "bc12b3cae92d5a7c8deef699fa00d0ef07b57625c18dbeac4387f15725b8e09f",
-      "intelligence.cjs": "a95ac9ee2759c340b14f9ff656765bcb05e0cefe2f018116bd26b3ba9987f3e4",
+      "intelligence.cjs": "1d981d6c6a35d70a66450e96458e26169e0cede11523ea246a2c129c197a5b4e",
       "statusline.cjs": "d72417ecb38634011a19f095a30e07b9929e6f97663520172ece9be7491b2eaa",
       "router.cjs": "16648b3c0d73b6681ac2d8d13def6a68286c57f5a11004de5b19a0fa088c833d"
     }
   },
-  "signature": "Ht+AuqnXP25KmeeDXXSoiQCKrwm7upYx89CGQajBLMpPEsiqHY93UUQthma2Jr2hhHZxys+ui0i4ZxvdAGcFBg==",
+  "signature": "1NC9a0vJ78KCh8TIZfhExMq0923sXMkAej7Dxg4hlTqmOBzS1Gn9ex7z1lpkCTOlVafXVVXXMsEa1BSdsvQ7CQ==",
   "algorithm": "ed25519"
 }

package/.claude/helpers/intelligence.cjs

@@ -277,11 +277,9 @@ function sessionGet(key) {
 
 function sessionSet(key, value) {
   try {
-    if (!fs.existsSync(SESSION_DIR)) fs.mkdirSync(SESSION_DIR, { recursive: true });
-    let session = {};
-    if (fs.existsSync(SESSION_FILE)) {
-      session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    }
+    // Session creation belongs to session.cjs; recall may run before SessionStart.
+    if (!fs.existsSync(SESSION_FILE)) return;
+    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
     if (!session.context) session.context = {};
     session.context[key] = value;
     session.updatedAt = new Date().toISOString();

package/README.md

@@ -10,10 +10,11 @@
 [![Star on GitHub](https://img.shields.io/github/stars/ruvnet/claude-flow?style=for-the-badge&logo=github&color=gold)](https://github.com/ruvnet/claude-flow)
 
 <p align="center">
-<a href="data/npm-downloads.latest.json"><img src="docs/assets/readme/badges/downloads.svg?v=mobile-readable-3" width="300" alt="Ecosystem npm downloads: 12.52M over 12 months through October 4, 2026"></a>
+<a href="docs/harness-origins.md"><img src="https://raw.githubusercontent.com/ruvnet/ruflo/e69e4b95aa08d65ea0f7715489bbf8e62a83a0d2/docs/assets/readme/badges/first-commit.svg" width="300" height="76" alt="Claude Flow lineage: first commit June 2, 2025 by rUv; inspect the evidence"></a>
+<a href="data/npm-downloads.latest.json"><img src="https://raw.githubusercontent.com/ruvnet/ruflo/275aff65a198af758923669acff36f03d1f41623/docs/assets/readme/badges/downloads.svg" width="300" height="76" alt="Illustrative download counter starts at 98,000,000 and adds varied amounts each second in a 30 second loop. Verified dataset: 97,022,120 download events."></a>
 <br>
-<a href="https://github.com/ruvnet/claude-flow"><img src="docs/assets/readme/badges/claude.svg?v=mobile-readable-3" width="300" alt="Claude Code"></a>
-<a href="https://www.npmjs.com/package/@claude-flow/codex"><img src="docs/assets/readme/badges/codex.svg?v=mobile-readable-3" width="300" alt="Codex Plugin"></a>
+<a href="https://github.com/ruvnet/claude-flow"><img src="https://raw.githubusercontent.com/ruvnet/ruflo/d1e80400bdefe01d3b13e70395f88fffab76bb18/docs/assets/readme/badges/claude.svg" width="300" height="76" alt="Claude Code plugin"></a>
+<a href="https://www.npmjs.com/package/@claude-flow/codex"><img src="https://raw.githubusercontent.com/ruvnet/ruflo/d1e80400bdefe01d3b13e70395f88fffab76bb18/docs/assets/readme/badges/codex.svg" width="300" height="76" alt="Codex plugin"></a>
 </p>
 
 </div>
@@ -109,6 +110,14 @@ User → Ruflo (CLI/MCP) → Router → Swarm → Agents → Memory → LLM prov
 
 > **New to Ruflo?** You don't need to learn 314 MCP tools or 26 CLI commands. After `init`, just use Claude Code normally — the hooks system automatically routes tasks, learns from successful patterns, and coordinates agents in the background.
 
+### An origin you can inspect
+
+[![Claude Flow to Ruflo: founding idea on June 2, 2025, orchestration source on June 10, and the continuing Ruflo lineage.](docs/assets/readme/harness-origins.svg)](docs/harness-origins.md)
+
+**Built by [Reuven Cohen (rUv)](https://github.com/ruvnet), originally as Claude Flow.** The [first commit, June 2, 2025](https://github.com/ruvnet/ruflo/commit/7c1f9402d70e7af56c01a879073cbac92564dc4e), describes a code orchestration layer for recursive agent cycles: Claude writes, edits, tests and improves. The [June 10 source snapshot](https://github.com/ruvnet/ruflo/tree/dba545f012ea92a2375a26332bbf3797495e93c9) adds orchestration, task scheduling, memory and terminal modules.
+
+A harness is the workbench around the model: it organizes tasks, carries context between steps and helps check results. **This establishes Ruflo's lineage, not a universal first across every Claude Code tool.** [See the illustrated explainer, exact commits and earlier ecosystem context](docs/harness-origins.md).
+
 <details>
 <summary><strong>📖 Background — where the name comes from</strong></summary>
 

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-17T22:34:44.747Z",
-  "gitSha": "e4fb889e",
+  "generatedAt": "2026-10-19T23:34:04.095Z",
+  "gitSha": "7be330bc",
   "catalog": {
     "agents": 176,
     "tools": 423,

package/dist/src/commands/hooks.js

@@ -2333,6 +2333,19 @@ const workerListCommand = {
         }
     }
 };
+// Render the status hooks_worker-dispatch actually returned. Only a status that
+// means work finished may read as "completed" (#4196).
+function dispatchStatusLabel(status) {
+    switch (status) {
+        case 'dispatched': return output.highlight('dispatched (background)');
+        case 'queued': return output.highlight('queued (daemon)');
+        case 'no-daemon': return output.warning('no-daemon (not run)');
+        case 'mcp-only': return output.warning('mcp-only (not queued)');
+        case 'synthetic-completed': return output.warning('recorded (no work executed)');
+        case 'completed': return output.success('completed');
+        default: return output.dim(String(status));
+    }
+}
 const workerDispatchCommand = {
     name: 'dispatch',
     description: 'Dispatch a background worker for analysis/optimization',
@@ -2386,9 +2399,15 @@ const workerDispatchCommand = {
                     { field: 'Description', value: result.config.description },
                     { field: 'Est. Duration', value: result.config.estimatedDuration },
                     { field: 'Capabilities', value: result.config.capabilities.join(', ') },
-                    { field: 'Status', value: result.status === 'dispatched' ? output.highlight('dispatched (background)') : output.success('completed') },
+                    { field: 'Status', value: dispatchStatusLabel(result.status) },
                 ],
             });
+            // The tool says why it could not run the worker (e.g. no daemon); show it
+            // rather than letting a recorded-only dispatch read as finished work (#4196).
+            if (result.note) {
+                output.writeln();
+                output.printWarning(result.note);
+            }
             if (background) {
                 output.writeln();
                 output.writeln(output.dim(`Check status: claude-flow hooks worker status --id ${result.workerId}`));

package/dist/src/commands/memory.js

@@ -659,7 +659,9 @@ const searchCommand = {
                     });
                     return {
                         results: r.results.map(e => ({
-                            id: e.id,
+                            // #2271: searchEntries() ids are truncated to 12 chars and collide
+                            // for entries written within ~2.8h; SmartRetrieval dedupes on id.
+                            id: JSON.stringify([e.namespace, e.key]),
                             key: e.key,
                             content: e.content,
                             score: e.score,
@@ -1592,6 +1594,13 @@ const exportCommand = {
                 namespace: ctx.flags.namespace,
                 includeVectors: ctx.flags.includeVectors ?? true,
             });
+            // memory_export reports failure as { error } rather than throwing; without
+            // this check the command printed "Exported to undefined" and then crashed
+            // reading result.exported.entries (#4204).
+            if (!result || result.error || !result.exported) {
+                output.printError(`Export error: ${result?.error ?? 'memory_export returned no export summary'}`);
+                return { success: false, exitCode: 1 };
+            }
             output.printSuccess(`Exported to ${result.outputPath}`);
             output.printList([
                 `Entries: ${result.exported.entries}`,
@@ -1657,6 +1666,21 @@ const importCommand = {
                 namespace: ctx.flags.namespace,
                 dbPath: resolveDbPath(ctx.flags.path),
             });
+            // memory_import reports a bad file as { error } rather than throwing, and
+            // a partial write as { success: false, error, imported }. Without this the
+            // command printed "Imported from undefined" and crashed on result.imported,
+            // or reported success for an import that dropped entries.
+            const failure = result?.error;
+            if (!result || failure || result.success === false || !result.imported) {
+                output.printError(`Import error: ${failure ?? 'memory_import returned no import summary'}`);
+                if (result?.imported) {
+                    output.printList([
+                        `Entries imported: ${result.imported.entries}`,
+                        `Failed: ${result.failed ?? 'unknown'}`,
+                    ]);
+                }
+                return { success: false, exitCode: 1 };
+            }
             output.printSuccess(`Imported from ${result.inputPath}`);
             output.printList([
                 `Entries: ${result.imported.entries}`,

package/dist/src/commands/workflow.js

@@ -111,6 +111,12 @@ const runCommand = {
                     dryRun,
                 },
             });
+            const runError = toolError(result);
+            if (runError || !result.metrics) {
+                spinner.fail('Workflow failed');
+                output.printError(`Workflow error: ${runError ?? 'workflow_run returned no workflow summary'}`);
+                return { success: false, exitCode: 1 };
+            }
             if (dryRun) {
                 spinner.succeed('Workflow validated successfully');
             }
@@ -277,6 +283,11 @@ const listCommand = {
                 status: status || 'all',
                 limit,
             });
+            const listError = toolError(result);
+            if (listError || !Array.isArray(result.workflows)) {
+                output.printError(`Failed to list workflows: ${listError ?? 'workflow_list returned no workflows'}`);
+                return { success: false, exitCode: 1 };
+            }
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
@@ -290,13 +301,19 @@ const listCommand = {
             }
             output.printTable({
                 columns: [
-                    { key: 'id', header: 'ID', width: 15 },
-                    { key: 'template', header: 'Template', width: 15 },
+                    { key: 'id', header: 'ID', width: 30 },
+                    { key: 'name', header: 'Name', width: 24 },
                     { key: 'status', header: 'Status', width: 12, format: formatStageStatus },
-                    { key: 'progress', header: 'Progress', width: 10, align: 'right', format: (v) => `${v}%` },
-                    { key: 'startedAt', header: 'Started', width: 20, format: (v) => new Date(String(v)).toLocaleString() }
+                    { key: 'steps', header: 'Steps', width: 6, align: 'right' },
+                    { key: 'createdAt', header: 'Created', width: 20, format: (v) => new Date(String(v)).toLocaleString() }
                 ],
-                data: result.workflows
+                data: result.workflows.map(w => ({
+                    id: w.workflowId,
+                    name: w.name,
+                    status: w.status,
+                    steps: w.stepCount,
+                    createdAt: w.createdAt,
+                }))
             });
             output.writeln();
             output.printInfo(`Total: ${result.total} workflows`);
@@ -335,30 +352,37 @@ const statusCommand = {
         try {
             const result = await callMCPTool('workflow_status', {
                 workflowId,
+                verbose: true,
             });
+            const statusError = toolError(result);
+            if (statusError) {
+                output.printError(`Failed to get status: ${statusError}`);
+                return { success: false, exitCode: 1 };
+            }
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
             }
+            const started = result.startedAt ? Date.parse(result.startedAt) : NaN;
+            const ended = result.completedAt ? Date.parse(result.completedAt) : Date.now();
             output.writeln();
             output.printBox([
-                `ID: ${result.id}`,
-                `Template: ${result.template}`,
+                `ID: ${result.workflowId}`,
+                `Name: ${result.name}`,
                 `Status: ${formatStageStatus(result.status)}`,
-                `Progress: ${result.progress}%`,
-                `Duration: ${(result.metrics.duration / 1000).toFixed(1)}s`,
-                `Tokens: ${result.metrics.tokensUsed.toLocaleString()}`,
-                `Agents: ${result.metrics.agentsSpawned}`
+                `Progress: ${Math.round(result.progress)}% (${result.completedSteps}/${result.totalSteps} steps)`,
+                ...(Number.isNaN(started) ? [] : [`Duration: ${((ended - started) / 1000).toFixed(1)}s`]),
+                ...(result.error ? [`Error: ${result.error}`] : []),
             ].join('\n'), 'Workflow Status');
             output.writeln();
-            output.writeln(output.bold('Stage Progress'));
+            output.writeln(output.bold('Step Progress'));
             output.printTable({
                 columns: [
-                    { key: 'name', header: 'Stage', width: 20 },
+                    { key: 'name', header: 'Step', width: 24 },
+                    { key: 'type', header: 'Type', width: 10 },
                     { key: 'status', header: 'Status', width: 12, format: formatStageStatus },
-                    { key: 'agents', header: 'Agents', width: 25, format: (v) => Array.isArray(v) ? v.length.toString() : '0' }
                 ],
-                data: result.stages
+                data: result.steps ?? []
             });
             return { success: true, data: result };
         }
@@ -408,6 +432,11 @@ const stopCommand = {
                 workflowId,
                 graceful: !force,
             });
+            const stopError = toolError(result);
+            if (stopError || result.stopped !== true) {
+                output.printError(`Failed to stop workflow: ${stopError ?? 'the workflow was not stopped'}`);
+                return { success: false, exitCode: 1 };
+            }
             output.printSuccess(`Workflow ${workflowId} stopped`);
             return { success: true, data: result };
         }
@@ -556,6 +585,17 @@ export const workflowCommand = {
     }
 };
 // Helper functions
+/**
+ * The workflow MCP tools report failure as `{ error }` (or `{ success: false, error }`)
+ * instead of throwing, so a command that reads the result without checking it prints
+ * a false success or crashes on a field the error result does not have.
+ */
+function toolError(result) {
+    const r = result;
+    if (!r)
+        return 'the workflow tool returned no result';
+    return typeof r.error === 'string' && r.error.length > 0 ? r.error : undefined;
+}
 function formatStageStatus(status) {
     const statusStr = String(status);
     switch (statusStr) {

package/dist/src/init/executor.js

@@ -18,7 +18,7 @@ import { generatePreCommitHook, generatePostCommitHook, generateSessionManager,
 import { getInstalledCliVersion, HELPERS_STAMP_FILE } from './helper-refresh.js';
 import { generateClaudeMd } from './claudemd-generator.js';
 import { recordMemoryPackagePath } from './memory-package-resolver.js';
-import { ensureCommonJsCompanions } from './helper-companions.js';
+import { COMMONJS_COMPANION_HELPERS, ensureCommonJsCompanions } from './helper-companions.js';
 import { scanSettingsForRisk, formatRiskFindingsAsWarnings } from './settings-risk-scanner.js';
 import { AUTO_MEMORY_HOOK_TIMEOUT_S, helperHookCommand, helperScopeFor, helperStatusLineCommand, pinToUserHelpers } from './helper-commands.js';
 /**
@@ -548,10 +548,14 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 catch { }
             }
         }
-        // #3555: the refreshed hook-handler requires the .cjs companions; older
-        // installs only have session.js / memory.js, which can't load in ESM.
-        for (const name of await ensureCommonJsCompanions(path.join(targetDir, '.claude', 'helpers'))) {
-            result.created.push(`.claude/helpers/${name}`);
+        // #4198: refresh existing companions too, so upgraded hook handlers never
+        // keep obsolete session/memory logic. Generate from the CLI trust root.
+        const helpersDir = path.join(targetDir, '.claude', 'helpers');
+        const existingCompanions = new Set(COMMONJS_COMPANION_HELPERS.filter((name) => fs.existsSync(path.join(helpersDir, name))));
+        for (const name of await ensureCommonJsCompanions(helpersDir, true)) {
+            const changes = existingCompanions.has(name)
+                ? result.updated : result.created;
+            changes.push(`.claude/helpers/${name}`);
         }
         // Stamp the installed version so the startup auto-refresh treats these as
         // current (no redundant re-copy on the next command).

package/dist/src/init/helper-companions.d.ts

@@ -1,3 +1,3 @@
 export declare const COMMONJS_COMPANION_HELPERS: readonly ["session.cjs", "memory.cjs"];
-export declare function ensureCommonJsCompanions(helpersDir: string): Promise<string[]>;
+export declare function ensureCommonJsCompanions(helpersDir: string, force?: boolean): Promise<string[]>;
 //# sourceMappingURL=helper-companions.d.ts.map

package/dist/src/init/helper-companions.js

@@ -7,13 +7,14 @@
  * `.js` copies, which the refreshed hook-handler no longer requires, so the
  * refresh writes any missing `.cjs` companion from the CLI's own compiled
  * generators (the trust root; no external file to verify). Stale `.js` copies
- * are left in place and ignored. Existing `.cjs` files are never overwritten.
+ * are left in place and ignored. Existing `.cjs` files are preserved during
+ * startup refresh; an explicit init upgrade replaces them from the generators.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 export const COMMONJS_COMPANION_HELPERS = ['session.cjs', 'memory.cjs'];
-export async function ensureCommonJsCompanions(helpersDir) {
-    const missing = COMMONJS_COMPANION_HELPERS.filter((name) => !fs.existsSync(path.join(helpersDir, name)));
+export async function ensureCommonJsCompanions(helpersDir, force = false) {
+    const missing = COMMONJS_COMPANION_HELPERS.filter((name) => force || !fs.existsSync(path.join(helpersDir, name)));
     if (missing.length === 0)
         return [];
     const gen = await import('./helpers-generator.js');

package/dist/src/mcp-tools/hooks-tools.js

@@ -4175,12 +4175,12 @@ export const hooksIntelligenceLearn = {
 // Intelligence attention hook
 export const hooksIntelligenceAttention = {
     name: 'hooks_intelligence_attention',
-    description: 'Compute attention-weighted similarity using MoE/Flash/Hyperbolic Use when native Bash hooks (via Claude Code\'s settings.json) are wrong because you need Ruflo-side state — pattern persistence, neural training signals, model-routing learning, cost tracking, audit chain. For one-off shell commands, plain Bash hooks are fine.',
+    description: 'Compute attention-weighted similarity using MoE/Flash. Use when native Bash hooks (via Claude Code\'s settings.json) are wrong because you need Ruflo-side state — pattern persistence, neural training signals, model-routing learning, cost tracking, audit chain. For one-off shell commands, plain Bash hooks are fine.',
     inputSchema: {
         type: 'object',
         properties: {
             query: { type: 'string', description: 'Query for attention computation' },
-            mode: { type: 'string', description: 'Attention mode (flash, moe, hyperbolic)' },
+            mode: { type: 'string', description: 'Attention mode (flash, moe)' },
             topK: { type: 'number', description: 'Top-k results' },
         },
         required: ['query'],
@@ -4195,6 +4195,12 @@ export const hooksIntelligenceAttention = {
             if (!v.valid)
                 return { success: false, error: v.error };
         }
+        // #3548: only flash and moe have an implementation. Any other mode
+        // (including the previously advertised 'hyperbolic') used to return an
+        // empty stub whose note blamed a missing package; say so instead.
+        if (mode !== 'flash' && mode !== 'moe') {
+            return { success: false, error: `Attention mode "${mode}" is not implemented; supported modes: flash, moe` };
+        }
         let implementation = 'placeholder';
         let embeddingSource = 'none';
         const results = [];
@@ -4370,7 +4376,7 @@ export const hooksIntelligenceAttention = {
                 implementation,
                 _embeddingSource: embeddingSource,
                 _stub: implementation === 'none',
-                _note: implementation === 'none' ? 'No attention backend available. Install @ruvector/attention for real computation.' : undefined,
+                _note: implementation === 'none' ? 'No attention backend available: flash/moe attention from @claude-flow/neural could not be loaded or failed.' : undefined,
                 ...(embeddingSource === 'hash-fallback' && implementation !== 'none'
                     ? { _embeddingNote: 'Query embeddings are hash-based (not semantic). Install @claude-flow/embeddings for real ONNX embeddings.' }
                     : {}),

package/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/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/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/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/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;
     }