moflo 4.8.87-rc.4 → 4.8.87

package/bin/hooks.mjs

@@ -24,6 +24,7 @@ import { existsSync, appendFileSync, readFileSync, writeFileSync, mkdirSync, sta
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { createProcessManager } from './lib/process-manager.mjs';
+import { shouldDaemonAutoStart } from './lib/daemon-config.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -560,13 +561,19 @@ function touchSpawnStamp() {
 
 // Run daemon start in background (non-blocking) — skip if already running
 function runDaemonStartBackground() {
-  // 1. Check if a live daemon already holds the lock
+  // 1. Honor user opt-out via .claude/settings.json claudeFlow.daemon.autoStart
+  if (!shouldDaemonAutoStart(projectRoot)) {
+    log('info', 'Daemon autoStart disabled in settings, skipping');
+    return;
+  }
+
+  // 2. Check if a live daemon already holds the lock
   if (isDaemonLockHeld()) {
     log('info', 'Daemon already running (lock held), skipping start');
     return;
   }
 
-  // 2. Debounce: skip if we spawned recently (prevents thundering herd)
+  // 3. Debounce: skip if we spawned recently (prevents thundering herd)
   if (isDaemonSpawnRecent()) {
     log('info', 'Daemon spawn debounced (recent attempt), skipping');
     return;
@@ -578,7 +585,7 @@ function runDaemonStartBackground() {
     return;
   }
 
-  // 3. Write stamp BEFORE spawning so concurrent callers see it immediately
+  // 4. Write stamp BEFORE spawning so concurrent callers see it immediately
   touchSpawnStamp();
 
   spawnWindowless('node', [localCli, 'daemon', 'start', '--quiet'], 'daemon');

package/bin/lib/daemon-config.mjs

@@ -0,0 +1,19 @@
+// Daemon spawn-gate for bin/ scripts. Reads .claude/settings.json — the
+// Claude-Code-facing surface. moflo.yaml's daemon.auto_start is a separate
+// parallel gate honored by src/cli/index.ts maybeAutoStartDaemon.
+
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+
+// Default-true on missing file, missing key, or malformed JSON so a broken
+// config can't silently disable the daemon.
+export function shouldDaemonAutoStart(projectRoot) {
+  try {
+    const settingsPath = resolve(projectRoot, '.claude', 'settings.json');
+    if (!existsSync(settingsPath)) return true;
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    return settings?.claudeFlow?.daemon?.autoStart !== false;
+  } catch {
+    return true;
+  }
+}

package/bin/lib/process-manager.mjs

@@ -56,7 +56,8 @@ function lockPath(root) {
   return resolve(root, '.claude-flow', 'spawn.lock');
 }
 
-function readRegistry(root) {
+/** Raw read — returns whatever's on disk without filtering or rewriting. */
+function readRegistryRaw(root) {
   const p = registryPath(root);
   if (!existsSync(p)) return [];
   try {
@@ -67,6 +68,22 @@ function readRegistry(root) {
   }
 }
 
+/**
+ * Default read — auto-prunes dead PIDs and rewrites the file when stale
+ * entries are detected. Catches the "abnormal session termination" case
+ * (Claude killed via task manager, OS reboot, hard crash) where session-end
+ * never ran and the registry would otherwise grow unboundedly. Rewrite is
+ * skipped when nothing changed so steady-state reads stay cheap.
+ */
+function readRegistry(root) {
+  const raw = readRegistryRaw(root);
+  const live = raw.filter(e => e && typeof e.pid === 'number' && isAlive(e.pid));
+  if (live.length !== raw.length) {
+    try { writeRegistry(root, live); } catch { /* non-fatal */ }
+  }
+  return live;
+}
+
 /** Atomic write: write to tmp file then rename to avoid torn reads. */
 function writeRegistry(root, entries) {
   const p = registryPath(root);
@@ -191,7 +208,9 @@ export function createProcessManager(root) {
      * @returns {{ killed: number, total: number }}
      */
     killAll() {
-      const entries = readRegistry(projectRoot);
+      // Use raw read so `total` reflects every on-disk entry — including
+      // dead ones we'd otherwise skip silently. Matches the prior contract.
+      const entries = readRegistryRaw(projectRoot);
       let killed = 0;
 
       for (const entry of entries) {
@@ -227,7 +246,9 @@ export function createProcessManager(root) {
      * @returns {{ pruned: number, remaining: number }}
      */
     prune() {
-      const entries = readRegistry(projectRoot);
+      // Use raw read so the pruned count reflects what was on disk, not
+      // what the auto-pruning readRegistry would have already cleaned up.
+      const entries = readRegistryRaw(projectRoot);
       const alive = entries.filter(e => isAlive(e.pid));
       writeRegistry(projectRoot, alive);
       return { pruned: entries.length - alive.length, remaining: alive.length };

package/bin/session-start-launcher.mjs

@@ -222,6 +222,42 @@ try {
         }
       }
 
+      // Recycle the running daemon — its in-process module cache holds the
+      // previous moflo image. After an upgrade that cache is stale, which
+      // shows up as warnings from removed code paths (e.g. the
+      // `[neural-tools] @moflo/embeddings not resolvable` spam from #639,
+      // emitted by pre-#592 collapse code that no longer exists in source)
+      // and means freshly-disabled workers keep running.
+      //
+      // Recycle = stop old + start new. We kill the lock-recorded PID,
+      // remove the lock, then fire a fresh daemon so the user keeps the
+      // functionality they had. `daemon.autoStart` only governs the
+      // cold-start case (no daemon existed); here a daemon was actually
+      // running, so replacing it with a current-code copy is the desired
+      // behaviour regardless of that flag.
+      try {
+        const lockFile = resolve(projectRoot, '.claude-flow', 'daemon.lock');
+        if (existsSync(lockFile)) {
+          let stalePid = null;
+          try {
+            const lock = JSON.parse(readFileSync(lockFile, 'utf-8'));
+            if (typeof lock?.pid === 'number' && lock.pid > 0) stalePid = lock.pid;
+          } catch { /* malformed lock — fall through to unlink */ }
+          if (stalePid !== null) {
+            try { process.kill(stalePid, 'SIGTERM'); } catch { /* already dead */ }
+          }
+          try { unlinkSync(lockFile); } catch { /* non-fatal */ }
+          // Respawn only if a live daemon was actually recorded — no point
+          // starting one when there wasn't one before.
+          if (stalePid !== null) {
+            const localCliPath = resolve(binDir, 'cli.js');
+            if (existsSync(localCliPath)) {
+              fireAndForget('node', [localCliPath, 'daemon', 'start', '--quiet'], 'daemon-recycle');
+            }
+          }
+        }
+      } catch { /* non-fatal — daemon recycle is best-effort */ }
+
       // Write updated manifest + version stamp
       try {
         const cfDir = resolve(projectRoot, '.claude-flow');

package/dist/src/cli/init/settings-generator.js

@@ -104,9 +104,12 @@ export function generateSettings(options) {
         },
         daemon: {
             autoStart: true,
+            // Note: this list is documentation for the user — the daemon's actual
+            // worker registry lives in src/cli/services/worker-daemon.ts DEFAULT_WORKERS.
+            // 'audit' is intentionally absent here because it's default-disabled
+            // pending the perf fix in #631.
             workers: [
                 'map', // Codebase mapping
-                'audit', // Security auditing (critical priority)
                 'optimize', // Performance optimization (high priority)
                 'consolidate', // Memory consolidation
                 'testgaps', // Test coverage gaps

package/dist/src/cli/memory/memory-initializer.js

@@ -17,16 +17,17 @@ import { createEmbeddingService } from '../embeddings/index.js';
 import { HnswLite } from './hnsw-lite.js';
 /**
  * Write vector-stats.json cache for the statusline (no subprocess needed).
- * Called after memory store/delete to keep the cache fresh.
+ * Called after memory store in the raw-sql.js fallback path. The bridge path
+ * goes through refreshVectorStatsCache() in bridge-core.ts instead.
  * @param dbPath - path to the SQLite database file
- * @param stats  - optional exact counts from a db query already in progress
+ * @param stats  - exact counts from a db query already in progress (required —
+ *                 making this optional caused issue #639 by silently writing 0)
  */
 function writeVectorStatsCache(dbPath, stats) {
     try {
         const fileStat = fs.statSync(dbPath);
         const dbSizeKB = Math.floor(fileStat.size / 1024);
-        const vectorCount = stats?.vectorCount ?? 0;
-        const namespaces = stats?.namespaces ?? 0;
+        const { vectorCount, namespaces } = stats;
         // Check HNSW index presence
         const dbDir = path.dirname(dbPath);
         const projectDir = path.dirname(dbDir); // .swarm -> project root
@@ -1568,17 +1569,15 @@ export async function verifyMemoryInit(dbPath, options) {
  * This bypasses MCP and writes directly to the database
  */
 export async function storeEntry(options) {
-    // ADR-053: Try AgentDB v3 bridge first
+    // ADR-053: Try AgentDB v3 bridge first. The bridge calls
+    // refreshVectorStatsCache() itself (bridge-entries.ts:191) — a second
+    // write here was redundant and previously clobbered the correct count
+    // with 0 (#639).
     const bridge = await getBridge();
     if (bridge) {
         const bridgeResult = await bridge.bridgeStoreEntry(options);
-        if (bridgeResult) {
-            // Update statusline cache after successful bridge store
-            const swarmDir = path.join(process.cwd(), '.swarm');
-            const dbFile = options.dbPath || path.join(swarmDir, 'memory.db');
-            writeVectorStatsCache(dbFile);
+        if (bridgeResult)
             return bridgeResult;
-        }
     }
     // Fallback: raw sql.js
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;

package/dist/src/cli/services/spell-gate.js

@@ -17,6 +17,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { atomicWriteFileSync } from './atomic-file-write.js';
 import { loadMofloConfig } from '../config/moflo-config.js';
 // ============================================================================
 // Constants
@@ -108,10 +109,11 @@ export class GateService {
     writeState(state) {
         try {
             fs.mkdirSync(path.dirname(this.stateFilePath), { recursive: true });
-            fs.writeFileSync(this.stateFilePath, JSON.stringify(state, null, 2));
+            // Atomic write so concurrent gate-hook processes never produce torn JSON.
+            atomicWriteFileSync(this.stateFilePath, JSON.stringify(state, null, 2));
         }
         catch {
-            // Non-fatal
+            // Non-fatal — last-writer-wins; updates may be lost, never corrupted.
         }
     }
     // --------------------------------------------------------------------------

package/dist/src/cli/services/worker-daemon.js

@@ -11,13 +11,17 @@
  */
 import { EventEmitter } from 'events';
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { atomicWriteFileSync } from './atomic-file-write.js';
 import { cpus } from 'os';
 import { join } from 'path';
 import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
 // Default worker configurations with improved intervals (P0 fix: map 5min -> 15min)
 const DEFAULT_WORKERS = [
     { type: 'map', intervalMs: 15 * 60 * 1000, offsetMs: 0, priority: 'normal', description: 'Codebase mapping', enabled: true },
-    { type: 'audit', intervalMs: 10 * 60 * 1000, offsetMs: 2 * 60 * 1000, priority: 'critical', description: 'Security analysis', enabled: true },
+    // Default-disabled until the perf regression in #631 is remediated. The
+    // worker averages 238 s/run on real installs, saturating cores back-to-back
+    // when scheduled at the 10-minute interval. Re-enable here when #631 ships.
+    { type: 'audit', intervalMs: 10 * 60 * 1000, offsetMs: 2 * 60 * 1000, priority: 'critical', description: 'Security analysis', enabled: false },
     { type: 'optimize', intervalMs: 15 * 60 * 1000, offsetMs: 4 * 60 * 1000, priority: 'high', description: 'Performance optimization', enabled: true },
     { type: 'consolidate', intervalMs: 30 * 60 * 1000, offsetMs: 6 * 60 * 1000, priority: 'low', description: 'Memory consolidation', enabled: true },
     { type: 'testgaps', intervalMs: 20 * 60 * 1000, offsetMs: 8 * 60 * 1000, priority: 'normal', description: 'Test coverage analysis', enabled: true },
@@ -336,10 +340,17 @@ export class WorkerDaemon extends EventEmitter {
         this.startedAt = new Date();
         this.emit('started', { pid: process.pid, startedAt: this.startedAt });
         // Schedule all enabled workers
+        const skipped = [];
         for (const workerConfig of this.config.workers) {
             if (workerConfig.enabled) {
                 this.scheduleWorker(workerConfig);
             }
+            else {
+                skipped.push(workerConfig.type);
+            }
+        }
+        if (skipped.length > 0) {
+            this.log('info', `Skipping disabled workers: ${skipped.join(', ')}`);
         }
         if (this.scheduler && !this.scheduler.isRunning) {
             this.scheduler.start();
@@ -881,7 +892,8 @@ export class WorkerDaemon extends EventEmitter {
             savedAt: new Date().toISOString(),
         };
         try {
-            writeFileSync(this.config.stateFile, JSON.stringify(state, null, 2));
+            // Atomic write so a force-kill mid-write can't leave partial JSON behind.
+            atomicWriteFileSync(this.config.stateFile, JSON.stringify(state, null, 2));
         }
         catch (error) {
             this.log('error', `Failed to save state: ${error}`);

package/dist/src/cli/shared/utils/atomic-file-write.d.ts

@@ -1,12 +1,19 @@
 /**
  * Atomic filesystem writes for files that must not be left corrupted if the
- * process is interrupted mid-write (SIGINT, power loss, ENOSPC).
+ * process is interrupted mid-write (SIGINT, power loss, ENOSPC) or if multiple
+ * processes write to the same target concurrently.
  *
- * Pattern: write to `<target>.tmp`, then rename onto `target`.
+ * Pattern: write to a process-unique temp path `<target>.tmp.<pid>.<rand>`,
+ * then rename onto `target`.
  *   - `fs.renameSync` is atomic on POSIX.
  *   - On Windows, Node maps it to `MoveFileExW(..., MOVEFILE_REPLACE_EXISTING)`,
  *     which replaces the destination near-atomically — concurrent readers
  *     always observe either the old file or the new, never a truncated one.
+ *   - The unique temp path means concurrent writers can't clobber each other's
+ *     in-flight bytes (#635). Last-writer-wins semantics: each rename is fully
+ *     atomic, so the destination always reflects exactly one writer's data.
+ *     Updates from earlier writers may be lost — that's a separate concern
+ *     requiring read-modify-write under a file lock.
  *
  * On any failure, the temp file is best-effort removed and the original
  * `target` stays intact. The underlying error is always re-thrown.

package/dist/src/cli/shared/utils/atomic-file-write.js

@@ -1,12 +1,19 @@
 /**
  * Atomic filesystem writes for files that must not be left corrupted if the
- * process is interrupted mid-write (SIGINT, power loss, ENOSPC).
+ * process is interrupted mid-write (SIGINT, power loss, ENOSPC) or if multiple
+ * processes write to the same target concurrently.
  *
- * Pattern: write to `<target>.tmp`, then rename onto `target`.
+ * Pattern: write to a process-unique temp path `<target>.tmp.<pid>.<rand>`,
+ * then rename onto `target`.
  *   - `fs.renameSync` is atomic on POSIX.
  *   - On Windows, Node maps it to `MoveFileExW(..., MOVEFILE_REPLACE_EXISTING)`,
  *     which replaces the destination near-atomically — concurrent readers
  *     always observe either the old file or the new, never a truncated one.
+ *   - The unique temp path means concurrent writers can't clobber each other's
+ *     in-flight bytes (#635). Last-writer-wins semantics: each rename is fully
+ *     atomic, so the destination always reflects exactly one writer's data.
+ *     Updates from earlier writers may be lost — that's a separate concern
+ *     requiring read-modify-write under a file lock.
  *
  * On any failure, the temp file is best-effort removed and the original
  * `target` stays intact. The underlying error is always re-thrown.
@@ -18,7 +25,7 @@
  */
 import * as realFs from 'node:fs';
 export function atomicWriteFileSync(targetPath, data, fs = realFs) {
-    const tmpPath = `${targetPath}.tmp`;
+    const tmpPath = `${targetPath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
     try {
         fs.writeFileSync(tmpPath, data);
         fs.renameSync(tmpPath, targetPath);

package/dist/src/cli/version.d.ts

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export declare const VERSION = "4.8.87-rc.4";
+export declare const VERSION = "4.8.87";
 //# sourceMappingURL=version.d.ts.map

package/dist/src/cli/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.87-rc.4';
+export const VERSION = '4.8.87';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.8.87-rc.4",
+  "version": "4.8.87",
   "description": "MoFlo — AI agent orchestration for Claude Code. Forked from ruflo/claude-flow with patches applied to source, plus feature-level orchestration.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -45,7 +45,7 @@
   "scripts": {
     "dev": "tsx watch src/cli/index.ts",
     "prebuild": "node scripts/sync-version.mjs && node scripts/clean-dist.mjs",
-    "build": "tsc -b && node -e \"const{cpSync}=require('fs');cpSync('src/cli/epic/spells','dist/src/cli/epic/spells',{recursive:true})\"",
+    "build": "tsc && node -e \"const{cpSync}=require('fs');cpSync('src/cli/epic/spells','dist/src/cli/epic/spells',{recursive:true})\"",
     "prepublishOnly": "npm run build",
     "postinstall": "node scripts/prune-native-binaries.mjs",
     "test": "node scripts/test-runner.mjs",
@@ -79,7 +79,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.8.87-rc.3",
+    "moflo": "^4.8.87-rc.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"