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

package/.agentic-flow/intelligence.json

@@ -1,8 +1,8 @@
 {
   "patterns": {
     "command:": {
-      "success": 0.9999872957652524,
-      "failure": -0.343094701955
+      "success": 0.9999970936785837,
+      "failure": -0.3587852317595
     }
   },
   "sequences": {},
@@ -10,8 +10,8 @@
   "dirPatterns": {},
   "errorPatterns": [],
   "metrics": {
-    "totalRoutes": 118,
-    "successfulRoutes": 107,
+    "totalRoutes": 133,
+    "successfulRoutes": 121,
     "routingHistory": []
   }
 }

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

@@ -3,49 +3,49 @@
   "startedAt": "2026-01-07T03:07:50.010Z",
   "workers": {
     "map": {
-      "runCount": 3,
-      "successCount": 3,
+      "runCount": 7,
+      "successCount": 7,
       "failureCount": 0,
-      "averageDurationMs": 0.6666666666666666,
+      "averageDurationMs": 0.5714285714285714,
       "isRunning": false,
-      "nextRun": "2026-01-07T03:17:50.077Z",
-      "lastRun": "2026-01-07T03:17:50.116Z"
+      "nextRun": "2026-01-07T03:37:50.197Z",
+      "lastRun": "2026-01-07T03:37:50.198Z"
     },
     "audit": {
-      "runCount": 2,
-      "successCount": 2,
+      "runCount": 4,
+      "successCount": 4,
       "failureCount": 0,
-      "averageDurationMs": 0.5,
+      "averageDurationMs": 0.25,
       "isRunning": false,
-      "nextRun": "2026-01-07T03:27:50.115Z",
-      "lastRun": "2026-01-07T03:17:50.115Z"
+      "nextRun": "2026-01-07T03:47:50.117Z",
+      "lastRun": "2026-01-07T03:37:50.117Z"
     },
     "optimize": {
-      "runCount": 1,
-      "successCount": 1,
+      "runCount": 3,
+      "successCount": 3,
       "failureCount": 0,
       "averageDurationMs": 0,
       "isRunning": false,
-      "nextRun": "2026-01-07T03:22:50.014Z",
-      "lastRun": "2026-01-07T03:07:50.014Z"
+      "nextRun": "2026-01-07T03:52:50.090Z",
+      "lastRun": "2026-01-07T03:37:50.089Z"
     },
     "consolidate": {
-      "runCount": 1,
-      "successCount": 1,
+      "runCount": 2,
+      "successCount": 2,
       "failureCount": 0,
       "averageDurationMs": 1,
       "isRunning": false,
-      "nextRun": "2026-01-07T03:37:50.015Z",
-      "lastRun": "2026-01-07T03:07:50.015Z"
+      "nextRun": "2026-01-07T04:07:50.089Z",
+      "lastRun": "2026-01-07T03:37:50.089Z"
     },
     "testgaps": {
-      "runCount": 1,
-      "successCount": 1,
+      "runCount": 2,
+      "successCount": 2,
       "failureCount": 0,
       "averageDurationMs": 0,
       "isRunning": false,
-      "nextRun": "2026-01-07T03:27:50.015Z",
-      "lastRun": "2026-01-07T03:07:50.015Z"
+      "nextRun": "2026-01-07T03:47:50.072Z",
+      "lastRun": "2026-01-07T03:27:50.072Z"
     },
     "predict": {
       "runCount": 0,
@@ -119,5 +119,5 @@
       }
     ]
   },
-  "savedAt": "2026-01-07T03:17:50.116Z"
+  "savedAt": "2026-01-07T03:37:50.198Z"
 }

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

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

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:37:50.090Z",
+  "memoryUsage": {
+    "rss": 65044480,
+    "heapTotal": 11042816,
+    "heapUsed": 9247808,
+    "external": 2145622,
+    "arrayBuffers": 24811
+  },
+  "uptime": 1594.301482026,
+  "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:37:50.117Z",
   "checks": {
     "envFilesProtected": true,
     "gitIgnoreExists": false,

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

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

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

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-01-07T03:07:50.015Z",
+  "timestamp": "2026-01-07T03:27:50.072Z",
   "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:36:27.039Z"

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:36:27.039Z"

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:36:27.039Z"

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:36:27.039Z"

package/agents/tester.yaml

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

package/dist/src/services/worker-daemon.d.ts

@@ -48,6 +48,11 @@ interface DaemonConfig {
     logDir: string;
     stateFile: string;
     maxConcurrent: number;
+    workerTimeoutMs: number;
+    resourceThresholds: {
+        maxCpuLoad: number;
+        minFreeMemoryPercent: number;
+    };
     workers: WorkerConfig[];
 }
 /**
@@ -60,7 +65,21 @@ export declare class WorkerDaemon extends EventEmitter {
     private running;
     private startedAt?;
     private projectRoot;
+    private runningWorkers;
+    private pendingWorkers;
     constructor(projectRoot: string, config?: Partial<DaemonConfig>);
+    /**
+     * Setup graceful shutdown handlers
+     */
+    private setupShutdownHandlers;
+    /**
+     * Check if system resources allow worker execution
+     */
+    private canRunWorker;
+    /**
+     * Process pending workers queue
+     */
+    private processPendingWorkers;
     private initializeWorkerStates;
     /**
      * Start the daemon and all enabled workers
@@ -75,13 +94,21 @@ export declare class WorkerDaemon extends EventEmitter {
      */
     getStatus(): DaemonStatus;
     /**
-     * Schedule a worker to run at intervals
+     * Schedule a worker to run at intervals with staggered start
      */
     private scheduleWorker;
     /**
-     * Execute a worker
+     * Execute a worker with concurrency control (P0 fix)
+     */
+    private executeWorkerWithConcurrencyControl;
+    /**
+     * Execute a worker with timeout protection
      */
     private executeWorker;
+    /**
+     * Run a function with timeout (P1 fix)
+     */
+    private runWithTimeout;
     /**
      * Run the actual worker logic
      */

package/dist/src/services/worker-daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker-daemon.d.ts","sourceRoot":"","sources":["../../../src/services/worker-daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAKtC,MAAM,MAAM,UAAU,GAClB,YAAY,GACZ,UAAU,GACV,aAAa,GACb,SAAS,GACT,OAAO,GACP,KAAK,GACL,SAAS,GACT,UAAU,GACV,UAAU,GACV,UAAU,GACV,WAAW,GACX,UAAU,CAAC;AAEf,UAAU,YAAY;IACpB,IAAI,EAAE,UAAU,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,WAAW;IACnB,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,UAAU,YAAY;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,UAAU,YAAY;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,OAAO,EAAE,GAAG,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IACtC,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,UAAU,YAAY;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAaD;;GAEG;AACH,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,OAAO,CAA2C;IAC1D,OAAO,CAAC,MAAM,CAA8C;IAC5D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAC,CAAO;IACzB,OAAO,CAAC,WAAW,CAAS;gBAEhB,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC;IA0B/D,OAAO,CAAC,sBAAsB;IAuC9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB3B;;OAEG;IACH,SAAS,IAAI,YAAY;IAUzB;;OAEG;IACH,OAAO,CAAC,cAAc;IAgCtB;;OAEG;YACW,aAAa;IA4D3B;;OAEG;YACW,cAAc;YAuBd,YAAY;YAyBZ,cAAc;YAwBd,iBAAiB;YAuBjB,oBAAoB;YAoBpB,iBAAiB;YAoBjB,gBAAgB;YAQhB,iBAAiB;IAQ/B;;OAEG;IACG,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAQ5D;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAmB1D;;OAEG;IACH,OAAO,CAAC,SAAS;IA4BjB;;OAEG;IACH,OAAO,CAAC,GAAG;CAeZ;AAKD;;GAEG;AACH,wBAAgB,SAAS,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAQ5D;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAI5E;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAIhD;AAED,eAAe,YAAY,CAAC"}
+{"version":3,"file":"worker-daemon.d.ts","sourceRoot":"","sources":["../../../src/services/worker-daemon.ts"],"names":[],"mappings":"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"}

package/dist/src/services/worker-daemon.js

@@ -12,16 +12,18 @@
 import { EventEmitter } from 'events';
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 import { join } from 'path';
-// Default worker configurations with intervals
+// Default worker configurations with improved intervals (P0 fix: map 5min -> 15min)
 const DEFAULT_WORKERS = [
-    { type: 'map', intervalMs: 5 * 60 * 1000, priority: 'normal', description: 'Codebase mapping', enabled: true },
-    { type: 'audit', intervalMs: 10 * 60 * 1000, priority: 'critical', description: 'Security analysis', enabled: true },
-    { type: 'optimize', intervalMs: 15 * 60 * 1000, priority: 'high', description: 'Performance optimization', enabled: true },
-    { type: 'consolidate', intervalMs: 30 * 60 * 1000, priority: 'low', description: 'Memory consolidation', enabled: true },
-    { type: 'testgaps', intervalMs: 20 * 60 * 1000, priority: 'normal', description: 'Test coverage analysis', enabled: true },
-    { type: 'predict', intervalMs: 2 * 60 * 1000, priority: 'low', description: 'Predictive preloading', enabled: false },
-    { type: 'document', intervalMs: 60 * 60 * 1000, priority: 'low', description: 'Auto-documentation', enabled: false },
+    { type: 'map', intervalMs: 15 * 60 * 1000, offsetMs: 0, priority: 'normal', description: 'Codebase mapping', enabled: true },
+    { type: 'audit', intervalMs: 10 * 60 * 1000, offsetMs: 2 * 60 * 1000, priority: 'critical', description: 'Security analysis', enabled: true },
+    { type: 'optimize', intervalMs: 15 * 60 * 1000, offsetMs: 4 * 60 * 1000, priority: 'high', description: 'Performance optimization', enabled: true },
+    { type: 'consolidate', intervalMs: 30 * 60 * 1000, offsetMs: 6 * 60 * 1000, priority: 'low', description: 'Memory consolidation', enabled: true },
+    { type: 'testgaps', intervalMs: 20 * 60 * 1000, offsetMs: 8 * 60 * 1000, priority: 'normal', description: 'Test coverage analysis', enabled: true },
+    { type: 'predict', intervalMs: 10 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Predictive preloading', enabled: false },
+    { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
 ];
+// Worker timeout (5 minutes max per worker)
+const DEFAULT_WORKER_TIMEOUT_MS = 5 * 60 * 1000;
 /**
  * Worker Daemon - Manages background workers with Node.js
  */
@@ -32,17 +34,26 @@ export class WorkerDaemon extends EventEmitter {
     running = false;
     startedAt;
     projectRoot;
+    runningWorkers = new Set(); // Track concurrent workers
+    pendingWorkers = []; // Queue for deferred workers
     constructor(projectRoot, config) {
         super();
         this.projectRoot = projectRoot;
         const claudeFlowDir = join(projectRoot, '.claude-flow');
         this.config = {
-            autoStart: config?.autoStart ?? true,
+            autoStart: config?.autoStart ?? false, // P1 fix: Default to false for explicit consent
             logDir: config?.logDir ?? join(claudeFlowDir, 'logs'),
             stateFile: config?.stateFile ?? join(claudeFlowDir, 'daemon-state.json'),
-            maxConcurrent: config?.maxConcurrent ?? 3,
+            maxConcurrent: config?.maxConcurrent ?? 2, // P0 fix: Limit concurrent workers
+            workerTimeoutMs: config?.workerTimeoutMs ?? DEFAULT_WORKER_TIMEOUT_MS,
+            resourceThresholds: config?.resourceThresholds ?? {
+                maxCpuLoad: 2.0,
+                minFreeMemoryPercent: 20,
+            },
             workers: config?.workers ?? DEFAULT_WORKERS,
         };
+        // Setup graceful shutdown handlers
+        this.setupShutdownHandlers();
         // Ensure directories exist
         if (!existsSync(claudeFlowDir)) {
             mkdirSync(claudeFlowDir, { recursive: true });
@@ -53,6 +64,48 @@ export class WorkerDaemon extends EventEmitter {
         // Initialize worker states
         this.initializeWorkerStates();
     }
+    /**
+     * Setup graceful shutdown handlers
+     */
+    setupShutdownHandlers() {
+        const shutdown = async () => {
+            this.log('info', 'Received shutdown signal, stopping daemon...');
+            await this.stop();
+            process.exit(0);
+        };
+        process.on('SIGTERM', shutdown);
+        process.on('SIGINT', shutdown);
+        process.on('SIGHUP', shutdown);
+    }
+    /**
+     * Check if system resources allow worker execution
+     */
+    async canRunWorker() {
+        const os = await import('os');
+        const cpuLoad = os.loadavg()[0];
+        const totalMem = os.totalmem();
+        const freeMem = os.freemem();
+        const freePercent = (freeMem / totalMem) * 100;
+        if (cpuLoad > this.config.resourceThresholds.maxCpuLoad) {
+            return { allowed: false, reason: `CPU load too high: ${cpuLoad.toFixed(2)}` };
+        }
+        if (freePercent < this.config.resourceThresholds.minFreeMemoryPercent) {
+            return { allowed: false, reason: `Memory too low: ${freePercent.toFixed(1)}% free` };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Process pending workers queue
+     */
+    async processPendingWorkers() {
+        while (this.pendingWorkers.length > 0 && this.runningWorkers.size < this.config.maxConcurrent) {
+            const workerType = this.pendingWorkers.shift();
+            const workerConfig = this.config.workers.find(w => w.type === workerType);
+            if (workerConfig) {
+                await this.executeWorkerWithConcurrencyControl(workerConfig);
+            }
+        }
+    }
     initializeWorkerStates() {
         // Try to restore state from file
         if (existsSync(this.config.stateFile)) {
@@ -144,21 +197,24 @@ export class WorkerDaemon extends EventEmitter {
         };
     }
     /**
-     * Schedule a worker to run at intervals
+     * Schedule a worker to run at intervals with staggered start
      */
     scheduleWorker(workerConfig) {
         const state = this.workers.get(workerConfig.type);
-        // Calculate initial delay (run immediately if never run, otherwise respect interval)
-        let initialDelay = 0;
+        const internalConfig = workerConfig;
+        const staggerOffset = internalConfig.offsetMs || 0;
+        // Calculate initial delay with stagger offset
+        let initialDelay = staggerOffset;
         if (state.lastRun) {
             const timeSinceLastRun = Date.now() - state.lastRun.getTime();
-            initialDelay = Math.max(0, workerConfig.intervalMs - timeSinceLastRun);
+            initialDelay = Math.max(staggerOffset, workerConfig.intervalMs - timeSinceLastRun);
         }
         state.nextRun = new Date(Date.now() + initialDelay);
         const runAndReschedule = async () => {
             if (!this.running)
                 return;
-            await this.executeWorker(workerConfig);
+            // Use concurrency-controlled execution (P0 fix)
+            await this.executeWorkerWithConcurrencyControl(workerConfig);
             // Reschedule
             if (this.running) {
                 const timer = setTimeout(runAndReschedule, workerConfig.intervalMs);
@@ -166,24 +222,47 @@ export class WorkerDaemon extends EventEmitter {
                 state.nextRun = new Date(Date.now() + workerConfig.intervalMs);
             }
         };
-        // Schedule first run
+        // Schedule first run with stagger offset
         const timer = setTimeout(runAndReschedule, initialDelay);
         this.timers.set(workerConfig.type, timer);
         this.log('info', `Scheduled ${workerConfig.type} (interval: ${workerConfig.intervalMs / 1000}s, first run in ${initialDelay / 1000}s)`);
     }
     /**
-     * Execute a worker
+     * Execute a worker with concurrency control (P0 fix)
+     */
+    async executeWorkerWithConcurrencyControl(workerConfig) {
+        // Check concurrency limit
+        if (this.runningWorkers.size >= this.config.maxConcurrent) {
+            this.log('info', `Worker ${workerConfig.type} deferred: max concurrent (${this.config.maxConcurrent}) reached`);
+            this.pendingWorkers.push(workerConfig.type);
+            this.emit('worker:deferred', { type: workerConfig.type, reason: 'max_concurrent' });
+            return null;
+        }
+        // Check resource availability
+        const resourceCheck = await this.canRunWorker();
+        if (!resourceCheck.allowed) {
+            this.log('info', `Worker ${workerConfig.type} deferred: ${resourceCheck.reason}`);
+            this.pendingWorkers.push(workerConfig.type);
+            this.emit('worker:deferred', { type: workerConfig.type, reason: resourceCheck.reason });
+            return null;
+        }
+        return this.executeWorker(workerConfig);
+    }
+    /**
+     * Execute a worker with timeout protection
      */
     async executeWorker(workerConfig) {
         const state = this.workers.get(workerConfig.type);
         const workerId = `${workerConfig.type}_${Date.now()}`;
         const startTime = Date.now();
+        // Track running worker
+        this.runningWorkers.add(workerConfig.type);
         state.isRunning = true;
         this.emit('worker:start', { workerId, type: workerConfig.type });
-        this.log('info', `Starting worker: ${workerConfig.type}`);
+        this.log('info', `Starting worker: ${workerConfig.type} (${this.runningWorkers.size}/${this.config.maxConcurrent} concurrent)`);
         try {
-            // Execute worker logic
-            const output = await this.runWorkerLogic(workerConfig);
+            // Execute worker logic with timeout (P1 fix)
+            const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`);
             const durationMs = Date.now() - startTime;
             // Update state
             state.runCount++;
@@ -223,6 +302,30 @@ export class WorkerDaemon extends EventEmitter {
             this.saveState();
             return result;
         }
+        finally {
+            // Remove from running set and process queue
+            this.runningWorkers.delete(workerConfig.type);
+            this.processPendingWorkers();
+        }
+    }
+    /**
+     * Run a function with timeout (P1 fix)
+     */
+    async runWithTimeout(fn, timeoutMs, timeoutMessage) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(timeoutMessage));
+            }, timeoutMs);
+            fn()
+                .then((result) => {
+                clearTimeout(timer);
+                resolve(result);
+            })
+                .catch((error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
     }
     /**
      * Run the actual worker logic