moflo 4.8.37 → 4.8.38

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

@@ -35,8 +35,10 @@ function resolveBin(binName, localScript) {
 
 function getLocalCliPath() {
   const paths = [
+    resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/bin/cli.js'),
     resolve(projectRoot, 'node_modules/moflo/bin/cli.js'),
     resolve(projectRoot, 'node_modules/.bin/flo'),
+    resolve(projectRoot, 'src/@claude-flow/cli/bin/cli.js'),
   ];
   for (const p of paths) {
     if (existsSync(p)) return p;
@@ -92,8 +94,23 @@ async function main() {
     log('SKIP  test-index (script not found)');
   }
 
-  // 4. HNSW rebuild — MUST run last, after all writes are committed
+  // 4. Patterns indexer
+  const patternsScript = resolveBin('flo-patterns', 'index-patterns.mjs');
+  if (patternsScript) {
+    runStep('patterns-index', 'node', [patternsScript]);
+  } else {
+    log('SKIP  patterns-index (script not found)');
+  }
+
+  // 5. Pretrain (extracts patterns from repository)
   const localCli = getLocalCliPath();
+  if (localCli) {
+    runStep('pretrain', 'node', [localCli, 'hooks', 'pretrain']);
+  } else {
+    log('SKIP  pretrain (CLI not found)');
+  }
+
+  // 6. HNSW rebuild — MUST run last, after all writes are committed (#81)
   if (localCli) {
     runStep('hnsw-rebuild', 'node', [localCli, 'memory', 'rebuild', '--force']);
   } else {
@@ -106,5 +123,5 @@ async function main() {
 
 main().catch(err => {
   log(`FATAL: ${err.message}`);
-  process.exit(0);
+  process.exit(1);
 });

package/bin/hooks.mjs

@@ -258,24 +258,15 @@ 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();
         // Initialize embeddings engine (must run before indexers that generate embeddings)
         runEmbeddingsInitBackground();
-        // Index guidance files in background
-        runIndexGuidanceBackground();
-        // Generate structural code map in background
-        runCodeMapBackground();
-        // Index test files in background
-        runTestIndexBackground();
-        // Index code patterns into patterns namespace
-        runPatternsIndexBackground();
-        // Run pretrain in background to extract patterns from repository
-        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();
+        // Run all DB-writing indexers SEQUENTIALLY in a single background process.
+        // This avoids sql.js last-write-wins concurrency (#78) and ensures
+        // HNSW rebuild runs after all indexers finish (#81).
+        // Chain: guidance → code-map → tests → patterns → pretrain → HNSW rebuild.
+        spawnWindowless('node', [resolve(__dirname, 'index-all.mjs')], 'sequential indexing chain');
         // Neural patterns now loaded by moflo core routing — no external patching.
         break;
       }
@@ -471,55 +462,6 @@ function runIndexGuidanceBackground(specificFile = null) {
   spawnWindowless('node', indexArgs, desc);
 }
 
-// Run structural code map generator in background (non-blocking)
-function runCodeMapBackground() {
-  // Check auto_index.code_map flag in moflo.yaml (default: true)
-  const yamlPath = resolve(projectRoot, 'moflo.yaml');
-  if (existsSync(yamlPath)) {
-    try {
-      const content = readFileSync(yamlPath, 'utf-8');
-      const match = content.match(/auto_index:\s*\n(?:.*\n)*?\s+code_map:\s*(true|false)/);
-      if (match && match[1] === 'false') {
-        log('info', 'Code map generation disabled (auto_index.code_map: false)');
-        return;
-      }
-    } catch { /* ignore, proceed with indexing */ }
-  }
-
-  const codeMapScript = resolveBinOrLocal('flo-codemap', 'generate-code-map.mjs');
-
-  if (!codeMapScript) {
-    log('warn', 'Code map generator not found (checked npm bin + .claude/scripts/)');
-    return;
-  }
-
-  spawnWindowless('node', [codeMapScript], 'background code map generation');
-}
-
-// Run test file indexer in background (non-blocking)
-function runTestIndexBackground() {
-  // Check auto_index.tests flag in moflo.yaml (default: true)
-  const yamlPath = resolve(projectRoot, 'moflo.yaml');
-  if (existsSync(yamlPath)) {
-    try {
-      const content = readFileSync(yamlPath, 'utf-8');
-      const match = content.match(/auto_index:\s*\n(?:.*\n)*?\s+tests:\s*(true|false)/);
-      if (match && match[1] === 'false') {
-        log('info', 'Test indexing disabled (auto_index.tests: false)');
-        return;
-      }
-    } catch { /* ignore, proceed with indexing */ }
-  }
-
-  const testIndexScript = resolveBinOrLocal('flo-testmap', 'index-tests.mjs');
-
-  if (!testIndexScript) {
-    log('info', 'Test indexer not found (checked npm bin + .claude/scripts/)');
-    return;
-  }
-
-  spawnWindowless('node', [testIndexScript], 'background test indexing');
-}
 
 // Run ReasoningBank + MicroLoRA training + EWC++ consolidation in background (non-blocking)
 function runBackgroundTraining() {
@@ -627,28 +569,6 @@ function runDaemonStartBackground() {
   spawnWindowless('node', [localCli, 'daemon', 'start', '--quiet'], 'daemon');
 }
 
-// Run pretrain in background on session start (non-blocking)
-function runBackgroundPretrain() {
-  const localCli = getLocalCliPath();
-  if (!localCli) {
-    log('warn', 'Local CLI not found, skipping background pretrain');
-    return;
-  }
-
-  spawnWindowless('node', [localCli, 'hooks', 'pretrain'], 'background pretrain');
-}
-
-// Force HNSW rebuild in background to ensure all processes use identical fresh index
-// This fixes the issue where spawned agents return different search results than CLI/MCP
-function runHNSWRebuildBackground() {
-  const localCli = getLocalCliPath();
-  if (!localCli) {
-    log('warn', 'Local CLI not found, skipping HNSW rebuild');
-    return;
-  }
-
-  spawnWindowless('node', [localCli, 'memory', 'rebuild', '--force'], 'HNSW rebuild');
-}
 
 // Initialize embeddings ONNX engine on session start (non-blocking)
 function runEmbeddingsInitBackground() {
@@ -661,30 +581,6 @@ function runEmbeddingsInitBackground() {
   spawnWindowless('node', [localCli, 'embeddings', 'init'], 'embeddings init');
 }
 
-// Index code patterns into the patterns namespace (non-blocking)
-// Extracts architectural patterns, idioms, and recurring structures from source
-function runPatternsIndexBackground() {
-  // Check auto_index.patterns flag in moflo.yaml (default: true)
-  const yamlPath = resolve(projectRoot, 'moflo.yaml');
-  if (existsSync(yamlPath)) {
-    try {
-      const content = readFileSync(yamlPath, 'utf-8');
-      const match = content.match(/auto_index:\s*\n(?:.*\n)*?\s+patterns:\s*(true|false)/);
-      if (match && match[1] === 'false') {
-        log('info', 'Patterns indexing disabled (auto_index.patterns: false)');
-        return;
-      }
-    } catch { /* ignore, proceed with indexing */ }
-  }
-
-  const patternsScript = resolveBinOrLocal('flo-patterns', 'index-patterns.mjs');
-  if (!patternsScript) {
-    log('warn', 'Patterns indexer not found (checked npm bin + .claude/scripts/)');
-    return;
-  }
-
-  spawnWindowless('node', [patternsScript], 'background patterns indexing');
-}
 
 // Neural pattern application — now handled by moflo core routing (learned patterns
 // loaded from routing-outcomes.json by hooks-tools.ts getSemanticRouter).

package/bin/index-all.mjs

@@ -0,0 +1,168 @@
+#!/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 (#78), then triggers HNSW rebuild once everything is
+ * committed (#81).
+ *
+ * Spawned as a single detached background process by hooks.mjs session-start.
+ */
+
+import { existsSync, appendFileSync, readFileSync } 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, '.swarm/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;
+  // Also check bin/ directory (for development use)
+  const binPath = resolve(projectRoot, 'bin', localScript);
+  if (existsSync(binPath)) return binPath;
+  return null;
+}
+
+function getLocalCliPath() {
+  const paths = [
+    resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/bin/cli.js'),
+    resolve(projectRoot, 'node_modules/moflo/bin/cli.js'),
+    resolve(projectRoot, 'node_modules/.bin/flo'),
+    // Development: local CLI
+    resolve(projectRoot, 'src/@claude-flow/cli/bin/cli.js'),
+  ];
+  for (const p of paths) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+/** Read moflo.yaml once and cache auto_index flags. */
+let _autoIndexFlags = null;
+function isIndexEnabled(key) {
+  if (_autoIndexFlags === null) {
+    _autoIndexFlags = {};
+    const yamlPath = resolve(projectRoot, 'moflo.yaml');
+    if (existsSync(yamlPath)) {
+      try {
+        const content = readFileSync(yamlPath, 'utf-8');
+        for (const k of ['guidance', 'code_map', 'tests', 'patterns']) {
+          const re = new RegExp(`auto_index:\\s*\\n(?:.*\\n)*?\\s+${k}:\\s*(true|false)`);
+          const match = content.match(re);
+          _autoIndexFlags[k] = match ? match[1] !== 'false' : true;
+        }
+      } catch { /* ignore, all default to true */ }
+    }
+  }
+  return _autoIndexFlags[key] !== false;
+}
+
+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
+  if (isIndexEnabled('guidance')) {
+    const guidanceScript = resolveBin('flo-index', 'index-guidance.mjs');
+    if (guidanceScript) {
+      runStep('guidance-index', 'node', [guidanceScript]);
+    } else {
+      log('SKIP  guidance-index (script not found)');
+    }
+  } else {
+    log('SKIP  guidance-index (disabled in moflo.yaml)');
+  }
+
+  // 2. Code map generator (the big one — ~22s)
+  if (isIndexEnabled('code_map')) {
+    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)');
+    }
+  } else {
+    log('SKIP  code-map (disabled in moflo.yaml)');
+  }
+
+  // 3. Test indexer
+  if (isIndexEnabled('tests')) {
+    const testScript = resolveBin('flo-testmap', 'index-tests.mjs');
+    if (testScript) {
+      runStep('test-index', 'node', [testScript]);
+    } else {
+      log('SKIP  test-index (script not found)');
+    }
+  } else {
+    log('SKIP  test-index (disabled in moflo.yaml)');
+  }
+
+  // 4. Patterns indexer
+  if (isIndexEnabled('patterns')) {
+    const patternsScript = resolveBin('flo-patterns', 'index-patterns.mjs');
+    if (patternsScript) {
+      runStep('patterns-index', 'node', [patternsScript]);
+    } else {
+      log('SKIP  patterns-index (script not found)');
+    }
+  } else {
+    log('SKIP  patterns-index (disabled in moflo.yaml)');
+  }
+
+  // 5. Pretrain (extracts patterns from repository)
+  const localCli = getLocalCliPath();
+  if (localCli) {
+    runStep('pretrain', 'node', [localCli, 'hooks', 'pretrain']);
+  } else {
+    log('SKIP  pretrain (CLI not found)');
+  }
+
+  // 6. HNSW rebuild — MUST run last, after all writes are committed (#81)
+  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(1);
+});

package/package.json

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

@@ -798,12 +798,19 @@ async function checkIntelligence() {
                 trajectoryId: 'doctor-test',
                 context: 'health check',
                 domain: 'general',
-                steps: [{ action: 'test', reward: 1, embedding: new Float32Array(64).fill(0.2), timestamp: Date.now() }],
+                steps: [{ action: 'test', reward: 1, stateAfter: new Float32Array(64).fill(0.2), timestamp: Date.now() }],
                 startTime: Date.now(),
                 endTime: Date.now(),
                 qualityScore: 0.9,
                 isComplete: true,
-                verdict: { success: true, quality: 0.9, feedback: 'test' },
+                verdict: {
+                    success: true,
+                    confidence: 0.9,
+                    strengths: ['health check passed'],
+                    weaknesses: [],
+                    improvements: [],
+                    relevanceScore: 0.9,
+                },
             };
             rb.storeTrajectory(trajectory);
             // distill() populates memories (storeTrajectory alone does not)

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.37';
+export const VERSION = '4.8.38';
 //# sourceMappingURL=version.js.map

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

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