moflo 4.7.7 → 4.8.0

package/.claude/helpers/statusline.cjs

@@ -330,25 +330,33 @@ function getSecurityStatus() {
 }
 
 // Swarm status (pure file reads, NO ps aux)
+// Metrics files older than 5 minutes are considered stale (swarm no longer running)
 function getSwarmStatus() {
+  const STALE_MS = 5 * 60_000;
+  const now = Date.now();
+
   const activityData = readJSON(path.join(CWD, '.claude-flow', 'metrics', 'swarm-activity.json'));
   if (activityData?.swarm) {
-    const count = activityData.swarm.agent_count || 0;
+    const ts = activityData.timestamp ? new Date(activityData.timestamp).getTime() : 0;
+    const stale = (now - ts) > STALE_MS;
+    const count = stale ? 0 : (activityData.swarm.agent_count || 0);
     return {
       activeAgents: Math.min(count, CONFIG.maxAgents),
       maxAgents: CONFIG.maxAgents,
-      coordinationActive: activityData.swarm.coordination_active || activityData.swarm.active || false,
+      coordinationActive: stale ? false : (activityData.swarm.coordination_active || activityData.swarm.active || false),
     };
   }
 
   const progressData = readJSON(path.join(CWD, '.claude-flow', 'metrics', 'v3-progress.json'));
   if (progressData?.swarm) {
-    const count = progressData.swarm.activeAgents || progressData.swarm.agent_count || 0;
+    const ts = progressData.timestamp ? new Date(progressData.timestamp).getTime() : 0;
+    const stale = (now - ts) > STALE_MS;
+    const count = stale ? 0 : (progressData.swarm.activeAgents || progressData.swarm.agent_count || 0);
     const max = progressData.swarm.totalAgents || CONFIG.maxAgents;
     return {
       activeAgents: Math.min(count, max),
       maxAgents: max,
-      coordinationActive: progressData.swarm.active || (count > 0),
+      coordinationActive: stale ? false : (progressData.swarm.active || (count > 0)),
     };
   }
 
@@ -461,44 +469,44 @@ function getHooksStatus() {
   return { enabled, total };
 }
 
-// AgentDB stats — queries real count from sqlite when possible, falls back to file size estimate
+// AgentDB stats — reads from cache file written by embedding/memory operations.
+// No subprocess spawning. Falls back to DB file size estimate if cache is missing.
 function getAgentDBStats() {
   let vectorCount = 0;
   let dbSizeKB = 0;
   let namespaces = 0;
   let hasHnsw = false;
-  let dbPath = null;
 
+  // Read cached stats (written by memory store/embed/rebuild commands)
+  const cachePaths = [
+    path.join(CWD, '.claude-flow', 'vector-stats.json'),
+    path.join(CWD, '.swarm', 'vector-stats.json'),
+  ];
+  for (const cp of cachePaths) {
+    const cached = readJSON(cp);
+    if (cached && typeof cached.vectorCount === 'number') {
+      vectorCount = cached.vectorCount;
+      dbSizeKB = cached.dbSizeKB || 0;
+      namespaces = cached.namespaces || 0;
+      hasHnsw = cached.hasHnsw || false;
+      return { vectorCount, dbSizeKB, namespaces, hasHnsw };
+    }
+  }
+
+  // Fallback: estimate from DB file size (no subprocess)
   const dbFiles = [
     path.join(CWD, '.swarm', 'memory.db'),
     path.join(CWD, '.claude-flow', 'memory.db'),
     path.join(CWD, '.claude', 'memory.db'),
     path.join(CWD, 'data', 'memory.db'),
   ];
-
   for (const f of dbFiles) {
     const stat = safeStat(f);
     if (stat) {
-      dbSizeKB = stat.size / 1024;
-      dbPath = f;
-      break;
-    }
-  }
-
-  // Try to get real count from sqlite (fast — single COUNT query)
-  if (dbPath) {
-    const countOutput = safeExec(`node -e "const S=require('sql.js');const f=require('fs');S().then(Q=>{const d=new Q.Database(f.readFileSync('${dbPath.replace(/\\/g, '/')}'));const s=d.prepare('SELECT COUNT(*) as c FROM memory_entries WHERE status=\\"active\\" AND embedding IS NOT NULL');s.step();console.log(JSON.stringify(s.getAsObject()));s.free();const n=d.prepare('SELECT COUNT(DISTINCT namespace) as n FROM memory_entries WHERE status=\\"active\\"');n.step();console.log(JSON.stringify(n.getAsObject()));n.free();d.close();})"`, 3000);
-    if (countOutput) {
-      try {
-        const lines = countOutput.trim().split('\n');
-        vectorCount = JSON.parse(lines[0]).c || 0;
-        namespaces = lines[1] ? JSON.parse(lines[1]).n || 0 : 0;
-      } catch { /* fall back to estimate */ }
-    }
-    // Fallback to file size estimate if query failed
-    if (vectorCount === 0) {
+      dbSizeKB = Math.floor(stat.size / 1024);
       vectorCount = Math.floor(dbSizeKB / 2);
       namespaces = 1;
+      break;
     }
   }
 
@@ -513,7 +521,7 @@ function getAgentDBStats() {
     }
   }
 
-  return { vectorCount, dbSizeKB: Math.floor(dbSizeKB), namespaces, hasHnsw };
+  return { vectorCount, dbSizeKB, namespaces, hasHnsw };
 }
 
 // Test stats (count files only — NO reading file contents)

package/.claude/settings.json

@@ -275,9 +275,9 @@
   },
   "mcpServers": {
     "claude-flow": {
-      "command": "npx",
+      "command": "node",
       "args": [
-        "moflo",
+        "bin/cli.js",
         "mcp",
         "start"
       ]

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/eric-cielo/moflo/main/docs/Moflo_md.png?v=5" alt="MoFlo" />
+  <img src="https://raw.githubusercontent.com/eric-cielo/moflo/main/docs/Moflo_md.png?v=6" alt="MoFlo" />
 </p>
 
 # MoFlo

package/bin/hooks.mjs

@@ -20,7 +20,7 @@
  */
 
 import { spawn } from 'child_process';
-import { existsSync, appendFileSync } from 'fs';
+import { existsSync, appendFileSync, readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -306,7 +306,11 @@ async function main() {
       }
 
       case 'daemon-start': {
-        await runClaudeFlow('daemon', ['start', '--quiet']);
+        if (!isDaemonLockHeld()) {
+          await runClaudeFlow('daemon', ['start', '--quiet']);
+        } else {
+          log('info', 'Daemon already running (lock held), skipping start');
+        }
         break;
       }
 
@@ -475,8 +479,34 @@ function runBackgroundTraining() {
   spawnWindowless('node', [localCli, 'neural', 'optimize'], 'neural optimize');
 }
 
-// Run daemon start in background (non-blocking)
+// 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).
+function isDaemonLockHeld() {
+  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
+      return true;
+    }
+  } catch {
+    // Dead process or corrupt file — lock is stale
+  }
+  return false;
+}
+
+// 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.
+  if (isDaemonLockHeld()) {
+    log('info', 'Daemon already running (lock held), skipping start');
+    return;
+  }
+
   const localCli = getLocalCliPath();
   if (!localCli) {
     log('warn', 'Local CLI not found, skipping daemon start');

package/bin/session-start-launcher.mjs

@@ -8,7 +8,7 @@
  */
 
 import { spawn } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync, copyFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -47,7 +47,92 @@ try {
   // Non-fatal - workflow gate will use defaults
 }
 
-// ── 3. Spawn background tasks ───────────────────────────────────────────────
+// ── 3. Auto-sync scripts and helpers on version change ───────────────────────
+// Controlled by `auto_update.enabled` in moflo.yaml (default: true).
+// When moflo is upgraded (npm install), scripts and helpers may be stale.
+// Detect version change and sync from source before running hooks.
+let autoUpdateConfig = { enabled: true, scripts: true, helpers: true };
+try {
+  const mofloYaml = resolve(projectRoot, 'moflo.yaml');
+  if (existsSync(mofloYaml)) {
+    const yamlContent = readFileSync(mofloYaml, 'utf-8');
+    // Simple YAML parsing for auto_update block (avoids js-yaml dependency)
+    const enabledMatch = yamlContent.match(/auto_update:\s*\n\s+enabled:\s*(true|false)/);
+    const scriptsMatch = yamlContent.match(/auto_update:\s*\n(?:\s+\w+:.*\n)*?\s+scripts:\s*(true|false)/);
+    const helpersMatch = yamlContent.match(/auto_update:\s*\n(?:\s+\w+:.*\n)*?\s+helpers:\s*(true|false)/);
+    if (enabledMatch) autoUpdateConfig.enabled = enabledMatch[1] === 'true';
+    if (scriptsMatch) autoUpdateConfig.scripts = scriptsMatch[1] === 'true';
+    if (helpersMatch) autoUpdateConfig.helpers = helpersMatch[1] === 'true';
+  }
+} catch { /* non-fatal — use defaults (all true) */ }
+
+try {
+  const mofloPkgPath = resolve(projectRoot, 'node_modules/moflo/package.json');
+  const versionStampPath = resolve(projectRoot, '.claude-flow', 'moflo-version');
+  if (autoUpdateConfig.enabled && existsSync(mofloPkgPath)) {
+    const installedVersion = JSON.parse(readFileSync(mofloPkgPath, 'utf-8')).version;
+    let cachedVersion = '';
+    try { cachedVersion = readFileSync(versionStampPath, 'utf-8').trim(); } catch {}
+
+    if (installedVersion !== cachedVersion) {
+      // Version changed — sync scripts from bin/
+      if (autoUpdateConfig.scripts) {
+        const binDir = resolve(projectRoot, 'node_modules/moflo/bin');
+        const scriptsDir = resolve(projectRoot, '.claude/scripts');
+        const scriptFiles = [
+          'hooks.mjs', 'session-start-launcher.mjs', 'index-guidance.mjs',
+          'build-embeddings.mjs', 'generate-code-map.mjs', 'semantic-search.mjs',
+        ];
+        for (const file of scriptFiles) {
+          const src = resolve(binDir, file);
+          const dest = resolve(scriptsDir, file);
+          if (existsSync(src)) {
+            try { copyFileSync(src, dest); } catch { /* non-fatal */ }
+          }
+        }
+      }
+
+      // Sync helpers from source .claude/helpers/
+      if (autoUpdateConfig.helpers) {
+        const sourceHelpersDir = resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/.claude/helpers');
+        const helpersDir = resolve(projectRoot, '.claude/helpers');
+        const helperFiles = [
+          'auto-memory-hook.mjs', 'statusline.cjs', 'pre-commit', 'post-commit',
+        ];
+        for (const file of helperFiles) {
+          const src = resolve(sourceHelpersDir, file);
+          const dest = resolve(helpersDir, file);
+          if (existsSync(src)) {
+            try { copyFileSync(src, dest); } catch { /* non-fatal */ }
+          }
+        }
+
+        // Also sync generated helpers via upgrade CLI (hook-handler.cjs, gate.cjs, etc.)
+        // These are generated, not shipped, so we trigger an upgrade in the background
+        const localCli = resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/bin/cli.js');
+        if (existsSync(localCli)) {
+          try {
+            const proc = spawn('node', [localCli, 'init', '--upgrade', '--quiet'], {
+              cwd: projectRoot, stdio: 'ignore', detached: true, windowsHide: true,
+            });
+            proc.unref();
+          } catch { /* non-fatal */ }
+        }
+      }
+
+      // Write version stamp
+      try {
+        const cfDir = resolve(projectRoot, '.claude-flow');
+        if (!existsSync(cfDir)) mkdirSync(cfDir, { recursive: true });
+        writeFileSync(versionStampPath, installedVersion);
+      } catch {}
+    }
+  }
+} catch {
+  // Non-fatal — scripts will still work, just may be stale
+}
+
+// ── 4. Spawn background tasks ───────────────────────────────────────────────
 const localCli = resolve(projectRoot, 'node_modules/moflo/src/@claude-flow/cli/bin/cli.js');
 const hasLocalCli = existsSync(localCli);
 
@@ -59,5 +144,5 @@ if (existsSync(hooksScript)) {
 
 // Patches are now baked into moflo@4.0.0 source — no runtime patching needed.
 
-// ── 4. Done — exit immediately ──────────────────────────────────────────────
+// ── 5. Done — exit immediately ──────────────────────────────────────────────
 process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.7.7",
+  "version": "4.8.0",
   "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",
@@ -49,7 +49,7 @@
     "dev": "tsx watch src/index.ts",
     "build": "tsc",
     "build:ts": "cd src/@claude-flow/cli && npm run build || true",
-    "test": "vitest",
+    "test": "vitest run",
     "test:ui": "vitest --ui",
     "test:security": "vitest run src/__tests__/security/",
     "lint": "cd src/@claude-flow/cli && npm run lint || true",
@@ -67,7 +67,6 @@
     "zod": "^3.22.4"
   },
   "optionalDependencies": {
-    "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
     "@ruvector/attention": "^0.1.3",
     "@ruvector/core": "^0.1.30",
@@ -81,14 +80,13 @@
     "hono": ">=4.11.4"
   },
   "devDependencies": {
-    "@openai/codex": "^0.98.0",
     "@types/bcrypt": "^5.0.2",
     "@types/node": "^20.0.0",
     "eslint": "^8.0.0",
     "moflo": "^4.7.4",
     "tsx": "^4.21.0",
     "typescript": "^5.0.0",
-    "vitest": "^1.0.0"
+    "vitest": "^4.0.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/@claude-flow/cli/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/eric-cielo/moflo/main/docs/Moflo_md.png?v=5" alt="MoFlo" />
+  <img src="https://raw.githubusercontent.com/eric-cielo/moflo/main/docs/Moflo_md.png?v=6" alt="MoFlo" />
 </p>
 
 # MoFlo

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

@@ -4,6 +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 { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
@@ -64,60 +65,26 @@ const startCommand = {
                 config.resourceThresholds = thresholds;
             }
         }
-        // Check if background daemon already running (skip if we ARE the daemon process)
-        if (!isDaemonProcess) {
-            const bgPid = getBackgroundDaemonPid(projectRoot);
-            if (bgPid && isProcessRunning(bgPid)) {
-                if (!quiet) {
-                    output.printWarning(`Daemon already running in background (PID: ${bgPid})`);
-                }
-                return { success: true };
-            }
-        }
         // Background mode (default): fork a detached process
         if (!foreground) {
             return startBackgroundDaemon(projectRoot, quiet, rawMaxCpu, rawMinMem);
         }
         // Foreground mode: run in current process (blocks terminal)
         try {
-            const stateDir = join(projectRoot, '.claude-flow');
-            const pidFile = join(stateDir, 'daemon.pid');
-            // Ensure state directory exists
-            if (!fs.existsSync(stateDir)) {
-                fs.mkdirSync(stateDir, { recursive: true });
-            }
-            // Check if another foreground daemon is already running (prevents duplicate daemons)
-            if (fs.existsSync(pidFile)) {
-                try {
-                    const existingPid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-                    if (!isNaN(existingPid) && existingPid !== process.pid) {
-                        try {
-                            process.kill(existingPid, 0); // Check if alive
-                            // Another daemon is running — exit silently
-                            if (!quiet) {
-                                output.printWarning(`Daemon already running (PID: ${existingPid})`);
-                            }
-                            return { success: true };
-                        }
-                        catch {
-                            // Process not running — stale PID file, continue startup
-                        }
+            // 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})`);
                     }
-                }
-                catch {
-                    // Can't read PID file — continue startup
+                    return { success: true };
                 }
             }
-            // Write PID file for foreground mode
-            fs.writeFileSync(pidFile, String(process.pid));
-            // Clean up PID file on exit
+            // Clean up lock file on exit
             const cleanup = () => {
-                try {
-                    if (fs.existsSync(pidFile)) {
-                        fs.unlinkSync(pidFile);
-                    }
-                }
-                catch { /* ignore */ }
+                releaseDaemonLock(projectRoot, process.pid, true);
             };
             process.on('exit', cleanup);
             process.on('SIGINT', () => { cleanup(); process.exit(0); });
@@ -219,12 +186,18 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     const resolvedRoot = resolve(projectRoot);
     validatePath(resolvedRoot, 'Project root');
     const stateDir = join(resolvedRoot, '.claude-flow');
-    const pidFile = join(stateDir, 'daemon.pid');
     const logFile = join(stateDir, 'daemon.log');
     // Validate all paths
     validatePath(stateDir, 'State directory');
-    validatePath(pidFile, 'PID file');
     validatePath(logFile, 'Log file');
+    // Acquire atomic lock BEFORE spawning to prevent races
+    const lockResult = acquireDaemonLock(resolvedRoot);
+    if (!lockResult.acquired) {
+        if (!quiet) {
+            output.printWarning(`Daemon already running in background (PID: ${lockResult.holder})`);
+        }
+        return { success: true };
+    }
     // Ensure state directory exists
     if (!fs.existsSync(stateDir)) {
         fs.mkdirSync(stateDir, { recursive: true });
@@ -273,16 +246,21 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     // Get PID from spawned process directly (no shell echo needed)
     const pid = child.pid;
     if (!pid || pid <= 0) {
+        // Release lock — spawn failed, no daemon running
+        releaseDaemonLock(resolvedRoot, process.pid, true);
         output.printError('Failed to get daemon PID');
         return { success: false, exitCode: 1 };
     }
-    // Unref BEFORE writing PID file — prevents race where parent exits
+    // Unref BEFORE updating lock — prevents race where parent exits
     // but child hasn't fully detached yet (fixes macOS daemon death #1283)
     child.unref();
     // Small delay to let the child process fully detach on macOS
     await new Promise(resolve => setTimeout(resolve, 100));
-    // Save PID only after child is detached
-    fs.writeFileSync(pidFile, String(pid));
+    // 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);
     if (!quiet) {
         output.printSuccess(`Daemon started in background (PID: ${pid})`);
         output.printInfo(`Logs: ${logFile}`);
@@ -326,76 +304,45 @@ const stopCommand = {
     },
 };
 /**
- * Kill background daemon process using PID file
+ * Kill background daemon process using lock file
  */
 async function killBackgroundDaemon(projectRoot) {
-    const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
-    if (!fs.existsSync(pidFile)) {
+    const holderPid = getDaemonLockHolder(projectRoot);
+    if (!holderPid) {
+        // No live daemon — clean up any stale lock
+        releaseDaemonLock(projectRoot, 0, true);
         return false;
     }
     try {
-        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-        if (isNaN(pid)) {
-            fs.unlinkSync(pidFile);
-            return false;
-        }
-        // Check if process is running
-        try {
-            process.kill(pid, 0); // Signal 0 = check if alive
-        }
-        catch {
-            // Process not running, clean up stale PID file
-            fs.unlinkSync(pidFile);
-            return false;
-        }
         // Kill the process
-        process.kill(pid, 'SIGTERM');
+        process.kill(holderPid, 'SIGTERM');
         // Wait a moment then force kill if needed
         await new Promise(resolve => setTimeout(resolve, 1000));
         try {
-            process.kill(pid, 0);
+            process.kill(holderPid, 0);
             // Still alive, force kill
-            process.kill(pid, 'SIGKILL');
+            process.kill(holderPid, 'SIGKILL');
         }
         catch {
             // Process terminated
         }
-        // Clean up PID file
-        if (fs.existsSync(pidFile)) {
-            fs.unlinkSync(pidFile);
-        }
+        // Release lock
+        releaseDaemonLock(projectRoot, holderPid, true);
         return true;
     }
     catch (error) {
-        // Clean up PID file on any error
-        if (fs.existsSync(pidFile)) {
-            fs.unlinkSync(pidFile);
-        }
+        // Clean up lock on any error
+        releaseDaemonLock(projectRoot, 0, true);
         return false;
     }
 }
-/**
- * Get PID of background daemon from PID file
- */
+// Legacy aliases — delegate to daemon-lock module
 function getBackgroundDaemonPid(projectRoot) {
-    const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
-    if (!fs.existsSync(pidFile)) {
-        return null;
-    }
-    try {
-        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-        return isNaN(pid) ? null : pid;
-    }
-    catch {
-        return null;
-    }
+    return getDaemonLockHolder(projectRoot);
 }
-/**
- * Check if a process is running
- */
 function isProcessRunning(pid) {
     try {
-        process.kill(pid, 0); // Signal 0 = check if alive
+        process.kill(pid, 0);
         return true;
     }
     catch {

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

@@ -93,17 +93,23 @@ async function checkConfigFile() {
 // Check daemon status
 async function checkDaemonStatus() {
     try {
-        const pidFile = '.claude-flow/daemon.pid';
-        if (existsSync(pidFile)) {
-            const pid = readFileSync(pidFile, 'utf8').trim();
+        const lockFile = '.claude-flow/daemon.lock';
+        if (existsSync(lockFile)) {
             try {
-                process.kill(parseInt(pid, 10), 0); // Check if process exists
+                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 PID file', fix: 'rm .claude-flow/daemon.pid && claude-flow daemon start' };
+                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';
+        if (existsSync(pidFile)) {
+            return { name: 'Daemon Status', status: 'warn', message: 'Legacy PID file found', fix: 'rm .claude-flow/daemon.pid && claude-flow daemon start' };
+        }
         return { name: 'Daemon Status', status: 'warn', message: 'Not running', fix: 'claude-flow daemon start' };
     }
     catch {