moflo 4.7.8 → 4.8.0

package/bin/hooks.mjs

@@ -306,10 +306,10 @@ async function main() {
       }
 
       case 'daemon-start': {
-        if (!isDaemonRunning()) {
+        if (!isDaemonLockHeld()) {
           await runClaudeFlow('daemon', ['start', '--quiet']);
         } else {
-          log('info', 'Daemon already running, skipping start');
+          log('info', 'Daemon already running (lock held), skipping start');
         }
         break;
       }
@@ -479,34 +479,37 @@ function runBackgroundTraining() {
   spawnWindowless('node', [localCli, 'neural', 'optimize'], 'neural optimize');
 }
 
-// Check if daemon is already running via PID file.
-// Returns true if a live daemon process exists, false otherwise.
-function isDaemonRunning() {
-  const pidFile = resolve(projectRoot, '.claude-flow', 'daemon.pid');
-  if (existsSync(pidFile)) {
-    try {
-      const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
-      if (pid && !isNaN(pid)) {
-        process.kill(pid, 0); // signal 0 = check if process exists, doesn't kill
-        return true;
-      }
-    } catch {
-      // Process doesn't exist — stale PID file
+// 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() {
-  const localCli = getLocalCliPath();
-  if (!localCli) {
-    log('warn', 'Local CLI not found, skipping daemon start');
+  // 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;
   }
 
-  if (isDaemonRunning()) {
-    log('info', 'Daemon already running, skipping start');
+  const localCli = getLocalCliPath();
+  if (!localCli) {
+    log('warn', 'Local CLI not found, skipping daemon start');
     return;
   }
 

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.8",
+  "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",

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 {

package/src/@claude-flow/cli/dist/src/config/moflo-config.d.ts

@@ -50,6 +50,11 @@ export interface MofloConfig {
         circuit_breaker: boolean;
         agent_overrides: Record<string, string>;
     };
+    auto_update: {
+        enabled: boolean;
+        scripts: boolean;
+        helpers: boolean;
+    };
     status_line: {
         enabled: boolean;
         branding: string;

package/src/@claude-flow/cli/dist/src/config/moflo-config.js

@@ -69,6 +69,11 @@ const DEFAULT_CONFIG = {
         circuit_breaker: true,
         agent_overrides: {},
     },
+    auto_update: {
+        enabled: true,
+        scripts: true,
+        helpers: true,
+    },
     status_line: {
         enabled: true,
         branding: 'Moflo V4',
@@ -159,6 +164,11 @@ function mergeConfig(raw, root) {
             circuit_breaker: raw.model_routing?.circuit_breaker ?? raw.modelRouting?.circuitBreaker ?? DEFAULT_CONFIG.model_routing.circuit_breaker,
             agent_overrides: raw.model_routing?.agent_overrides ?? raw.modelRouting?.agentOverrides ?? DEFAULT_CONFIG.model_routing.agent_overrides,
         },
+        auto_update: {
+            enabled: raw.auto_update?.enabled ?? raw.autoUpdate?.enabled ?? DEFAULT_CONFIG.auto_update.enabled,
+            scripts: raw.auto_update?.scripts ?? raw.autoUpdate?.scripts ?? DEFAULT_CONFIG.auto_update.scripts,
+            helpers: raw.auto_update?.helpers ?? raw.autoUpdate?.helpers ?? DEFAULT_CONFIG.auto_update.helpers,
+        },
         status_line: {
             enabled: raw.status_line?.enabled ?? raw.statusLine?.enabled ?? DEFAULT_CONFIG.status_line.enabled,
             branding: raw.status_line?.branding ?? raw.statusLine?.branding ?? DEFAULT_CONFIG.status_line.branding,
@@ -314,6 +324,12 @@ model_routing:
   #   security-architect: opus     # Always use opus for security
   #   researcher: sonnet           # Pin research to sonnet
 
+# Auto-update on session start (syncs scripts and helpers when moflo version changes)
+auto_update:
+  enabled: true                  # Master toggle for version-change auto-sync
+  scripts: true                  # Sync .claude/scripts/ from moflo bin/
+  helpers: true                  # Sync .claude/helpers/ from moflo source
+
 # Status line items (show/hide individual sections)
 status_line:
   enabled: true

package/src/@claude-flow/cli/dist/src/init/executor.js

@@ -423,6 +423,46 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             };
             fs.writeFileSync(statuslinePath, generateStatuslineScript(upgradeOptions), 'utf-8');
         }
+        // 1b. ALWAYS sync .claude/scripts/ from moflo bin/ (derived files, not user-edited)
+        // Scripts contain critical daemon guards, hook logic, etc. that must stay in sync.
+        const scriptsDir = path.join(targetDir, '.claude', 'scripts');
+        if (!fs.existsSync(scriptsDir)) {
+            fs.mkdirSync(scriptsDir, { recursive: true });
+        }
+        const UPGRADE_SCRIPT_MAP = {
+            'hooks.mjs': 'hooks.mjs',
+            'session-start-launcher.mjs': 'session-start-launcher.mjs',
+            'index-guidance.mjs': 'index-guidance.mjs',
+            'build-embeddings.mjs': 'build-embeddings.mjs',
+            'generate-code-map.mjs': 'generate-code-map.mjs',
+            'semantic-search.mjs': 'semantic-search.mjs',
+        };
+        const binDir = findMofloBinDir();
+        if (binDir) {
+            for (const [destName, srcName] of Object.entries(UPGRADE_SCRIPT_MAP)) {
+                const srcPath = path.join(binDir, srcName);
+                const destPath = path.join(scriptsDir, destName);
+                if (!fs.existsSync(srcPath))
+                    continue;
+                try {
+                    const srcStat = fs.statSync(srcPath);
+                    const destExists = fs.existsSync(destPath);
+                    // Always overwrite if source is newer or dest doesn't exist
+                    if (!destExists || srcStat.mtimeMs > fs.statSync(destPath).mtimeMs) {
+                        fs.copyFileSync(srcPath, destPath);
+                        if (destExists) {
+                            result.updated.push(`.claude/scripts/${destName}`);
+                        }
+                        else {
+                            result.created.push(`.claude/scripts/${destName}`);
+                        }
+                    }
+                }
+                catch {
+                    // Non-fatal — skip individual script on error
+                }
+            }
+        }
         // 2. Create MISSING metrics files only (preserve existing data)
         const metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
         const securityDir = path.join(targetDir, '.claude-flow', 'security');
@@ -898,6 +938,40 @@ function findSourceHelpersDir(sourceBaseDir) {
     }
     return null;
 }
+/**
+ * Find the moflo bin/ directory (source of truth for .claude/scripts/).
+ * Uses the same resolution strategies as findSourceHelpersDir.
+ */
+function findMofloBinDir() {
+    const possiblePaths = [];
+    const SENTINEL_FILE = 'hooks.mjs'; // Must exist in valid bin/
+    // Strategy 1: require.resolve
+    try {
+        const esmRequire = createRequire(import.meta.url);
+        const pkgJsonPath = esmRequire.resolve('moflo/package.json');
+        possiblePaths.push(path.join(path.dirname(pkgJsonPath), 'bin'));
+    }
+    catch { /* not installed as package */ }
+    // Strategy 2: __dirname-based (dist/src/init -> package root -> bin)
+    possiblePaths.push(path.resolve(__dirname, '..', '..', '..', 'bin'));
+    // Strategy 3: Walk up from __dirname
+    let currentDir = __dirname;
+    for (let i = 0; i < 10; i++) {
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        possiblePaths.push(path.join(parentDir, 'bin'));
+        currentDir = parentDir;
+    }
+    // Strategy 4: cwd-relative (node_modules/moflo/bin)
+    possiblePaths.push(path.join(process.cwd(), 'node_modules', 'moflo', 'bin'));
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p) && fs.existsSync(path.join(p, SENTINEL_FILE))) {
+            return p;
+        }
+    }
+    return null;
+}
 /**
  * Write helper scripts
  */

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

@@ -0,0 +1,39 @@
+/**
+ * Atomic daemon lock — prevents duplicate daemon processes.
+ *
+ * Uses fs.writeFileSync with { flag: 'wx' } (O_CREAT | O_EXCL) which is
+ * atomic on all platforms: the write fails immediately if the file exists,
+ * eliminating the TOCTOU race in the old PID-file approach.
+ *
+ * Also solves Windows PID recycling by storing a label in the lock payload
+ * and verifying the process command line before trusting a "live" PID.
+ */
+export interface DaemonLockPayload {
+    pid: number;
+    startedAt: number;
+    label: string;
+}
+/** Resolve the lock file path for a project root. */
+export declare function lockPath(projectRoot: string): string;
+/**
+ * Try to acquire the daemon lock atomically.
+ *
+ * @returns `{ acquired: true }` on success,
+ *          `{ acquired: false, holder: pid }` if another daemon owns the lock.
+ */
+export declare function acquireDaemonLock(projectRoot: string, pid?: number): {
+    acquired: true;
+} | {
+    acquired: false;
+    holder: 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;
+/**
+ * Check if the daemon lock is currently held by a live daemon.
+ * Returns the holder PID or null.
+ */
+export declare function getDaemonLockHolder(projectRoot: string): number | null;
+//# sourceMappingURL=daemon-lock.d.ts.map