claude-flow 3.7.0-alpha.16 → 3.7.0-alpha.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.16",
+  "version": "3.7.0-alpha.18",
   "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/commands/hooks.js

@@ -270,7 +270,7 @@ const preEditCommand = {
     ],
     action: async (ctx) => {
         // Default file to 'unknown' for backward compatibility (env var may be empty)
-        const filePath = ctx.args[0] || ctx.flags.file || 'unknown';
+        const filePath = ctx.flags.file || ctx.args[0] || 'unknown';
         const operation = ctx.flags.operation || 'update';
         output.printInfo(`Analyzing context for: ${output.highlight(filePath)}`);
         try {
@@ -375,7 +375,7 @@ const postEditCommand = {
     ],
     action: async (ctx) => {
         // Default file to 'unknown' for backward compatibility (env var may be empty)
-        const filePath = ctx.args[0] || ctx.flags.file || 'unknown';
+        const filePath = ctx.flags.file || ctx.args[0] || 'unknown';
         // Default success to true for backward compatibility (PostToolUse = success, PostToolUseFailure = failure)
         const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
         output.printInfo(`Recording outcome for: ${output.highlight(filePath)}`);
@@ -458,7 +458,7 @@ const preCommandCommand = {
         { command: 'claude-flow hooks pre-command -c "npm install lodash"', description: 'Check package install' }
     ],
     action: async (ctx) => {
-        const command = ctx.args[0] || ctx.flags.command;
+        const command = ctx.flags.command || ctx.args[0];
         if (!command) {
             output.printError('Command is required. Use --command or -c flag.');
             return { success: false, exitCode: 1 };
@@ -567,7 +567,7 @@ const postCommandCommand = {
         { command: 'claude-flow hooks post-command -c "npm build" --success false -e 1', description: 'Record failed build' }
     ],
     action: async (ctx) => {
-        const command = ctx.args[0] || ctx.flags.command;
+        const command = ctx.flags.command || ctx.args[0];
         // Default success to true for backward compatibility
         const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
         if (!command) {
@@ -639,7 +639,7 @@ const routeCommand = {
         { command: 'claude-flow hooks route -t "Optimize database queries" -K 5', description: 'Get top 5 suggestions' }
     ],
     action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
+        const task = ctx.flags.task || ctx.args[0];
         const topK = ctx.flags.topK || 3;
         if (!task) {
             output.printError('Task description is required. Use --task or -t flag.');
@@ -751,7 +751,7 @@ const explainCommand = {
         { command: 'claude-flow hooks explain -t "Optimize queries" -a coder --verbose', description: 'Verbose explanation for specific agent' }
     ],
     action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
+        const task = ctx.flags.task || ctx.args[0];
         if (!task) {
             output.printError('Task description is required. Use --task or -t flag.');
             return { success: false, exitCode: 1 };
@@ -1224,7 +1224,7 @@ const transferFromProjectCommand = {
         { command: 'claude-flow hooks transfer from-project -s ../prod --filter security -m 0.9', description: 'Transfer high-confidence security patterns' }
     ],
     action: async (ctx) => {
-        const sourcePath = ctx.args[0] || ctx.flags.source;
+        const sourcePath = ctx.flags.source || ctx.args[0];
         const minConfidence = ctx.flags.minConfidence || 0.7;
         if (!sourcePath) {
             output.printError('Source project path is required. Use --source or -s flag.');
@@ -1422,7 +1422,7 @@ const preTaskCommand = {
     ],
     action: async (ctx) => {
         const taskId = ctx.flags.taskId || `task-${Date.now().toString(36)}`;
-        const description = ctx.args[0] || ctx.flags.description;
+        const description = ctx.flags.description || ctx.args[0];
         if (!description) {
             output.printError('Description is required: --description "your task"');
             return { success: false, exitCode: 1 };
@@ -1707,7 +1707,7 @@ const sessionRestoreCommand = {
         { command: 'claude-flow hooks session-restore -i session-12345', description: 'Restore specific session' }
     ],
     action: async (ctx) => {
-        const sessionId = ctx.args[0] || ctx.flags.sessionId || 'latest';
+        const sessionId = ctx.flags.sessionId || ctx.args[0] || 'latest';
         output.printInfo(`Restoring session: ${output.highlight(sessionId)}`);
         try {
             const result = await callMCPTool('hooks_session-restore', {
@@ -2519,7 +2519,7 @@ const coverageRouteCommand = {
         { command: 'claude-flow hooks coverage-route -t "add tests" --threshold 90', description: 'Route with custom threshold' }
     ],
     action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
+        const task = ctx.flags.task || ctx.args[0];
         const threshold = ctx.flags.threshold || 80;
         const useRuvector = !ctx.flags['no-ruvector'];
         if (!task) {
@@ -2739,7 +2739,7 @@ const coverageSuggestCommand = {
         { command: 'claude-flow hooks coverage-suggest -p src/services --threshold 90', description: 'Stricter threshold' }
     ],
     action: async (ctx) => {
-        const targetPath = ctx.args[0] || ctx.flags.path;
+        const targetPath = ctx.flags.path || ctx.args[0];
         const threshold = ctx.flags.threshold || 80;
         const limit = ctx.flags.limit || 20;
         if (!targetPath) {
@@ -3977,7 +3977,7 @@ const modelRouteCommand = {
         { command: 'claude-flow hooks model-route -t "architect auth system"', description: 'Route complex task (likely opus)' },
     ],
     action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
+        const task = ctx.flags.task || ctx.args[0];
         if (!task) {
             output.printError('Task description required. Use --task or -t flag.');
             return { success: false, exitCode: 1 };
@@ -4285,7 +4285,7 @@ const taskCompletedCommand = {
         { command: 'claude-flow hooks task-completed -i task-456 --notify-lead --quality 0.95', description: 'Complete with quality score' }
     ],
     action: async (ctx) => {
-        const taskId = ctx.args[0] || ctx.flags.taskId;
+        const taskId = ctx.flags.taskId || ctx.args[0];
         const trainPatterns = ctx.flags.trainPatterns !== false;
         const notifyLead = ctx.flags.notifyLead !== false;
         const success = ctx.flags.success !== false;
@@ -4363,7 +4363,7 @@ const notifyCommand = {
         { command: 'claude-flow hooks notify -m "Test failed" -l error', description: 'Send error notification' },
     ],
     action: async (ctx) => {
-        const message = ctx.args[0] || ctx.flags.message;
+        const message = ctx.flags.message || ctx.args[0];
         const level = ctx.flags.level || 'info';
         if (!message) {
             output.printError('Message is required: --message "your message"');

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;
@@ -128,6 +129,16 @@ export declare class WorkerDaemon extends EventEmitter {
      * 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.

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

@@ -315,6 +315,33 @@ export class WorkerDaemon extends EventEmitter {
     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.
@@ -460,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,
                         });
@@ -570,6 +599,13 @@ export class WorkerDaemon extends EventEmitter {
         // 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();
@@ -764,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 {
@@ -1215,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.16",
+  "version": "3.7.0-alpha.18",
   "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",

package/.claude/scheduled_tasks.lock

@@ -1 +0,0 @@
-{"sessionId":"7c6134bf-6c84-4145-9232-421e80ca3692","pid":85190,"procStart":"Fri May  8 13:13:24 2026","acquiredAt":1778246373999}