moflo 4.7.8 → 4.8.1

package/.claude/settings.local.json

@@ -8,7 +8,10 @@
       "Bash(tasklist.exe /FI \"IMAGENAME eq node.exe\" /V)",
       "Bash(powershell.exe -NoProfile -Command \"Get-Process node -ErrorAction SilentlyContinue | Select-Object Id,ProcessName,StartTime,CommandLine | Format-Table -AutoSize\")",
       "Bash(npm version:*)",
-      "Bash(gh pr:*)"
+      "Bash(gh pr:*)",
+      "mcp__claude-flow__memory_store",
+      "mcp__claude-flow__memory_retrieve",
+      "mcp__claude-flow__memory_search"
     ]
   }
 }

package/.claude/workflow-state.json

@@ -1,9 +1,5 @@
 {
-  "tasksCreated": false,
-  "taskCount": 0,
-  "memorySearched": false,
-  "memoryRequired": true,
-  "interactionCount": 10,
-  "sessionStart": null,
-  "lastBlockedAt": "2026-03-21T05:00:01.929Z"
+  "tasksCreated": true,
+  "taskCount": 1,
+  "memorySearched": true
 }

package/README.md

@@ -4,6 +4,8 @@
 
 # MoFlo
 
+**⚠️ MoFlo is experimental software. APIs, commands, and behavior may change without notice.**
+
 **An opinionated fork of [Ruflo/Claude Flow](https://github.com/ruvnet/ruflo), optimized for local development.**
 
 MoFlo adds automatic code and guidance cataloging along with memory gating on top of the original Ruflo/Claude Flow orchestration engine. Where the upstream project provides raw building blocks, MoFlo ships opinionated defaults — workflow gates that enforce memory-first patterns, semantic indexing that runs at session start, and learned routing that improves over time — so you get a productive setup from `flo init` without manual tuning.
@@ -30,7 +32,7 @@ MoFlo makes deliberate choices so you don't have to:
 - **Task registration before agents** — Sub-agents can't spawn until work is tracked. Prevents runaway agent proliferation.
 - **Learned routing** — Task outcomes feed back into the routing system automatically. No manual configuration needed — it gets smarter with use.
 - **Incremental indexing** — Guidance and code map indexes run on every session start but skip unchanged files. Fast after the first run.
-- **AI client agnostic** — Works with any MCP-capable AI client. We develop and test with Claude Code, but the MCP tools, memory system, and hooks are client-independent.
+- **Built for Claude Code, works with others** — We develop and test exclusively with Claude Code. The MCP tools, memory system, and hooks are client-independent and should work with any MCP-capable AI client, but Claude Code is the only tested target.
 - **GitHub-oriented** — The `/flo` skill, PR workflows, and issue tracking are built around GitHub. With Claude's help, you can adapt them to your own issue tracker and source control system.
 - **Cross-platform** — Forward-slash path normalization, no `sh -c` shell commands, `windowsHide` on all spawn calls.
 

package/bin/build-embeddings.mjs

@@ -20,7 +20,8 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { resolve, dirname } from 'path';
-import initSqlJs from 'sql.js';
+import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 
 function findProjectRoot() {
   let dir = process.cwd();
@@ -227,7 +228,7 @@ async function loadTransformersModel() {
   log('Attempting to load Transformers.js neural model...');
 
   try {
-    const { env, pipeline: createPipeline } = await import('@xenova/transformers');
+    const { env, pipeline: createPipeline } = await import(mofloResolveURL('@xenova/transformers'));
     env.allowLocalModels = false;
     env.backends.onnx.wasm.numThreads = 1;
 
@@ -310,6 +311,25 @@ function updateEmbedding(db, id, embedding, model) {
   stmt.free();
 }
 
+function getNamespaceStats(db) {
+  const stmt = db.prepare(`
+    SELECT
+      namespace,
+      COUNT(*) as total,
+      SUM(CASE WHEN embedding IS NOT NULL AND embedding != '' AND embedding_model != 'domain-aware-hash-v1' THEN 1 ELSE 0 END) as vectorized,
+      SUM(CASE WHEN embedding IS NULL OR embedding = '' THEN 1 ELSE 0 END) as missing,
+      SUM(CASE WHEN embedding_model = 'domain-aware-hash-v1' THEN 1 ELSE 0 END) as hash_only
+    FROM memory_entries
+    WHERE status = 'active'
+    GROUP BY namespace
+    ORDER BY namespace
+  `);
+  const results = [];
+  while (stmt.step()) results.push(stmt.getAsObject());
+  stmt.free();
+  return results;
+}
+
 function getEmbeddingStats(db) {
   const stmtTotal = db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
   const total = stmtTotal.step() ? stmtTotal.getAsObject() : { cnt: 0 };
@@ -426,7 +446,6 @@ async function main() {
       }
     }
   }
-  db.close();
 
   console.log('');
   log('═══════════════════════════════════════════════════════════');
@@ -445,7 +464,44 @@ async function main() {
       log(`    - ${m.embedding_model}: ${m.cnt}`);
     }
   }
+  log('');
+
+  // Per-namespace health report
+  const nsStats = getNamespaceStats(db);
+  if (nsStats.length > 0) {
+    log('  Namespace Health:');
+    log('  ┌─────────────────┬───────┬────────────┬─────────┬───────────┐');
+    log('  │ Namespace       │ Total │ Vectorized │ Missing │ Hash-Only │');
+    log('  ├─────────────────┼───────┼────────────┼─────────┼───────────┤');
+    let hasWarnings = false;
+    for (const ns of nsStats) {
+      const name = String(ns.namespace).padEnd(15);
+      const total = String(ns.total).padStart(5);
+      const vectorized = String(ns.vectorized).padStart(10);
+      const missing = String(ns.missing).padStart(7);
+      const hashOnly = String(ns.hash_only).padStart(9);
+      const warn = (ns.missing > 0 || ns.hash_only > 0) ? ' ⚠' : '  ';
+      log(`  │ ${name} │${total} │${vectorized} │${missing} │${hashOnly} │${warn}`);
+      if (ns.missing > 0 || ns.hash_only > 0) hasWarnings = true;
+    }
+    log('  └─────────────────┴───────┴────────────┴─────────┴───────────┘');
+    if (hasWarnings) {
+      log('');
+      log('  ⚠ Some namespaces have entries without Xenova embeddings.');
+      log('  Run with --force to re-embed all entries:');
+      log('    node node_modules/moflo/bin/build-embeddings.mjs --force');
+      if (!useTransformers) {
+        log('');
+        log('  ⚠ Xenova model not available — using hash fallback.');
+        log('  Install @xenova/transformers for neural embeddings:');
+        log('    npm install @xenova/transformers');
+      }
+    }
+  }
+
   log('═══════════════════════════════════════════════════════════');
+
+  db.close();
 }
 
 main().catch(err => {

package/bin/generate-code-map.mjs

@@ -30,7 +30,9 @@ import { resolve, dirname, relative, basename, extname } from 'path';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 import { execSync, spawn } from 'child_process';
-import initSqlJs from 'sql.js';
+import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
+
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 

package/bin/hooks.mjs

@@ -306,10 +306,10 @@ async function main() {
       }
 
       case 'daemon-start': {
-        if (!isDaemonRunning()) {
+        if (!isDaemonLockHeld()) {
           await runClaudeFlow('daemon', ['start', '--quiet']);
         } else {
-          log('info', 'Daemon already running, skipping start');
+          log('info', 'Daemon already running (lock held), skipping start');
         }
         break;
       }
@@ -479,34 +479,37 @@ function runBackgroundTraining() {
   spawnWindowless('node', [localCli, 'neural', 'optimize'], 'neural optimize');
 }
 
-// Check if daemon is already running via PID file.
-// Returns true if a live daemon process exists, false otherwise.
-function isDaemonRunning() {
-  const pidFile = resolve(projectRoot, '.claude-flow', 'daemon.pid');
-  if (existsSync(pidFile)) {
-    try {
-      const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
-      if (pid && !isNaN(pid)) {
-        process.kill(pid, 0); // signal 0 = check if process exists, doesn't kill
-        return true;
-      }
-    } catch {
-      // Process doesn't exist — stale PID file
+// Check if daemon lock exists — fast pre-check to avoid spawning a Node process
+// just to have it bail out via the atomic lock in daemon.ts.
+// Uses daemon.lock (atomic wx-based) instead of the old daemon.pid (TOCTOU-vulnerable).
+function isDaemonLockHeld() {
+  const lockFile = resolve(projectRoot, '.claude-flow', 'daemon.lock');
+  if (!existsSync(lockFile)) return false;
+
+  try {
+    const data = JSON.parse(readFileSync(lockFile, 'utf-8'));
+    if (typeof data.pid === 'number' && data.pid > 0) {
+      process.kill(data.pid, 0); // check if alive
+      return true;
     }
+  } catch {
+    // Dead process or corrupt file — lock is stale
   }
   return false;
 }
 
 // Run daemon start in background (non-blocking) — skip if already running
 function runDaemonStartBackground() {
-  const localCli = getLocalCliPath();
-  if (!localCli) {
-    log('warn', 'Local CLI not found, skipping daemon start');
+  // Fast check: if daemon lock is held by a live process, skip spawning entirely.
+  // This avoids zombie Node processes from subagents that all fire SessionStart.
+  if (isDaemonLockHeld()) {
+    log('info', 'Daemon already running (lock held), skipping start');
     return;
   }
 
-  if (isDaemonRunning()) {
-    log('info', 'Daemon already running, skipping start');
+  const localCli = getLocalCliPath();
+  if (!localCli) {
+    log('warn', 'Local CLI not found, skipping daemon start');
     return;
   }
 

package/bin/index-guidance.mjs

@@ -25,7 +25,9 @@
 import { existsSync, readdirSync, readFileSync, statSync, mkdirSync, writeFileSync } from 'fs';
 import { resolve, dirname, basename, extname } from 'path';
 import { fileURLToPath } from 'url';
-import initSqlJs from 'sql.js';
+import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
+
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 

package/bin/lib/moflo-resolve.mjs

@@ -0,0 +1,14 @@
+/**
+ * Shared dependency resolver for moflo bin scripts.
+ * Resolves packages from moflo's own node_modules (not the consuming project's).
+ * On Windows, converts native paths to file:// URLs required by ESM import().
+ */
+
+import { createRequire } from 'module';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __require = createRequire(fileURLToPath(import.meta.url));
+
+export function mofloResolveURL(specifier) {
+  return pathToFileURL(__require.resolve(specifier)).href;
+}

package/bin/semantic-search.mjs

@@ -16,7 +16,8 @@
 
 import { existsSync, readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
-import initSqlJs from 'sql.js';
+import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 
 function findProjectRoot() {
   let dir = process.cwd();
@@ -34,6 +35,8 @@ const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
 const EMBEDDING_DIMS = 384;
 const EMBEDDING_MODEL_NEURAL = 'Xenova/all-MiniLM-L6-v2';
 const EMBEDDING_MODEL_HASH = 'domain-aware-hash-v1';
+// 'onnx' is a legacy alias for the Xenova model — treat them as compatible vector spaces
+const NEURAL_ALIASES = new Set([EMBEDDING_MODEL_NEURAL, 'onnx']);
 
 // Parse args
 const args = process.argv.slice(2);
@@ -58,7 +61,7 @@ let useTransformers = false;
 
 async function loadTransformersModel() {
   try {
-    const { env, pipeline: createPipeline } = await import('@xenova/transformers');
+    const { env, pipeline: createPipeline } = await import(mofloResolveURL('@xenova/transformers'));
     env.allowLocalModels = false;
     env.backends.onnx.wasm.numThreads = 1;
 
@@ -251,7 +254,8 @@ async function generateQueryEmbedding(queryText, db) {
   if (debug) console.error(`[semantic-search] Stored model: ${storedModel}`);
 
   // If stored embeddings are neural, try to use neural for query too
-  if (storedModel === EMBEDDING_MODEL_NEURAL) {
+  // Accept both canonical name and legacy 'onnx' tag (both use the same Xenova pipeline)
+  if (storedModel === EMBEDDING_MODEL_NEURAL || storedModel === 'onnx') {
     await loadTransformersModel();
     if (useTransformers) {
       const neuralEmb = await generateNeuralEmbedding(queryText);
@@ -325,8 +329,9 @@ async function semanticSearch(queryText, options = {}) {
   while (stmt.step()) {
     const entry = stmt.getAsObject();
     try {
-      // Skip entries with mismatched embedding model (incompatible vector spaces)
-      if (entry.embedding_model && entry.embedding_model !== queryModel) continue;
+      const storedIsNeural = NEURAL_ALIASES.has(entry.embedding_model);
+      const queryIsNeural = NEURAL_ALIASES.has(queryModel);
+      if (entry.embedding_model && entry.embedding_model !== queryModel && !(storedIsNeural && queryIsNeural)) continue;
 
       const embedding = JSON.parse(entry.embedding);
       if (!Array.isArray(embedding) || embedding.length !== EMBEDDING_DIMS) continue;

package/bin/session-start-launcher.mjs

@@ -8,7 +8,7 @@
  */
 
 import { spawn } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync, copyFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -47,7 +47,120 @@ try {
   // Non-fatal - workflow gate will use defaults
 }
 
-// ── 3. Spawn background tasks ───────────────────────────────────────────────
+// ── 3. Auto-sync scripts and helpers on version change ───────────────────────
+// Controlled by `auto_update.enabled` in moflo.yaml (default: true).
+// When moflo is upgraded (npm install), scripts and helpers may be stale.
+// Detect version change and sync from source before running hooks.
+let autoUpdateConfig = { enabled: true, scripts: true, helpers: true };
+try {
+  const mofloYaml = resolve(projectRoot, 'moflo.yaml');
+  if (existsSync(mofloYaml)) {
+    const yamlContent = readFileSync(mofloYaml, 'utf-8');
+    // Simple YAML parsing for auto_update block (avoids js-yaml dependency)
+    const enabledMatch = yamlContent.match(/auto_update:\s*\n\s+enabled:\s*(true|false)/);
+    const scriptsMatch = yamlContent.match(/auto_update:\s*\n(?:\s+\w+:.*\n)*?\s+scripts:\s*(true|false)/);
+    const helpersMatch = yamlContent.match(/auto_update:\s*\n(?:\s+\w+:.*\n)*?\s+helpers:\s*(true|false)/);
+    if (enabledMatch) autoUpdateConfig.enabled = enabledMatch[1] === 'true';
+    if (scriptsMatch) autoUpdateConfig.scripts = scriptsMatch[1] === 'true';
+    if (helpersMatch) autoUpdateConfig.helpers = helpersMatch[1] === 'true';
+  }
+} catch { /* non-fatal — use defaults (all true) */ }
+
+try {
+  const mofloPkgPath = resolve(projectRoot, 'node_modules/moflo/package.json');
+  const versionStampPath = resolve(projectRoot, '.claude-flow', 'moflo-version');
+  if (autoUpdateConfig.enabled && existsSync(mofloPkgPath)) {
+    const installedVersion = JSON.parse(readFileSync(mofloPkgPath, 'utf-8')).version;
+    let cachedVersion = '';
+    try { cachedVersion = readFileSync(versionStampPath, 'utf-8').trim(); } catch {}
+
+    if (installedVersion !== cachedVersion) {
+      // Version changed — sync scripts from bin/
+      if (autoUpdateConfig.scripts) {
+        const binDir = resolve(projectRoot, 'node_modules/moflo/bin');
+        const scriptsDir = resolve(projectRoot, '.claude/scripts');
+        const scriptFiles = [
+          'hooks.mjs', 'session-start-launcher.mjs', 'index-guidance.mjs',
+          'build-embeddings.mjs', 'generate-code-map.mjs', 'semantic-search.mjs',
+        ];
+        for (const file of scriptFiles) {
+          const src = resolve(binDir, file);
+          const dest = resolve(scriptsDir, file);
+          if (existsSync(src)) {
+            try { copyFileSync(src, dest); } catch { /* non-fatal */ }
+          }
+        }
+      }
+
+      // Sync helpers from source .claude/helpers/
+      if (autoUpdateConfig.helpers) {
+        const sourceHelpersDir = resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/.claude/helpers');
+        const helpersDir = resolve(projectRoot, '.claude/helpers');
+        const helperFiles = [
+          'auto-memory-hook.mjs', 'statusline.cjs', 'pre-commit', 'post-commit',
+        ];
+        for (const file of helperFiles) {
+          const src = resolve(sourceHelpersDir, file);
+          const dest = resolve(helpersDir, file);
+          if (existsSync(src)) {
+            try { copyFileSync(src, dest); } catch { /* non-fatal */ }
+          }
+        }
+
+        // Also sync generated helpers via upgrade CLI (hook-handler.cjs, gate.cjs, etc.)
+        // These are generated, not shipped, so we trigger an upgrade in the background
+        const localCli = resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/bin/cli.js');
+        if (existsSync(localCli)) {
+          try {
+            const proc = spawn('node', [localCli, 'init', '--upgrade', '--quiet'], {
+              cwd: projectRoot, stdio: 'ignore', detached: true, windowsHide: true,
+            });
+            proc.unref();
+          } catch { /* non-fatal */ }
+        }
+      }
+
+      // Sync guidance bootstrap file (moflo-bootstrap.md)
+      // Ensures subagents can read guidance directly from disk
+      const bootstrapSrc = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/agent-bootstrap.md');
+      const guidanceDir = resolve(projectRoot, '.claude/guidance');
+      const bootstrapDest = resolve(guidanceDir, 'moflo-bootstrap.md');
+      if (existsSync(bootstrapSrc)) {
+        try {
+          if (!existsSync(guidanceDir)) mkdirSync(guidanceDir, { recursive: true });
+          const header = '<!-- AUTO-GENERATED by moflo session-start. Do not edit — changes will be overwritten. -->\n<!-- Source: node_modules/moflo/.claude/guidance/agent-bootstrap.md -->\n\n';
+          const content = readFileSync(bootstrapSrc, 'utf-8');
+          writeFileSync(bootstrapDest, header + content);
+        } catch { /* non-fatal */ }
+      }
+
+      // Write version stamp
+      try {
+        const cfDir = resolve(projectRoot, '.claude-flow');
+        if (!existsSync(cfDir)) mkdirSync(cfDir, { recursive: true });
+        writeFileSync(versionStampPath, installedVersion);
+      } catch {}
+    }
+  }
+} catch {
+  // Non-fatal — scripts will still work, just may be stale
+}
+
+// ── 3b. Ensure guidance bootstrap file exists (even without version change) ──
+// Subagents need this file on disk for direct reads without memory search.
+try {
+  const bootstrapSrc = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/agent-bootstrap.md');
+  const guidanceDir = resolve(projectRoot, '.claude/guidance');
+  const bootstrapDest = resolve(guidanceDir, 'moflo-bootstrap.md');
+  if (existsSync(bootstrapSrc) && !existsSync(bootstrapDest)) {
+    if (!existsSync(guidanceDir)) mkdirSync(guidanceDir, { recursive: true });
+    const header = '<!-- AUTO-GENERATED by moflo session-start. Do not edit — changes will be overwritten. -->\n<!-- Source: node_modules/moflo/.claude/guidance/agent-bootstrap.md -->\n\n';
+    const content = readFileSync(bootstrapSrc, 'utf-8');
+    writeFileSync(bootstrapDest, header + content);
+  }
+} catch { /* non-fatal */ }
+
+// ── 4. Spawn background tasks ───────────────────────────────────────────────
 const localCli = resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/bin/cli.js');
 const hasLocalCli = existsSync(localCli);
 
@@ -59,5 +172,5 @@ if (existsSync(hooksScript)) {
 
 // Patches are now baked into moflo@4.0.0 source — no runtime patching needed.
 
-// ── 4. Done — exit immediately ──────────────────────────────────────────────
+// ── 5. Done — exit immediately ──────────────────────────────────────────────
 process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.7.8",
+  "version": "4.8.1",
   "description": "MoFlo — AI agent orchestration for Claude Code. Forked from ruflo/claude-flow with patches applied to source, plus feature-level orchestration.",
   "main": "dist/index.js",
   "type": "module",
@@ -62,8 +62,8 @@
   "dependencies": {
     "@ruvector/learning-wasm": "^0.1.29",
     "js-yaml": "^4.1.1",
-    "semver": "^7.6.0",
-    "sql.js": "^1.12.0",
+    "semver": "^7.7.4",
+    "sql.js": "^1.14.1",
     "zod": "^3.22.4"
   },
   "optionalDependencies": {
@@ -81,11 +81,11 @@
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",
-    "@types/node": "^20.0.0",
+    "@types/node": "^20.19.37",
     "eslint": "^8.0.0",
-    "moflo": "^4.7.4",
+    "moflo": "^4.8.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.0.0",
+    "typescript": "^5.9.3",
     "vitest": "^4.0.0"
   },
   "engines": {

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

@@ -14,6 +14,7 @@
  */
 import { readdir, stat } from 'node:fs/promises';
 import { join, extname, basename } from 'node:path';
+import { mofloImport } from '../services/moflo-require.js';
 const DEFAULT_CONFIG = {
     modelsDir: './models', defaultModel: '', maxTokens: 512,
     temperature: 0.7, contextSize: 4096, kvCachePath: '', verbose: false,
@@ -281,12 +282,7 @@ export function getRuvllmBridge(config) {
 export function resetRuvllmBridge() { instance = null; }
 /** Check whether @ruvector/core is importable without loading the bridge. */
 export async function isRuvllmAvailable() {
-    try {
-        await import('@ruvector/core');
-        return true;
-    }
-    catch {
-        return false;
-    }
+    const mod = await mofloImport('@ruvector/core');
+    return mod !== null;
 }
 //# sourceMappingURL=ruvllm-bridge.js.map