moflo 4.7.8 → 4.8.1

package/src/@claude-flow/cli/dist/src/index.js

@@ -27,6 +27,7 @@ function getPackageVersion() {
     }
 }
 export const VERSION = getPackageVersion();
+const LONG_RUNNING_COMMANDS = ['mcp', 'daemon'];
 /**
  * V3 CLI Application
  */
@@ -201,6 +202,17 @@ export class CLI {
                 if (result && !result.success) {
                     process.exit(result.exitCode || 1);
                 }
+                // Explicitly exit after successful non-long-running commands to prevent
+                // zombie processes on Windows where open handles keep node alive.
+                // Skip for MCP/daemon commands that need to stay running.
+                // Also skip in test environments (vitest/jest) where process.exit is mocked.
+                const isTestEnv = 'VITEST' in process.env
+                    || 'JEST_WORKER_ID' in process.env
+                    || process.env.NODE_ENV === 'test';
+                if (!LONG_RUNNING_COMMANDS.includes(commandName) && !isTestEnv) {
+                    // Use setImmediate to let any pending I/O flush before exit
+                    setImmediate(() => process.exit(0));
+                }
             }
             else {
                 // No action - show command help

package/src/@claude-flow/cli/dist/src/init/executor.js

@@ -423,6 +423,46 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             };
             fs.writeFileSync(statuslinePath, generateStatuslineScript(upgradeOptions), 'utf-8');
         }
+        // 1b. ALWAYS sync .claude/scripts/ from moflo bin/ (derived files, not user-edited)
+        // Scripts contain critical daemon guards, hook logic, etc. that must stay in sync.
+        const scriptsDir = path.join(targetDir, '.claude', 'scripts');
+        if (!fs.existsSync(scriptsDir)) {
+            fs.mkdirSync(scriptsDir, { recursive: true });
+        }
+        const UPGRADE_SCRIPT_MAP = {
+            'hooks.mjs': 'hooks.mjs',
+            'session-start-launcher.mjs': 'session-start-launcher.mjs',
+            'index-guidance.mjs': 'index-guidance.mjs',
+            'build-embeddings.mjs': 'build-embeddings.mjs',
+            'generate-code-map.mjs': 'generate-code-map.mjs',
+            'semantic-search.mjs': 'semantic-search.mjs',
+        };
+        const binDir = findMofloBinDir();
+        if (binDir) {
+            for (const [destName, srcName] of Object.entries(UPGRADE_SCRIPT_MAP)) {
+                const srcPath = path.join(binDir, srcName);
+                const destPath = path.join(scriptsDir, destName);
+                if (!fs.existsSync(srcPath))
+                    continue;
+                try {
+                    const srcStat = fs.statSync(srcPath);
+                    const destExists = fs.existsSync(destPath);
+                    // Always overwrite if source is newer or dest doesn't exist
+                    if (!destExists || srcStat.mtimeMs > fs.statSync(destPath).mtimeMs) {
+                        fs.copyFileSync(srcPath, destPath);
+                        if (destExists) {
+                            result.updated.push(`.claude/scripts/${destName}`);
+                        }
+                        else {
+                            result.created.push(`.claude/scripts/${destName}`);
+                        }
+                    }
+                }
+                catch {
+                    // Non-fatal — skip individual script on error
+                }
+            }
+        }
         // 2. Create MISSING metrics files only (preserve existing data)
         const metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
         const securityDir = path.join(targetDir, '.claude-flow', 'security');
@@ -898,6 +938,40 @@ function findSourceHelpersDir(sourceBaseDir) {
     }
     return null;
 }
+/**
+ * Find the moflo bin/ directory (source of truth for .claude/scripts/).
+ * Uses the same resolution strategies as findSourceHelpersDir.
+ */
+function findMofloBinDir() {
+    const possiblePaths = [];
+    const SENTINEL_FILE = 'hooks.mjs'; // Must exist in valid bin/
+    // Strategy 1: require.resolve
+    try {
+        const esmRequire = createRequire(import.meta.url);
+        const pkgJsonPath = esmRequire.resolve('moflo/package.json');
+        possiblePaths.push(path.join(path.dirname(pkgJsonPath), 'bin'));
+    }
+    catch { /* not installed as package */ }
+    // Strategy 2: __dirname-based (dist/src/init -> package root -> bin)
+    possiblePaths.push(path.resolve(__dirname, '..', '..', '..', 'bin'));
+    // Strategy 3: Walk up from __dirname
+    let currentDir = __dirname;
+    for (let i = 0; i < 10; i++) {
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        possiblePaths.push(path.join(parentDir, 'bin'));
+        currentDir = parentDir;
+    }
+    // Strategy 4: cwd-relative (node_modules/moflo/bin)
+    possiblePaths.push(path.join(process.cwd(), 'node_modules', 'moflo', 'bin'));
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p) && fs.existsSync(path.join(p, SENTINEL_FILE))) {
+            return p;
+        }
+    }
+    return null;
+}
 /**
  * Write helper scripts
  */

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

@@ -105,6 +105,8 @@ export async function initMoflo(options) {
     steps.push(syncScripts(projectRoot, force));
     // Step 6: .gitignore entries
     steps.push(updateGitignore(projectRoot));
+    // Step 7: .claude/guidance/moflo-bootstrap.md (subagent bootstrap protocol)
+    steps.push(syncBootstrapGuidance(projectRoot, force));
     return { steps };
 }
 // ============================================================================
@@ -647,4 +649,51 @@ function updateGitignore(root) {
     fs.appendFileSync(gitignorePath, '\n# MoFlo state (gitignored)\n' + toAdd.join('\n') + '\n');
     return { name: '.gitignore', status: 'updated', detail: `Added: ${toAdd.join(', ')}` };
 }
+// ============================================================================
+// Step 7: .claude/guidance/moflo-bootstrap.md
+// Copies the agent bootstrap guidance to the project so subagents can read it
+// from disk without requiring memory search.
+// ============================================================================
+function syncBootstrapGuidance(root, force) {
+    const guidanceDir = path.join(root, '.claude', 'guidance');
+    const targetFile = path.join(guidanceDir, 'moflo-bootstrap.md');
+    // Find the source bootstrap file from the moflo package
+    let sourceDir;
+    try {
+        sourceDir = path.dirname(fileURLToPath(import.meta.url));
+    }
+    catch {
+        sourceDir = typeof __dirname !== 'undefined' ? __dirname : '';
+    }
+    const candidates = [
+        path.join(root, 'node_modules', 'moflo', '.claude', 'guidance', 'agent-bootstrap.md'),
+        // When running from moflo repo itself
+        ...(sourceDir ? [path.join(sourceDir, '..', '..', '..', '..', '.claude', 'guidance', 'agent-bootstrap.md')] : []),
+    ];
+    const sourceFile = candidates.find(f => { try {
+        return fs.existsSync(f);
+    }
+    catch {
+        return false;
+    } });
+    if (!sourceFile) {
+        return { name: 'guidance/moflo-bootstrap.md', status: 'skipped', detail: 'Source bootstrap not found' };
+    }
+    // Check if target exists and is up to date
+    if (fs.existsSync(targetFile) && !force) {
+        if (!isStale(sourceFile, targetFile)) {
+            return { name: 'guidance/moflo-bootstrap.md', status: 'skipped', detail: 'Already up to date' };
+        }
+    }
+    // Read source and prepend header
+    const content = fs.readFileSync(sourceFile, 'utf-8');
+    const header = `<!-- AUTO-GENERATED by moflo init. Do not edit — changes will be overwritten on next init. -->\n<!-- Source: moflo/.claude/guidance/agent-bootstrap.md -->\n<!-- To customize, create .claude/guidance/agent-bootstrap.md for project-specific rules. -->\n\n`;
+    fs.mkdirSync(guidanceDir, { recursive: true });
+    fs.writeFileSync(targetFile, header + content, 'utf-8');
+    return {
+        name: 'guidance/moflo-bootstrap.md',
+        status: fs.existsSync(targetFile) ? 'updated' : 'created',
+        detail: 'Subagent bootstrap protocol'
+    };
+}
 //# sourceMappingURL=moflo-init.js.map

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

@@ -263,7 +263,7 @@ export const memoryTools = [
             type: 'object',
             properties: {
                 query: { type: 'string', description: 'Search query (semantic similarity)' },
-                namespace: { type: 'string', description: 'Namespace to search (default: "default")' },
+                namespace: { type: 'string', description: 'Namespace to search (default: all namespaces)' },
                 limit: { type: 'number', description: 'Maximum results (default: 10)' },
                 threshold: { type: 'number', description: 'Minimum similarity threshold 0-1 (default: 0.3)' },
             },
@@ -273,7 +273,7 @@ export const memoryTools = [
             await ensureInitialized();
             const { searchEntries } = await getMemoryFunctions();
             const query = input.query;
-            const namespace = input.namespace || 'default';
+            const namespace = input.namespace || 'all';
             const limit = input.limit || 10;
             const threshold = input.threshold || 0.3;
             validateMemoryInput(undefined, undefined, query);

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

@@ -13,12 +13,13 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { mofloImport } from '../services/moflo-require.js';
 // Try to import real embeddings — prefer agentic-flow v3 ReasoningBank, then @claude-flow/embeddings
 let realEmbeddings = null;
 let embeddingServiceName = 'none';
 try {
     // Tier 1: agentic-flow v3 ReasoningBank (fastest — WASM-accelerated)
-    const rb = await import('agentic-flow/reasoningbank').catch(() => null);
+    const rb = await mofloImport('agentic-flow/reasoningbank');
     if (rb?.computeEmbedding) {
         realEmbeddings = { embed: (text) => rb.computeEmbedding(text) };
         embeddingServiceName = 'agentic-flow/reasoningbank';

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

@@ -18,6 +18,7 @@
  */
 import * as path from 'path';
 import * as crypto from 'crypto';
+import { mofloImport } from '../services/moflo-require.js';
 // ===== Project root resolution =====
 // When run via npx, CWD may be node_modules/moflo — walk up to find actual project
 import * as fs from 'fs';
@@ -59,7 +60,10 @@ async function getFallbackEmbedder() {
     if (_tfEmbedder)
         return _tfEmbedder;
     try {
-        const { pipeline } = await import('@xenova/transformers');
+        const transformersModule = await mofloImport('@xenova/transformers');
+        if (!transformersModule)
+            throw new Error('@xenova/transformers not available');
+        const { pipeline } = transformersModule;
         _tfEmbedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
         return _tfEmbedder;
     }

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

@@ -10,6 +10,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { mofloImport } from '../services/moflo-require.js';
 /**
  * Write vector-stats.json cache for the statusline (no subprocess needed).
  * Called after memory store/delete to keep the cache fresh.
@@ -379,7 +380,7 @@ export async function getHNSWIndex(options) {
     try {
         // Import @ruvector/core dynamically
         // Handle both ESM (default export) and CJS patterns
-        const ruvectorModule = await import('@ruvector/core').catch(() => null);
+        const ruvectorModule = await mofloImport('@ruvector/core');
         if (!ruvectorModule) {
             hnswInitializing = false;
             return null; // HNSW not available
@@ -436,7 +437,7 @@ export async function getHNSWIndex(options) {
         }
         if (fs.existsSync(dbPath)) {
             try {
-                const initSqlJs = (await import('sql.js')).default;
+                const initSqlJs = (await mofloImport('sql.js')).default;
                 const SQL = await initSqlJs();
                 const fileBuffer = fs.readFileSync(dbPath);
                 const sqlDb = new SQL.Database(fileBuffer);
@@ -852,7 +853,7 @@ export async function ensureSchemaColumns(dbPath) {
         if (!fs.existsSync(dbPath)) {
             return { success: true, columnsAdded: [] };
         }
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
@@ -919,7 +920,7 @@ export async function checkAndMigrateLegacy(options) {
     for (const legacyPath of legacyPaths) {
         if (fs.existsSync(legacyPath) && legacyPath !== dbPath) {
             try {
-                const initSqlJs = (await import('sql.js')).default;
+                const initSqlJs = (await mofloImport('sql.js')).default;
                 const SQL = await initSqlJs();
                 const legacyBuffer = fs.readFileSync(legacyPath);
                 const legacyDb = new SQL.Database(legacyBuffer);
@@ -1038,7 +1039,7 @@ export async function initializeMemoryDatabase(options) {
         let usedSqlJs = false;
         try {
             // Dynamic import of sql.js
-            const initSqlJs = (await import('sql.js')).default;
+            const initSqlJs = (await mofloImport('sql.js')).default;
             const SQL = await initSqlJs();
             // Load existing database or create new
             if (fs.existsSync(dbPath) && force) {
@@ -1188,7 +1189,7 @@ export async function checkMemoryInitialization(dbPath) {
     }
     try {
         // Try to load with sql.js
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(path_);
         const db = new SQL.Database(fileBuffer);
@@ -1233,7 +1234,7 @@ export async function applyTemporalDecay(dbPath) {
     const swarmDir = path.join(process.cwd(), '.swarm');
     const path_ = dbPath || path.join(swarmDir, 'memory.db');
     try {
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(path_);
         const db = new SQL.Database(fileBuffer);
@@ -1294,14 +1295,14 @@ export async function loadEmbeddingModel(options) {
                 loaded: true,
                 model: null, // Bridge handles embedding
                 tokenizer: null,
-                dimensions: bridgeResult.dimensions
+                dimensions: bridgeResult.dimensions,
+                modelName: bridgeResult.modelName || 'bridge'
             };
             return bridgeResult;
         }
     }
     try {
-        // Try to import @xenova/transformers for ONNX embeddings
-        const transformers = await import('@xenova/transformers').catch(() => null);
+        const transformers = await mofloImport('@xenova/transformers');
         if (transformers) {
             if (verbose) {
                 console.log('Loading ONNX embedding model (all-MiniLM-L6-v2)...');
@@ -1313,7 +1314,8 @@ export async function loadEmbeddingModel(options) {
                 loaded: true,
                 model: embedder,
                 tokenizer: null,
-                dimensions: 384 // MiniLM-L6 produces 384-dim vectors
+                dimensions: 384, // MiniLM-L6 produces 384-dim vectors
+                modelName: 'Xenova/all-MiniLM-L6-v2'
             };
             return {
                 success: true,
@@ -1323,7 +1325,7 @@ export async function loadEmbeddingModel(options) {
             };
         }
         // Fallback: Check for agentic-flow ReasoningBank embeddings (v3)
-        const reasoningBank = await import('agentic-flow/reasoningbank').catch(() => null);
+        const reasoningBank = await mofloImport('agentic-flow/reasoningbank');
         if (reasoningBank?.computeEmbedding) {
             if (verbose) {
                 console.log('Loading agentic-flow ReasoningBank embedding model...');
@@ -1332,7 +1334,8 @@ export async function loadEmbeddingModel(options) {
                 loaded: true,
                 model: { embed: reasoningBank.computeEmbedding },
                 tokenizer: null,
-                dimensions: 768
+                dimensions: 768,
+                modelName: 'agentic-flow/reasoningbank'
             };
             return {
                 success: true,
@@ -1342,7 +1345,7 @@ export async function loadEmbeddingModel(options) {
             };
         }
         // Legacy fallback: Check for agentic-flow core embeddings
-        const agenticFlow = await import('agentic-flow').catch(() => null);
+        const agenticFlow = await mofloImport('agentic-flow');
         if (agenticFlow && agenticFlow.embeddings) {
             if (verbose) {
                 console.log('Loading agentic-flow embedding model...');
@@ -1351,7 +1354,8 @@ export async function loadEmbeddingModel(options) {
                 loaded: true,
                 model: agenticFlow.embeddings,
                 tokenizer: null,
-                dimensions: 768
+                dimensions: 768,
+                modelName: 'agentic-flow'
             };
             return {
                 success: true,
@@ -1365,7 +1369,8 @@ export async function loadEmbeddingModel(options) {
             loaded: true,
             model: null, // Will use domain-aware hash fallback
             tokenizer: null,
-            dimensions: 384 // Domain-aware hash embedding dimensions
+            dimensions: 384, // Domain-aware hash embedding dimensions
+            modelName: 'domain-aware-hash-384'
         };
         return {
             success: true,
@@ -1408,7 +1413,7 @@ export async function generateEmbedding(text) {
             return {
                 embedding,
                 dimensions: embedding.length,
-                model: 'onnx'
+                model: state.modelName || 'Xenova/all-MiniLM-L6-v2'
             };
         }
         catch {
@@ -1420,7 +1425,7 @@ export async function generateEmbedding(text) {
     return {
         embedding,
         dimensions: 384,
-        model: 'domain-aware-hash-384'
+        model: state.modelName || 'domain-aware-hash-384'
     };
 }
 /**
@@ -1610,7 +1615,7 @@ export async function verifyMemoryInit(dbPath, options) {
     const { verbose = false } = options || {};
     const tests = [];
     try {
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fs = await import('fs');
         // Load database
@@ -1800,7 +1805,7 @@ export async function storeEntry(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
@@ -1919,7 +1924,7 @@ export async function searchEntries(options) {
             };
         }
         // Fall back to brute-force SQLite search
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
@@ -2025,7 +2030,7 @@ export async function listEntries(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
@@ -2094,7 +2099,7 @@ export async function getEntry(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
@@ -2184,7 +2189,7 @@ export async function deleteEntry(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
-        const initSqlJs = (await import('sql.js')).default;
+        const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);

package/src/@claude-flow/cli/dist/src/ruvector/ast-analyzer.js

@@ -6,6 +6,7 @@
  *
  * @module ast-analyzer
  */
+import { mofloImport } from '../services/moflo-require.js';
 const DEFAULT_CONFIG = {
     maxFileSize: 1024 * 1024,
     languages: ['typescript', 'javascript', 'python', 'rust', 'go'],
@@ -31,7 +32,7 @@ export class ASTAnalyzer {
     async initialize() {
         try {
             // @ruvector/ast is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/ast').catch(() => null);
+            const ruvector = await mofloImport('@ruvector/ast');
             if (ruvector) {
                 this.ruvectorEngine = ruvector.createASTAnalyzer?.(this.config);
                 this.useNative = !!this.ruvectorEngine;

package/src/@claude-flow/cli/dist/src/ruvector/coverage-router.js

@@ -9,6 +9,7 @@
 // ============================================================================
 // Caching for Performance
 // ============================================================================
+import { mofloImport } from '../services/moflo-require.js';
 /**
  * Cache for coverage data (1 minute TTL)
  */
@@ -43,7 +44,7 @@ export class CoverageRouter {
     async initialize() {
         try {
             // @ruvector/coverage is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/coverage').catch(() => null);
+            const ruvector = await mofloImport('@ruvector/coverage');
             if (ruvector) {
                 this.ruvectorEngine = ruvector.createCoverageRouter?.(this.config);
                 this.useNative = !!this.ruvectorEngine;

package/src/@claude-flow/cli/dist/src/ruvector/diff-classifier.js

@@ -1,6 +1,7 @@
 /**
  * Diff Classifier for Change Analysis
  */
+import { mofloImport } from '../services/moflo-require.js';
 const DEFAULT_CONFIG = {
     maxDiffSize: 10000,
     classifyByImpact: true,
@@ -31,7 +32,7 @@ export class DiffClassifier {
     async initialize() {
         try {
             // @ruvector/diff is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/diff').catch(() => null);
+            const ruvector = await mofloImport('@ruvector/diff');
             if (ruvector) {
                 this.ruvectorEngine = ruvector.createDiffClassifier?.(this.config);
                 this.useNative = !!this.ruvectorEngine;

package/src/@claude-flow/cli/dist/src/ruvector/enhanced-model-router.js

@@ -11,6 +11,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { extname } from 'path';
 import { getModelRouter } from './model-router.js';
+import { mofloImport } from '../services/moflo-require.js';
 // ============================================================================
 // Intent Detection Patterns
 // ============================================================================
@@ -432,9 +433,8 @@ export class EnhancedModelRouter {
             const language = intent.language || 'javascript';
             // Try local agentic-flow agent-booster (v3 — no npx needed)
             // Note: agent-booster export declared but dist missing in alpha.1; use intelligence path as fallback
-            const boosterModule = await import('agentic-flow/agent-booster')
-                .catch(() => import(/* @vite-ignore */ 'agentic-flow/intelligence/agent-booster-enhanced'))
-                .catch(() => null);
+            const boosterModule = await mofloImport('agentic-flow/agent-booster')
+                || await mofloImport('agentic-flow/intelligence/agent-booster-enhanced');
             if (boosterModule?.enhancedApply) {
                 const result = await boosterModule.enhancedApply({
                     code: originalCode,

package/src/@claude-flow/cli/dist/src/ruvector/index.js

@@ -33,28 +33,21 @@ export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttentio
 export { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, } from './lora-adapter.js';
 export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, } from './model-router.js';
 export { SemanticRouter, createSemanticRouter, } from './semantic-router.js';
+import { mofloImport } from '../services/moflo-require.js';
 /**
  * Check if ruvector packages are available
  */
 export async function isRuvectorAvailable() {
-    try {
-        await import('@ruvector/core');
-        return true;
-    }
-    catch {
-        return false;
-    }
+    const mod = await mofloImport('@ruvector/core');
+    return mod !== null;
 }
 /**
  * Get ruvector version if available
  */
 export async function getRuvectorVersion() {
-    try {
-        const ruvector = await import('@ruvector/core');
-        return ruvector.version || '1.0.0';
-    }
-    catch {
+    const ruvector = await mofloImport('@ruvector/core');
+    if (!ruvector)
         return null;
-    }
+    return ruvector.version || '1.0.0';
 }
 //# sourceMappingURL=index.js.map

package/src/@claude-flow/cli/dist/src/ruvector/q-learning-router.js

@@ -15,6 +15,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
+import { mofloImport } from '../services/moflo-require.js';
 /**
  * Default configuration
  */
@@ -110,7 +111,9 @@ export class QLearningRouter {
      */
     async initialize() {
         try {
-            const ruvector = await import('@ruvector/core');
+            const ruvector = await mofloImport('@ruvector/core');
+            if (!ruvector)
+                throw new Error('not available');
             this.ruvectorEngine = ruvector.createQLearning?.(this.config);
             this.useNative = !!this.ruvectorEngine;
         }

package/src/@claude-flow/cli/dist/src/services/daemon-lock.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Atomic daemon lock — prevents duplicate daemon processes.
+ *
+ * Uses fs.writeFileSync with { flag: 'wx' } (O_CREAT | O_EXCL) which is
+ * atomic on all platforms: the write fails immediately if the file exists,
+ * eliminating the TOCTOU race in the old PID-file approach.
+ *
+ * Also solves Windows PID recycling by storing a label in the lock payload
+ * and verifying the process command line before trusting a "live" PID.
+ */
+export interface DaemonLockPayload {
+    pid: number;
+    startedAt: number;
+    label: string;
+}
+/** Resolve the lock file path for a project root. */
+export declare function lockPath(projectRoot: string): string;
+/**
+ * Try to acquire the daemon lock atomically.
+ *
+ * @returns `{ acquired: true }` on success,
+ *          `{ acquired: false, holder: pid }` if another daemon owns the lock.
+ */
+export declare function acquireDaemonLock(projectRoot: string, pid?: number): {
+    acquired: true;
+} | {
+    acquired: false;
+    holder: number;
+};
+/**
+ * Release the daemon lock. Only removes if we own it (or force = true).
+ */
+export declare function releaseDaemonLock(projectRoot: string, pid?: number, force?: boolean): void;
+/**
+ * Check if the daemon lock is currently held by a live daemon.
+ * Returns the holder PID or null.
+ */
+export declare function getDaemonLockHolder(projectRoot: string): number | null;
+//# sourceMappingURL=daemon-lock.d.ts.map