moflo 4.8.34 → 4.8.37

package/.claude/scripts/hooks.mjs

@@ -258,21 +258,23 @@ async function main() {
       }
 
       case 'session-start': {
-        // All startup tasks run in background (non-blocking)
-        // Start daemon quietly in background
+        // Start daemon quietly in background (no DB writes)
         runDaemonStartBackground();
-        // Index guidance files in background
-        runIndexGuidanceBackground();
-        // Generate structural code map in background
-        runCodeMapBackground();
-        // Index test files in background
-        runTestIndexBackground();
-        // Run pretrain in background to extract patterns from repository
+        // Run pretrain in background (writes to patterns namespace, fast)
         runBackgroundPretrain();
-        // Force HNSW rebuild to ensure all processes use identical fresh index
-        // This fixes agent search result mismatches (0.61 vs 0.81 similarity)
-        runHNSWRebuildBackground();
-        // Neural patterns now loaded by moflo core routing — no external patching.
+        // Run all DB-writing indexers SEQUENTIALLY in a single background process.
+        // This avoids sql.js last-write-wins concurrency (issue #78).
+        // Chain: guidance → code-map → tests → HNSW rebuild (must be last).
+        const indexAllScript = resolve(__dirname, 'index-all.mjs');
+        if (existsSync(indexAllScript)) {
+          spawnWindowless('node', [indexAllScript], 'sequential indexing chain');
+        } else {
+          // Fallback to parallel if index-all.mjs not available
+          runIndexGuidanceBackground();
+          runCodeMapBackground();
+          runTestIndexBackground();
+          runHNSWRebuildBackground();
+        }
         break;
       }
 

package/.claude/scripts/index-all.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Sequential indexer chain for session-start.
+ *
+ * Runs all DB-writing indexers one at a time to avoid sql.js last-write-wins
+ * concurrency issues, then triggers HNSW rebuild once everything is committed.
+ *
+ * Spawned as a single detached background process by hooks.mjs session-start.
+ */
+
+import { existsSync, appendFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execFileSync } from 'child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '../..');
+const LOG_PATH = resolve(projectRoot, '.claude/hooks.log');
+
+function log(msg) {
+  const ts = new Date().toISOString().replace('T', ' ').slice(0, 19);
+  const line = `[${ts}] [index-all] ${msg}\n`;
+  try { appendFileSync(LOG_PATH, line); } catch { /* ignore */ }
+}
+
+function resolveBin(binName, localScript) {
+  const mofloScript = resolve(projectRoot, 'node_modules/moflo/bin', localScript);
+  if (existsSync(mofloScript)) return mofloScript;
+  const npmBin = resolve(projectRoot, 'node_modules/.bin', binName);
+  if (existsSync(npmBin)) return npmBin;
+  const localPath = resolve(projectRoot, '.claude/scripts', localScript);
+  if (existsSync(localPath)) return localPath;
+  return null;
+}
+
+function getLocalCliPath() {
+  const paths = [
+    resolve(projectRoot, 'node_modules/moflo/bin/cli.js'),
+    resolve(projectRoot, 'node_modules/.bin/flo'),
+  ];
+  for (const p of paths) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+function runStep(label, cmd, args, timeoutMs = 120_000) {
+  const start = Date.now();
+  log(`START ${label}`);
+  try {
+    execFileSync(cmd, args, {
+      cwd: projectRoot,
+      timeout: timeoutMs,
+      stdio: 'ignore',
+      windowsHide: true,
+    });
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+    log(`DONE  ${label} (${elapsed}s)`);
+    return true;
+  } catch (err) {
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+    log(`FAIL  ${label} (${elapsed}s): ${err.message?.split('\n')[0] || 'unknown'}`);
+    return false;
+  }
+}
+
+async function main() {
+  const startTime = Date.now();
+  log('Sequential indexing chain started');
+
+  // 1. Guidance indexer
+  const guidanceScript = resolveBin('flo-index', 'index-guidance.mjs');
+  if (guidanceScript) {
+    runStep('guidance-index', 'node', [guidanceScript]);
+  } else {
+    log('SKIP  guidance-index (script not found)');
+  }
+
+  // 2. Code map generator (the big one — ~22s)
+  const codeMapScript = resolveBin('flo-codemap', 'generate-code-map.mjs');
+  if (codeMapScript) {
+    runStep('code-map', 'node', [codeMapScript], 180_000);
+  } else {
+    log('SKIP  code-map (script not found)');
+  }
+
+  // 3. Test indexer
+  const testScript = resolveBin('flo-testmap', 'index-tests.mjs');
+  if (testScript) {
+    runStep('test-index', 'node', [testScript]);
+  } else {
+    log('SKIP  test-index (script not found)');
+  }
+
+  // 4. HNSW rebuild — MUST run last, after all writes are committed
+  const localCli = getLocalCliPath();
+  if (localCli) {
+    runStep('hnsw-rebuild', 'node', [localCli, 'memory', 'rebuild', '--force']);
+  } else {
+    log('SKIP  hnsw-rebuild (CLI not found)');
+  }
+
+  const totalElapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  log(`Sequential indexing chain complete (${totalElapsed}s)`);
+}
+
+main().catch(err => {
+  log(`FATAL: ${err.message}`);
+  process.exit(0);
+});

package/README.md

@@ -163,7 +163,7 @@ 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. To reindex everything at once:
+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. The first index may take a minute or two on large codebases (1,000+ files) but runs in the background — you can start working immediately. Subsequent indexes are incremental and typically finish in under a second. To reindex everything at once:
 
 ```bash
 npx flo memory refresh           # Reindex all content, rebuild embeddings, cleanup, vacuum
@@ -183,8 +183,8 @@ MoFlo automatically indexes three types of content on every session start, so yo
 
 ### How it works
 
-1. **Session start hook** — When your AI client starts a new session, MoFlo's `SessionStart` hook launches three indexers in parallel as background processes.
-2. **Incremental** — Each indexer tracks file modification times. Only files that changed since the last index run are re-processed. The first run takes longer; subsequent runs typically finish in under a second.
+1. **Session start hook** — When your AI client starts a new session, MoFlo's `SessionStart` hook launches the indexers sequentially in a single background process. This runs silently — you can start working immediately.
+2. **Incremental** — Each indexer tracks file modification times. Only files that changed since the last index run are re-processed. The first run on a large codebase may take a minute or two; subsequent runs typically finish in under a second.
 3. **Embedding generation** — Guidance chunks are embedded using MiniLM-L6-v2 (384 dimensions, WASM). These vectors are stored in the SQLite memory database and used for semantic search.
 4. **No blocking** — The indexers run in the background and don't block your session from starting. You can begin working immediately.
 

package/bin/index-patterns.mjs

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+/**
+ * Index code patterns into claude-flow memory under the `patterns` namespace
+ *
+ * Extracts per-file patterns (not just aggregate summaries like pretrain):
+ *   - Service/controller/repository class patterns
+ *   - API route definitions and middleware usage
+ *   - Error handling strategies per file
+ *   - Export conventions per module
+ *   - Test patterns (describe/it structure)
+ *   - Configuration patterns
+ *
+ * Chunk types:
+ *   pattern:file:{path}     — Per-file pattern summary
+ *   pattern:service:{name}  — Service class patterns
+ *   pattern:route:{path}    — API route patterns
+ *   pattern:error:{path}    — Error handling patterns per file
+ *
+ * Usage:
+ *   node node_modules/moflo/bin/index-patterns.mjs             # Incremental
+ *   node node_modules/moflo/bin/index-patterns.mjs --force     # Full reindex
+ *   node node_modules/moflo/bin/index-patterns.mjs --verbose   # Detailed logging
+ *   node node_modules/moflo/bin/index-patterns.mjs --stats     # Print stats and exit
+ *   npx flo-patterns                                           # Via npx
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { resolve, dirname, relative, basename, extname } from 'path';
+import { fileURLToPath } from 'url';
+import { createHash } from 'crypto';
+import { spawn } from 'child_process';
+import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  const root = resolve(dir, '/');
+  while (dir !== root) {
+    if (existsSync(resolve(dir, 'package.json'))) return dir;
+    dir = dirname(dir);
+  }
+  return process.cwd();
+}
+
+const projectRoot = findProjectRoot();
+const NAMESPACE = 'patterns';
+const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
+const HASH_CACHE_PATH = resolve(projectRoot, '.swarm/patterns-hash.txt');
+
+const args = process.argv.slice(2);
+const force = args.includes('--force');
+const verbose = args.includes('--verbose') || args.includes('-v');
+const statsOnly = args.includes('--stats');
+
+function log(msg) { console.log(`[index-patterns] ${msg}`); }
+function debug(msg) { if (verbose) console.log(`[index-patterns]   ${msg}`); }
+
+const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.py', '.go', '.rs']);
+const EXCLUDE_DIRS = new Set([
+  'node_modules', 'dist', 'build', '.next', 'coverage',
+  '.claude', '.swarm', '.claude-flow', '.git', 'template',
+]);
+
+// ---------------------------------------------------------------------------
+// Database helpers
+// ---------------------------------------------------------------------------
+
+function ensureDbDir() {
+  const dir = dirname(DB_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+async function getDb() {
+  ensureDbDir();
+  const SQL = await initSqlJs();
+  let db;
+  if (existsSync(DB_PATH)) {
+    const buffer = readFileSync(DB_PATH);
+    db = new SQL.Database(buffer);
+  } else {
+    db = new SQL.Database();
+  }
+  db.run(`
+    CREATE TABLE IF NOT EXISTS memory_entries (
+      id TEXT PRIMARY KEY,
+      key TEXT NOT NULL,
+      namespace TEXT DEFAULT 'default',
+      content TEXT NOT NULL,
+      type TEXT DEFAULT 'semantic',
+      embedding TEXT,
+      embedding_model TEXT DEFAULT 'local',
+      embedding_dimensions INTEGER,
+      tags TEXT,
+      metadata TEXT,
+      owner_id TEXT,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+      updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+      expires_at INTEGER,
+      last_accessed_at INTEGER,
+      access_count INTEGER DEFAULT 0,
+      status TEXT DEFAULT 'active',
+      UNIQUE(namespace, key)
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_memory_key_ns ON memory_entries(key, namespace)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace)`);
+  return db;
+}
+
+function saveDb(db) {
+  const data = db.export();
+  writeFileSync(DB_PATH, Buffer.from(data));
+}
+
+function generateId() {
+  return `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+
+function storeEntry(db, key, content, tags = []) {
+  const now = Date.now();
+  const id = generateId();
+  db.run(`
+    INSERT OR REPLACE INTO memory_entries
+    (id, key, namespace, content, metadata, tags, created_at, updated_at, status)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active')
+  `, [id, key, NAMESPACE, content, '{}', JSON.stringify(tags), now, now]);
+}
+
+function deleteNamespace(db) {
+  db.run(`DELETE FROM memory_entries WHERE namespace = ?`, [NAMESPACE]);
+}
+
+function countNamespace(db) {
+  const stmt = db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = ?`);
+  stmt.bind([NAMESPACE]);
+  let count = 0;
+  if (stmt.step()) count = stmt.getAsObject().cnt;
+  stmt.free();
+  return count;
+}
+
+// ---------------------------------------------------------------------------
+// File collection
+// ---------------------------------------------------------------------------
+
+function collectSourceFiles(dir, maxDepth = 8, depth = 0) {
+  if (depth > maxDepth) return [];
+  const files = [];
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return []; }
+  for (const entry of entries) {
+    if (EXCLUDE_DIRS.has(entry.name)) continue;
+    const fullPath = resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectSourceFiles(fullPath, maxDepth, depth + 1));
+    } else if (entry.isFile() && SOURCE_EXTENSIONS.has(extname(entry.name))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+// ---------------------------------------------------------------------------
+// Pattern extraction — per-file
+// ---------------------------------------------------------------------------
+
+function extractFilePatterns(filePath, content) {
+  const lines = content.split('\n');
+  const relPath = relative(projectRoot, filePath);
+  const patterns = [];
+  const tags = [];
+
+  // Collect metrics
+  const imports = [];
+  const exports = [];
+  const classes = [];
+  const functions = [];
+  const routes = [];
+  const errorHandling = [];
+  const interfaces = [];
+
+  for (const line of lines) {
+    const t = line.trim();
+
+    // Imports
+    const impMatch = t.match(/^import\s+.*?from\s+['"]([^'"]+)['"]/);
+    if (impMatch) imports.push(impMatch[1]);
+
+    // Exports
+    if (/^export\s+default\b/.test(t)) exports.push('default');
+    const namedExp = t.match(/^export\s+(?:const|function|class|interface|type|enum)\s+(\w+)/);
+    if (namedExp) exports.push(namedExp[1]);
+
+    // Classes
+    const classMatch = t.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
+    if (classMatch) {
+      classes.push(classMatch[1]);
+      if (/Service\b/.test(classMatch[1])) tags.push('service');
+      if (/Controller\b/.test(classMatch[1])) tags.push('controller');
+      if (/Repository\b/.test(classMatch[1])) tags.push('repository');
+      if (/Provider\b/.test(classMatch[1])) tags.push('provider');
+    }
+
+    // Functions
+    const fnMatch = t.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+    if (fnMatch) functions.push(fnMatch[1]);
+    const arrowMatch = t.match(/^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+    if (arrowMatch) functions.push(arrowMatch[1]);
+
+    // Interfaces/types
+    const ifaceMatch = t.match(/^(?:export\s+)?(?:interface|type)\s+(\w+)/);
+    if (ifaceMatch) interfaces.push(ifaceMatch[1]);
+
+    // Routes
+    const routeMatch = t.match(/\.(get|post|put|patch|delete)\s*\(\s*['"]([^'"]*)['"]/i);
+    if (routeMatch) routes.push(`${routeMatch[1].toUpperCase()} ${routeMatch[2]}`);
+    if (/@(Get|Post|Put|Delete|Patch)\s*\(/.test(t)) {
+      const dec = t.match(/@(\w+)\s*\(\s*['"]([^'"]*)['"]/);
+      if (dec) routes.push(`${dec[1].toUpperCase()} ${dec[2]}`);
+    }
+
+    // Error handling
+    if (/\bcatch\s*\(/.test(t)) errorHandling.push('try-catch');
+    if (/\.catch\(/.test(t)) errorHandling.push('promise-catch');
+    if (/throw\s+new\s+(\w+)/.test(t)) {
+      const err = t.match(/throw\s+new\s+(\w+)/);
+      if (err) errorHandling.push(`throws:${err[1]}`);
+    }
+  }
+
+  // Only create entries for files with meaningful patterns
+  if (classes.length === 0 && functions.length < 2 && routes.length === 0 && interfaces.length < 2) {
+    return [];
+  }
+
+  // Build human-readable pattern summary for this file
+  const parts = [];
+  if (classes.length > 0) parts.push(`Classes: ${classes.join(', ')}`);
+  if (functions.length > 0) parts.push(`Functions: ${functions.slice(0, 10).join(', ')}${functions.length > 10 ? ` (+${functions.length - 10} more)` : ''}`);
+  if (interfaces.length > 0) parts.push(`Types: ${interfaces.slice(0, 8).join(', ')}${interfaces.length > 8 ? ` (+${interfaces.length - 8} more)` : ''}`);
+  if (routes.length > 0) parts.push(`Routes: ${routes.join(', ')}`);
+  if (exports.length > 0) parts.push(`Exports: ${exports.slice(0, 8).join(', ')}${exports.length > 8 ? ` (+${exports.length - 8} more)` : ''}`);
+  if (errorHandling.length > 0) {
+    const unique = [...new Set(errorHandling)];
+    parts.push(`Error handling: ${unique.join(', ')}`);
+  }
+
+  const summary = `# ${relPath}\n${parts.join('\n')}`;
+
+  // File-level pattern entry
+  patterns.push({
+    key: `pattern:file:${relPath}`,
+    content: summary,
+    tags: ['file-pattern', ...tags],
+  });
+
+  // Service/controller entries get their own chunk for better search
+  for (const cls of classes) {
+    if (/Service|Controller|Repository|Provider|Handler|Manager/.test(cls)) {
+      const clsMethods = functions.filter(f => f !== cls); // rough heuristic
+      patterns.push({
+        key: `pattern:class:${cls}`,
+        content: `# ${cls} (${relPath})\nType: ${tags.filter(t => ['service', 'controller', 'repository', 'provider'].includes(t)).join(', ') || 'class'}\nMethods: ${clsMethods.slice(0, 15).join(', ') || 'none detected'}`,
+        tags: ['class-pattern', ...tags],
+      });
+    }
+  }
+
+  // Route entries
+  if (routes.length > 0) {
+    patterns.push({
+      key: `pattern:routes:${relPath}`,
+      content: `# Routes in ${relPath}\n${routes.join('\n')}`,
+      tags: ['route-pattern', 'api'],
+    });
+  }
+
+  return patterns;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const startTime = Date.now();
+
+  // Stats mode
+  if (statsOnly) {
+    const db = await getDb();
+    const count = countNamespace(db);
+    const files = collectSourceFiles(projectRoot);
+    log(`${files.length} source files, ${count} chunks in patterns namespace`);
+    db.close();
+    return;
+  }
+
+  // Collect files
+  const files = collectSourceFiles(projectRoot);
+  log(`Found ${files.length} source files`);
+
+  if (files.length === 0) {
+    log('No source files found');
+    return;
+  }
+
+  // Hash check for incremental
+  const hashInput = files.map(f => {
+    try { return `${f}:${statSync(f).mtimeMs}`; } catch { return f; }
+  }).join('\n');
+  const currentHash = createHash('sha256').update(hashInput).digest('hex');
+
+  if (!force && existsSync(HASH_CACHE_PATH)) {
+    const cached = readFileSync(HASH_CACHE_PATH, 'utf-8').trim();
+    if (cached === currentHash) {
+      log('No changes detected (use --force to reindex)');
+      return;
+    }
+  }
+
+  // Extract patterns from all files
+  const allPatterns = [];
+  let filesWithPatterns = 0;
+
+  for (const filePath of files) {
+    let content;
+    try { content = readFileSync(filePath, 'utf-8'); } catch { continue; }
+    const patterns = extractFilePatterns(filePath, content);
+    if (patterns.length > 0) {
+      filesWithPatterns++;
+      allPatterns.push(...patterns);
+    }
+    debug(`${relative(projectRoot, filePath)}: ${patterns.length} patterns`);
+  }
+
+  log(`Extracted ${allPatterns.length} pattern chunks from ${filesWithPatterns} files`);
+
+  // Write to database
+  const db = await getDb();
+  deleteNamespace(db);
+
+  for (const p of allPatterns) {
+    storeEntry(db, p.key, p.content, p.tags);
+  }
+
+  saveDb(db);
+  db.close();
+
+  // Save hash
+  writeFileSync(HASH_CACHE_PATH, currentHash, 'utf-8');
+
+  // Trigger embedding generation in background
+  try {
+    const embeddingScript = resolve(projectRoot, 'node_modules/moflo/bin/build-embeddings.mjs');
+    if (existsSync(embeddingScript)) {
+      const child = spawn('node', [embeddingScript, '--namespace', NAMESPACE], {
+        cwd: projectRoot,
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+      child.unref();
+      debug('Embedding generation started in background');
+    }
+  } catch { /* ignore */ }
+
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  log(`Done in ${elapsed}s — ${allPatterns.length} pattern chunks written`);
+}
+
+main().catch(err => {
+  log(`Error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.8.34",
+  "version": "4.8.37",
   "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",

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

@@ -730,24 +730,36 @@ async function checkSemanticQuality() {
         };
     }
 }
-// Check memory-backed patterns (populated by pretrain) as a fallback for neural checks
-async function checkMemoryPatterns(namespace) {
+// Check memory-backed patterns (populated by pretrain) as a fallback for neural checks.
+// Uses the same pattern-search handler that pretrain writes to.
+async function checkMemoryPatterns(_namespace) {
     try {
-        // @ts-ignore — memory is not in tsconfig project references but is available at runtime
-        const memoryMod = await import('../../../../memory/dist/index.js');
-        if (memoryMod.search) {
-            const results = await memoryMod.search({ query: 'pattern', namespace, limit: 1 });
-            return results?.length ?? 0;
-        }
-        // Fallback: try AgentDB route
-        if (memoryMod.getStore) {
-            const store = memoryMod.getStore();
-            const entries = store?.list?.(namespace) ?? [];
-            return entries.length;
+        // Use the pattern-search handler (same store pretrain writes to)
+        const hooksMod = await import('../mcp-tools/hooks-tools.js');
+        if (hooksMod.hooksPatternSearch) {
+            const result = await hooksMod.hooksPatternSearch.handler({
+                query: 'pretrain',
+                topK: 1,
+                minConfidence: 0.1,
+            });
+            const matches = result?.results;
+            if (Array.isArray(matches))
+                return matches.length;
         }
     }
     catch {
-        // Memory module not available
+        // hooks module not available
+    }
+    // Secondary fallback: check the memory DB file exists
+    try {
+        const { existsSync } = await import('fs');
+        const { join } = await import('path');
+        const dbPath = join(process.cwd(), '.claude', 'memory.db');
+        if (existsSync(dbPath))
+            return 1;
+    }
+    catch {
+        // fs not available
     }
     return 0;
 }
@@ -779,22 +791,24 @@ async function checkIntelligence() {
         catch (e) {
             failures.push(`SONA (${e instanceof Error ? e.message : 'error'})`);
         }
-        // 2. ReasoningBank — store + retrieve
+        // 2. ReasoningBank — verify instantiation and trajectory store/distill lifecycle
         try {
             const rb = neural.createReasoningBank();
-            const embedding = new Float32Array(64).fill(0.2);
-            rb.storeTrajectory({
-                id: 'doctor-test',
+            const trajectory = {
+                trajectoryId: 'doctor-test',
                 context: 'health check',
                 domain: 'general',
-                mode: 'balanced',
-                steps: [{ action: 'test', reward: 1, embedding, timestamp: Date.now() }],
+                steps: [{ action: 'test', reward: 1, embedding: new Float32Array(64).fill(0.2), timestamp: Date.now() }],
                 startTime: Date.now(),
                 endTime: Date.now(),
-                quality: 1,
-            });
-            const retrieved = rb.retrieve(embedding, 1);
-            if (retrieved.length > 0) {
+                qualityScore: 0.9,
+                isComplete: true,
+                verdict: { success: true, quality: 0.9, feedback: 'test' },
+            };
+            rb.storeTrajectory(trajectory);
+            // distill() populates memories (storeTrajectory alone does not)
+            const distilled = await rb.distill(trajectory);
+            if (distilled || rb.getTrajectories().length > 0) {
                 results.push('ReasoningBank');
             }
             else {
@@ -804,7 +818,7 @@ async function checkIntelligence() {
                     results.push('ReasoningBank(memory)');
                 }
                 else {
-                    failures.push('ReasoningBank (retrieve failed)');
+                    failures.push('ReasoningBank (distill returned no data)');
                 }
             }
         }

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

@@ -1244,6 +1244,13 @@ function extractPatterns(files) {
     const structurePatterns = new Map();
     const apiPatterns = new Map();
     const functionSigs = [];
+    // Extended counters (collected in single pass)
+    let asyncCount = 0, syncCount = 0, promiseCatchCount = 0, awaitCount = 0;
+    const decoratorCounts = new Map();
+    let interfaceCount = 0, typeAliasCount = 0, enumCount = 0, genericCount = 0;
+    let describeCount = 0, itCount = 0, testCount = 0, expectCount = 0, mockCount = 0;
+    let envAccessCount = 0, configImportCount = 0;
+    const logPatterns = new Map();
     for (const file of files) {
         let content;
         try {
@@ -1286,8 +1293,8 @@ function extractPatterns(files) {
                 const errClass = trimmed.match(/throw\s+new\s+(\w+)/)?.[1] || 'Error';
                 errorPatterns.set(`throw:${errClass}`, (errorPatterns.get(`throw:${errClass}`) || 0) + 1);
             }
-            // Function signatures (collect first 50)
-            if (functionSigs.length < 50) {
+            // Function signatures (collect first 200)
+            if (functionSigs.length < 200) {
                 const fnMatch = trimmed.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
                 if (fnMatch)
                     functionSigs.push(fnMatch[1]);
@@ -1333,23 +1340,91 @@ function extractPatterns(files) {
             if (/interface\s+\w+/.test(trimmed)) {
                 structurePatterns.set('typed-interface', (structurePatterns.get('typed-interface') || 0) + 1);
             }
+            // Extended: async patterns
+            if (/^(?:export\s+)?async\s+function\b/.test(trimmed) || /=\s*async\s*\(/.test(trimmed))
+                asyncCount++;
+            else if (/^(?:export\s+)?function\b/.test(trimmed) || /=\s*\([^)]*\)\s*=>/.test(trimmed))
+                syncCount++;
+            if (/\.catch\(/.test(trimmed))
+                promiseCatchCount++;
+            if (/\bawait\b/.test(trimmed))
+                awaitCount++;
+            // Extended: decorators
+            const dec = trimmed.match(/^@(\w+)/);
+            if (dec)
+                decoratorCounts.set(dec[1], (decoratorCounts.get(dec[1]) || 0) + 1);
+            // Extended: type system
+            if (/^(?:export\s+)?interface\s+\w+/.test(trimmed))
+                interfaceCount++;
+            if (/^(?:export\s+)?type\s+\w+\s*=/.test(trimmed))
+                typeAliasCount++;
+            if (/^(?:export\s+)?enum\s+\w+/.test(trimmed))
+                enumCount++;
+            if (/<\w+(?:\s+extends\s+\w+)?>/.test(trimmed) && /(?:function|class|interface|type)\s/.test(trimmed))
+                genericCount++;
+            // Extended: testing
+            if (/^describe\s*\(/.test(trimmed))
+                describeCount++;
+            if (/^\s*it\s*\(/.test(trimmed))
+                itCount++;
+            if (/^\s*test\s*\(/.test(trimmed))
+                testCount++;
+            if (/expect\s*\(/.test(trimmed))
+                expectCount++;
+            if (/\b(?:vi\.mock|jest\.mock|sinon\.stub|\.mockImplementation|\.mockReturnValue)\b/.test(trimmed))
+                mockCount++;
+            // Extended: config/env
+            if (/process\.env\b/.test(trimmed))
+                envAccessCount++;
+            if (/config|\.env|dotenv|convict/i.test(trimmed) && /import|require/.test(trimmed))
+                configImportCount++;
+            // Extended: logging
+            if (/console\.log\b/.test(trimmed))
+                logPatterns.set('console.log', (logPatterns.get('console.log') || 0) + 1);
+            if (/console\.error\b/.test(trimmed))
+                logPatterns.set('console.error', (logPatterns.get('console.error') || 0) + 1);
+            if (/console\.warn\b/.test(trimmed))
+                logPatterns.set('console.warn', (logPatterns.get('console.warn') || 0) + 1);
+            if (/\blogger\.\w+/.test(trimmed))
+                logPatterns.set('logger.*', (logPatterns.get('logger.*') || 0) + 1);
         }
     }
     const patterns = [];
-    // Top imports by frequency
-    const sortedImports = [...importCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15);
+    // --- Import patterns: one entry per top module (not just a single aggregate) ---
+    const sortedImports = [...importCounts.entries()].sort((a, b) => b[1] - a[1]);
+    // Summary entry
     if (sortedImports.length > 0) {
         patterns.push({
-            type: 'import',
-            value: `Top modules: ${sortedImports.map(([m, c]) => `${m}(${c})`).join(', ')}`,
+            type: 'import-summary',
+            value: `Top modules: ${sortedImports.slice(0, 15).map(([m, c]) => `${m}(${c})`).join(', ')}`,
             count: sortedImports.reduce((s, [, c]) => s + c, 0),
             examples: sortedImports.slice(0, 5).map(([m]) => m),
         });
     }
-    // Export patterns
+    // Individual module entries (top 20 non-relative)
+    for (const [mod, count] of sortedImports.filter(([m]) => m !== '<relative>').slice(0, 20)) {
+        patterns.push({
+            type: 'import-module',
+            value: `Module "${mod}" imported ${count} times across codebase`,
+            count,
+            examples: [mod],
+        });
+    }
+    // Relative vs external ratio
+    const relativeCount = importCounts.get('<relative>') || 0;
+    const externalCount = sortedImports.filter(([m]) => m !== '<relative>').reduce((s, [, c]) => s + c, 0);
+    if (relativeCount + externalCount > 0) {
+        patterns.push({
+            type: 'import-ratio',
+            value: `relative:${relativeCount} external:${externalCount} ratio:${(relativeCount / Math.max(1, relativeCount + externalCount) * 100).toFixed(0)}%`,
+            count: relativeCount + externalCount,
+            examples: relativeCount > externalCount ? ['Mostly internal imports'] : ['Mostly external deps'],
+        });
+    }
+    // --- Export patterns ---
     if (exportPatterns.default + exportPatterns.named > 0) {
         patterns.push({
-            type: 'export',
+            type: 'export-style',
             value: `default:${exportPatterns.default} named:${exportPatterns.named}`,
             count: exportPatterns.default + exportPatterns.named,
             examples: exportPatterns.named > exportPatterns.default
@@ -1357,44 +1432,153 @@ function extractPatterns(files) {
                 : ['Default exports preferred'],
         });
     }
-    // Error handling
-    const sortedErrors = [...errorPatterns.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+    // --- Error handling: one entry per strategy ---
+    const sortedErrors = [...errorPatterns.entries()].sort((a, b) => b[1] - a[1]);
+    // Summary
     if (sortedErrors.length > 0) {
         patterns.push({
-            type: 'error-handling',
+            type: 'error-summary',
             value: sortedErrors.map(([t, c]) => `${t}(${c})`).join(', '),
             count: sortedErrors.reduce((s, [, c]) => s + c, 0),
             examples: sortedErrors.slice(0, 3).map(([t]) => t),
         });
     }
-    // Naming conventions
+    // Individual error strategies
+    for (const [errType, count] of sortedErrors.slice(0, 15)) {
+        patterns.push({
+            type: 'error-strategy',
+            value: `${errType}: ${count} occurrences`,
+            count,
+            examples: [errType],
+        });
+    }
+    // --- Naming conventions ---
     const dominant = namingStyles.camelCase >= namingStyles.snake_case ? 'camelCase' : 'snake_case';
     patterns.push({
-        type: 'naming',
+        type: 'naming-convention',
         value: `camelCase:${namingStyles.camelCase} snake_case:${namingStyles.snake_case} PascalCase:${namingStyles.PascalCase} dominant:${dominant}`,
         count: namingStyles.camelCase + namingStyles.snake_case + namingStyles.PascalCase,
         examples: functionSigs.slice(0, 5),
     });
-    // Structure patterns
+    // Individual naming entries
+    if (namingStyles.camelCase > 0) {
+        patterns.push({ type: 'naming-camelCase', value: `camelCase identifiers: ${namingStyles.camelCase}`, count: namingStyles.camelCase, examples: functionSigs.filter(f => /^[a-z]/.test(f)).slice(0, 5) });
+    }
+    if (namingStyles.PascalCase > 0) {
+        patterns.push({ type: 'naming-PascalCase', value: `PascalCase identifiers: ${namingStyles.PascalCase}`, count: namingStyles.PascalCase, examples: functionSigs.filter(f => /^[A-Z]/.test(f)).slice(0, 5) });
+    }
+    if (namingStyles.snake_case > 0) {
+        patterns.push({ type: 'naming-snake_case', value: `snake_case identifiers: ${namingStyles.snake_case}`, count: namingStyles.snake_case, examples: [] });
+    }
+    // --- Structure patterns: one entry per pattern type ---
     const sortedStructures = [...structurePatterns.entries()].sort((a, b) => b[1] - a[1]);
     if (sortedStructures.length > 0) {
         patterns.push({
-            type: 'structure',
+            type: 'structure-summary',
             value: sortedStructures.map(([t, c]) => `${t}(${c})`).join(', '),
             count: sortedStructures.reduce((s, [, c]) => s + c, 0),
             examples: sortedStructures.slice(0, 3).map(([t]) => t),
         });
     }
-    // API patterns
+    for (const [structType, count] of sortedStructures) {
+        patterns.push({
+            type: `structure-${structType}`,
+            value: `${structType}: ${count} occurrences`,
+            count,
+            examples: [structType],
+        });
+    }
+    // --- API patterns: one entry per method/type ---
     const sortedApi = [...apiPatterns.entries()].sort((a, b) => b[1] - a[1]);
     if (sortedApi.length > 0) {
         patterns.push({
-            type: 'api-pattern',
+            type: 'api-summary',
             value: sortedApi.map(([t, c]) => `${t}(${c})`).join(', '),
             count: sortedApi.reduce((s, [, c]) => s + c, 0),
             examples: sortedApi.slice(0, 3).map(([t]) => t),
         });
     }
+    for (const [apiType, count] of sortedApi) {
+        patterns.push({
+            type: `api-${apiType.toLowerCase()}`,
+            value: `${apiType}: ${count} occurrences`,
+            count,
+            examples: [apiType],
+        });
+    }
+    // --- Function signature patterns ---
+    if (functionSigs.length > 0) {
+        // Prefix grouping: group functions by common prefixes (get*, set*, handle*, on*, is*, etc.)
+        const prefixGroups = new Map();
+        const prefixRegex = /^(get|set|handle|on|is|has|create|update|delete|find|fetch|load|save|init|check|validate|parse|format|build|render|compute|process|resolve|transform|convert|ensure|generate|register|dispatch|emit|notify|apply|reset|clear|remove|add|with|to|from)/i;
+        for (const fn of functionSigs) {
+            const match = fn.match(prefixRegex);
+            const prefix = match ? match[1].toLowerCase() : '_other';
+            if (!prefixGroups.has(prefix))
+                prefixGroups.set(prefix, []);
+            prefixGroups.get(prefix).push(fn);
+        }
+        for (const [prefix, fns] of [...prefixGroups.entries()].sort((a, b) => b[1].length - a[1].length).slice(0, 15)) {
+            if (fns.length >= 2) {
+                patterns.push({
+                    type: `function-prefix-${prefix}`,
+                    value: `${prefix}* functions: ${fns.length} (${fns.slice(0, 5).join(', ')}${fns.length > 5 ? ` +${fns.length - 5} more` : ''})`,
+                    count: fns.length,
+                    examples: fns.slice(0, 5),
+                });
+            }
+        }
+    }
+    // --- Async patterns (collected in single pass above) ---
+    if (asyncCount + syncCount > 0) {
+        patterns.push({
+            type: 'async-style',
+            value: `async:${asyncCount} sync:${syncCount} await-usage:${awaitCount} promise-catch:${promiseCatchCount}`,
+            count: asyncCount + syncCount,
+            examples: asyncCount > syncCount ? ['Async-first codebase'] : ['Sync-first codebase'],
+        });
+    }
+    // --- Decorator/annotation patterns (collected in single pass above) ---
+    for (const [decName, count] of [...decoratorCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10)) {
+        if (count >= 2) {
+            patterns.push({
+                type: 'decorator',
+                value: `@${decName}: ${count} usages`,
+                count,
+                examples: [`@${decName}`],
+            });
+        }
+    }
+    // --- Type system patterns (collected in single pass above) ---
+    if (interfaceCount > 0)
+        patterns.push({ type: 'type-interface', value: `${interfaceCount} interfaces defined`, count: interfaceCount, examples: [] });
+    if (typeAliasCount > 0)
+        patterns.push({ type: 'type-alias', value: `${typeAliasCount} type aliases`, count: typeAliasCount, examples: [] });
+    if (enumCount > 0)
+        patterns.push({ type: 'type-enum', value: `${enumCount} enums`, count: enumCount, examples: [] });
+    if (genericCount > 0)
+        patterns.push({ type: 'type-generics', value: `${genericCount} generic declarations`, count: genericCount, examples: [] });
+    // --- Testing patterns (collected in single pass above) ---
+    if (describeCount + itCount + testCount > 0) {
+        patterns.push({
+            type: 'test-framework',
+            value: `describe:${describeCount} it:${itCount} test:${testCount} expect:${expectCount} mocks:${mockCount}`,
+            count: describeCount + itCount + testCount,
+            examples: itCount > testCount ? ['it() style (BDD)'] : ['test() style'],
+        });
+    }
+    if (mockCount > 0) {
+        patterns.push({ type: 'test-mocking', value: `${mockCount} mock/stub usages`, count: mockCount, examples: [] });
+    }
+    // --- Config/env patterns (collected in single pass above) ---
+    if (envAccessCount > 0)
+        patterns.push({ type: 'config-env', value: `process.env accessed ${envAccessCount} times`, count: envAccessCount, examples: [] });
+    if (configImportCount > 0)
+        patterns.push({ type: 'config-import', value: `${configImportCount} config-related imports`, count: configImportCount, examples: [] });
+    // --- Logging patterns (collected in single pass above) ---
+    for (const [logType, count] of [...logPatterns.entries()].sort((a, b) => b[1] - a[1])) {
+        patterns.push({ type: `logging-${logType.replace(/\./g, '-')}`, value: `${logType}: ${count} usages`, count, examples: [logType] });
+    }
     return patterns;
 }
 export const hooksPretrain = {
@@ -1419,7 +1603,7 @@ export const hooksPretrain = {
             : (typeof rawFileTypes === 'string' ? rawFileTypes : 'ts,js,py,md').split(',').map(e => e.trim());
         const startTime = Date.now();
         // Determine file limit by depth
-        const fileLimit = depth === 'deep' ? 100 : depth === 'shallow' ? 30 : 60;
+        const fileLimit = depth === 'deep' ? 500 : depth === 'shallow' ? 80 : 200;
         const extensions = new Set(fileTypesArr);
         // Phase 1: Retrieve - collect source files
         const retrieveStart = Date.now();

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

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.8.34';
+export const VERSION = '4.8.37';
 //# sourceMappingURL=version.js.map

package/src/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moflo/cli",
-  "version": "4.8.34",
+  "version": "4.8.37",
   "type": "module",
   "description": "MoFlo CLI — AI agent orchestration with specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",