@claude-flow/cli 3.0.0-alpha.7 → 3.0.0-alpha.9

package/.agentic-flow/intelligence.json

@@ -1,8 +1,8 @@
 {
   "patterns": {
     "command:": {
-      "success": 0.9999872957652524,
-      "failure": -0.343094701955
+      "success": 0.9999999972244487,
+      "failure": -0.44529050543424387
     }
   },
   "sequences": {},
@@ -10,8 +10,8 @@
   "dirPatterns": {},
   "errorPatterns": [],
   "metrics": {
-    "totalRoutes": 118,
-    "successfulRoutes": 107,
+    "totalRoutes": 208,
+    "successfulRoutes": 187,
     "routingHistory": []
   }
 }

package/.claude-flow/daemon-state.json

@@ -1,51 +1,46 @@
 {
-  "running": true,
-  "startedAt": "2026-01-07T03:07:50.010Z",
+  "running": false,
+  "startedAt": "2026-01-07T03:59:44.097Z",
   "workers": {
     "map": {
-      "runCount": 3,
-      "successCount": 3,
+      "runCount": 0,
+      "successCount": 0,
       "failureCount": 0,
-      "averageDurationMs": 0.6666666666666666,
-      "isRunning": false,
-      "nextRun": "2026-01-07T03:17:50.077Z",
-      "lastRun": "2026-01-07T03:17:50.116Z"
+      "averageDurationMs": 0,
+      "nextRun": "2026-01-07T04:14:44.099Z",
+      "isRunning": false
     },
     "audit": {
-      "runCount": 2,
-      "successCount": 2,
+      "runCount": 0,
+      "successCount": 0,
       "failureCount": 0,
-      "averageDurationMs": 0.5,
-      "isRunning": false,
-      "nextRun": "2026-01-07T03:27:50.115Z",
-      "lastRun": "2026-01-07T03:17:50.115Z"
+      "averageDurationMs": 0,
+      "nextRun": "2026-01-07T04:01:44.097Z",
+      "isRunning": false
     },
     "optimize": {
-      "runCount": 1,
-      "successCount": 1,
+      "runCount": 0,
+      "successCount": 0,
       "failureCount": 0,
       "averageDurationMs": 0,
-      "isRunning": false,
-      "nextRun": "2026-01-07T03:22:50.014Z",
-      "lastRun": "2026-01-07T03:07:50.014Z"
+      "nextRun": "2026-01-07T04:03:44.097Z",
+      "isRunning": false
     },
     "consolidate": {
-      "runCount": 1,
-      "successCount": 1,
+      "runCount": 0,
+      "successCount": 0,
       "failureCount": 0,
-      "averageDurationMs": 1,
-      "isRunning": false,
-      "nextRun": "2026-01-07T03:37:50.015Z",
-      "lastRun": "2026-01-07T03:07:50.015Z"
+      "averageDurationMs": 0,
+      "nextRun": "2026-01-07T04:05:44.097Z",
+      "isRunning": false
     },
     "testgaps": {
-      "runCount": 1,
-      "successCount": 1,
+      "runCount": 0,
+      "successCount": 0,
       "failureCount": 0,
       "averageDurationMs": 0,
-      "isRunning": false,
-      "nextRun": "2026-01-07T03:27:50.015Z",
-      "lastRun": "2026-01-07T03:07:50.015Z"
+      "nextRun": "2026-01-07T04:07:44.097Z",
+      "isRunning": false
     },
     "predict": {
       "runCount": 0,
@@ -63,14 +58,20 @@
     }
   },
   "config": {
-    "autoStart": true,
+    "autoStart": false,
     "logDir": "/workspaces/claude-flow/v3/@claude-flow/cli/.claude-flow/logs",
     "stateFile": "/workspaces/claude-flow/v3/@claude-flow/cli/.claude-flow/daemon-state.json",
-    "maxConcurrent": 3,
+    "maxConcurrent": 2,
+    "workerTimeoutMs": 300000,
+    "resourceThresholds": {
+      "maxCpuLoad": 2,
+      "minFreeMemoryPercent": 20
+    },
     "workers": [
       {
         "type": "map",
-        "intervalMs": 300000,
+        "intervalMs": 900000,
+        "offsetMs": 0,
         "priority": "normal",
         "description": "Codebase mapping",
         "enabled": true
@@ -78,6 +79,7 @@
       {
         "type": "audit",
         "intervalMs": 600000,
+        "offsetMs": 120000,
         "priority": "critical",
         "description": "Security analysis",
         "enabled": true
@@ -85,6 +87,7 @@
       {
         "type": "optimize",
         "intervalMs": 900000,
+        "offsetMs": 240000,
         "priority": "high",
         "description": "Performance optimization",
         "enabled": true
@@ -92,6 +95,7 @@
       {
         "type": "consolidate",
         "intervalMs": 1800000,
+        "offsetMs": 360000,
         "priority": "low",
         "description": "Memory consolidation",
         "enabled": true
@@ -99,13 +103,15 @@
       {
         "type": "testgaps",
         "intervalMs": 1200000,
+        "offsetMs": 480000,
         "priority": "normal",
         "description": "Test coverage analysis",
         "enabled": true
       },
       {
         "type": "predict",
-        "intervalMs": 120000,
+        "intervalMs": 600000,
+        "offsetMs": 0,
         "priority": "low",
         "description": "Predictive preloading",
         "enabled": false
@@ -113,11 +119,12 @@
       {
         "type": "document",
         "intervalMs": 3600000,
+        "offsetMs": 0,
         "priority": "low",
         "description": "Auto-documentation",
         "enabled": false
       }
     ]
   },
-  "savedAt": "2026-01-07T03:17:50.116Z"
+  "savedAt": "2026-01-07T03:59:45.210Z"
 }

package/.claude-flow/metrics/codebase-map.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-01-07T03:17:50.116Z",
+  "timestamp": "2026-01-07T03:57:50.243Z",
   "projectRoot": "/workspaces/claude-flow/v3/@claude-flow/cli",
   "structure": {
     "hasPackageJson": true,
@@ -7,5 +7,5 @@
     "hasClaudeConfig": false,
     "hasClaudeFlow": true
   },
-  "scannedAt": 1767755870116
+  "scannedAt": 1767758270243
 }

package/.claude-flow/metrics/consolidation.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-01-07T03:07:50.015Z",
+  "timestamp": "2026-01-07T03:37:50.088Z",
   "patternsConsolidated": 0,
   "memoryCleaned": 0,
   "duplicatesRemoved": 0

package/.claude-flow/metrics/performance.json

@@ -1,87 +1,15 @@
 {
-  "startTime": 1767756039785,
-  "sessionId": "session-1767756039785",
-  "lastActivity": 1767756039785,
-  "sessionDuration": 0,
-  "totalTasks": 1,
-  "successfulTasks": 1,
-  "failedTasks": 0,
-  "totalAgents": 0,
-  "activeAgents": 0,
-  "neuralEvents": 0,
-  "memoryMode": {
-    "reasoningbankOperations": 0,
-    "basicOperations": 0,
-    "autoModeSelections": 0,
-    "modeOverrides": 0,
-    "currentMode": "auto"
-  },
-  "operations": {
-    "store": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "retrieve": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "query": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "list": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "delete": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "search": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "init": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    }
-  },
-  "performance": {
-    "avgOperationDuration": 0,
-    "minOperationDuration": null,
-    "maxOperationDuration": null,
-    "slowOperations": 0,
-    "fastOperations": 0,
-    "totalOperationTime": 0
-  },
-  "storage": {
-    "totalEntries": 0,
-    "reasoningbankEntries": 0,
-    "basicEntries": 0,
-    "databaseSize": 0,
-    "lastBackup": null,
-    "growthRate": 0
-  },
-  "errors": {
-    "total": 0,
-    "byType": {},
-    "byOperation": {},
-    "recent": []
-  },
-  "reasoningbank": {
-    "semanticSearches": 0,
-    "sqlFallbacks": 0,
-    "embeddingGenerated": 0,
-    "consolidations": 0,
-    "avgQueryTime": 0,
-    "cacheHits": 0,
-    "cacheMisses": 0
+  "timestamp": "2026-01-07T03:52:50.190Z",
+  "memoryUsage": {
+    "rss": 65392640,
+    "heapTotal": 11304960,
+    "heapUsed": 9487728,
+    "external": 2145622,
+    "arrayBuffers": 24811
+  },
+  "uptime": 2700.280050891,
+  "optimizations": {
+    "cacheHitRate": 0.78,
+    "avgResponseTime": 45
   }
 }

package/.claude-flow/metrics/security-audit.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-01-07T03:17:50.115Z",
+  "timestamp": "2026-01-07T03:57:50.234Z",
   "checks": {
     "envFilesProtected": true,
     "gitIgnoreExists": false,

package/.claude-flow/metrics/task-metrics.json

@@ -1,10 +1,10 @@
 [
   {
-    "id": "cmd-hooks-1767756039890",
+    "id": "cmd-hooks-1767757800648",
     "type": "hooks",
     "success": true,
-    "duration": 1.6088340000000017,
-    "timestamp": 1767756039891,
+    "duration": 1.631386999999961,
+    "timestamp": 1767757800650,
     "metadata": {}
   }
 ]

package/.claude-flow/metrics/test-gaps.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-01-07T03:07:50.015Z",
+  "timestamp": "2026-01-07T03:47:50.172Z",
   "hasTestDir": true,
   "estimatedCoverage": "unknown",
   "gaps": []

package/agents/architect.yaml

@@ -8,4 +8,4 @@ capabilities:
 optimizations:
   - context-caching
   - memory-persistence
-createdAt: "2026-01-07T03:15:23.193Z"
+createdAt: "2026-01-07T03:49:59.116Z"

package/agents/coder.yaml

@@ -8,4 +8,4 @@ capabilities:
 optimizations:
   - flash-attention
   - token-reduction
-createdAt: "2026-01-07T03:15:23.193Z"
+createdAt: "2026-01-07T03:49:59.116Z"

package/agents/reviewer.yaml

@@ -7,4 +7,4 @@ capabilities:
   - best-practices
 optimizations:
   - incremental-analysis
-createdAt: "2026-01-07T03:15:23.194Z"
+createdAt: "2026-01-07T03:49:59.116Z"

package/agents/security-architect.yaml

@@ -7,4 +7,4 @@ capabilities:
   - security-review
 optimizations:
   - pattern-matching
-createdAt: "2026-01-07T03:15:23.193Z"
+createdAt: "2026-01-07T03:49:59.116Z"

package/agents/tester.yaml

@@ -7,4 +7,4 @@ capabilities:
   - coverage
 optimizations:
   - parallel-execution
-createdAt: "2026-01-07T03:15:23.193Z"
+createdAt: "2026-01-07T03:49:59.116Z"

package/dist/src/commands/daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../../src/commands/daemon.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AA2U1E,eAAO,MAAM,aAAa,EAAE,OAwD3B,CAAC;AAEF,eAAe,aAAa,CAAC"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../../src/commands/daemon.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AAshB1E,eAAO,MAAM,aAAa,EAAE,OAwD3B,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/src/commands/daemon.js

@@ -4,6 +4,10 @@
  */
 import { output } from '../output.js';
 import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import * as fs from 'fs';
 // Start daemon subcommand
 const startCommand = {
     name: 'start',
@@ -11,21 +15,41 @@ const startCommand = {
     options: [
         { name: 'workers', short: 'w', type: 'string', description: 'Comma-separated list of workers to enable (default: map,audit,optimize,consolidate,testgaps)' },
         { name: 'quiet', short: 'q', type: 'boolean', description: 'Suppress output' },
+        { name: 'background', short: 'b', type: 'boolean', description: 'Run daemon in background (detached process)', default: true },
+        { name: 'foreground', short: 'f', type: 'boolean', description: 'Run daemon in foreground (blocks terminal)' },
     ],
     examples: [
-        { command: 'claude-flow daemon start', description: 'Start daemon with default workers' },
+        { command: 'claude-flow daemon start', description: 'Start daemon in background (default)' },
+        { command: 'claude-flow daemon start --foreground', description: 'Start in foreground (blocks terminal)' },
         { command: 'claude-flow daemon start -w map,audit,optimize', description: 'Start with specific workers' },
     ],
     action: async (ctx) => {
         const quiet = ctx.flags.quiet;
+        const foreground = ctx.flags.foreground;
         const projectRoot = process.cwd();
+        const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
+        // 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);
+        }
+        // Foreground mode: run in current process (blocks terminal)
         try {
             if (!quiet) {
                 const spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
                 spinner.start();
                 const daemon = await startDaemon(projectRoot);
                 const status = daemon.getStatus();
-                spinner.succeed('Worker daemon started');
+                spinner.succeed('Worker daemon started (foreground mode)');
                 output.writeln();
                 output.printBox([
                     `PID: ${status.pid}`,
@@ -53,6 +77,8 @@ const startCommand = {
                         description: w.description,
                     })),
                 });
+                output.writeln();
+                output.writeln(output.dim('Press Ctrl+C to stop daemon'));
                 // Listen for worker events
                 daemon.on('worker:start', ({ type }) => {
                     output.writeln(output.dim(`[daemon] Worker starting: ${type}`));
@@ -63,9 +89,12 @@ const startCommand = {
                 daemon.on('worker:error', ({ type, error }) => {
                     output.writeln(output.error(`[daemon] Worker failed: ${type} - ${error}`));
                 });
+                // Keep process alive
+                await new Promise(() => { }); // Never resolves - daemon runs until killed
             }
             else {
                 await startDaemon(projectRoot);
+                await new Promise(() => { }); // Keep alive
             }
             return { success: true };
         }
@@ -75,6 +104,62 @@ const startCommand = {
         }
     },
 };
+/**
+ * Start daemon as a detached background process
+ */
+async function startBackgroundDaemon(projectRoot, quiet) {
+    const stateDir = join(projectRoot, '.claude-flow');
+    const pidFile = join(stateDir, 'daemon.pid');
+    const logFile = join(stateDir, 'daemon.log');
+    // Ensure state directory exists
+    if (!fs.existsSync(stateDir)) {
+        fs.mkdirSync(stateDir, { recursive: true });
+    }
+    // Get path to CLI (from dist/src/commands/daemon.js -> bin/cli.js)
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    // dist/src/commands -> dist/src -> dist -> package root -> bin/cli.js
+    const cliPath = join(__dirname, '..', '..', '..', 'bin', 'cli.js');
+    // Verify CLI path exists
+    if (!fs.existsSync(cliPath)) {
+        output.printError(`CLI not found at: ${cliPath}`);
+        return { success: false, exitCode: 1 };
+    }
+    // Use shell to spawn daemon with proper output redirection
+    // This ensures the log file stays open even after parent exits
+    const shellCmd = `"${process.execPath}" "${cliPath}" daemon start --foreground --quiet >> "${logFile}" 2>&1 & echo $!`;
+    const child = spawn('sh', ['-c', shellCmd], {
+        cwd: projectRoot,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'ignore'],
+        env: { ...process.env, CLAUDE_FLOW_DAEMON: '1' },
+    });
+    // Wait for the PID to be echoed back
+    return new Promise((resolve) => {
+        let pidStr = '';
+        child.stdout?.on('data', (data) => {
+            pidStr += data.toString();
+        });
+        child.on('close', () => {
+            const pid = parseInt(pidStr.trim(), 10);
+            if (isNaN(pid) || pid <= 0) {
+                output.printError('Failed to get daemon PID');
+                resolve({ success: false, exitCode: 1 });
+                return;
+            }
+            // Save PID
+            fs.writeFileSync(pidFile, String(pid));
+            if (!quiet) {
+                output.printSuccess(`Daemon started in background (PID: ${pid})`);
+                output.printInfo(`Logs: ${logFile}`);
+                output.printInfo(`Stop with: claude-flow daemon stop`);
+            }
+            resolve({ success: true });
+        });
+        // Unref so parent can exit immediately
+        child.unref();
+    });
+}
 // Stop daemon subcommand
 const stopCommand = {
     name: 'stop',
@@ -87,15 +172,20 @@ const stopCommand = {
     ],
     action: async (ctx) => {
         const quiet = ctx.flags.quiet;
+        const projectRoot = process.cwd();
         try {
             if (!quiet) {
                 const spinner = output.createSpinner({ text: 'Stopping worker daemon...', spinner: 'dots' });
                 spinner.start();
+                // Try to stop in-process daemon first
                 await stopDaemon();
-                spinner.succeed('Worker daemon stopped');
+                // Also kill any background daemon by PID
+                const killed = await killBackgroundDaemon(projectRoot);
+                spinner.succeed(killed ? 'Worker daemon stopped' : 'Worker daemon was not running');
             }
             else {
                 await stopDaemon();
+                await killBackgroundDaemon(projectRoot);
             }
             return { success: true };
         }
@@ -105,6 +195,83 @@ const stopCommand = {
         }
     },
 };
+/**
+ * Kill background daemon process using PID file
+ */
+async function killBackgroundDaemon(projectRoot) {
+    const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
+    if (!fs.existsSync(pidFile)) {
+        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');
+        // Wait a moment then force kill if needed
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        try {
+            process.kill(pid, 0);
+            // Still alive, force kill
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // Process terminated
+        }
+        // Clean up PID file
+        if (fs.existsSync(pidFile)) {
+            fs.unlinkSync(pidFile);
+        }
+        return true;
+    }
+    catch (error) {
+        // Clean up PID file on any error
+        if (fs.existsSync(pidFile)) {
+            fs.unlinkSync(pidFile);
+        }
+        return false;
+    }
+}
+/**
+ * Get PID of background daemon from PID file
+ */
+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;
+    }
+}
+/**
+ * Check if a process is running
+ */
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0); // Signal 0 = check if alive
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // Status subcommand
 const statusCommand = {
     name: 'status',
@@ -118,16 +285,23 @@ const statusCommand = {
     ],
     action: async (ctx) => {
         const verbose = ctx.flags.verbose;
+        const projectRoot = process.cwd();
         try {
-            const daemon = getDaemon(process.cwd());
+            const daemon = getDaemon(projectRoot);
             const status = daemon.getStatus();
+            // Also check for background daemon
+            const bgPid = getBackgroundDaemonPid(projectRoot);
+            const bgRunning = bgPid ? isProcessRunning(bgPid) : false;
+            const isRunning = status.running || bgRunning;
+            const displayPid = bgPid || status.pid;
             output.writeln();
             // Daemon status box
-            const statusIcon = status.running ? output.success('●') : output.error('○');
-            const statusText = status.running ? output.success('RUNNING') : output.error('STOPPED');
+            const statusIcon = isRunning ? output.success('●') : output.error('○');
+            const statusText = isRunning ? output.success('RUNNING') : output.error('STOPPED');
+            const mode = bgRunning ? output.dim(' (background)') : status.running ? output.dim(' (foreground)') : '';
             output.printBox([
-                `Status: ${statusIcon} ${statusText}`,
-                `PID: ${status.pid}`,
+                `Status: ${statusIcon} ${statusText}${mode}`,
+                `PID: ${displayPid}`,
                 status.startedAt ? `Started: ${status.startedAt.toISOString()}` : '',
                 `Workers Enabled: ${status.config.workers.filter(w => w.enabled).length}`,
                 `Max Concurrent: ${status.config.maxConcurrent}`,