moflo 4.7.8 → 4.8.1

package/src/@claude-flow/cli/dist/src/commands/daemon.js

@@ -4,6 +4,7 @@
  */
 import { output } from '../output.js';
 import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
+import { acquireDaemonLock, releaseDaemonLock, getDaemonLockHolder } from '../services/daemon-lock.js';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
@@ -64,60 +65,26 @@ const startCommand = {
                 config.resourceThresholds = thresholds;
             }
         }
-        // Check if background daemon already running (skip if we ARE the daemon process)
-        if (!isDaemonProcess) {
-            const bgPid = getBackgroundDaemonPid(projectRoot);
-            if (bgPid && isProcessRunning(bgPid)) {
-                if (!quiet) {
-                    output.printWarning(`Daemon already running in background (PID: ${bgPid})`);
-                }
-                return { success: true };
-            }
-        }
         // Background mode (default): fork a detached process
         if (!foreground) {
             return startBackgroundDaemon(projectRoot, quiet, rawMaxCpu, rawMinMem);
         }
         // Foreground mode: run in current process (blocks terminal)
         try {
-            const stateDir = join(projectRoot, '.claude-flow');
-            const pidFile = join(stateDir, 'daemon.pid');
-            // Ensure state directory exists
-            if (!fs.existsSync(stateDir)) {
-                fs.mkdirSync(stateDir, { recursive: true });
-            }
-            // Check if another foreground daemon is already running (prevents duplicate daemons)
-            if (fs.existsSync(pidFile)) {
-                try {
-                    const existingPid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-                    if (!isNaN(existingPid) && existingPid !== process.pid) {
-                        try {
-                            process.kill(existingPid, 0); // Check if alive
-                            // Another daemon is running — exit silently
-                            if (!quiet) {
-                                output.printWarning(`Daemon already running (PID: ${existingPid})`);
-                            }
-                            return { success: true };
-                        }
-                        catch {
-                            // Process not running — stale PID file, continue startup
-                        }
+            // Acquire atomic daemon lock (prevents duplicate daemons)
+            // Skip lock acquisition if we're the spawned child — parent already holds it
+            if (!isDaemonProcess) {
+                const lockResult = acquireDaemonLock(projectRoot);
+                if (!lockResult.acquired) {
+                    if (!quiet) {
+                        output.printWarning(`Daemon already running (PID: ${lockResult.holder})`);
                     }
-                }
-                catch {
-                    // Can't read PID file — continue startup
+                    return { success: true };
                 }
             }
-            // Write PID file for foreground mode
-            fs.writeFileSync(pidFile, String(process.pid));
-            // Clean up PID file on exit
+            // Clean up lock file on exit
             const cleanup = () => {
-                try {
-                    if (fs.existsSync(pidFile)) {
-                        fs.unlinkSync(pidFile);
-                    }
-                }
-                catch { /* ignore */ }
+                releaseDaemonLock(projectRoot, process.pid, true);
             };
             process.on('exit', cleanup);
             process.on('SIGINT', () => { cleanup(); process.exit(0); });
@@ -219,12 +186,18 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     const resolvedRoot = resolve(projectRoot);
     validatePath(resolvedRoot, 'Project root');
     const stateDir = join(resolvedRoot, '.claude-flow');
-    const pidFile = join(stateDir, 'daemon.pid');
     const logFile = join(stateDir, 'daemon.log');
     // Validate all paths
     validatePath(stateDir, 'State directory');
-    validatePath(pidFile, 'PID file');
     validatePath(logFile, 'Log file');
+    // Acquire atomic lock BEFORE spawning to prevent races
+    const lockResult = acquireDaemonLock(resolvedRoot);
+    if (!lockResult.acquired) {
+        if (!quiet) {
+            output.printWarning(`Daemon already running in background (PID: ${lockResult.holder})`);
+        }
+        return { success: true };
+    }
     // Ensure state directory exists
     if (!fs.existsSync(stateDir)) {
         fs.mkdirSync(stateDir, { recursive: true });
@@ -273,16 +246,21 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     // Get PID from spawned process directly (no shell echo needed)
     const pid = child.pid;
     if (!pid || pid <= 0) {
+        // Release lock — spawn failed, no daemon running
+        releaseDaemonLock(resolvedRoot, process.pid, true);
         output.printError('Failed to get daemon PID');
         return { success: false, exitCode: 1 };
     }
-    // Unref BEFORE writing PID file — prevents race where parent exits
+    // Unref BEFORE updating lock — prevents race where parent exits
     // but child hasn't fully detached yet (fixes macOS daemon death #1283)
     child.unref();
     // Small delay to let the child process fully detach on macOS
     await new Promise(resolve => setTimeout(resolve, 100));
-    // Save PID only after child is detached
-    fs.writeFileSync(pidFile, String(pid));
+    // Update the lock file with the child's PID (parent acquired it, child owns it)
+    // We force-release our lock and re-acquire with the child PID so the lock
+    // accurately reflects the running daemon process.
+    releaseDaemonLock(resolvedRoot, process.pid, true);
+    acquireDaemonLock(resolvedRoot, pid);
     if (!quiet) {
         output.printSuccess(`Daemon started in background (PID: ${pid})`);
         output.printInfo(`Logs: ${logFile}`);
@@ -326,76 +304,45 @@ const stopCommand = {
     },
 };
 /**
- * Kill background daemon process using PID file
+ * Kill background daemon process using lock file
  */
 async function killBackgroundDaemon(projectRoot) {
-    const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
-    if (!fs.existsSync(pidFile)) {
+    const holderPid = getDaemonLockHolder(projectRoot);
+    if (!holderPid) {
+        // No live daemon — clean up any stale lock
+        releaseDaemonLock(projectRoot, 0, true);
         return false;
     }
     try {
-        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-        if (isNaN(pid)) {
-            fs.unlinkSync(pidFile);
-            return false;
-        }
-        // Check if process is running
-        try {
-            process.kill(pid, 0); // Signal 0 = check if alive
-        }
-        catch {
-            // Process not running, clean up stale PID file
-            fs.unlinkSync(pidFile);
-            return false;
-        }
         // Kill the process
-        process.kill(pid, 'SIGTERM');
+        process.kill(holderPid, 'SIGTERM');
         // Wait a moment then force kill if needed
         await new Promise(resolve => setTimeout(resolve, 1000));
         try {
-            process.kill(pid, 0);
+            process.kill(holderPid, 0);
             // Still alive, force kill
-            process.kill(pid, 'SIGKILL');
+            process.kill(holderPid, 'SIGKILL');
         }
         catch {
             // Process terminated
         }
-        // Clean up PID file
-        if (fs.existsSync(pidFile)) {
-            fs.unlinkSync(pidFile);
-        }
+        // Release lock
+        releaseDaemonLock(projectRoot, holderPid, true);
         return true;
     }
     catch (error) {
-        // Clean up PID file on any error
-        if (fs.existsSync(pidFile)) {
-            fs.unlinkSync(pidFile);
-        }
+        // Clean up lock on any error
+        releaseDaemonLock(projectRoot, 0, true);
         return false;
     }
 }
-/**
- * Get PID of background daemon from PID file
- */
+// Legacy aliases — delegate to daemon-lock module
 function getBackgroundDaemonPid(projectRoot) {
-    const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
-    if (!fs.existsSync(pidFile)) {
-        return null;
-    }
-    try {
-        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-        return isNaN(pid) ? null : pid;
-    }
-    catch {
-        return null;
-    }
+    return getDaemonLockHolder(projectRoot);
 }
-/**
- * Check if a process is running
- */
 function isProcessRunning(pid) {
     try {
-        process.kill(pid, 0); // Signal 0 = check if alive
+        process.kill(pid, 0);
         return true;
     }
     catch {

package/src/@claude-flow/cli/dist/src/commands/doctor.js

@@ -10,6 +10,7 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync, exec } from 'child_process';
 import { promisify } from 'util';
+import { getDaemonLockHolder, releaseDaemonLock } from '../services/daemon-lock.js';
 // Promisified exec with proper shell and env inheritance for cross-platform support
 const execAsync = promisify(exec);
 /**
@@ -93,17 +94,23 @@ async function checkConfigFile() {
 // Check daemon status
 async function checkDaemonStatus() {
     try {
-        const pidFile = '.claude-flow/daemon.pid';
-        if (existsSync(pidFile)) {
-            const pid = readFileSync(pidFile, 'utf8').trim();
+        const lockFile = '.claude-flow/daemon.lock';
+        if (existsSync(lockFile)) {
             try {
-                process.kill(parseInt(pid, 10), 0); // Check if process exists
+                const data = JSON.parse(readFileSync(lockFile, 'utf8'));
+                const pid = data.pid;
+                process.kill(pid, 0); // Check if process exists
                 return { name: 'Daemon Status', status: 'pass', message: `Running (PID: ${pid})` };
             }
             catch {
-                return { name: 'Daemon Status', status: 'warn', message: 'Stale PID file', fix: 'rm .claude-flow/daemon.pid && claude-flow daemon start' };
+                return { name: 'Daemon Status', status: 'warn', message: 'Stale lock file', fix: 'rm .claude-flow/daemon.lock && claude-flow daemon start' };
             }
         }
+        // Also check legacy PID file
+        const pidFile = '.claude-flow/daemon.pid';
+        if (existsSync(pidFile)) {
+            return { name: 'Daemon Status', status: 'warn', message: 'Legacy PID file found', fix: 'rm .claude-flow/daemon.pid && claude-flow daemon start' };
+        }
         return { name: 'Daemon Status', status: 'warn', message: 'Not running', fix: 'claude-flow daemon start' };
     }
     catch {
@@ -400,6 +407,69 @@ async function checkAgenticFlow() {
         return { name: 'agentic-flow', status: 'warn', message: 'Check failed' };
     }
 }
+// Find and optionally kill orphaned moflo/claude-flow node processes
+async function findZombieProcesses(kill = false) {
+    const legitimatePid = getDaemonLockHolder(process.cwd());
+    const currentPid = process.pid;
+    const parentPid = process.ppid;
+    const found = [];
+    let killed = 0;
+    try {
+        if (process.platform === 'win32') {
+            // Windows: use WMIC to find node processes with moflo/claude-flow in command line
+            const result = execSync('powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"Name=\'node.exe\'\\" | Select-Object ProcessId,CommandLine | Format-Table -AutoSize -Wrap"', { encoding: 'utf-8', timeout: 10000, windowsHide: true });
+            const lines = result.split('\n');
+            for (const line of lines) {
+                if (/moflo|claude-flow|flo\s+(hooks|gate|mcp|daemon)/i.test(line)) {
+                    const pidMatch = line.match(/^\s*(\d+)/);
+                    if (pidMatch) {
+                        const pid = parseInt(pidMatch[1], 10);
+                        // Skip our own process, parent, and the legitimate daemon
+                        if (pid === currentPid || pid === parentPid || pid === legitimatePid)
+                            continue;
+                        found.push(pid);
+                    }
+                }
+            }
+        }
+        else {
+            // Unix/macOS: use ps to find node processes
+            const result = execSync('ps aux | grep -E "node.*(moflo|claude-flow)" | grep -v grep', { encoding: 'utf-8', timeout: 5000 });
+            const lines = result.trim().split('\n');
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                const pid = parseInt(parts[1], 10);
+                if (pid === currentPid || pid === parentPid || pid === legitimatePid)
+                    continue;
+                found.push(pid);
+            }
+        }
+    }
+    catch {
+        // No matches found (grep exits non-zero) or command failed
+    }
+    if (kill && found.length > 0) {
+        for (const pid of found) {
+            try {
+                if (process.platform === 'win32') {
+                    execSync(`taskkill /F /PID ${pid}`, { timeout: 5000, windowsHide: true });
+                }
+                else {
+                    process.kill(pid, 'SIGKILL');
+                }
+                killed++;
+            }
+            catch {
+                // Process may have already exited
+            }
+        }
+        // Clean up stale daemon lock if we killed the holder
+        if (legitimatePid && found.includes(legitimatePid)) {
+            releaseDaemonLock(process.cwd(), legitimatePid, true);
+        }
+    }
+    return { found: found.length, killed, pids: found };
+}
 // Format health check result
 function formatCheck(check) {
     const icon = check.status === 'pass' ? output.success('✓') :
@@ -438,12 +508,20 @@ export const doctorCommand = {
             description: 'Verbose output',
             type: 'boolean',
             default: false
+        },
+        {
+            name: 'kill-zombies',
+            short: 'k',
+            description: 'Find and kill orphaned moflo/claude-flow node processes',
+            type: 'boolean',
+            default: false
         }
     ],
     examples: [
         { command: 'claude-flow doctor', description: 'Run full health check' },
         { command: 'claude-flow doctor --fix', description: 'Show fixes for issues' },
         { command: 'claude-flow doctor --install', description: 'Auto-install missing dependencies' },
+        { command: 'claude-flow doctor --kill-zombies', description: 'Find and kill zombie processes' },
         { command: 'claude-flow doctor -c version', description: 'Check for stale npx cache' },
         { command: 'claude-flow doctor -c claude', description: 'Check Claude Code CLI only' }
     ],
@@ -452,11 +530,53 @@ export const doctorCommand = {
         const autoInstall = ctx.flags.install;
         const component = ctx.flags.component;
         const verbose = ctx.flags.verbose;
+        const killZombies = ctx.flags['kill-zombies'];
         output.writeln();
         output.writeln(output.bold('MoFlo Doctor'));
         output.writeln(output.dim('System diagnostics and health check'));
         output.writeln(output.dim('─'.repeat(50)));
         output.writeln();
+        // Handle --kill-zombies early
+        if (killZombies) {
+            output.writeln(output.bold('Zombie Process Scan'));
+            output.writeln();
+            // First scan without killing to show what would be killed
+            const scan = await findZombieProcesses(false);
+            if (scan.found === 0) {
+                output.writeln(output.success('  No orphaned moflo processes found'));
+            }
+            else {
+                output.writeln(output.warning(`  Found ${scan.found} orphaned process(es): PIDs ${scan.pids.join(', ')}`));
+                // Kill them
+                const result = await findZombieProcesses(true);
+                if (result.killed > 0) {
+                    output.writeln(output.success(`  Killed ${result.killed} zombie process(es)`));
+                }
+                if (result.killed < result.found) {
+                    output.writeln(output.warning(`  ${result.found - result.killed} process(es) could not be killed`));
+                }
+            }
+            output.writeln();
+            output.writeln(output.dim('─'.repeat(50)));
+            output.writeln();
+        }
+        const checkZombieProcesses = async () => {
+            try {
+                const scan = await findZombieProcesses(false);
+                if (scan.found === 0) {
+                    return { name: 'Zombie Processes', status: 'pass', message: 'No orphaned processes' };
+                }
+                return {
+                    name: 'Zombie Processes',
+                    status: 'warn',
+                    message: `${scan.found} orphaned process(es) (PIDs: ${scan.pids.join(', ')})`,
+                    fix: 'moflo doctor --kill-zombies'
+                };
+            }
+            catch {
+                return { name: 'Zombie Processes', status: 'pass', message: 'Check skipped' };
+            }
+        };
         const allChecks = [
             checkVersionFreshness,
             checkNodeVersion,
@@ -470,7 +590,8 @@ export const doctorCommand = {
             checkMcpServers,
             checkDiskSpace,
             checkBuildTools,
-            checkAgenticFlow
+            checkAgenticFlow,
+            checkZombieProcesses
         ];
         const componentMap = {
             'version': checkVersionFreshness,

package/src/@claude-flow/cli/dist/src/commands/embeddings.js

@@ -13,6 +13,7 @@
  * Created with ❤️ by motailz.com
  */
 import { output } from '../output.js';
+import { mofloImport } from '../services/moflo-require.js';
 // Dynamic imports for embeddings package (optional — may not be installed)
 async function getEmbeddings() {
     try {
@@ -135,7 +136,7 @@ const searchCommand = {
                 return { success: false, exitCode: 1 };
             }
             // Load sql.js
-            const initSqlJs = (await import('sql.js')).default;
+            const initSqlJs = (await mofloImport('sql.js')).default;
             const SQL = await initSqlJs();
             const fileBuffer = fs.readFileSync(fullDbPath);
             const db = new SQL.Database(fileBuffer);
@@ -378,7 +379,7 @@ const collectionsCommand = {
                 return { success: true, data: [] };
             }
             // Load sql.js and query real data
-            const initSqlJs = (await import('sql.js')).default;
+            const initSqlJs = (await mofloImport('sql.js')).default;
             const SQL = await initSqlJs();
             const fileBuffer = fs.readFileSync(fullDbPath);
             const db = new SQL.Database(fileBuffer);
@@ -1200,7 +1201,7 @@ const cacheCommand = {
                 }
                 // Try to count real entries via sql.js
                 try {
-                    const initSqlJs = (await import('sql.js')).default;
+                    const initSqlJs = (await mofloImport('sql.js')).default;
                     const SQL = await initSqlJs();
                     const fileBuffer = fs.readFileSync(resolvedDbPath);
                     const db = new SQL.Database(fileBuffer);

package/src/@claude-flow/cli/dist/src/commands/hooks.js

@@ -6,6 +6,7 @@ import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { storeCommand } from './transfer-store.js';
+import { mofloImport } from '../services/moflo-require.js';
 // Hook types
 const HOOK_TYPES = [
     { value: 'pre-edit', label: 'Pre-Edit', hint: 'Get context before editing files' },
@@ -3074,7 +3075,7 @@ const tokenOptimizeCommand = {
         let reasoningBank = null;
         try {
             // Check if agentic-flow v3 is available
-            const rb = await import('agentic-flow/reasoningbank').catch(() => null);
+            const rb = await mofloImport('agentic-flow/reasoningbank');
             if (rb) {
                 agenticFlowAvailable = true;
                 if (typeof rb.retrieveMemories === 'function') {
@@ -3083,7 +3084,7 @@ const tokenOptimizeCommand = {
             }
             else {
                 // Legacy check for older agentic-flow
-                const af = await import('agentic-flow').catch(() => null);
+                const af = await mofloImport('agentic-flow');
                 if (af)
                     agenticFlowAvailable = true;
             }

package/src/@claude-flow/cli/dist/src/commands/mcp.js

@@ -9,6 +9,7 @@ import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { getServerManager, getMCPServerStatus, } from '../mcp-server.js';
 import { listMCPTools, callMCPTool, hasTool } from '../mcp-client.js';
+import { acquireDaemonLock, releaseDaemonLock, getDaemonLockHolder } from '../services/daemon-lock.js';
 // MCP tools categories
 const TOOL_CATEGORIES = [
     { value: 'coordination', label: 'Coordination', hint: 'Swarm and agent coordination tools' },
@@ -97,14 +98,19 @@ const startCommand = {
         output.writeln();
         output.printInfo('Starting MCP Server...');
         output.writeln();
-        // Check if already running
+        // Check daemon lock first — prevents duplicate MCP servers across all platforms
+        const projectRoot = process.cwd();
+        const lockHolder = getDaemonLockHolder(projectRoot);
+        if (lockHolder && lockHolder !== process.pid && !force) {
+            output.printWarning(`MCP Server already running (PID: ${lockHolder}, detected via daemon lock)`);
+            output.writeln(output.dim('Use --force to override, or stop the existing server first'));
+            return { success: true };
+        }
+        // Check if already running via server status
         const existingStatus = await getMCPServerStatus();
         if (existingStatus.running) {
-            // For stdio transport, always force restart since we can't health check it
-            // For other transports, check health unless --force is specified
-            const shouldForceRestart = force || transport === 'stdio';
-            if (!shouldForceRestart) {
-                // Verify the server is actually healthy/responsive
+            // For non-stdio transports, check health unless --force is specified
+            if (!force && transport !== 'stdio') {
                 const manager = getServerManager();
                 const health = await manager.checkHealth();
                 if (health.healthy) {
@@ -113,26 +119,36 @@ const startCommand = {
                     return { success: false, exitCode: 1 };
                 }
             }
-            // Force restart or unresponsive - auto-recover
-            output.printWarning(`MCP Server (PID: ${existingStatus.pid}) - restarting...`);
-            try {
-                // Force kill the existing process
-                if (existingStatus.pid) {
-                    try {
-                        process.kill(existingStatus.pid, 'SIGKILL');
-                    }
-                    catch {
-                        // Process may already be dead
+            if (force) {
+                // Force restart — kill existing and continue
+                output.printWarning(`MCP Server (PID: ${existingStatus.pid}) - restarting...`);
+                try {
+                    if (existingStatus.pid) {
+                        try {
+                            process.kill(existingStatus.pid, 'SIGKILL');
+                        }
+                        catch {
+                            // Process may already be dead
+                        }
                     }
+                    const manager = getServerManager();
+                    await manager.stop();
+                    // Release stale daemon lock from old process
+                    releaseDaemonLock(projectRoot, existingStatus.pid || 0, true);
+                    output.writeln(output.dim('  Cleaned up existing server'));
+                }
+                catch {
+                    // Continue anyway - the stop/cleanup may partially fail
                 }
-                const manager = getServerManager();
-                await manager.stop();
-                output.writeln(output.dim('  Cleaned up existing server'));
-            }
-            catch {
-                // Continue anyway - the stop/cleanup may partially fail
             }
         }
+        // Acquire daemon lock for the new server
+        const lockResult = acquireDaemonLock(projectRoot);
+        if (!lockResult.acquired) {
+            output.printWarning(`Cannot acquire daemon lock (held by PID: ${lockResult.holder})`);
+            output.writeln(output.dim('Use --force to override'));
+            return { success: true };
+        }
         const options = {
             transport,
             host,

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

@@ -7,6 +7,7 @@ import * as pathModule from 'path';
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import { mofloImport } from '../services/moflo-require.js';
 // Memory backends
 const BACKENDS = [
     { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing (150x-12,500x faster)' },
@@ -1263,7 +1264,7 @@ const SWARM_DIR = '.swarm';
 async function openDb(cwd) {
     const fs = await import('fs');
     const path = await import('path');
-    const initSqlJs = (await import('sql.js')).default;
+    const initSqlJs = (await mofloImport('sql.js')).default;
     const SQL = await initSqlJs();
     const dbPath = path.join(cwd, SWARM_DIR, DB_FILENAME);
     const dir = path.dirname(dbPath);

package/src/@claude-flow/cli/dist/src/commands/neural.js

@@ -5,6 +5,7 @@
  * Created with ❤️ by motailz.com
  */
 import { output } from '../output.js';
+import { mofloImport, mofloResolve } from '../services/moflo-require.js';
 // Train subcommand - REAL WASM training with RuVector
 const trainCommand = {
     name: 'train',
@@ -1305,7 +1306,9 @@ const benchmarkCommand = {
         const spinner = output.createSpinner({ text: 'Running benchmarks...', spinner: 'dots' });
         spinner.start();
         try {
-            const attention = await import('@ruvector/attention');
+            const attention = await mofloImport('@ruvector/attention');
+            if (!attention)
+                throw new Error('@ruvector/attention not available');
             // Manual benchmark since benchmarkAttention has a binding bug
             const benchmarkMechanism = async (name, mechanism) => {
                 const query = new Float32Array(dim);
@@ -1381,11 +1384,13 @@ const benchmarkCommand = {
             spinner.setText('Benchmarking MicroLoRA adaptation...');
             // Load WASM file directly (Node.js compatible)
             const fs = await import('fs');
-            const { createRequire } = await import('module');
-            const require = createRequire(import.meta.url);
-            const wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+            const wasmPath = mofloResolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+            if (!wasmPath)
+                throw new Error('@ruvector/learning-wasm not found');
             const wasmBuffer = fs.readFileSync(wasmPath);
-            const learningWasm = await import('@ruvector/learning-wasm');
+            const learningWasm = await mofloImport('@ruvector/learning-wasm');
+            if (!learningWasm)
+                throw new Error('@ruvector/learning-wasm not available');
             learningWasm.initSync({ module: wasmBuffer });
             const lora = new learningWasm.WasmMicroLoRA(dim, 0.1, 0.01);
             const gradient = new Float32Array(dim);

package/src/@claude-flow/cli/dist/src/config/moflo-config.d.ts

@@ -50,6 +50,11 @@ export interface MofloConfig {
         circuit_breaker: boolean;
         agent_overrides: Record<string, string>;
     };
+    auto_update: {
+        enabled: boolean;
+        scripts: boolean;
+        helpers: boolean;
+    };
     status_line: {
         enabled: boolean;
         branding: string;

package/src/@claude-flow/cli/dist/src/config/moflo-config.js

@@ -69,6 +69,11 @@ const DEFAULT_CONFIG = {
         circuit_breaker: true,
         agent_overrides: {},
     },
+    auto_update: {
+        enabled: true,
+        scripts: true,
+        helpers: true,
+    },
     status_line: {
         enabled: true,
         branding: 'Moflo V4',
@@ -159,6 +164,11 @@ function mergeConfig(raw, root) {
             circuit_breaker: raw.model_routing?.circuit_breaker ?? raw.modelRouting?.circuitBreaker ?? DEFAULT_CONFIG.model_routing.circuit_breaker,
             agent_overrides: raw.model_routing?.agent_overrides ?? raw.modelRouting?.agentOverrides ?? DEFAULT_CONFIG.model_routing.agent_overrides,
         },
+        auto_update: {
+            enabled: raw.auto_update?.enabled ?? raw.autoUpdate?.enabled ?? DEFAULT_CONFIG.auto_update.enabled,
+            scripts: raw.auto_update?.scripts ?? raw.autoUpdate?.scripts ?? DEFAULT_CONFIG.auto_update.scripts,
+            helpers: raw.auto_update?.helpers ?? raw.autoUpdate?.helpers ?? DEFAULT_CONFIG.auto_update.helpers,
+        },
         status_line: {
             enabled: raw.status_line?.enabled ?? raw.statusLine?.enabled ?? DEFAULT_CONFIG.status_line.enabled,
             branding: raw.status_line?.branding ?? raw.statusLine?.branding ?? DEFAULT_CONFIG.status_line.branding,
@@ -314,6 +324,12 @@ model_routing:
   #   security-architect: opus     # Always use opus for security
   #   researcher: sonnet           # Pin research to sonnet
 
+# Auto-update on session start (syncs scripts and helpers when moflo version changes)
+auto_update:
+  enabled: true                  # Master toggle for version-change auto-sync
+  scripts: true                  # Sync .claude/scripts/ from moflo bin/
+  helpers: true                  # Sync .claude/helpers/ from moflo source
+
 # Status line items (show/hide individual sections)
 status_line:
   enabled: true