moflo 4.8.1 → 4.8.3

package/README.md

@@ -124,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
 
@@ -217,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
 ```
 
@@ -238,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/hooks.mjs

@@ -20,7 +20,7 @@
  */
 
 import { spawn } from 'child_process';
-import { existsSync, appendFileSync, readFileSync } from 'fs';
+import { existsSync, appendFileSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -306,10 +306,13 @@ async function main() {
       }
 
       case 'daemon-start': {
-        if (!isDaemonLockHeld()) {
-          await runClaudeFlow('daemon', ['start', '--quiet']);
-        } else {
+        if (isDaemonLockHeld()) {
           log('info', 'Daemon already running (lock held), skipping start');
+        } else if (isDaemonSpawnRecent()) {
+          log('info', 'Daemon spawn debounced (recent attempt), skipping');
+        } else {
+          touchSpawnStamp();
+          await runClaudeFlow('daemon', ['start', '--quiet']);
         }
         break;
       }
@@ -479,17 +482,30 @@ function runBackgroundTraining() {
   spawnWindowless('node', [localCli, 'neural', 'optimize'], 'neural optimize');
 }
 
-// Check if daemon lock exists — fast pre-check to avoid spawning a Node process
-// just to have it bail out via the atomic lock in daemon.ts.
-// Uses daemon.lock (atomic wx-based) instead of the old daemon.pid (TOCTOU-vulnerable).
+// Delegate to daemon-lock.js for proper PID + command-line verification.
+// Falls back to a naive kill(0) check if the import fails (e.g. dist not built).
+let _getDaemonLockHolder = null;
+try {
+  const daemonLockPath = resolve(__dirname, '..', 'src', '@claude-flow', 'cli', 'dist', 'src', 'services', 'daemon-lock.js');
+  if (existsSync(daemonLockPath)) {
+    const mod = await import('file://' + daemonLockPath.replace(/\\/g, '/'));
+    _getDaemonLockHolder = mod.getDaemonLockHolder;
+  }
+} catch { /* fallback below */ }
+
 function isDaemonLockHeld() {
+  // Prefer the real daemon-lock module (PID + command-line verification)
+  if (_getDaemonLockHolder) {
+    return _getDaemonLockHolder(projectRoot) !== null;
+  }
+
+  // Fallback: naive PID check (only if daemon-lock.js unavailable)
   const lockFile = resolve(projectRoot, '.claude-flow', 'daemon.lock');
   if (!existsSync(lockFile)) return false;
-
   try {
     const data = JSON.parse(readFileSync(lockFile, 'utf-8'));
     if (typeof data.pid === 'number' && data.pid > 0) {
-      process.kill(data.pid, 0); // check if alive
+      process.kill(data.pid, 0);
       return true;
     }
   } catch {
@@ -498,21 +514,52 @@ function isDaemonLockHeld() {
   return false;
 }
 
+// Debounce file — prevents thundering-herd spawns when multiple hooks fire
+// within the same second (e.g. subagents each triggering SessionStart).
+const SPAWN_DEBOUNCE_MS = 30_000;
+const SPAWN_STAMP_FILE = resolve(projectRoot, '.claude-flow', 'daemon-spawn.stamp');
+
+function isDaemonSpawnRecent() {
+  try {
+    if (existsSync(SPAWN_STAMP_FILE)) {
+      const age = Date.now() - statSync(SPAWN_STAMP_FILE).mtimeMs;
+      return age < SPAWN_DEBOUNCE_MS;
+    }
+  } catch { /* non-fatal */ }
+  return false;
+}
+
+function touchSpawnStamp() {
+  try {
+    const dir = resolve(projectRoot, '.claude-flow');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(SPAWN_STAMP_FILE, String(Date.now()));
+  } catch { /* non-fatal */ }
+}
+
 // Run daemon start in background (non-blocking) — skip if already running
 function runDaemonStartBackground() {
-  // Fast check: if daemon lock is held by a live process, skip spawning entirely.
-  // This avoids zombie Node processes from subagents that all fire SessionStart.
+  // 1. 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)
+  if (isDaemonSpawnRecent()) {
+    log('info', 'Daemon spawn debounced (recent attempt), skipping');
+    return;
+  }
+
   const localCli = getLocalCliPath();
   if (!localCli) {
     log('warn', 'Local CLI not found, skipping daemon start');
     return;
   }
 
+  // 3. Write stamp BEFORE spawning so concurrent callers see it immediately
+  touchSpawnStamp();
+
   spawnWindowless('node', [localCli, 'daemon', 'start', '--quiet'], 'daemon');
 }
 

package/bin/index-guidance.mjs

@@ -635,6 +635,29 @@ function indexFile(db, filePath, keyPrefix) {
   }
 }
 
+/**
+ * Recursively collect all .md files under a directory.
+ * Skips node_modules, .git, and other non-content directories.
+ */
+function walkMdFiles(dir) {
+  const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next']);
+  const files = [];
+
+  function walk(current) {
+    if (!existsSync(current)) return;
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(resolve(current, entry.name));
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        files.push(resolve(current, entry.name));
+      }
+    }
+  }
+
+  walk(dir);
+  return files;
+}
+
 function indexDirectory(db, dirConfig) {
   const dirPath = dirConfig.absolute ? dirConfig.path : resolve(projectRoot, dirConfig.path);
   const results = [];
@@ -644,13 +667,12 @@ function indexDirectory(db, dirConfig) {
     return results;
   }
 
-  const allMdFiles = readdirSync(dirPath).filter(f => f.endsWith('.md'));
-  const files = dirConfig.fileFilter
-    ? allMdFiles.filter(f => dirConfig.fileFilter.includes(f))
+  const allMdFiles = walkMdFiles(dirPath);
+  const filtered = dirConfig.fileFilter
+    ? allMdFiles.filter(f => dirConfig.fileFilter.includes(basename(f)))
     : allMdFiles;
 
-  for (const file of files) {
-    const filePath = resolve(dirPath, file);
+  for (const filePath of filtered) {
     const result = indexFile(db, filePath, dirConfig.prefix);
     results.push(result);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.8.1",
+  "version": "4.8.3",
   "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",
@@ -83,7 +83,7 @@
     "@types/bcrypt": "^5.0.2",
     "@types/node": "^20.19.37",
     "eslint": "^8.0.0",
-    "moflo": "^4.8.0",
+    "moflo": "^4.8.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"

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

@@ -4,7 +4,7 @@
  */
 import { output } from '../output.js';
 import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
-import { acquireDaemonLock, releaseDaemonLock, getDaemonLockHolder } from '../services/daemon-lock.js';
+import { acquireDaemonLock, releaseDaemonLock, getDaemonLockHolder, transferDaemonLock } from '../services/daemon-lock.js';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
@@ -71,16 +71,16 @@ const startCommand = {
         }
         // Foreground mode: run in current process (blocks terminal)
         try {
-            // Acquire atomic daemon lock (prevents duplicate daemons)
-            // Skip lock acquisition if we're the spawned child — parent already holds it
-            if (!isDaemonProcess) {
-                const lockResult = acquireDaemonLock(projectRoot);
-                if (!lockResult.acquired) {
-                    if (!quiet) {
-                        output.printWarning(`Daemon already running (PID: ${lockResult.holder})`);
-                    }
-                    return { success: true };
+            // Acquire atomic daemon lock (prevents duplicate daemons).
+            // Always acquire here — even when spawned as a child (CLAUDE_FLOW_DAEMON=1)
+            // because on Windows the parent's child.pid is the shell PID (cmd.exe),
+            // not the actual node process. The child must write its own real PID.
+            const lockResult = acquireDaemonLock(projectRoot);
+            if (!lockResult.acquired) {
+                if (!quiet) {
+                    output.printWarning(`Daemon already running (PID: ${lockResult.holder})`);
                 }
+                return { success: true };
             }
             // Clean up lock file on exit
             const cleanup = () => {
@@ -256,11 +256,21 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     child.unref();
     // Small delay to let the child process fully detach on macOS
     await new Promise(resolve => setTimeout(resolve, 100));
-    // Update the lock file with the child's PID (parent acquired it, child owns it)
-    // We force-release our lock and re-acquire with the child PID so the lock
-    // accurately reflects the running daemon process.
-    releaseDaemonLock(resolvedRoot, process.pid, true);
-    acquireDaemonLock(resolvedRoot, pid);
+    // On Windows with shell: true, child.pid is the cmd.exe shell PID, not the
+    // actual node daemon. The child will acquire the lock itself with its real PID
+    // (see foreground start path). Release the parent's lock so the child can take it.
+    //
+    // On POSIX (no shell), child.pid IS the real daemon PID, so we can transfer
+    // atomically to avoid any gap where the lock is absent.
+    if (isWin) {
+        releaseDaemonLock(resolvedRoot, process.pid, true);
+    }
+    else {
+        if (!transferDaemonLock(resolvedRoot, pid)) {
+            releaseDaemonLock(resolvedRoot, process.pid, true);
+            acquireDaemonLock(resolvedRoot, pid);
+        }
+    }
     if (!quiet) {
         output.printSuccess(`Daemon started in background (PID: ${pid})`);
         output.printInfo(`Logs: ${logFile}`);

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

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

@@ -0,0 +1,503 @@
+/**
+ * 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 { output } from '../output.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const DIAG_NAMESPACE = '__moflo_diagnose__';
+const DIAG_KEY = '__diag_test_entry__';
+async function timed(name, fn) {
+    const t0 = performance.now();
+    try {
+        const r = await fn();
+        return { name, ...r, duration: performance.now() - t0 };
+    }
+    catch (err) {
+        return { name, status: 'fail', message: err instanceof Error ? err.message : String(err), duration: performance.now() - t0 };
+    }
+}
+/**
+ * Lazy-load memory functions to avoid pulling in WASM at import time.
+ */
+async function getMemFns() {
+    const { storeEntry, searchEntries, listEntries, getEntry, deleteEntry, initializeMemoryDatabase, checkMemoryInitialization, } = await import('../memory/memory-initializer.js');
+    return { storeEntry, searchEntries, listEntries, getEntry, deleteEntry, initializeMemoryDatabase, checkMemoryInitialization };
+}
+// ---------------------------------------------------------------------------
+// Individual diagnostic tests
+// ---------------------------------------------------------------------------
+function testMemoryInit() {
+    return () => timed('Memory Init', async () => {
+        const { initializeMemoryDatabase, checkMemoryInitialization } = await getMemFns();
+        const status = await checkMemoryInitialization();
+        if (!status.initialized) {
+            await initializeMemoryDatabase({ force: false, verbose: false });
+            const recheck = await checkMemoryInitialization();
+            if (!recheck.initialized)
+                return { status: 'fail', message: 'Could not initialize memory database' };
+        }
+        return { status: 'pass', message: `Initialized (v${status.version || '3.0.0'})` };
+    });
+}
+function testMemoryStore() {
+    return () => timed('Memory Store', async () => {
+        const { storeEntry, deleteEntry } = await getMemFns();
+        // Clean up any leftover from a previous run
+        try {
+            await deleteEntry({ key: DIAG_KEY, namespace: DIAG_NAMESPACE });
+        }
+        catch { /* ignore */ }
+        const result = await storeEntry({
+            key: DIAG_KEY,
+            value: 'diagnose test value — safe to delete',
+            namespace: DIAG_NAMESPACE,
+            generateEmbeddingFlag: true,
+            tags: ['diagnose'],
+            upsert: true,
+        });
+        if (!result.success)
+            return { status: 'fail', message: result.error || 'store failed' };
+        const dims = result.embedding?.dimensions;
+        return { status: 'pass', message: `Stored with ${dims ?? 0}-dim vector` };
+    });
+}
+function testMemoryRetrieve() {
+    return () => timed('Memory Retrieve', async () => {
+        const { getEntry } = await getMemFns();
+        const result = await getEntry({ key: DIAG_KEY, namespace: DIAG_NAMESPACE });
+        if (!result.found)
+            return { status: 'fail', message: 'Entry not found after store' };
+        if (!result.entry?.content?.includes('diagnose test value'))
+            return { status: 'fail', message: 'Content mismatch' };
+        return { status: 'pass', message: 'Retrieved and verified' };
+    });
+}
+function testMemorySearch() {
+    return () => timed('Memory Search', async () => {
+        const { searchEntries } = await getMemFns();
+        const result = await searchEntries({
+            query: 'diagnose test value safe delete',
+            namespace: DIAG_NAMESPACE,
+            limit: 5,
+            threshold: 0.1,
+        });
+        if (!result.results || result.results.length === 0)
+            return { status: 'fail', message: 'No search results returned' };
+        const top = result.results[0];
+        return { status: 'pass', message: `Top hit: ${top.key} (score ${top.score.toFixed(2)})` };
+    });
+}
+function testMemoryList() {
+    return () => timed('Memory List', async () => {
+        const { listEntries } = await getMemFns();
+        const result = await listEntries({ namespace: DIAG_NAMESPACE, limit: 50 });
+        if (result.total === 0)
+            return { status: 'fail', message: 'No entries in diagnose namespace' };
+        return { status: 'pass', message: `${result.total} entries found` };
+    });
+}
+function testMemoryDelete() {
+    return () => timed('Memory Delete', async () => {
+        const { deleteEntry, listEntries } = await getMemFns();
+        const result = await deleteEntry({ key: DIAG_KEY, namespace: DIAG_NAMESPACE });
+        if (!result.deleted)
+            return { status: 'fail', message: 'Delete returned false' };
+        // Verify it's gone
+        const list = await listEntries({ namespace: DIAG_NAMESPACE, limit: 50 });
+        if (list.total !== 0)
+            return { status: 'fail', message: `${list.total} entries still remain after delete` };
+        return { status: 'pass', message: 'Deleted and verified' };
+    });
+}
+function testSwarmLifecycle() {
+    return () => timed('Swarm Lifecycle', async () => {
+        // Use dynamic import to the MCP tools which contain the swarm logic
+        let swarmId;
+        try {
+            const { swarmTools } = await import('../mcp-tools/swarm-tools.js');
+            const tools = swarmTools;
+            const initTool = tools.find(t => t.name === 'swarm_init');
+            if (!initTool)
+                return { status: 'skip', message: 'swarm_init tool not found' };
+            const initResult = await initTool.handler({
+                topology: 'hierarchical',
+                maxAgents: 4,
+                strategy: 'specialized',
+            });
+            swarmId = initResult?.swarmId;
+            if (!swarmId)
+                return { status: 'fail', message: 'No swarm ID returned' };
+            // Spawn an agent
+            const spawnTool = tools.find(t => t.name === 'agent_spawn');
+            if (spawnTool) {
+                await spawnTool.handler({ type: 'coder', name: '__diag_agent__' });
+            }
+            // Status
+            const statusTool = tools.find(t => t.name === 'swarm_status');
+            if (statusTool) {
+                await statusTool.handler({});
+            }
+            // Stop the agent and swarm
+            const agentListTool = tools.find(t => t.name === 'agent_list');
+            if (agentListTool) {
+                const agents = await agentListTool.handler({});
+                const agentList = (agents?.agents ?? []);
+                const stopAgentTool = tools.find(t => t.name === 'agent_stop');
+                if (stopAgentTool) {
+                    for (const a of agentList) {
+                        if (a.id)
+                            await stopAgentTool.handler({ agentId: a.id });
+                    }
+                }
+            }
+            return { status: 'pass', message: `Swarm ${swarmId} — init/spawn/status/stop OK` };
+        }
+        catch (err) {
+            return { status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+}
+function testHiveMindLifecycle() {
+    return () => timed('Hive-Mind Lifecycle', async () => {
+        try {
+            const { hiveMindTools } = await import('../mcp-tools/hive-mind-tools.js');
+            const tools = hiveMindTools;
+            const initTool = tools.find(t => t.name === 'hive-mind_init');
+            if (!initTool)
+                return { status: 'skip', message: 'hive-mind_init tool not found' };
+            const initResult = await initTool.handler({
+                topology: 'hierarchical-mesh',
+                consensus: 'raft',
+                maxAgents: 4,
+            });
+            const hiveId = initResult?.hiveId;
+            if (!hiveId)
+                return { status: 'fail', message: 'No hive ID returned' };
+            // Spawn a worker
+            const spawnTool = tools.find(t => t.name === 'hive-mind_spawn');
+            if (spawnTool) {
+                await spawnTool.handler({ role: 'worker', name: '__diag_worker__' });
+            }
+            // Status
+            const statusTool = tools.find(t => t.name === 'hive-mind_status');
+            if (statusTool) {
+                await statusTool.handler({});
+            }
+            // Shutdown
+            const shutdownTool = tools.find(t => t.name === 'hive-mind_shutdown');
+            if (shutdownTool) {
+                await shutdownTool.handler({});
+            }
+            return { status: 'pass', message: `Hive ${hiveId} — init/spawn/status/shutdown OK` };
+        }
+        catch (err) {
+            return { status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+}
+function testTaskLifecycle() {
+    return () => timed('Task Lifecycle', async () => {
+        try {
+            const { taskTools } = await import('../mcp-tools/task-tools.js');
+            const tools = taskTools;
+            const createTool = tools.find(t => t.name === 'task_create');
+            if (!createTool)
+                return { status: 'skip', message: 'task_create tool not found' };
+            const createResult = await createTool.handler({
+                type: 'implementation',
+                description: '__moflo_diagnose__ test task — safe to delete',
+            });
+            const taskId = createResult?.taskId;
+            if (!taskId)
+                return { status: 'fail', message: 'No task ID returned' };
+            // List tasks
+            const listTool = tools.find(t => t.name === 'task_list');
+            if (listTool) {
+                const list = await listTool.handler({});
+                const tasks = (list?.tasks ?? []);
+                if (tasks.length === 0)
+                    return { status: 'fail', message: 'Task list empty after create' };
+            }
+            return { status: 'pass', message: `Task ${taskId} — create/list OK` };
+        }
+        catch (err) {
+            return { status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+}
+function testHooksRouting() {
+    return () => timed('Hooks Routing', async () => {
+        try {
+            const { hooksTools } = await import('../mcp-tools/hooks-tools.js');
+            const tools = hooksTools;
+            const routeTool = tools.find(t => t.name === 'hooks_route');
+            if (!routeTool)
+                return { status: 'skip', message: 'hooks_route tool not found' };
+            const result = await routeTool.handler({
+                task: 'add user authentication with OAuth',
+            });
+            const primary = result?.primaryAgent;
+            const agent = primary?.type;
+            const confidence = primary?.confidence;
+            if (!agent)
+                return { status: 'fail', message: 'No agent recommendation returned' };
+            return { status: 'pass', message: `Routed to ${agent} (${confidence}% confidence)` };
+        }
+        catch (err) {
+            return { status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+}
+function testConfigShow() {
+    return () => timed('Config Show', async () => {
+        try {
+            const { existsSync, readFileSync } = await import('fs');
+            const yamlPaths = [
+                'moflo.yaml',
+                '.claude-flow/config.yaml',
+                '.claude-flow/config.yml',
+            ];
+            for (const p of yamlPaths) {
+                if (existsSync(p)) {
+                    const content = readFileSync(p, 'utf-8');
+                    if (content.length > 10) {
+                        return { status: 'pass', message: `${p} (${content.length} bytes)` };
+                    }
+                }
+            }
+            const jsonPaths = [
+                '.claude-flow/config.json',
+                'claude-flow.config.json',
+            ];
+            for (const p of jsonPaths) {
+                if (existsSync(p)) {
+                    JSON.parse(readFileSync(p, 'utf-8'));
+                    return { status: 'pass', message: `${p} (valid JSON)` };
+                }
+            }
+            return { status: 'fail', message: 'No config file found' };
+        }
+        catch (err) {
+            return { status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+}
+function testInitIdempotency() {
+    return () => timed('Init Idempotency', async () => {
+        try {
+            const { existsSync } = await import('fs');
+            // Verify that key init artifacts exist (but don't re-run init to avoid side effects)
+            const expected = [
+                '.claude/settings.json',
+                '.claude/agents',
+                '.claude/skills/flo/SKILL.md',
+            ];
+            const missing = expected.filter(p => !existsSync(p));
+            if (missing.length > 0) {
+                return { status: 'fail', message: `Missing: ${missing.join(', ')}` };
+            }
+            return { status: 'pass', message: `${expected.length} artifacts verified` };
+        }
+        catch (err) {
+            return { status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+}
+function testNeuralStatus() {
+    return () => timed('Neural Status', async () => {
+        try {
+            const { neuralTools } = await import('../mcp-tools/neural-tools.js');
+            const tools = neuralTools;
+            const statusTool = tools.find(t => t.name === 'neural_status');
+            if (!statusTool)
+                return { status: 'skip', message: 'neural_status tool not found' };
+            const result = await statusTool.handler({});
+            const components = result?.components;
+            if (!components || components.length === 0) {
+                // Still pass if we got a response — neural may not be fully loaded
+                return { status: 'pass', message: 'Neural subsystem responded' };
+            }
+            const active = components.filter(c => c.status === 'Active' || c.status === 'Available' || c.status === 'Loaded');
+            return { status: 'pass', message: `${active.length}/${components.length} components active` };
+        }
+        catch (err) {
+            // Neural is optional — don't fail the whole suite
+            return { status: 'skip', message: `Neural not available: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    });
+}
+function testMcpParity() {
+    return () => timed('MCP Tools Available', async () => {
+        try {
+            const { memoryTools: memTools } = await import('../mcp-tools/memory-tools.js');
+            const expectedMemTools = ['memory_store', 'memory_retrieve', 'memory_search', 'memory_delete', 'memory_list', 'memory_stats'];
+            const found = expectedMemTools.filter(name => memTools.find(t => t.name === name));
+            const missing = expectedMemTools.filter(name => !memTools.find(t => t.name === name));
+            if (missing.length > 0) {
+                return { status: 'fail', message: `Missing MCP tools: ${missing.join(', ')}` };
+            }
+            return { status: 'pass', message: `${found.length} memory tools registered` };
+        }
+        catch (err) {
+            return { status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// Main command
+// ---------------------------------------------------------------------------
+export const diagnoseCommand = {
+    name: 'diagnose',
+    description: 'Full integration test suite — exercises all subsystems non-destructively',
+    aliases: ['diag'],
+    options: [
+        {
+            name: 'suite',
+            short: 's',
+            description: 'Run specific suite: memory, swarm, hive, task, hooks, config, neural, mcp, init, all',
+            type: 'string',
+            default: 'all',
+        },
+        {
+            name: 'verbose',
+            short: 'v',
+            description: 'Show detailed output for each test',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'json',
+            description: 'Output results as JSON',
+            type: 'boolean',
+            default: false,
+        },
+    ],
+    examples: [
+        { command: 'moflo diagnose', description: 'Run full integration diagnostics' },
+        { command: 'moflo diagnose --suite memory', description: 'Run only memory tests' },
+        { command: 'moflo diagnose --json', description: 'Output results as JSON' },
+        { command: 'moflo diag', description: 'Alias for diagnose' },
+    ],
+    action: async (ctx) => {
+        const suite = ctx.flags.suite || 'all';
+        const verbose = ctx.flags.verbose;
+        const jsonOutput = ctx.flags.json;
+        if (!jsonOutput) {
+            output.writeln();
+            output.writeln(output.bold('MoFlo Diagnose'));
+            output.writeln(output.dim('Full integration test suite — all test data is cleaned up'));
+            output.writeln(output.dim('─'.repeat(60)));
+            output.writeln();
+        }
+        // Build test list based on suite filter
+        const suites = {
+            memory: [
+                testMemoryInit(),
+                testMemoryStore(),
+                testMemoryRetrieve(),
+                testMemorySearch(),
+                testMemoryList(),
+                testMemoryDelete(),
+            ],
+            swarm: [testSwarmLifecycle()],
+            hive: [testHiveMindLifecycle()],
+            task: [testTaskLifecycle()],
+            hooks: [testHooksRouting()],
+            config: [testConfigShow()],
+            neural: [testNeuralStatus()],
+            mcp: [testMcpParity()],
+            init: [testInitIdempotency()],
+        };
+        let tests;
+        if (suite === 'all') {
+            tests = Object.values(suites).flat();
+        }
+        else if (suites[suite]) {
+            tests = suites[suite];
+        }
+        else {
+            const valid = Object.keys(suites).join(', ');
+            output.writeln(output.error(`Unknown suite "${suite}". Valid: ${valid}, all`));
+            return { success: false, exitCode: 1 };
+        }
+        // Run tests sequentially (some depend on prior state, e.g. memory store → retrieve)
+        const results = [];
+        const spinner = output.createSpinner({ text: 'Running diagnostics...', spinner: 'dots' });
+        if (!jsonOutput)
+            spinner.start();
+        for (const test of tests) {
+            const result = await test();
+            results.push(result);
+            if (!jsonOutput) {
+                spinner.stop();
+                const icon = result.status === 'pass' ? output.success('✓')
+                    : result.status === 'skip' ? output.dim('○')
+                        : output.error('✗');
+                const dur = result.duration < 1000
+                    ? `${result.duration.toFixed(0)}ms`
+                    : `${(result.duration / 1000).toFixed(1)}s`;
+                output.writeln(`${icon} ${result.name}: ${result.message} ${output.dim(`(${dur})`)}`);
+                spinner.start();
+            }
+        }
+        if (!jsonOutput)
+            spinner.stop();
+        // Summary
+        const passed = results.filter(r => r.status === 'pass').length;
+        const failed = results.filter(r => r.status === 'fail').length;
+        const skipped = results.filter(r => r.status === 'skip').length;
+        const totalTime = results.reduce((s, r) => s + r.duration, 0);
+        if (jsonOutput) {
+            const out = {
+                passed,
+                failed,
+                skipped,
+                total: results.length,
+                totalTime: `${totalTime.toFixed(0)}ms`,
+                results: results.map(r => ({
+                    name: r.name,
+                    status: r.status,
+                    message: r.message,
+                    duration: `${r.duration.toFixed(0)}ms`,
+                })),
+            };
+            output.writeln(JSON.stringify(out, null, 2));
+        }
+        else {
+            output.writeln();
+            output.writeln(output.dim('─'.repeat(60)));
+            output.writeln();
+            const parts = [
+                output.success(`${passed} passed`),
+                failed > 0 ? output.error(`${failed} failed`) : null,
+                skipped > 0 ? output.dim(`${skipped} skipped`) : null,
+            ].filter(Boolean);
+            output.writeln(`${output.bold('Results:')} ${parts.join(', ')} ${output.dim(`(${(totalTime / 1000).toFixed(1)}s)`)}`);
+            if (failed > 0) {
+                output.writeln();
+                output.writeln(output.error('Some tests failed. Run with --verbose or fix the issues above.'));
+            }
+            else {
+                output.writeln();
+                output.writeln(output.success('All systems operational.'));
+            }
+        }
+        return {
+            success: failed === 0,
+            exitCode: failed > 0 ? 1 : 0,
+            data: { passed, failed, skipped, total: results.length, results },
+        };
+    },
+};
+export default diagnoseCommand;
+//# sourceMappingURL=diagnose.js.map

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

@@ -91,20 +91,20 @@ async function checkConfigFile() {
     }
     return { name: 'Config File', status: 'warn', message: 'No config file (using defaults)', fix: 'claude-flow config init' };
 }
-// Check daemon status
+// Check daemon status — delegates to daemon-lock module for proper
+// PID + command-line verification (avoids Windows PID-recycling false positives).
 async function checkDaemonStatus() {
     try {
+        const holderPid = getDaemonLockHolder(process.cwd());
+        if (holderPid) {
+            return { name: 'Daemon Status', status: 'pass', message: `Running (PID: ${holderPid})` };
+        }
+        // getDaemonLockHolder auto-cleans stale locks, but check for legacy PID file
         const lockFile = '.claude-flow/daemon.lock';
         if (existsSync(lockFile)) {
-            try {
-                const data = JSON.parse(readFileSync(lockFile, 'utf8'));
-                const pid = data.pid;
-                process.kill(pid, 0); // Check if process exists
-                return { name: 'Daemon Status', status: 'pass', message: `Running (PID: ${pid})` };
-            }
-            catch {
-                return { name: 'Daemon Status', status: 'warn', message: 'Stale lock file', fix: 'rm .claude-flow/daemon.lock && claude-flow daemon start' };
-            }
+            // Lock exists but holder is null — getDaemonLockHolder already cleaned it,
+            // but if it persists it means cleanup failed (permissions, etc.)
+            return { name: 'Daemon Status', status: 'warn', message: 'Stale lock file', fix: 'rm .claude-flow/daemon.lock && claude-flow daemon start' };
         }
         // Also check legacy PID file
         const pidFile = '.claude-flow/daemon.pid';

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

@@ -29,6 +29,7 @@ export { ruvectorCommand } from './ruvector/index.js';
 export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
+export { diagnoseCommand } from './diagnose.js';
 export declare function getConfigCommand(): Promise<Command | undefined>;
 export declare function getMigrateCommand(): Promise<Command | undefined>;
 export declare function getWorkflowCommand(): Promise<Command | undefined>;

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

@@ -55,6 +55,8 @@ const commandLoaders = {
     update: () => import('./update.js'),
     // RuVector PostgreSQL Bridge
     ruvector: () => import('./ruvector/index.js'),
+    // Full integration diagnostics
+    diagnose: () => import('./diagnose.js'),
     // Benchmark Suite (Pre-training, Neural, Memory)
     benchmark: () => import('./benchmark.js'),
     // Guidance Control Plane
@@ -134,6 +136,7 @@ import updateCommand from './update.js';
 import { processCommand } from './process.js';
 import { guidanceCommand } from './guidance.js';
 import { applianceCommand } from './appliance.js';
+import { diagnoseCommand } from './diagnose.js';
 // Pre-populate cache with core commands
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
@@ -154,6 +157,7 @@ loadedCommands.set('security', securityCommand);
 loadedCommands.set('ruvector', ruvectorCommand);
 loadedCommands.set('hive-mind', hiveMindCommand);
 loadedCommands.set('guidance', guidanceCommand);
+loadedCommands.set('diagnose', diagnoseCommand);
 // =============================================================================
 // Exports (maintain backwards compatibility)
 // =============================================================================
@@ -178,6 +182,7 @@ export { ruvectorCommand } from './ruvector/index.js';
 export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
+export { diagnoseCommand } from './diagnose.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
 export async function getConfigCommand() { return loadCommand('config'); }
 export async function getMigrateCommand() { return loadCommand('migrate'); }
@@ -227,6 +232,7 @@ export const commands = [
     ruvectorCommand,
     hiveMindCommand,
     guidanceCommand,
+    diagnoseCommand,
 ];
 /**
  * Commands organized by category for help display
@@ -256,6 +262,7 @@ export const commandsByCategory = {
     utility: [
         configCommand,
         doctorCommand,
+        diagnoseCommand,
         daemonCommand,
         completionsCommand,
         migrateCommand,

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

@@ -2384,11 +2384,173 @@ const codeMapCommand = {
         return { success: true };
     }
 };
+// refresh subcommand — reindex everything + vacuum
+const refreshCommand = {
+    name: 'refresh',
+    description: 'Reindex all guidance and code, rebuild embeddings, clean up expired entries, and vacuum the database',
+    options: [
+        {
+            name: 'skip-guidance',
+            description: 'Skip guidance reindexing',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'skip-code-map',
+            description: 'Skip code map regeneration',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'skip-cleanup',
+            description: 'Skip expired entry cleanup',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'verbose',
+            short: 'v',
+            description: 'Verbose output',
+            type: 'boolean',
+            default: false,
+        },
+    ],
+    examples: [
+        { command: 'flo memory refresh', description: 'Full reindex + vacuum' },
+        { command: 'flo memory refresh --skip-code-map', description: 'Reindex guidance only + vacuum' },
+    ],
+    action: async (ctx) => {
+        const skipGuidance = ctx.flags['skip-guidance'];
+        const skipCodeMap = ctx.flags['skip-code-map'];
+        const skipCleanup = ctx.flags['skip-cleanup'];
+        output.writeln();
+        output.writeln(output.bold('MoFlo Memory Refresh'));
+        output.writeln(output.dim('Reindex all content, rebuild embeddings, clean up, and vacuum'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.writeln();
+        const t0 = performance.now();
+        const steps = [];
+        // Helper to run a subcommand action
+        const runStep = async (name, skip, action) => {
+            if (skip) {
+                steps.push({ name, status: 'skip', message: 'Skipped', duration: 0 });
+                output.writeln(`${output.dim('○')} ${name}: ${output.dim('Skipped')}`);
+                return;
+            }
+            const stepStart = performance.now();
+            try {
+                const result = await action();
+                const dur = performance.now() - stepStart;
+                const success = result === undefined || result.success;
+                steps.push({ name, status: success ? 'pass' : 'fail', message: success ? 'Done' : (result?.message || 'Failed'), duration: dur });
+                const icon = success ? output.success('✓') : output.error('✗');
+                const durStr = dur < 1000 ? `${dur.toFixed(0)}ms` : `${(dur / 1000).toFixed(1)}s`;
+                output.writeln(`${icon} ${name} ${output.dim(`(${durStr})`)}`);
+            }
+            catch (err) {
+                const dur = performance.now() - stepStart;
+                const msg = err instanceof Error ? err.message : String(err);
+                steps.push({ name, status: 'fail', message: msg, duration: dur });
+                output.writeln(`${output.error('✗')} ${name}: ${msg}`);
+            }
+        };
+        // Build a fake context with force flag for subcommand calls
+        const forceCtx = {
+            args: [],
+            flags: { force: true, _: [], 'no-embeddings': false, overlap: 20 },
+            cwd: ctx.cwd,
+            interactive: false,
+        };
+        // Step 1: Index guidance
+        await runStep('Index Guidance', skipGuidance, async () => {
+            return indexGuidanceCommand.action(forceCtx);
+        });
+        // Step 2: Code map
+        await runStep('Code Map', skipCodeMap, async () => {
+            const codeMapCtx = {
+                args: [],
+                flags: { force: true, _: [], stats: false },
+                cwd: ctx.cwd,
+                interactive: false,
+            };
+            return codeMapCommand.action(codeMapCtx);
+        });
+        // Step 3: Rebuild embeddings
+        await runStep('Rebuild Embeddings', false, async () => {
+            const rebuildCtx = {
+                args: [],
+                flags: { force: true, _: [] },
+                cwd: ctx.cwd,
+                interactive: false,
+            };
+            return rebuildIndexCommand.action(rebuildCtx);
+        });
+        // Step 4: Cleanup expired entries (direct SQL — avoids MCP dependency)
+        await runStep('Cleanup Expired', skipCleanup, async () => {
+            const { db, dbPath } = await openDb(ctx.cwd);
+            try {
+                const now = Date.now();
+                const result = db.run(`DELETE FROM memory_entries WHERE expires_at IS NOT NULL AND expires_at > 0 AND expires_at < ?`, [now]);
+                const deleted = db.getRowsModified();
+                if (deleted > 0) {
+                    saveAndCloseDb(db, dbPath);
+                    output.writeln(output.dim(`  Removed ${deleted} expired entries`));
+                }
+                else {
+                    db.close();
+                    output.writeln(output.dim('  No expired entries found'));
+                }
+                return { success: true };
+            }
+            catch (err) {
+                try {
+                    db.close();
+                }
+                catch { /* ignore */ }
+                throw err;
+            }
+        });
+        // Step 5: VACUUM the database
+        await runStep('Vacuum Database', false, async () => {
+            const { db, dbPath } = await openDb(ctx.cwd);
+            try {
+                db.run('VACUUM');
+                saveAndCloseDb(db, dbPath);
+                return { success: true };
+            }
+            catch (err) {
+                try {
+                    db.close();
+                }
+                catch { /* ignore */ }
+                throw err;
+            }
+        });
+        // Summary
+        const totalTime = performance.now() - t0;
+        const passed = steps.filter(s => s.status === 'pass').length;
+        const failed = steps.filter(s => s.status === 'fail').length;
+        const skipped = steps.filter(s => s.status === 'skip').length;
+        output.writeln();
+        output.writeln(output.dim('─'.repeat(60)));
+        const parts = [
+            output.success(`${passed} done`),
+            failed > 0 ? output.error(`${failed} failed`) : null,
+            skipped > 0 ? output.dim(`${skipped} skipped`) : null,
+        ].filter(Boolean);
+        const durStr = totalTime < 1000 ? `${totalTime.toFixed(0)}ms` : `${(totalTime / 1000).toFixed(1)}s`;
+        output.writeln(`${output.bold('Refresh complete:')} ${parts.join(', ')} ${output.dim(`(${durStr})`)}`);
+        if (failed > 0) {
+            return { success: false, exitCode: 1 };
+        }
+        return { success: true };
+    },
+};
 // Main memory command
 export const memoryCommand = {
     name: 'memory',
     description: 'Memory management commands',
-    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, indexGuidanceCommand, rebuildIndexCommand, codeMapCommand],
+    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, indexGuidanceCommand, rebuildIndexCommand, codeMapCommand, refreshCommand],
     options: [],
     examples: [
         { command: 'claude-flow memory store -k "key" -v "value"', description: 'Store data' },
@@ -2417,7 +2579,8 @@ export const memoryCommand = {
             `${output.highlight('import')}          - Import from file`,
             `${output.highlight('index-guidance')}  - Index .claude/guidance/ files with RAG segments`,
             `${output.highlight('rebuild-index')}   - Regenerate embeddings for memory entries`,
-            `${output.highlight('code-map')}        - Generate structural code map`
+            `${output.highlight('code-map')}        - Generate structural code map`,
+            `${output.highlight('refresh')}         - Reindex all content, rebuild embeddings, cleanup, and vacuum`
         ]);
         return { success: true };
     }

package/src/@claude-flow/cli/dist/src/services/daemon-lock.d.ts

@@ -31,6 +31,13 @@ export declare function acquireDaemonLock(projectRoot: string, pid?: number): {
  * Release the daemon lock. Only removes if we own it (or force = true).
  */
 export declare function releaseDaemonLock(projectRoot: string, pid?: number, force?: boolean): void;
+/**
+ * Atomically transfer the daemon lock to a new PID (e.g. parent → child).
+ *
+ * Overwrites the lock file in-place so there is no window where the lock
+ * is absent.  Only succeeds if the lock is currently held by `fromPid`.
+ */
+export declare function transferDaemonLock(projectRoot: string, newPid: number, fromPid?: number): boolean;
 /**
  * Check if the daemon lock is currently held by a live daemon.
  * Returns the holder PID or null.

package/src/@claude-flow/cli/dist/src/services/daemon-lock.js

@@ -79,6 +79,32 @@ export function releaseDaemonLock(projectRoot, pid = process.pid, force = false)
         safeUnlink(lock);
     }
 }
+/**
+ * Atomically transfer the daemon lock to a new PID (e.g. parent → child).
+ *
+ * Overwrites the lock file in-place so there is no window where the lock
+ * is absent.  Only succeeds if the lock is currently held by `fromPid`.
+ */
+export function transferDaemonLock(projectRoot, newPid, fromPid = process.pid) {
+    const lock = lockPath(projectRoot);
+    const existing = readLockPayload(lock);
+    if (!existing || existing.pid !== fromPid) {
+        return false; // We don't own the lock — can't transfer
+    }
+    const payload = {
+        pid: newPid,
+        startedAt: Date.now(),
+        label: LOCK_LABEL,
+    };
+    try {
+        // Atomic overwrite — no unlink/recreate gap
+        fs.writeFileSync(lock, JSON.stringify(payload));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Check if the daemon lock is currently held by a live daemon.
  * Returns the holder PID or null.

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

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

package/.claude/workflow-state.json

@@ -1,5 +0,0 @@
-{
-  "tasksCreated": true,
-  "taskCount": 1,
-  "memorySearched": true
-}