moflo 4.8.0 → 4.8.2

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.
 
@@ -122,7 +124,11 @@ npx flo memory code-map          # Index your code structure
 npx flo doctor                   # Verify everything works
 ```
 
-Both indexes run automatically at session start after this, so you only need to run them manually on first setup or after major structural changes.
+Both indexes run automatically at session start after this, so you only need to run them manually on first setup or after major structural changes. To reindex everything at once:
+
+```bash
+npx flo memory refresh           # Reindex all content, rebuild embeddings, cleanup, vacuum
+```
 
 ## The `/flo` Skill
 
@@ -215,6 +221,7 @@ flo memory search -q "auth patterns"         # Semantic search
 flo memory index-guidance                    # Index guidance docs
 flo memory code-map                          # Index code structure
 flo memory rebuild-index                     # Regenerate all embeddings
+flo memory refresh                           # Reindex all + rebuild + cleanup + vacuum
 flo memory stats                             # Show statistics
 ```
 
@@ -236,11 +243,19 @@ flo gate prompt-reminder         # Context bracket tracking
 flo gate session-reset           # Reset workflow state
 ```
 
+### Diagnostics
+
+```bash
+flo doctor                       # Quick health check (environment, deps, config)
+flo diagnose                     # Full integration test (memory, swarm, hive, hooks, neural)
+flo diagnose --suite memory      # Run only memory tests
+flo diagnose --json              # JSON output for CI/automation
+```
+
 ### System
 
 ```bash
 flo init                          # Initialize project (one-time setup)
-flo doctor                       # Health check
 flo --version                    # Show version
 ```
 

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/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

@@ -120,6 +120,20 @@ try {
         }
       }
 
+      // 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');
@@ -132,6 +146,20 @@ try {
   // 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.8.0",
+  "version": "4.8.2",
   "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.1",
     "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

package/src/@claude-flow/cli/dist/src/commands/diagnose.d.ts

@@ -0,0 +1,16 @@
+/**
+ * V3 CLI Diagnose Command
+ * Full integration test suite — runs non-destructively in the destination project.
+ *
+ * Unlike `doctor` (which checks environment health), `diagnose` exercises
+ * every subsystem end-to-end: memory CRUD, swarm lifecycle, hive-mind,
+ * task management, hooks, config, neural, and init idempotency.
+ *
+ * All test data is cleaned up after each test — no code or state is left behind.
+ *
+ * Created with motailz.com
+ */
+import type { Command } from '../types.js';
+export declare const diagnoseCommand: Command;
+export default diagnoseCommand;
+//# sourceMappingURL=diagnose.d.ts.map