@claude-flow/cli 3.38.9 → 3.38.11

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

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.38.9",
+    "version": "3.38.11",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "dae295fb9ae2626b89899c19a20cc911541af82b52d2eeb9b214d618b96e9a86",
@@ -8,6 +8,6 @@
       "statusline.cjs": "0457fe53f8cd2c56458ff178392536a5868efd1a573665fa43bc01d2d95ca677"
     }
   },
-  "signature": "3d1AL1dnpOuXC44aTkQIjVmh6laRNnIEo99/iamUYH1IlCzQEwvA2svMe3hgchi7XjeKFRCkjWWtGpq0jv5uDg==",
+  "signature": "rNkivgIb+R5mwQcChrNF+m4lsfPPlKBn4oizP9Q7nuuIi8en/J3NJYf5l6mPRfEc4vdlqnnf0+Oid/007092Dw==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 4,
-  "generatedAt": "2026-08-13T12:38:48.969Z",
-  "gitSha": "c1e8e0c4",
+  "generatedAt": "2026-08-14T23:30:39.000Z",
+  "gitSha": "45e65b5d",
   "catalog": {
     "agents": 164,
     "tools": 397,

package/dist/src/commands/doctor.js

@@ -361,6 +361,38 @@ function isMemoryDbEncryptedAtRest(dbPath) {
         return false;
     }
 }
+/**
+ * Distinguish an unavailable native addon from a database that the native
+ * driver opened and found malformed. Importing better-sqlite3 can succeed even
+ * when its postinstall script was skipped: the JavaScript wrapper loads, then
+ * the first Database construction throws because better_sqlite3.node is absent
+ * or incompatible with the active Node ABI.
+ */
+function isNativeSqliteBindingUnavailable(error) {
+    const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    return [
+        /Could not locate the bindings file/i,
+        /better_sqlite3\.node/i,
+        /NODE_MODULE_VERSION/i,
+        /compiled against a different Node\.js version/i,
+        /ERR_DLOPEN_FAILED/i,
+        /invalid ELF header/i,
+        /wrong ELF class/i,
+        /not a valid Win32 application/i,
+        /Module did not self-register/i,
+        /no suitable image found/i,
+    ].some((pattern) => pattern.test(message));
+}
+function nativeBindingUnavailableCheck(name, dbPath, error, suffix) {
+    const details = error instanceof Error ? error.message : String(error);
+    const summary = details.split(/\r?\n/, 1)[0].replace(/\s+Tried:\s*$/i, '');
+    return {
+        name,
+        status: 'warn',
+        message: `${dbPath} — better-sqlite3 package found, but its native binding is unavailable: ${summary} ${suffix}`,
+        fix: 'reinstall with npm install scripts enabled or run `npm rebuild better-sqlite3`; then rerun this check',
+    };
+}
 // #2737 part 1 — bare `doctor` (no --component flag) never actually opened
 // memory.db: checkMemoryDatabase above is existsSync()+statSync() only, so
 // it PASSES on any file that exists and can be stat'd, corrupt or not, and
@@ -416,8 +448,8 @@ async function checkMemoryStructuralIntegrity() {
         return {
             name: NAME,
             status: 'warn',
-            message: `${dbPath} — better-sqlite3 not installed; structural-only check skipped (optional native module)`,
-            fix: 'npm install better-sqlite3  (enables WAL-aware structural checks on every `doctor` run)',
+            message: `${dbPath} — better-sqlite3 not installed; native WAL-backed persistence and the structural-only check are unavailable`,
+            fix: 'install better-sqlite3 with npm install scripts enabled, then rerun this check',
         };
     }
     let db;
@@ -425,6 +457,9 @@ async function checkMemoryStructuralIntegrity() {
         db = new Database(dbPath, { readonly: true, fileMustExist: true });
     }
     catch (e) {
+        if (isNativeSqliteBindingUnavailable(e)) {
+            return nativeBindingUnavailableCheck(NAME, dbPath, e, '[structural-only; durable WAL-backed persistence unavailable]');
+        }
         const msg = e.message || String(e);
         // Encryption already ruled out above — an unencrypted file
         // better-sqlite3 can't even open is definitive corruption.
@@ -498,9 +533,9 @@ async function checkMemoryIntegrity() {
     }
     // Prefer native better-sqlite3 (WAL-aware, full integrity_check). Module
     // load is isolated in its own try/catch so ONLY "not installed" falls
-    // through to the sql.js fallback below — once the module loaded, any
-    // open/query failure is resolved (fail) right here, not silently
-    // reclassified as "sql.js fallback, main-image-only" by an outer catch.
+    // through to the sql.js fallback below. A loaded JavaScript wrapper can
+    // still lack its native binding (#2968); that capability failure is a warn,
+    // while genuine open/query failures remain authoritative failures here.
     let Database;
     try {
         Database = (await import('better-sqlite3')).default;
@@ -514,6 +549,9 @@ async function checkMemoryIntegrity() {
             db = new Database(dbPath, { readonly: true, fileMustExist: true });
         }
         catch (e) {
+            if (isNativeSqliteBindingUnavailable(e)) {
+                return nativeBindingUnavailableCheck('Memory Integrity', dbPath, e, '[native WAL-backed persistence unavailable]');
+            }
             const msg = e.message || String(e);
             return {
                 name: 'Memory Integrity',
@@ -574,7 +612,12 @@ async function checkMemoryIntegrity() {
         const res = db.exec('PRAGMA integrity_check');
         const rows = res[0]?.values?.map((v) => String(v[0])) ?? [];
         if (rows.length === 1 && rows[0] === 'ok') {
-            return { name: 'Memory Integrity', status: 'pass', message: `${dbPath} — PRAGMA integrity_check: ok [main-image-only fallback — sql.js can't see WAL-only data; install better-sqlite3 for full coverage]` };
+            return {
+                name: 'Memory Integrity',
+                status: 'warn',
+                message: `${dbPath} — PRAGMA integrity_check: ok, but only for the main image [sql.js fallback; native WAL-backed persistence unavailable]`,
+                fix: 'install better-sqlite3 with npm install scripts enabled, then rerun this check',
+            };
         }
         return {
             name: 'Memory Integrity',
@@ -885,8 +928,10 @@ async function checkApiKeys() {
             found.push(key);
         }
     }
-    // Detect Claude Code environment — API keys are managed internally
-    const inClaudeCode = !!(process.env.CLAUDE_CODE || process.env.CLAUDE_PROJECT_DIR || process.env.MCP_SESSION_ID);
+    // Detect Claude Code environment — API keys are managed internally.
+    // Claude Code sets CLAUDECODE (no underscore); CLAUDE_CODE is kept for
+    // compatibility with anything else that might set it.
+    const inClaudeCode = !!(process.env.CLAUDECODE || process.env.CLAUDE_CODE || process.env.CLAUDE_PROJECT_DIR || process.env.MCP_SESSION_ID);
     if (found.includes('ANTHROPIC_API_KEY') || found.includes('CLAUDE_API_KEY')) {
         return { name: 'API Keys', status: 'pass', message: `Found: ${found.join(', ')}` };
     }

package/dist/src/commands/mcp.js

@@ -64,8 +64,7 @@ const startCommand = {
         {
             name: 'tools',
             description: 'Tools to advertise (comma-separated categories, prefixes, exact names, or "all")',
-            type: 'string',
-            default: 'all'
+            type: 'string'
         },
         {
             name: 'daemon',
@@ -92,7 +91,9 @@ const startCommand = {
         const port = ctx.flags.port ?? 3000;
         const host = ctx.flags.host ?? 'localhost';
         const transport = ctx.flags.transport ?? 'stdio';
-        const tools = ctx.flags.tools || 'all';
+        const tools = ctx.flags.tools
+            || process.env.CLAUDE_FLOW_MCP_TOOLS
+            || 'all';
         const daemon = ctx.flags.daemon ?? false;
         const force = ctx.flags.force ?? false;
         output.writeln();

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

@@ -1,4 +1,15 @@
 export declare const HELPERS_STAMP_FILE = ".helpers-version";
+export declare const HELPERS_REFRESH_LOCK_FILE = ".helpers-refresh.lock";
+interface RefreshOptions {
+    sourceDirOverride?: string;
+    pubkeyPemOverride?: string;
+    versionOverride?: string;
+    alsoRefreshGlobal?: boolean;
+    beforeWriteOverride?: () => void | Promise<void>;
+    lockWaitMsOverride?: number;
+    lockRetryMsOverride?: number;
+    malformedLockStaleMsOverride?: number;
+}
 /**
  * ruflo-owned helpers that carry hook logic (or the render surface for the
  * funnel disclosure row) and must track the package version. Adding to this
@@ -40,9 +51,9 @@ export declare function getInstalledCliVersion(): string;
  * running `daemon start` (or any command) would see its own older version !=
  * the project's newer stamp and silently overwrite hand-fixed
  * `hook-handler.cjs`/`intelligence.cjs` with its own older, already-superseded
- * bundled copies. Comparing with `semver.gt` instead of `!==` makes that
- * impossible: an older or equal installed version is always a no-op,
- * regardless of how it got invoked.
+ * bundled copies. The semver guard is therefore re-evaluated while holding a
+ * per-directory cross-process lock; otherwise an older process can pass the
+ * guard first but finish writing last.
  *
  * `opts` exists for tests ONLY (mirrors daemon-autostart.ts's injectable
  * `SpawnDaemonFn` pattern): the real signed-copy path is otherwise coupled
@@ -59,12 +70,7 @@ export declare function getInstalledCliVersion(): string;
  * compat with pre-3.31.3 callers). If the global pass ran, its own result is
  * carried in the optional `global` field.
  */
-export declare function autoRefreshHelpersIfStale(cwd: string, opts?: {
-    sourceDirOverride?: string;
-    pubkeyPemOverride?: string;
-    versionOverride?: string;
-    alsoRefreshGlobal?: boolean;
-}): Promise<{
+export declare function autoRefreshHelpersIfStale(cwd: string, opts?: RefreshOptions): Promise<{
     refreshed: boolean;
     from?: string;
     to?: string;
@@ -76,4 +82,5 @@ export declare function autoRefreshHelpersIfStale(cwd: string, opts?: {
         blocked?: string;
     };
 }>;
+export {};
 //# sourceMappingURL=helper-refresh.d.ts.map

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

@@ -53,6 +53,11 @@ function findPackageRoot(startDir, maxUp = 6) {
     return null;
 }
 export const HELPERS_STAMP_FILE = '.helpers-version';
+export const HELPERS_REFRESH_LOCK_FILE = '.helpers-refresh.lock';
+const DEFAULT_LOCK_WAIT_MS = 2_000;
+const DEFAULT_LOCK_RETRY_MS = 10;
+const DEFAULT_MALFORMED_LOCK_STALE_MS = 5 * 60_000;
+let tempFileCounter = 0;
 /**
  * ruflo-owned helpers that carry hook logic (or the render surface for the
  * funnel disclosure row) and must track the package version. Adding to this
@@ -67,6 +72,139 @@ export const CRITICAL_HELPERS = [
     // existing installs on the next `ruflo` command, not only fresh `ruflo init`.
     'statusline.cjs',
 ];
+function errorCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code)
+        : undefined;
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return errorCode(error) !== 'ESRCH';
+    }
+}
+function removeAbandonedLock(lockPath, malformedStaleMs) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+        if (Number.isSafeInteger(parsed.pid) && Number(parsed.pid) > 0) {
+            if (processIsAlive(Number(parsed.pid)))
+                return false;
+            fs.unlinkSync(lockPath);
+            return true;
+        }
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return true;
+    }
+    // A process can die after the exclusive create but before writing metadata.
+    // Only reclaim such malformed locks after a generous age; valid locks with a
+    // live PID are never age-evicted, so a slow refresh cannot lose ownership.
+    try {
+        if (Date.now() - fs.statSync(lockPath).mtimeMs >= malformedStaleMs) {
+            fs.unlinkSync(lockPath);
+            return true;
+        }
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return true;
+    }
+    return false;
+}
+async function acquireRefreshLock(helpersDir, opts) {
+    const lockPath = path.join(helpersDir, HELPERS_REFRESH_LOCK_FILE);
+    const waitMs = opts.lockWaitMsOverride ?? DEFAULT_LOCK_WAIT_MS;
+    const retryMs = opts.lockRetryMsOverride ?? DEFAULT_LOCK_RETRY_MS;
+    const malformedStaleMs = opts.malformedLockStaleMsOverride ?? DEFAULT_MALFORMED_LOCK_STALE_MS;
+    const deadline = Date.now() + Math.max(0, waitMs);
+    while (true) {
+        const token = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        let fd;
+        let created = false;
+        try {
+            fd = fs.openSync(lockPath, 'wx');
+            created = true;
+            fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, token }), 'utf-8');
+            fs.closeSync(fd);
+            fd = undefined;
+            return () => {
+                try {
+                    const current = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+                    if (current.token === token)
+                        fs.unlinkSync(lockPath);
+                }
+                catch { /* best-effort release; a replaced lock is never removed */ }
+            };
+        }
+        catch (error) {
+            if (fd !== undefined) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch { /* best-effort */ }
+            }
+            if (created) {
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch { /* best-effort */ }
+            }
+            if (errorCode(error) !== 'EEXIST')
+                throw error;
+            if (removeAbandonedLock(lockPath, malformedStaleMs))
+                continue;
+            if (Date.now() >= deadline)
+                return null;
+            await new Promise((resolve) => setTimeout(resolve, Math.max(1, retryMs)));
+        }
+    }
+}
+function temporarySiblingPath(target) {
+    tempFileCounter += 1;
+    return `${target}.tmp-${process.pid}-${Date.now()}-${tempFileCounter}`;
+}
+function atomicCopyFileSync(source, target, mode) {
+    const temporary = temporarySiblingPath(target);
+    try {
+        fs.copyFileSync(source, temporary, fs.constants.COPYFILE_EXCL);
+        if (mode) {
+            try {
+                fs.chmodSync(temporary, mode);
+            }
+            catch { /* non-fatal */ }
+        }
+        fs.renameSync(temporary, target);
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* already renamed or never created */ }
+    }
+}
+function atomicWriteFileSync(target, content, mode) {
+    const temporary = temporarySiblingPath(target);
+    try {
+        fs.writeFileSync(temporary, content, { encoding: 'utf-8', flag: 'wx' });
+        if (mode) {
+            try {
+                fs.chmodSync(temporary, mode);
+            }
+            catch { /* non-fatal */ }
+        }
+        fs.renameSync(temporary, target);
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* already renamed or never created */ }
+    }
+}
 /** Installed @claude-flow/cli version — the value the helpers are stamped with. */
 export function getInstalledCliVersion() {
     try {
@@ -148,20 +286,16 @@ async function writeCriticalHelpers(helpersDir, version, opts = {}) {
         let wrote = false;
         for (const name of toCopy) {
             const tp = path.join(helpersDir, name);
-            fs.copyFileSync(path.join(source, name), tp);
-            try {
-                fs.chmodSync(tp, '755');
-            }
-            catch { /* non-fatal */ }
+            atomicCopyFileSync(path.join(source, name), tp, '755');
             wrote = true;
         }
         try {
-            fs.copyFileSync(path.join(source, HELPERS_MANIFEST_FILE), path.join(helpersDir, HELPERS_MANIFEST_FILE));
+            atomicCopyFileSync(path.join(source, HELPERS_MANIFEST_FILE), path.join(helpersDir, HELPERS_MANIFEST_FILE));
         }
         catch { /* non-fatal */ }
         if (wrote) {
             try {
-                fs.writeFileSync(path.join(helpersDir, HELPERS_STAMP_FILE), version, 'utf-8');
+                atomicWriteFileSync(path.join(helpersDir, HELPERS_STAMP_FILE), version);
             }
             catch { /* non-fatal */ }
         }
@@ -187,16 +321,12 @@ async function writeCriticalHelpers(helpersDir, version, opts = {}) {
     let wrote = false;
     for (const [name, content] of Object.entries(files)) {
         const tp = path.join(helpersDir, name);
-        fs.writeFileSync(tp, content, 'utf-8');
-        try {
-            fs.chmodSync(tp, '755');
-        }
-        catch { /* non-fatal */ }
+        atomicWriteFileSync(tp, content, '755');
         wrote = true;
     }
     if (wrote) {
         try {
-            fs.writeFileSync(path.join(helpersDir, HELPERS_STAMP_FILE), version, 'utf-8');
+            atomicWriteFileSync(path.join(helpersDir, HELPERS_STAMP_FILE), version);
         }
         catch { /* non-fatal */ }
     }
@@ -216,9 +346,9 @@ async function writeCriticalHelpers(helpersDir, version, opts = {}) {
  * running `daemon start` (or any command) against THIS project directory
  * would see its own older version != the project's newer stamp and silently
  * overwrite hand-fixed `hook-handler.cjs`/`intelligence.cjs` with its own
- * older, already-superseded bundled copies. Comparing with `semver.gt`
- * instead of `!==` makes that impossible: an older or equal installed
- * version is always a no-op, regardless of how it got invoked.
+ * older, already-superseded bundled copies. The semver guard is therefore
+ * re-evaluated while holding a per-directory cross-process lock; otherwise
+ * an older process can pass the guard first but finish writing last.
  *
  * `opts` exists for tests ONLY (mirrors daemon-autostart.ts's injectable
  * `SpawnDaemonFn` pattern): the real signed-copy path is otherwise coupled to
@@ -231,7 +361,7 @@ async function writeCriticalHelpers(helpersDir, version, opts = {}) {
  * signed fixture and get real, deterministic coverage of the verify → hash →
  * copy logic without depending on that.
  */
-async function refreshOneHelpersDir(helpersDir, version, opts) {
+async function refreshOneHelpersDirLocked(helpersDir, version, opts) {
     if (!fs.existsSync(path.join(helpersDir, 'hook-handler.cjs')))
         return { refreshed: false };
     // .LOCKED marker: users developing ruflo itself (or any project with
@@ -258,6 +388,7 @@ async function refreshOneHelpersDir(helpersDir, version, opts) {
         // would silently DOWNGRADE the helpers. Skip, untouched.
         return { refreshed: false };
     }
+    await opts.beforeWriteOverride?.();
     const res = await writeCriticalHelpers(helpersDir, version, {
         sourceDirOverride: opts.sourceDirOverride,
         pubkeyPemOverride: opts.pubkeyPemOverride,
@@ -266,6 +397,32 @@ async function refreshOneHelpersDir(helpersDir, version, opts) {
         return { refreshed: false, blocked: res.blocked };
     return res.wrote ? { refreshed: true, from: stamped || '(unstamped)', to: version } : { refreshed: false };
 }
+async function refreshOneHelpersDir(helpersDir, version, opts) {
+    if (!fs.existsSync(path.join(helpersDir, 'hook-handler.cjs')))
+        return { refreshed: false };
+    // Respect the repository opt-out before creating even a transient lock file
+    // in a directory whose helpers are intentionally maintained by hand. Keep
+    // the check in the locked path too in case the marker appears while waiting.
+    if (fs.existsSync(path.join(helpersDir, '.LOCKED'))) {
+        return { refreshed: false, blocked: '.LOCKED marker present — refresh skipped (delete to re-enable)' };
+    }
+    try {
+        if (fs.readFileSync(path.join(helpersDir, HELPERS_STAMP_FILE), 'utf-8').trim() === version)
+            return { refreshed: false };
+    }
+    catch { /* unstamped: continue to the locked path */ }
+    const releaseLock = await acquireRefreshLock(helpersDir, opts);
+    if (!releaseLock)
+        return { refreshed: false, blocked: 'helper refresh already in progress' };
+    try {
+        // Re-read the stamp and .LOCKED marker under the cross-process lock. A
+        // concurrent newer CLI may have completed while this caller waited.
+        return await refreshOneHelpersDirLocked(helpersDir, version, opts);
+    }
+    finally {
+        releaseLock();
+    }
+}
 /**
  * On CLI startup, refresh critical helpers if their stamp is older than the
  * installed CLI version. Two passes:
@@ -298,9 +455,9 @@ async function refreshOneHelpersDir(helpersDir, version, opts) {
  * running `daemon start` (or any command) would see its own older version !=
  * the project's newer stamp and silently overwrite hand-fixed
  * `hook-handler.cjs`/`intelligence.cjs` with its own older, already-superseded
- * bundled copies. Comparing with `semver.gt` instead of `!==` makes that
- * impossible: an older or equal installed version is always a no-op,
- * regardless of how it got invoked.
+ * bundled copies. The semver guard is therefore re-evaluated while holding a
+ * per-directory cross-process lock; otherwise an older process can pass the
+ * guard first but finish writing last.
  *
  * `opts` exists for tests ONLY (mirrors daemon-autostart.ts's injectable
  * `SpawnDaemonFn` pattern): the real signed-copy path is otherwise coupled

package/dist/src/log-filters.d.ts

@@ -40,7 +40,7 @@ declare const STDERR_REDIRECT_PREFIXES: string[];
 declare const AGENTDB_MOCK_FALLBACK_DROP_PREFIXES: string[];
 declare const shouldRedirectToStderr: (msg: unknown) => boolean;
 declare const isAgentdbMockFallbackNoise: (msg: unknown) => boolean;
-declare const origWarn: (...data: any[]) => void;
-declare const origLog: (...data: any[]) => void;
-declare const origError: (...data: any[]) => void;
+declare const origWarn: (message?: any, ...optionalParams: any[]) => void;
+declare const origLog: (message?: any, ...optionalParams: any[]) => void;
+declare const origError: (message?: any, ...optionalParams: any[]) => void;
 //# sourceMappingURL=log-filters.d.ts.map

package/dist/src/mcp-server.d.ts

@@ -84,6 +84,7 @@ export declare class MCPServerManager extends EventEmitter {
     private server?;
     private startTime?;
     private healthCheckInterval?;
+    private mcpServers;
     constructor(options?: MCPServerOptions);
     /**
      * Start the MCP server

package/dist/src/mcp-server.js

@@ -101,6 +101,7 @@ export class MCPServerManager extends EventEmitter {
     server;
     startTime;
     healthCheckInterval;
+    mcpServers = [];
     constructor(options = {}) {
         super();
         // `options.tools`, populated by the `mcp start --tools` CLI flag, is
@@ -185,6 +186,11 @@ export class MCPServerManager extends EventEmitter {
                 });
                 this.server = undefined;
             }
+            if (this.mcpServers.length > 0) {
+                const servers = this.mcpServers;
+                this.mcpServers = [];
+                await Promise.all(servers.map((server) => server.stop()));
+            }
             // Remove PID file
             await this.removePidFile();
             this.startTime = undefined;
@@ -560,18 +566,48 @@ export class MCPServerManager extends EventEmitter {
             warn: (msg, data) => this.emit('log', { level: 'warn', msg, data }),
             error: (msg, data) => this.emit('log', { level: 'error', msg, data }),
         };
+        const { listMCPTools, callMCPTool } = await import('./mcp-client.js');
+        const fallbackSessionId = `http-${randomUUID()}`;
+        const cliTools = filterAdvertisedMcpTools(listMCPTools(), this.options.tools).map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            category: tool.category,
+            tags: tool.tags,
+            version: tool.version,
+            cacheable: tool.cacheable,
+            cacheTTL: tool.cacheTTL,
+            handler: async (input, context) => {
+                try {
+                    const result = await callMCPTool(tool.name, input || {}, { sessionId: context?.sessionId || fallbackSessionId });
+                    trackRequest(tool.name, true);
+                    return result;
+                }
+                catch (error) {
+                    trackRequest(tool.name, false);
+                    throw error;
+                }
+            },
+        }));
+        // Use one MCP server with two HTTP transports for the localhost default.
+        // Both loopback sockets therefore share sessions, tools, and notifications.
+        const dualLoopback = this.options.host === 'localhost';
         const mcpServer = createMCPServer({
             name: 'Claude-Flow MCP Server V3',
             version: '3.0.0',
             transport: this.options.transport,
-            host: this.options.host,
+            host: dualLoopback ? '127.0.0.1' : this.options.host,
+            additionalHosts: dualLoopback && this.options.transport === 'http' ? ['::1'] : undefined,
             port: this.options.port,
             enableMetrics: true,
             enableCaching: true,
         }, logger);
+        const registration = mcpServer.registerTools(cliTools);
+        if (registration.failed.length > 0) {
+            throw new Error(`Failed to register MCP tools: ${registration.failed.join(', ')}`);
+        }
         await mcpServer.start();
-        // Store reference for stopping
-        this._mcpServer = mcpServer;
+        this.mcpServers = [mcpServer];
     }
     /**
      * Wait for server to be ready

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

@@ -199,11 +199,12 @@ function ensureEmbeddings() {
     })();
     return embeddingsPromise;
 }
-// Storage paths
+// Storage paths. Note: `.claude-flow/neural/patterns.json` is a SEPARATE
+// file owned by the ReasoningBank store in memory/intelligence.ts — this
+// module only ever reads/writes MODELS_FILE, never a patterns.json.
 const STORAGE_DIR = '.claude-flow';
 const NEURAL_DIR = 'neural';
 const MODELS_FILE = 'models.json';
-const PATTERNS_FILE = 'patterns.json';
 function getNeuralDir() {
     return join(getProjectCwd(), STORAGE_DIR, NEURAL_DIR);
 }
@@ -262,7 +263,7 @@ export function getNeuralStoreStats() {
         patternCount: patterns.length,
         byType,
         modelCount: Object.values(store.models ?? {}).length,
-        source: '.claude-flow/neural/patterns.json (loadNeuralStore)',
+        source: '.claude-flow/neural/models.json (loadNeuralStore)',
     };
 }
 /**

package/dist/src/memory/memory-bridge.d.ts

@@ -16,6 +16,14 @@
  *
  * @module v3/cli/memory-bridge
  */
+/**
+ * #3024: AgentDB's optional native controller stack can abort the whole Node
+ * process on Windows during registry initialization (a Rust allocation panic),
+ * which cannot be caught by JavaScript. Keep the CLI/MCP server on the
+ * sql.js + local-embedding path there until the native dependency is proven
+ * safe. Advanced users and CI can opt back in explicitly for diagnosis.
+ */
+export declare function shouldDisableNativeBridge(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): boolean;
 /**
  * Should this init-time log line be swallowed?
  *

package/dist/src/memory/memory-bridge.js

@@ -38,6 +38,18 @@ const ACTIVE_MEMORY_ROW_SQL = `(status = 'active' OR status IS NULL)`;
  * better-sqlite3 bridge") the caller has no way to check.
  */
 let bridgeFailureReason = null;
+/**
+ * #3024: AgentDB's optional native controller stack can abort the whole Node
+ * process on Windows during registry initialization (a Rust allocation panic),
+ * which cannot be caught by JavaScript. Keep the CLI/MCP server on the
+ * sql.js + local-embedding path there until the native dependency is proven
+ * safe. Advanced users and CI can opt back in explicitly for diagnosis.
+ */
+export function shouldDisableNativeBridge(platform = process.platform, env = process.env) {
+    if (env.CLAUDE_FLOW_DISABLE_BRIDGE === '1')
+        return true;
+    return platform === 'win32' && env.CLAUDE_FLOW_ENABLE_NATIVE_BRIDGE_ON_WINDOWS !== '1';
+}
 /**
  * ADR-323: reuse memory-initializer's provenance-type allowlist rather than
  * duplicating it (drift risk). Lazy CJS require for the same circular-ESM-
@@ -154,6 +166,12 @@ export function shouldSuppressInitLog(msg) {
  * Returns null if @claude-flow/memory is not available.
  */
 async function getRegistry(dbPath) {
+    if (shouldDisableNativeBridge()) {
+        bridgeFailureReason = process.platform === 'win32'
+            ? 'AgentDB native bridge disabled on Windows after #3024; set CLAUDE_FLOW_ENABLE_NATIVE_BRIDGE_ON_WINDOWS=1 to opt in'
+            : 'AgentDB native bridge disabled by CLAUDE_FLOW_DISABLE_BRIDGE=1';
+        return null;
+    }
     if (bridgeAvailable === false)
         return null;
     if (registryInstance)