claude-flow 3.7.0-alpha.15 → 3.7.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.15",
+  "version": "3.7.0-alpha.17",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

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

@@ -391,10 +391,17 @@ async function killBackgroundDaemon(projectRoot) {
     }
 }
 /**
- * Kill stale daemon processes not tracked by the PID file (#1551).
- * Uses `ps` to find all daemon processes for this project and kills them.
+ * Kill stale daemon processes not tracked by the PID file (#1551, #1857).
+ * Uses `ps` on POSIX and `tasklist` on Windows to find all daemon
+ * processes for this project and kill them.
  */
 async function killStaleDaemons(projectRoot, quiet) {
+    if (process.platform === 'win32') {
+        return killStaleDaemonsWindows(projectRoot, quiet);
+    }
+    return killStaleDaemonsPosix(projectRoot, quiet);
+}
+async function killStaleDaemonsPosix(projectRoot, quiet) {
     try {
         const { execFileSync } = await import('child_process');
         const psOutput = execFileSync('ps', ['-eo', 'pid,command'], { encoding: 'utf-8', timeout: 5000 });
@@ -430,6 +437,63 @@ async function killStaleDaemons(projectRoot, quiet) {
         // ps not available or failed — skip stale cleanup
     }
 }
+/**
+ * #1857: Windows replacement for the POSIX `ps -eo pid,command` path.
+ * Uses `tasklist /v /fo csv` which returns CSV with the full Window
+ * Title column (last field) — Node-spawned daemon processes carry
+ * their command line there. Best-effort like the POSIX path: any
+ * tooling failure (tasklist missing, parse error, etc.) is swallowed
+ * silently so cleanup doesn't break daemon start.
+ */
+async function killStaleDaemonsWindows(projectRoot, quiet) {
+    try {
+        const { execFileSync } = await import('child_process');
+        // /v includes the Window Title; /fo csv uses comma-separated quoted fields
+        const out = execFileSync('tasklist', ['/v', '/fo', 'csv', '/nh'], { encoding: 'utf-8', timeout: 5000 });
+        const lines = out.split(/\r?\n/);
+        const currentPid = process.pid;
+        const trackedPid = getBackgroundDaemonPid(projectRoot);
+        let killed = 0;
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            // Match daemon command line markers — the Window Title field
+            // typically holds the full invocation. Skip rows that aren't ours.
+            if (!line.includes('daemon start --foreground'))
+                continue;
+            if (!line.includes('claude-flow') && !line.includes('@claude-flow/cli'))
+                continue;
+            // Parse CSV: tasklist quotes each field, so split on `","`
+            const fields = line.split(/","/).map(f => f.replace(/^"|"$/g, ''));
+            // fields[0] = Image Name, fields[1] = PID, …
+            const pidStr = fields[1];
+            const pid = parseInt(pidStr ?? '', 10);
+            if (isNaN(pid) || pid === currentPid || pid === trackedPid)
+                continue;
+            if (!isProcessRunning(pid))
+                continue;
+            try {
+                // taskkill is the Windows equivalent of kill — /pid <n> /f forces.
+                // Use SIGTERM-equivalent (no /f) first; the daemon's signal handler
+                // catches and cleans up; force-kill is the next start's job.
+                execFileSync('taskkill', ['/pid', String(pid), '/t'], { encoding: 'utf-8', timeout: 5000 });
+                killed++;
+                if (!quiet) {
+                    output.printWarning(`Killed stale daemon process (PID: ${pid})`);
+                }
+            }
+            catch { /* taskkill failed — process may have exited; ignore */ }
+        }
+        if (killed > 0 && !quiet) {
+            output.printInfo(`Cleaned up ${killed} stale daemon process(es)`);
+        }
+    }
+    catch {
+        // tasklist not available or failed — skip stale cleanup. Defensive
+        // shape matches the POSIX path. Not tested on Windows by the
+        // maintainer; please report regressions on the issue tracker.
+    }
+}
 /**
  * Get PID of background daemon from PID file
  */
@@ -671,6 +735,222 @@ function formatTimeUntil(date) {
         return `in ${Math.floor(seconds / 3600)}h`;
     return `in ${Math.floor(seconds / 86400)}d`;
 }
+// #1565: Supervisor installer subcommand. Writes a native auto-restart
+// unit (launchd plist on macOS, systemd-user .service on Linux) so the
+// daemon survives crashes and reboots without requiring the operator
+// to manually run `daemon start` after every failure.
+const installSupervisorCommand = {
+    name: 'install-supervisor',
+    description: 'Install OS-level auto-restart supervisor (launchd on macOS, systemd-user on Linux)',
+    options: [
+        { name: 'force', short: 'f', type: 'boolean', description: 'Overwrite existing unit file', default: 'false' },
+        { name: 'load', type: 'boolean', description: 'Load/enable the unit immediately', default: 'true' },
+        { name: 'dry-run', type: 'boolean', description: 'Print the unit file content without writing', default: 'false' },
+    ],
+    examples: [
+        { command: 'claude-flow daemon install-supervisor', description: 'Install + load (auto-restart enabled)' },
+        { command: 'claude-flow daemon install-supervisor --no-load', description: 'Write unit file but do not enable yet' },
+        { command: 'claude-flow daemon install-supervisor --dry-run', description: 'Preview the unit file' },
+    ],
+    action: async (ctx) => {
+        const force = ctx.flags.force === true;
+        const load = ctx.flags.load !== false;
+        const dryRun = ctx.flags['dry-run'] === true || ctx.flags.dryRun === true;
+        const projectRoot = process.cwd();
+        const platform = process.platform;
+        if (platform === 'win32') {
+            output.printError('Windows scheduled-task installer is not yet implemented.');
+            output.printInfo('Use Task Scheduler manually, or follow this issue: https://github.com/ruvnet/ruflo/issues/1565');
+            return { success: false, exitCode: 1 };
+        }
+        if (platform !== 'darwin' && platform !== 'linux') {
+            output.printError(`Unsupported platform: ${platform}. Supported: darwin (launchd), linux (systemd-user).`);
+            return { success: false, exitCode: 1 };
+        }
+        // Resolve absolute paths the unit file will reference.
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
+        if (!home) {
+            output.printError('HOME/USERPROFILE not set; cannot resolve user unit path.');
+            return { success: false, exitCode: 1 };
+        }
+        const nodeBin = process.execPath;
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const cliJs = resolve(join(__dirname, '..', '..', '..', 'bin', 'cli.js'));
+        if (!fs.existsSync(cliJs)) {
+            output.printError(`CLI not found at: ${cliJs}`);
+            return { success: false, exitCode: 1 };
+        }
+        if (platform === 'darwin') {
+            const plistDir = join(home, 'Library', 'LaunchAgents');
+            const plistPath = join(plistDir, 'io.ruv.ruflo.daemon.plist');
+            const logDir = join(projectRoot, '.claude-flow', 'logs');
+            const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key><string>io.ruv.ruflo.daemon</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodeBin}</string>
+        <string>${cliJs}</string>
+        <string>daemon</string><string>start</string><string>--foreground</string><string>--quiet</string>
+    </array>
+    <key>WorkingDirectory</key><string>${projectRoot}</string>
+    <key>RunAtLoad</key><true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key><false/>
+        <key>Crashed</key><true/>
+    </dict>
+    <key>ThrottleInterval</key><integer>10</integer>
+    <key>StandardOutPath</key><string>${logDir}/supervisor.out.log</string>
+    <key>StandardErrorPath</key><string>${logDir}/supervisor.err.log</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>CLAUDE_FLOW_DAEMON</key><string>1</string>
+    </dict>
+</dict>
+</plist>
+`;
+            if (dryRun) {
+                output.writeln(plist);
+                return { success: true };
+            }
+            if (fs.existsSync(plistPath) && !force) {
+                output.printWarning(`Already installed: ${plistPath}`);
+                output.printInfo('Use --force to overwrite.');
+                return { success: false, exitCode: 1 };
+            }
+            if (!fs.existsSync(plistDir))
+                fs.mkdirSync(plistDir, { recursive: true });
+            if (!fs.existsSync(logDir))
+                fs.mkdirSync(logDir, { recursive: true });
+            fs.writeFileSync(plistPath, plist, 'utf-8');
+            output.printSuccess(`Wrote ${plistPath}`);
+            if (load) {
+                try {
+                    const { execFileSync } = await import('child_process');
+                    // unload first in case a previous version is loaded
+                    try {
+                        execFileSync('launchctl', ['unload', plistPath], { encoding: 'utf-8', timeout: 5000 });
+                    }
+                    catch { /* ok */ }
+                    execFileSync('launchctl', ['load', '-w', plistPath], { encoding: 'utf-8', timeout: 5000 });
+                    output.printSuccess('Supervisor loaded — daemon will auto-restart on crash and survive reboot.');
+                }
+                catch (err) {
+                    output.printWarning(`launchctl load failed: ${err instanceof Error ? err.message : String(err)}`);
+                    output.printInfo(`Run manually: launchctl load -w ${plistPath}`);
+                }
+            }
+            else {
+                output.printInfo(`Run when ready:  launchctl load -w ${plistPath}`);
+            }
+            return { success: true };
+        }
+        // Linux: systemd-user
+        const unitDir = join(home, '.config', 'systemd', 'user');
+        const unitPath = join(unitDir, 'ruflo-daemon.service');
+        const unit = `[Unit]
+Description=RuFlo background worker daemon
+After=default.target
+
+[Service]
+Type=simple
+WorkingDirectory=${projectRoot}
+Environment=CLAUDE_FLOW_DAEMON=1
+ExecStart=${nodeBin} ${cliJs} daemon start --foreground --quiet
+Restart=on-failure
+RestartSec=10
+# Restart on Crashed (signal) too
+StartLimitIntervalSec=300
+StartLimitBurst=5
+
+[Install]
+WantedBy=default.target
+`;
+        if (dryRun) {
+            output.writeln(unit);
+            return { success: true };
+        }
+        if (fs.existsSync(unitPath) && !force) {
+            output.printWarning(`Already installed: ${unitPath}`);
+            output.printInfo('Use --force to overwrite.');
+            return { success: false, exitCode: 1 };
+        }
+        if (!fs.existsSync(unitDir))
+            fs.mkdirSync(unitDir, { recursive: true });
+        fs.writeFileSync(unitPath, unit, 'utf-8');
+        output.printSuccess(`Wrote ${unitPath}`);
+        if (load) {
+            try {
+                const { execFileSync } = await import('child_process');
+                execFileSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf-8', timeout: 5000 });
+                execFileSync('systemctl', ['--user', 'enable', '--now', 'ruflo-daemon.service'], { encoding: 'utf-8', timeout: 10000 });
+                output.printSuccess('Supervisor enabled — daemon will auto-restart on crash and survive reboot.');
+                output.printInfo('Note: requires `loginctl enable-linger $USER` for restart-after-logout on some distros.');
+            }
+            catch (err) {
+                output.printWarning(`systemctl --user enable failed: ${err instanceof Error ? err.message : String(err)}`);
+                output.printInfo(`Run manually: systemctl --user daemon-reload && systemctl --user enable --now ruflo-daemon.service`);
+            }
+        }
+        else {
+            output.printInfo(`Run when ready:  systemctl --user daemon-reload && systemctl --user enable --now ruflo-daemon.service`);
+        }
+        return { success: true };
+    },
+};
+const uninstallSupervisorCommand = {
+    name: 'uninstall-supervisor',
+    description: 'Remove the auto-restart supervisor unit (launchd on macOS, systemd-user on Linux)',
+    options: [],
+    action: async () => {
+        const platform = process.platform;
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
+        if (platform === 'darwin') {
+            const plistPath = join(home, 'Library', 'LaunchAgents', 'io.ruv.ruflo.daemon.plist');
+            try {
+                const { execFileSync } = await import('child_process');
+                try {
+                    execFileSync('launchctl', ['unload', plistPath], { encoding: 'utf-8', timeout: 5000 });
+                }
+                catch { /* ok */ }
+            }
+            catch { /* ignore */ }
+            if (fs.existsSync(plistPath)) {
+                fs.unlinkSync(plistPath);
+                output.printSuccess(`Removed ${plistPath}`);
+            }
+            else {
+                output.printInfo(`Not installed: ${plistPath}`);
+            }
+            return { success: true };
+        }
+        if (platform === 'linux') {
+            const unitPath = join(home, '.config', 'systemd', 'user', 'ruflo-daemon.service');
+            try {
+                const { execFileSync } = await import('child_process');
+                try {
+                    execFileSync('systemctl', ['--user', 'disable', '--now', 'ruflo-daemon.service'], { encoding: 'utf-8', timeout: 5000 });
+                }
+                catch { /* ok */ }
+            }
+            catch { /* ignore */ }
+            if (fs.existsSync(unitPath)) {
+                fs.unlinkSync(unitPath);
+                output.printSuccess(`Removed ${unitPath}`);
+            }
+            else {
+                output.printInfo(`Not installed: ${unitPath}`);
+            }
+            return { success: true };
+        }
+        output.printError(`Unsupported platform: ${platform}`);
+        return { success: false, exitCode: 1 };
+    },
+};
 // Main daemon command
 export const daemonCommand = {
     name: 'daemon',
@@ -681,6 +961,8 @@ export const daemonCommand = {
         statusCommand,
         triggerCommand,
         enableCommand,
+        installSupervisorCommand,
+        uninstallSupervisorCommand,
     ],
     options: [],
     examples: [

package/v3/@claude-flow/cli/dist/src/services/headless-worker-executor.d.ts

@@ -222,6 +222,12 @@ export declare class HeadlessWorkerExecutor extends EventEmitter {
     /**
      * Get pool status
      */
+    /**
+     * #1855: return the PIDs of all currently-running headless worker
+     * children. Used by `WorkerDaemon` to snapshot active child PIDs to
+     * disk so the next lifetime can reap orphans after a hard crash.
+     */
+    getActiveChildPids(): number[];
     getPoolStatus(): PoolStatus;
     /**
      * Get number of active executions

package/v3/@claude-flow/cli/dist/src/services/headless-worker-executor.js

@@ -457,6 +457,20 @@ export class HeadlessWorkerExecutor extends EventEmitter {
     /**
      * Get pool status
      */
+    /**
+     * #1855: return the PIDs of all currently-running headless worker
+     * children. Used by `WorkerDaemon` to snapshot active child PIDs to
+     * disk so the next lifetime can reap orphans after a hard crash.
+     */
+    getActiveChildPids() {
+        const out = [];
+        for (const entry of this.processPool.values()) {
+            const pid = entry.process?.pid;
+            if (typeof pid === 'number' && pid > 0)
+                out.push(pid);
+        }
+        return out;
+    }
     getPoolStatus() {
         const now = Date.now();
         return {

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

@@ -27,6 +27,7 @@ interface WorkerState {
     failureCount: number;
     averageDurationMs: number;
     isRunning: boolean;
+    lastStartedAt?: Date;
 }
 interface WorkerResult {
     workerId: string;
@@ -106,6 +107,51 @@ export declare class WorkerDaemon extends EventEmitter {
      * Setup graceful shutdown handlers
      */
     private setupShutdownHandlers;
+    /**
+     * #1855: install crash handlers for uncaught exceptions and unhandled
+     * rejections. Without these, a thrown error from any timer callback,
+     * worker logic path, or transitive import crashes the daemon process
+     * silently — the PID file leaks and any in-flight child processes
+     * orphan. With these, we log a structured crash record, run stop()
+     * to clean up, then exit 1 so the process actually dies (otherwise
+     * Node would crash anyway after the handler returns).
+     */
+    private installCrashHandlers;
+    /**
+     * Append a structured crash record to .claude-flow/logs/crash.log.
+     * Inspectable by hand or via `ruflo daemon status` follow-ups.
+     */
+    private writeCrashRecord;
+    /**
+     * Path to the on-disk children registry — list of headless worker
+     * child PIDs the daemon currently owns. #1855: written on every
+     * execution:start / :complete / :error transition; read by the next
+     * lifetime to reap orphans after a hard crash.
+     */
+    private get childrenFile();
+    /**
+     * #1856: detect workers that were mid-flight when the previous daemon
+     * lifetime ended. A mid-flight worker has `lastStartedAt > lastRun`
+     * (started after the last successful completion). On crash recovery
+     * we count these as failures so the run-counter math stays consistent
+     * (`runCount === successCount + failureCount`). Workers naturally
+     * retry at their next scheduled interval; we deliberately don't
+     * immediately re-run because the failure may have been deterministic.
+     */
+    private detectMidFlightFailures;
+    /**
+     * Snapshot the currently-active headless worker child PIDs to disk.
+     * Best-effort; failures don't propagate.
+     */
+    private writeChildrenSnapshot;
+    /**
+     * #1855: reap orphan headless worker children left behind by a
+     * previous crashed lifetime. Reads `.claude-flow/daemon-children.json`,
+     * SIGTERMs any PID still alive that doesn't belong to the current
+     * daemon, then truncates the file. Called at the top of `start()`
+     * so the next lifetime starts with a clean process tree.
+     */
+    private reapOrphanedChildren;
     /**
      * Check if system resources allow worker execution
      */

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

@@ -79,6 +79,9 @@ export class WorkerDaemon extends EventEmitter {
         };
         // Setup graceful shutdown handlers
         this.setupShutdownHandlers();
+        // #1855: install crash handlers so uncaught exceptions and unhandled
+        // rejections don't leak the PID file or orphan child processes.
+        this.installCrashHandlers();
         // Ensure directories exist
         if (!existsSync(claudeFlowDir)) {
             mkdirSync(claudeFlowDir, { recursive: true });
@@ -104,14 +107,19 @@ export class WorkerDaemon extends EventEmitter {
             this.headlessAvailable = await this.headlessExecutor.isAvailable();
             if (this.headlessAvailable) {
                 this.log('info', 'Claude Code headless mode available - AI workers enabled');
-                // Forward headless executor events
+                // Forward headless executor events. #1855: also snapshot the
+                // active child PIDs to disk on every transition so the next
+                // lifetime can reap orphans after a hard crash.
                 this.headlessExecutor.on('execution:start', (data) => {
+                    this.writeChildrenSnapshot();
                     this.emit('headless:start', data);
                 });
                 this.headlessExecutor.on('execution:complete', (data) => {
+                    this.writeChildrenSnapshot();
                     this.emit('headless:complete', data);
                 });
                 this.headlessExecutor.on('execution:error', (data) => {
+                    this.writeChildrenSnapshot();
                     this.emit('headless:error', data);
                 });
                 this.headlessExecutor.on('output', (data) => {
@@ -249,6 +257,153 @@ export class WorkerDaemon extends EventEmitter {
         process.on('SIGINT', shutdown);
         process.on('SIGHUP', shutdown);
     }
+    /**
+     * #1855: install crash handlers for uncaught exceptions and unhandled
+     * rejections. Without these, a thrown error from any timer callback,
+     * worker logic path, or transitive import crashes the daemon process
+     * silently — the PID file leaks and any in-flight child processes
+     * orphan. With these, we log a structured crash record, run stop()
+     * to clean up, then exit 1 so the process actually dies (otherwise
+     * Node would crash anyway after the handler returns).
+     */
+    installCrashHandlers() {
+        const onCrash = (kind, err) => {
+            // Best-effort logging; never throw from inside the crash handler.
+            try {
+                this.writeCrashRecord(kind, err);
+            }
+            catch { /* nothing more we can do */ }
+            try {
+                // Synchronous stop — don't await; the process is dying. Just
+                // remove the PID file and snapshot state so the next start
+                // sees a clean slate.
+                this.removePidFile();
+                this.saveState();
+                // Snapshot any in-flight child PIDs one last time so the next
+                // lifetime can reap them.
+                this.writeChildrenSnapshot();
+            }
+            catch { /* ignore */ }
+            // Exit non-zero so supervisors / shells see the failure.
+            process.exit(1);
+        };
+        process.on('uncaughtException', (err) => onCrash('uncaughtException', err));
+        process.on('unhandledRejection', (err) => onCrash('unhandledRejection', err));
+    }
+    /**
+     * Append a structured crash record to .claude-flow/logs/crash.log.
+     * Inspectable by hand or via `ruflo daemon status` follow-ups.
+     */
+    writeCrashRecord(kind, err) {
+        const logDir = this.config.logDir;
+        if (!existsSync(logDir))
+            mkdirSync(logDir, { recursive: true });
+        const crashLog = join(logDir, 'crash.log');
+        const ts = new Date().toISOString();
+        const message = err instanceof Error ? err.message : String(err);
+        const stack = err instanceof Error && err.stack ? err.stack : '<no stack>';
+        const record = `[${ts}] [${kind}] pid=${process.pid} ${message}\n${stack}\n---\n`;
+        appendFileSync(crashLog, record, 'utf-8');
+        this.log('warn', `Daemon crashed (${kind}): ${message} — see ${crashLog}`);
+    }
+    /**
+     * Path to the on-disk children registry — list of headless worker
+     * child PIDs the daemon currently owns. #1855: written on every
+     * execution:start / :complete / :error transition; read by the next
+     * lifetime to reap orphans after a hard crash.
+     */
+    get childrenFile() {
+        return join(this.projectRoot, '.claude-flow', 'daemon-children.json');
+    }
+    /**
+     * #1856: detect workers that were mid-flight when the previous daemon
+     * lifetime ended. A mid-flight worker has `lastStartedAt > lastRun`
+     * (started after the last successful completion). On crash recovery
+     * we count these as failures so the run-counter math stays consistent
+     * (`runCount === successCount + failureCount`). Workers naturally
+     * retry at their next scheduled interval; we deliberately don't
+     * immediately re-run because the failure may have been deterministic.
+     */
+    detectMidFlightFailures() {
+        let detected = 0;
+        for (const [type, state] of this.workers.entries()) {
+            const startedAt = state.lastStartedAt?.getTime() ?? 0;
+            const lastRunAt = state.lastRun?.getTime() ?? 0;
+            // started after the last successful completion → was mid-flight
+            if (startedAt > 0 && startedAt > lastRunAt) {
+                state.failureCount++;
+                state.isRunning = false;
+                // Don't bump runCount — it was already incremented at start
+                this.log('info', `Worker ${type} was mid-flight at last crash (started ${state.lastStartedAt?.toISOString()}); counted as failure, will retry at next scheduled interval`);
+                detected++;
+            }
+        }
+        if (detected > 0) {
+            this.saveState();
+        }
+    }
+    /**
+     * Snapshot the currently-active headless worker child PIDs to disk.
+     * Best-effort; failures don't propagate.
+     */
+    writeChildrenSnapshot() {
+        if (!this.headlessExecutor)
+            return;
+        try {
+            const pids = this.headlessExecutor.getActiveChildPids();
+            const dir = join(this.projectRoot, '.claude-flow');
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(this.childrenFile, JSON.stringify({ pids, daemonPid: process.pid, timestamp: new Date().toISOString() }, null, 2), 'utf-8');
+        }
+        catch { /* best-effort */ }
+    }
+    /**
+     * #1855: reap orphan headless worker children left behind by a
+     * previous crashed lifetime. Reads `.claude-flow/daemon-children.json`,
+     * SIGTERMs any PID still alive that doesn't belong to the current
+     * daemon, then truncates the file. Called at the top of `start()`
+     * so the next lifetime starts with a clean process tree.
+     */
+    reapOrphanedChildren() {
+        const file = this.childrenFile;
+        if (!existsSync(file))
+            return;
+        let snapshot;
+        try {
+            snapshot = JSON.parse(readFileSync(file, 'utf-8'));
+        }
+        catch {
+            try {
+                unlinkSync(file);
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        const pids = Array.isArray(snapshot.pids) ? snapshot.pids : [];
+        let reaped = 0;
+        for (const pid of pids) {
+            if (typeof pid !== 'number' || pid <= 0)
+                continue;
+            if (pid === process.pid)
+                continue; // never our own PID
+            try {
+                process.kill(pid, 0); // is alive?
+                process.kill(pid, 'SIGTERM');
+                reaped++;
+            }
+            catch {
+                // already dead — fine
+            }
+        }
+        if (reaped > 0) {
+            this.log('info', `Reaped ${reaped} orphan headless worker child(ren) from previous lifetime`);
+        }
+        try {
+            unlinkSync(file);
+        }
+        catch { /* ignore */ }
+    }
     /**
      * Check if system resources allow worker execution
      */
@@ -332,12 +487,14 @@ export class WorkerDaemon extends EventEmitter {
                     for (const [type, state] of Object.entries(saved.workers)) {
                         const savedState = state;
                         const lastRunValue = savedState.lastRun;
+                        const lastStartedAtValue = savedState.lastStartedAt;
                         this.workers.set(type, {
                             runCount: savedState.runCount || 0,
                             successCount: savedState.successCount || 0,
                             failureCount: savedState.failureCount || 0,
                             averageDurationMs: savedState.averageDurationMs || 0,
                             lastRun: lastRunValue ? new Date(lastRunValue) : undefined,
+                            lastStartedAt: lastStartedAtValue ? new Date(lastStartedAtValue) : undefined,
                             nextRun: undefined,
                             isRunning: false,
                         });
@@ -437,6 +594,18 @@ export class WorkerDaemon extends EventEmitter {
             this.emit('warning', `Daemon already running (PID: ${existingPid})`);
             return;
         }
+        // #1855: reap orphan headless worker children left by a previous
+        // crashed lifetime, BEFORE we mark ourselves running and start
+        // accepting new work. The children file from the prior daemon's
+        // last-snapshot is the authoritative list.
+        this.reapOrphanedChildren();
+        // #1856: detect workers that were mid-flight at the previous crash
+        // and count them as failures so runCount/successCount/failureCount
+        // stay consistent. Workers retry naturally at their next scheduled
+        // interval — we don't immediately re-run them, which avoids a
+        // freshly-recovered daemon hammering the same code path that just
+        // killed it.
+        this.detectMidFlightFailures();
         this.running = true;
         this.startedAt = new Date();
         this.writePidFile();
@@ -631,6 +800,8 @@ export class WorkerDaemon extends EventEmitter {
         // Track running worker
         this.runningWorkers.add(workerConfig.type);
         state.isRunning = true;
+        state.lastStartedAt = new Date(); // #1856: timestamp the start
+        this.saveState(); // persist before we run anything
         this.emit('worker:start', { workerId, type: workerConfig.type });
         this.log('info', `Starting worker: ${workerConfig.type} (${this.runningWorkers.size}/${this.config.maxConcurrent} concurrent)`);
         try {
@@ -1082,6 +1253,7 @@ export class WorkerDaemon extends EventEmitter {
                 {
                     ...state,
                     lastRun: state.lastRun?.toISOString(),
+                    lastStartedAt: state.lastStartedAt?.toISOString(),
                     nextRun: state.nextRun?.toISOString(),
                 }
             ])),

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.15",
+  "version": "3.7.0-alpha.17",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",