claude-flow 3.10.1 → 3.10.4

package/.claude/worktrees/adr-120-impl/v3/@claude-flow/hooks/src/workers/index.ts

@@ -1,2075 +0,0 @@
-/**
- * V3 Workers System - Cross-Platform Background Workers
- *
- * Optimizes Claude Flow with non-blocking, scheduled workers.
- * Works on Linux, macOS, and Windows.
- */
-
-import { EventEmitter } from 'events';
-import * as os from 'os';
-import * as path from 'path';
-import * as fs from 'fs/promises';
-
-// ============================================================================
-// Security Constants
-// ============================================================================
-
-const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB limit
-const MAX_RECURSION_DEPTH = 20;
-const MAX_CONCURRENCY = 5;
-const MAX_ALERTS = 100;
-const MAX_HISTORY = 1000;
-const FILE_CACHE_TTL = 30_000; // 30 seconds
-
-// Allowed worker names for input validation
-const ALLOWED_WORKERS = new Set([
-  'performance', 'health', 'security', 'adr', 'ddd',
-  'patterns', 'learning', 'cache', 'git', 'swarm', 'v3progress'
-]);
-
-// ============================================================================
-// Security Utilities
-// ============================================================================
-
-/**
- * Validate and resolve a path ensuring it stays within projectRoot
- * Uses realpath to prevent TOCTOU symlink attacks
- */
-async function safePathAsync(projectRoot: string, ...segments: string[]): Promise<string> {
-  const resolved = path.resolve(projectRoot, ...segments);
-
-  try {
-    // Resolve symlinks to prevent TOCTOU attacks
-    const realResolved = await fs.realpath(resolved).catch(() => resolved);
-    const realRoot = await fs.realpath(projectRoot).catch(() => projectRoot);
-
-    if (!realResolved.startsWith(realRoot + path.sep) && realResolved !== realRoot) {
-      throw new Error(`Path traversal blocked: ${realResolved}`);
-    }
-    return realResolved;
-  } catch (error) {
-    // If file doesn't exist yet, validate the parent directory
-    const parent = path.dirname(resolved);
-    const realParent = await fs.realpath(parent).catch(() => parent);
-    const realRoot = await fs.realpath(projectRoot).catch(() => projectRoot);
-
-    if (!realParent.startsWith(realRoot + path.sep) && realParent !== realRoot) {
-      throw new Error(`Path traversal blocked: ${resolved}`);
-    }
-    return resolved;
-  }
-}
-
-/**
- * Synchronous path validation (for non-async contexts)
- */
-function safePath(projectRoot: string, ...segments: string[]): string {
-  const resolved = path.resolve(projectRoot, ...segments);
-  const realRoot = path.resolve(projectRoot);
-
-  if (!resolved.startsWith(realRoot + path.sep) && resolved !== realRoot) {
-    throw new Error(`Path traversal blocked: ${resolved}`);
-  }
-  return resolved;
-}
-
-/**
- * Safe JSON parse that strips dangerous prototype pollution keys
- */
-function safeJsonParse<T>(content: string): T {
-  return JSON.parse(content, (key, value) => {
-    // Strip prototype pollution vectors
-    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
-      return undefined;
-    }
-    return value;
-  });
-}
-
-/**
- * Validate worker name against allowed list
- */
-function isValidWorkerName(name: unknown): name is string {
-  return typeof name === 'string' && (ALLOWED_WORKERS.has(name) || name.startsWith('test-'));
-}
-
-// ============================================================================
-// Pre-compiled Regexes for DDD Pattern Detection (20-40% faster)
-// ============================================================================
-
-const DDD_PATTERNS = {
-  entity: /class\s+\w+Entity\b|interface\s+\w+Entity\b/,
-  valueObject: /class\s+\w+(VO|ValueObject)\b|type\s+\w+VO\s*=/,
-  aggregate: /class\s+\w+Aggregate\b|AggregateRoot/,
-  repository: /class\s+\w+Repository\b|interface\s+I\w+Repository\b/,
-  service: /class\s+\w+Service\b|interface\s+I\w+Service\b/,
-  domainEvent: /class\s+\w+Event\b|DomainEvent/,
-} as const;
-
-// ============================================================================
-// File Cache for Repeated Reads (30-50% I/O reduction)
-// ============================================================================
-
-interface CacheEntry {
-  content: string;
-  expires: number;
-}
-
-const fileCache = new Map<string, CacheEntry>();
-
-async function cachedReadFile(filePath: string): Promise<string> {
-  const cached = fileCache.get(filePath);
-  const now = Date.now();
-
-  if (cached && cached.expires > now) {
-    return cached.content;
-  }
-
-  const content = await fs.readFile(filePath, 'utf-8');
-  fileCache.set(filePath, {
-    content,
-    expires: now + FILE_CACHE_TTL,
-  });
-
-  // Cleanup old entries periodically (keep cache small)
-  if (fileCache.size > 100) {
-    for (const [key, entry] of fileCache) {
-      if (entry.expires < now) {
-        fileCache.delete(key);
-      }
-    }
-  }
-
-  return content;
-}
-
-/**
- * Safe file read with size limit
- */
-async function safeReadFile(filePath: string, maxSize = MAX_FILE_SIZE): Promise<string> {
-  try {
-    const stats = await fs.stat(filePath);
-    if (stats.size > maxSize) {
-      throw new Error(`File too large: ${stats.size} > ${maxSize}`);
-    }
-    return await fs.readFile(filePath, 'utf-8');
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      throw new Error('File not found');
-    }
-    throw error;
-  }
-}
-
-/**
- * Validate project root is a real directory
- */
-async function validateProjectRoot(root: string): Promise<string> {
-  const resolved = path.resolve(root);
-  try {
-    const stats = await fs.stat(resolved);
-    if (!stats.isDirectory()) {
-      throw new Error('Project root must be a directory');
-    }
-    return resolved;
-  } catch {
-    // If we can't validate, use cwd as fallback
-    return process.cwd();
-  }
-}
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface WorkerConfig {
-  name: string;
-  description: string;
-  interval: number;  // milliseconds
-  enabled: boolean;
-  priority: WorkerPriority;
-  timeout: number;
-  platforms?: ('linux' | 'darwin' | 'win32')[];
-}
-
-export enum WorkerPriority {
-  Critical = 0,
-  High = 1,
-  Normal = 2,
-  Low = 3,
-  Background = 4,
-}
-
-export interface WorkerResult {
-  worker: string;
-  success: boolean;
-  duration: number;
-  data?: Record<string, unknown>;
-  error?: string;
-  alerts?: WorkerAlert[];
-  timestamp: Date;
-}
-
-export interface WorkerMetrics {
-  name: string;
-  status: 'running' | 'idle' | 'error' | 'disabled';
-  lastRun?: Date;
-  lastDuration?: number;
-  runCount: number;
-  errorCount: number;
-  avgDuration: number;
-  lastResult?: Record<string, unknown>;
-}
-
-export interface WorkerManagerStatus {
-  running: boolean;
-  platform: string;
-  workers: WorkerMetrics[];
-  uptime: number;
-  totalRuns: number;
-  lastUpdate: Date;
-}
-
-export type WorkerHandler = () => Promise<WorkerResult>;
-
-// ============================================================================
-// Alert System Types
-// ============================================================================
-
-export enum AlertSeverity {
-  Info = 'info',
-  Warning = 'warning',
-  Critical = 'critical',
-}
-
-export interface WorkerAlert {
-  worker: string;
-  severity: AlertSeverity;
-  message: string;
-  metric?: string;
-  value?: number;
-  threshold?: number;
-  timestamp: Date;
-}
-
-export interface AlertThreshold {
-  metric: string;
-  warning: number;
-  critical: number;
-  comparison: 'gt' | 'lt' | 'eq';
-}
-
-export const DEFAULT_THRESHOLDS: Record<string, AlertThreshold[]> = {
-  health: [
-    { metric: 'memory.usedPct', warning: 80, critical: 95, comparison: 'gt' },
-    { metric: 'disk.usedPct', warning: 85, critical: 95, comparison: 'gt' },
-  ],
-  security: [
-    { metric: 'secrets', warning: 1, critical: 5, comparison: 'gt' },
-    { metric: 'vulnerabilities', warning: 10, critical: 50, comparison: 'gt' },
-  ],
-  adr: [
-    { metric: 'compliance', warning: 70, critical: 50, comparison: 'lt' },
-  ],
-  performance: [
-    { metric: 'memory.systemPct', warning: 80, critical: 95, comparison: 'gt' },
-  ],
-};
-
-// ============================================================================
-// Persistence Types
-// ============================================================================
-
-export interface PersistedWorkerState {
-  version: string;
-  lastSaved: string;
-  workers: Record<string, {
-    lastRun?: string;
-    lastResult?: Record<string, unknown>;
-    runCount: number;
-    errorCount: number;
-    avgDuration: number;
-  }>;
-  history: HistoricalMetric[];
-}
-
-export interface HistoricalMetric {
-  timestamp: string;
-  worker: string;
-  metrics: Record<string, number>;
-}
-
-// ============================================================================
-// Statusline Types
-// ============================================================================
-
-export interface StatuslineData {
-  workers: {
-    active: number;
-    total: number;
-    errors: number;
-  };
-  health: {
-    status: 'healthy' | 'warning' | 'critical';
-    memory: number;
-    disk: number;
-  };
-  security: {
-    status: 'clean' | 'warning' | 'critical';
-    issues: number;
-  };
-  adr: {
-    compliance: number;
-  };
-  ddd: {
-    progress: number;
-  };
-  performance: {
-    speedup: string;
-  };
-  alerts: WorkerAlert[];
-  lastUpdate: string;
-}
-
-// ============================================================================
-// Worker Definitions
-// ============================================================================
-
-export const WORKER_CONFIGS: Record<string, WorkerConfig> = {
-  'performance': {
-    name: 'performance',
-    description: 'Benchmark search, memory, startup performance',
-    interval: 300_000,  // 5 min
-    enabled: true,
-    priority: WorkerPriority.Normal,
-    timeout: 30_000,
-  },
-  'health': {
-    name: 'health',
-    description: 'Monitor disk, memory, CPU, processes',
-    interval: 300_000,  // 5 min
-    enabled: true,
-    priority: WorkerPriority.High,
-    timeout: 10_000,
-  },
-  'patterns': {
-    name: 'patterns',
-    description: 'Consolidate, dedupe, optimize learned patterns',
-    interval: 900_000,  // 15 min
-    enabled: true,
-    priority: WorkerPriority.Normal,
-    timeout: 60_000,
-  },
-  'ddd': {
-    name: 'ddd',
-    description: 'Track DDD domain implementation progress',
-    interval: 600_000,  // 10 min
-    enabled: true,
-    priority: WorkerPriority.Low,
-    timeout: 30_000,
-  },
-  'adr': {
-    name: 'adr',
-    description: 'Check ADR compliance across codebase',
-    interval: 900_000,  // 15 min
-    enabled: true,
-    priority: WorkerPriority.Low,
-    timeout: 60_000,
-  },
-  'security': {
-    name: 'security',
-    description: 'Scan for secrets, vulnerabilities, CVEs',
-    interval: 1_800_000,  // 30 min
-    enabled: true,
-    priority: WorkerPriority.High,
-    timeout: 120_000,
-  },
-  'learning': {
-    name: 'learning',
-    description: 'Optimize learning, SONA adaptation',
-    interval: 1_800_000,  // 30 min
-    enabled: true,
-    priority: WorkerPriority.Normal,
-    timeout: 60_000,
-  },
-  'cache': {
-    name: 'cache',
-    description: 'Clean temp files, old logs, stale cache',
-    interval: 3_600_000,  // 1 hour
-    enabled: true,
-    priority: WorkerPriority.Background,
-    timeout: 30_000,
-  },
-  'git': {
-    name: 'git',
-    description: 'Track uncommitted changes, branch status',
-    interval: 300_000,  // 5 min
-    enabled: true,
-    priority: WorkerPriority.Normal,
-    timeout: 10_000,
-  },
-  'swarm': {
-    name: 'swarm',
-    description: 'Monitor swarm activity, agent coordination',
-    interval: 60_000,  // 1 min
-    enabled: true,
-    priority: WorkerPriority.High,
-    timeout: 10_000,
-  },
-};
-
-// ============================================================================
-// Worker Manager with Full Features
-// ============================================================================
-
-const PERSISTENCE_VERSION = '1.0.0';
-const MAX_HISTORY_ENTRIES = 1000;
-const STATUSLINE_UPDATE_INTERVAL = 10_000; // 10 seconds
-
-export class WorkerManager extends EventEmitter {
-  private workers: Map<string, WorkerHandler> = new Map();
-  private metrics: Map<string, WorkerMetrics> = new Map();
-  private timers: Map<string, NodeJS.Timeout> = new Map();
-  private running = false;
-  private startTime?: Date;
-  private projectRoot: string;
-  private metricsDir: string;
-  private persistPath: string;
-  private statuslinePath: string;
-
-  // New features
-  private alerts: WorkerAlert[] = [];
-  private history: HistoricalMetric[] = [];
-  private thresholds: Record<string, AlertThreshold[]> = { ...DEFAULT_THRESHOLDS };
-  private statuslineTimer?: NodeJS.Timeout;
-  private autoSaveTimer?: NodeJS.Timeout;
-  private initialized = false;
-
-  constructor(projectRoot?: string) {
-    super();
-    this.projectRoot = projectRoot || process.cwd();
-    this.metricsDir = path.join(this.projectRoot, '.claude-flow', 'metrics');
-    this.persistPath = path.join(this.metricsDir, 'workers-state.json');
-    this.statuslinePath = path.join(this.metricsDir, 'statusline.json');
-    this.initializeMetrics();
-  }
-
-  private initializeMetrics(): void {
-    for (const [name, config] of Object.entries(WORKER_CONFIGS)) {
-      this.metrics.set(name, {
-        name,
-        status: config.enabled ? 'idle' : 'disabled',
-        runCount: 0,
-        errorCount: 0,
-        avgDuration: 0,
-      });
-    }
-  }
-
-  // =========================================================================
-  // Persistence Methods (using AgentDB-compatible JSON storage)
-  // =========================================================================
-
-  /**
-   * Load persisted state from disk
-   */
-  async loadState(): Promise<boolean> {
-    try {
-      const content = await safeReadFile(this.persistPath, 1024 * 1024); // 1MB limit
-      const state: PersistedWorkerState = safeJsonParse(content);
-
-      if (state.version !== PERSISTENCE_VERSION) {
-        this.emit('persistence:version-mismatch', { expected: PERSISTENCE_VERSION, got: state.version });
-        return false;
-      }
-
-      // Restore metrics
-      for (const [name, data] of Object.entries(state.workers)) {
-        const metrics = this.metrics.get(name);
-        if (metrics) {
-          metrics.runCount = data.runCount;
-          metrics.errorCount = data.errorCount;
-          metrics.avgDuration = data.avgDuration;
-          metrics.lastResult = data.lastResult;
-          if (data.lastRun) {
-            metrics.lastRun = new Date(data.lastRun);
-          }
-        }
-      }
-
-      // Restore history (limit to max entries)
-      this.history = state.history.slice(-MAX_HISTORY_ENTRIES);
-
-      this.emit('persistence:loaded', { workers: Object.keys(state.workers).length });
-      return true;
-    } catch {
-      // No persisted state or invalid - start fresh
-      return false;
-    }
-  }
-
-  /**
-   * Save current state to disk
-   */
-  async saveState(): Promise<void> {
-    try {
-      await this.ensureMetricsDir();
-
-      const state: PersistedWorkerState = {
-        version: PERSISTENCE_VERSION,
-        lastSaved: new Date().toISOString(),
-        workers: {},
-        history: this.history.slice(-MAX_HISTORY_ENTRIES),
-      };
-
-      for (const [name, metrics] of this.metrics.entries()) {
-        state.workers[name] = {
-          lastRun: metrics.lastRun?.toISOString(),
-          lastResult: metrics.lastResult,
-          runCount: metrics.runCount,
-          errorCount: metrics.errorCount,
-          avgDuration: metrics.avgDuration,
-        };
-      }
-
-      await fs.writeFile(this.persistPath, JSON.stringify(state, null, 2));
-      this.emit('persistence:saved');
-    } catch (error) {
-      this.emit('persistence:error', { error });
-    }
-  }
-
-  // =========================================================================
-  // Alert System
-  // =========================================================================
-
-  /**
-   * Check result against thresholds and generate alerts
-   */
-  private checkAlerts(workerName: string, result: WorkerResult): WorkerAlert[] {
-    const alerts: WorkerAlert[] = [];
-    const thresholds = this.thresholds[workerName];
-
-    if (!thresholds || !result.data) return alerts;
-
-    for (const threshold of thresholds) {
-      const rawValue = this.getNestedValue(result.data, threshold.metric);
-      if (rawValue === undefined || rawValue === null) continue;
-      if (typeof rawValue !== 'number') continue;
-
-      const value: number = rawValue;
-      let severity: AlertSeverity | null = null;
-
-      if (threshold.comparison === 'gt') {
-        if (value >= threshold.critical) severity = AlertSeverity.Critical;
-        else if (value >= threshold.warning) severity = AlertSeverity.Warning;
-      } else if (threshold.comparison === 'lt') {
-        if (value <= threshold.critical) severity = AlertSeverity.Critical;
-        else if (value <= threshold.warning) severity = AlertSeverity.Warning;
-      }
-
-      if (severity) {
-        const alert: WorkerAlert = {
-          worker: workerName,
-          severity,
-          message: `${threshold.metric} is ${value} (threshold: ${severity === AlertSeverity.Critical ? threshold.critical : threshold.warning})`,
-          metric: threshold.metric,
-          value: value as number,
-          threshold: severity === AlertSeverity.Critical ? threshold.critical : threshold.warning,
-          timestamp: new Date(),
-        };
-        alerts.push(alert);
-
-        // Ring buffer: remove oldest first to avoid memory spikes
-        if (this.alerts.length >= MAX_ALERTS) {
-          this.alerts.shift();
-        }
-        this.alerts.push(alert);
-
-        this.emit('alert', alert);
-      }
-    }
-
-    return alerts;
-  }
-
-  private getNestedValue(obj: Record<string, unknown>, path: string): unknown {
-    return path.split('.').reduce((acc: unknown, part) => {
-      if (acc && typeof acc === 'object') {
-        return (acc as Record<string, unknown>)[part];
-      }
-      return undefined;
-    }, obj);
-  }
-
-  /**
-   * Set custom alert thresholds
-   */
-  setThresholds(worker: string, thresholds: AlertThreshold[]): void {
-    this.thresholds[worker] = thresholds;
-  }
-
-  /**
-   * Get recent alerts
-   */
-  getAlerts(limit = 20): WorkerAlert[] {
-    return this.alerts.slice(-limit);
-  }
-
-  /**
-   * Clear alerts
-   */
-  clearAlerts(): void {
-    this.alerts = [];
-    this.emit('alerts:cleared');
-  }
-
-  // =========================================================================
-  // Historical Metrics
-  // =========================================================================
-
-  /**
-   * Record metrics to history
-   */
-  private recordHistory(workerName: string, result: WorkerResult): void {
-    if (!result.data) return;
-
-    const metrics: Record<string, number> = {};
-
-    // Extract numeric values from result
-    const extractNumbers = (obj: Record<string, unknown>, prefix = ''): void => {
-      for (const [key, value] of Object.entries(obj)) {
-        const fullKey = prefix ? `${prefix}.${key}` : key;
-        if (typeof value === 'number') {
-          metrics[fullKey] = value;
-        } else if (value && typeof value === 'object' && !Array.isArray(value)) {
-          extractNumbers(value as Record<string, unknown>, fullKey);
-        }
-      }
-    };
-
-    extractNumbers(result.data);
-
-    if (Object.keys(metrics).length > 0) {
-      // Ring buffer: remove oldest first to avoid memory spikes
-      if (this.history.length >= MAX_HISTORY) {
-        this.history.shift();
-      }
-      this.history.push({
-        timestamp: new Date().toISOString(),
-        worker: workerName,
-        metrics,
-      });
-    }
-  }
-
-  /**
-   * Get historical metrics for a worker
-   */
-  getHistory(worker?: string, limit = 100): HistoricalMetric[] {
-    let filtered = this.history;
-    if (worker) {
-      filtered = this.history.filter(h => h.worker === worker);
-    }
-    return filtered.slice(-limit);
-  }
-
-  // =========================================================================
-  // Statusline Integration
-  // =========================================================================
-
-  /**
-   * Generate statusline data
-   */
-  getStatuslineData(): StatuslineData {
-    const workers = Array.from(this.metrics.values());
-    const activeWorkers = workers.filter(w => w.status === 'running').length;
-    const errorWorkers = workers.filter(w => w.status === 'error').length;
-    const totalWorkers = workers.filter(w => w.status !== 'disabled').length;
-
-    // Get latest results
-    const healthResult = this.metrics.get('health')?.lastResult as Record<string, unknown> | undefined;
-    const securityResult = this.metrics.get('security')?.lastResult as Record<string, unknown> | undefined;
-    const adrResult = this.metrics.get('adr')?.lastResult as Record<string, unknown> | undefined;
-    const dddResult = this.metrics.get('ddd')?.lastResult as Record<string, unknown> | undefined;
-    const perfResult = this.metrics.get('performance')?.lastResult as Record<string, unknown> | undefined;
-
-    return {
-      workers: {
-        active: activeWorkers,
-        total: totalWorkers,
-        errors: errorWorkers,
-      },
-      health: {
-        status: healthResult?.status as 'healthy' | 'warning' | 'critical' ?? 'healthy',
-        memory: (healthResult?.memory as Record<string, unknown>)?.usedPct as number ?? 0,
-        disk: (healthResult?.disk as Record<string, unknown>)?.usedPct as number ?? 0,
-      },
-      security: {
-        status: securityResult?.status as 'clean' | 'warning' | 'critical' ?? 'clean',
-        issues: securityResult?.totalIssues as number ?? 0,
-      },
-      adr: {
-        compliance: adrResult?.compliance as number ?? 0,
-      },
-      ddd: {
-        progress: dddResult?.progress as number ?? 0,
-      },
-      performance: {
-        speedup: perfResult?.speedup as string ?? '1.0x',
-      },
-      alerts: this.alerts.filter(a => a.severity === AlertSeverity.Critical).slice(-5),
-      lastUpdate: new Date().toISOString(),
-    };
-  }
-
-  /**
-   * Export statusline data to file (for shell consumption)
-   */
-  async exportStatusline(): Promise<void> {
-    try {
-      const data = this.getStatuslineData();
-      await fs.writeFile(this.statuslinePath, JSON.stringify(data, null, 2));
-      this.emit('statusline:exported');
-    } catch {
-      // Ignore export errors
-    }
-  }
-
-  /**
-   * Generate shell-compatible statusline string
-   */
-  getStatuslineString(): string {
-    const data = this.getStatuslineData();
-    const parts: string[] = [];
-
-    // Workers status
-    parts.push(`👷${data.workers.active}/${data.workers.total}`);
-
-    // Health
-    const healthIcon = data.health.status === 'critical' ? '🔴' :
-                       data.health.status === 'warning' ? '🟡' : '🟢';
-    parts.push(`${healthIcon}${data.health.memory}%`);
-
-    // Security
-    const secIcon = data.security.status === 'critical' ? '🚨' :
-                    data.security.status === 'warning' ? '⚠️' : '🛡️';
-    parts.push(`${secIcon}${data.security.issues}`);
-
-    // ADR Compliance
-    parts.push(`📋${data.adr.compliance}%`);
-
-    // DDD Progress
-    parts.push(`🏗️${data.ddd.progress}%`);
-
-    // Performance
-    parts.push(`⚡${data.performance.speedup}`);
-
-    return parts.join(' │ ');
-  }
-
-  // =========================================================================
-  // Core Worker Methods
-  // =========================================================================
-
-  /**
-   * Register a worker handler
-   * Optionally pass config; if not provided, a default config is used for dynamically registered workers
-   */
-  register(name: string, handler: WorkerHandler, config?: Partial<WorkerConfig>): void {
-    this.workers.set(name, handler);
-
-    // Create config if not in WORKER_CONFIGS (for dynamic/test workers)
-    if (!WORKER_CONFIGS[name]) {
-      (WORKER_CONFIGS as Record<string, WorkerConfig>)[name] = {
-        name,
-        description: config?.description ?? `Dynamic worker: ${name}`,
-        interval: config?.interval ?? 60_000,
-        enabled: config?.enabled ?? true,
-        priority: config?.priority ?? WorkerPriority.Normal,
-        timeout: config?.timeout ?? 30_000,
-      };
-    }
-
-    // Initialize metrics if not already present
-    if (!this.metrics.has(name)) {
-      this.metrics.set(name, {
-        name,
-        status: 'idle',
-        runCount: 0,
-        errorCount: 0,
-        avgDuration: 0,
-      });
-    }
-
-    this.emit('worker:registered', { name });
-  }
-
-  /**
-   * Initialize and start workers (loads persisted state)
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) return;
-
-    await this.ensureMetricsDir();
-    await this.loadState();
-
-    this.initialized = true;
-    this.emit('manager:initialized');
-  }
-
-  /**
-   * Start all workers with scheduling
-   */
-  async start(options?: { autoSave?: boolean; statuslineUpdate?: boolean }): Promise<void> {
-    if (this.running) return;
-
-    if (!this.initialized) {
-      await this.initialize();
-    }
-
-    this.running = true;
-    this.startTime = new Date();
-
-    // Schedule all workers
-    for (const [name, config] of Object.entries(WORKER_CONFIGS)) {
-      if (!config.enabled) continue;
-      if (config.platforms && !config.platforms.includes(os.platform() as any)) continue;
-
-      this.scheduleWorker(name, config);
-    }
-
-    // Auto-save every 5 minutes
-    if (options?.autoSave !== false) {
-      this.autoSaveTimer = setInterval(() => {
-        this.saveState().catch(() => {});
-      }, 300_000);
-    }
-
-    // Update statusline file periodically
-    if (options?.statuslineUpdate !== false) {
-      this.statuslineTimer = setInterval(() => {
-        this.exportStatusline().catch(() => {});
-      }, STATUSLINE_UPDATE_INTERVAL);
-    }
-
-    this.emit('manager:started');
-  }
-
-  /**
-   * Stop all workers and save state
-   */
-  async stop(): Promise<void> {
-    this.running = false;
-
-    // Clear all timers
-    Array.from(this.timers.values()).forEach(timer => {
-      clearTimeout(timer);
-    });
-    this.timers.clear();
-
-    if (this.autoSaveTimer) {
-      clearInterval(this.autoSaveTimer);
-      this.autoSaveTimer = undefined;
-    }
-
-    if (this.statuslineTimer) {
-      clearInterval(this.statuslineTimer);
-      this.statuslineTimer = undefined;
-    }
-
-    // Save final state
-    await this.saveState();
-    await this.exportStatusline();
-
-    this.emit('manager:stopped');
-  }
-
-  /**
-   * Run a specific worker immediately
-   */
-  async runWorker(name: string): Promise<WorkerResult> {
-    const handler = this.workers.get(name);
-    const config = WORKER_CONFIGS[name];
-    const metrics = this.metrics.get(name);
-
-    if (!handler || !config || !metrics) {
-      return {
-        worker: name,
-        success: false,
-        duration: 0,
-        error: `Worker '${name}' not found`,
-        timestamp: new Date(),
-      };
-    }
-
-    metrics.status = 'running';
-    const startTime = Date.now();
-
-    try {
-      const result = await Promise.race([
-        handler(),
-        new Promise<WorkerResult>((_, reject) =>
-          setTimeout(() => reject(new Error('Timeout')), config.timeout)
-        ),
-      ]);
-
-      const duration = Date.now() - startTime;
-
-      metrics.status = 'idle';
-      metrics.lastRun = new Date();
-      metrics.lastDuration = duration;
-      metrics.runCount++;
-      metrics.avgDuration = (metrics.avgDuration * (metrics.runCount - 1) + duration) / metrics.runCount;
-      metrics.lastResult = result.data;
-
-      // Check alerts and record history
-      const alerts = this.checkAlerts(name, result);
-      result.alerts = alerts;
-      this.recordHistory(name, result);
-
-      this.emit('worker:completed', { name, result, duration, alerts });
-
-      return result;
-    } catch (error) {
-      const duration = Date.now() - startTime;
-
-      metrics.status = 'error';
-      metrics.errorCount++;
-      metrics.lastRun = new Date();
-
-      const result: WorkerResult = {
-        worker: name,
-        success: false,
-        duration,
-        error: error instanceof Error ? error.message : String(error),
-        timestamp: new Date(),
-      };
-
-      this.emit('worker:error', { name, error, duration });
-
-      return result;
-    }
-  }
-
-  /**
-   * Run all workers (non-blocking with concurrency limit)
-   */
-  async runAll(concurrency = MAX_CONCURRENCY): Promise<WorkerResult[]> {
-    const workers = Array.from(this.workers.keys());
-    const results: WorkerResult[] = [];
-
-    // Process in batches to limit concurrency
-    for (let i = 0; i < workers.length; i += concurrency) {
-      const batch = workers.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(name => this.runWorker(name))
-      );
-      results.push(...batchResults);
-    }
-
-    return results;
-  }
-
-  /**
-   * Get worker status
-   */
-  getStatus(): WorkerManagerStatus {
-    return {
-      running: this.running,
-      platform: os.platform(),
-      workers: Array.from(this.metrics.values()),
-      uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
-      totalRuns: Array.from(this.metrics.values()).reduce((sum, m) => sum + m.runCount, 0),
-      lastUpdate: new Date(),
-    };
-  }
-
-  /**
-   * Get statusline-friendly metrics
-   */
-  getStatuslineMetrics(): Record<string, unknown> {
-    const workers = Array.from(this.metrics.values());
-    const running = workers.filter(w => w.status === 'running').length;
-    const errors = workers.filter(w => w.status === 'error').length;
-    const total = workers.filter(w => w.status !== 'disabled').length;
-
-    return {
-      workersActive: running,
-      workersTotal: total,
-      workersError: errors,
-      lastResults: Object.fromEntries(
-        workers
-          .filter(w => w.lastResult)
-          .map(w => [w.name, w.lastResult])
-      ),
-    };
-  }
-
-  private scheduleWorker(name: string, config: WorkerConfig): void {
-    const run = async () => {
-      if (!this.running) return;
-
-      await this.runWorker(name);
-
-      if (this.running) {
-        this.timers.set(name, setTimeout(run, config.interval));
-      }
-    };
-
-    // Initial run with staggered start
-    const stagger = config.priority * 1000;
-    this.timers.set(name, setTimeout(run, stagger));
-  }
-
-  private async ensureMetricsDir(): Promise<void> {
-    try {
-      await fs.mkdir(this.metricsDir, { recursive: true });
-    } catch {
-      // Directory may already exist
-    }
-  }
-}
-
-// ============================================================================
-// Built-in Worker Implementations
-// ============================================================================
-
-export function createPerformanceWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    // Cross-platform memory check
-    const memUsage = process.memoryUsage();
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const memPct = Math.round((1 - freeMem / totalMem) * 100);
-
-    // CPU load
-    const cpus = os.cpus();
-    const loadAvg = os.loadavg()[0];
-
-    // V3 codebase stats
-    let v3Lines = 0;
-    try {
-      const v3Path = path.join(projectRoot, 'v3');
-      v3Lines = await countLines(v3Path, '.ts');
-    } catch {
-      // V3 dir may not exist
-    }
-
-    return {
-      worker: 'performance',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: {
-        memory: {
-          heapUsed: Math.round(memUsage.heapUsed / 1024 / 1024),
-          heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024),
-          systemPct: memPct,
-        },
-        cpu: {
-          cores: cpus.length,
-          loadAvg: loadAvg.toFixed(2),
-        },
-        codebase: {
-          v3Lines,
-        },
-        speedup: '1.0x',  // Placeholder
-      },
-    };
-  };
-}
-
-export function createHealthWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const memPct = Math.round((1 - freeMem / totalMem) * 100);
-
-    const uptime = os.uptime();
-    const loadAvg = os.loadavg();
-
-    // Disk space (cross-platform approximation)
-    let diskPct = 0;
-    let diskFree = 'N/A';
-    try {
-      const stats = await fs.statfs(projectRoot);
-      diskPct = Math.round((1 - stats.bavail / stats.blocks) * 100);
-      diskFree = `${Math.round(stats.bavail * stats.bsize / 1024 / 1024 / 1024)}GB`;
-    } catch {
-      // statfs may not be available on all platforms
-    }
-
-    const status = memPct > 90 || diskPct > 90 ? 'critical' :
-                   memPct > 80 || diskPct > 80 ? 'warning' : 'healthy';
-
-    return {
-      worker: 'health',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: {
-        status,
-        memory: { usedPct: memPct, freeMB: Math.round(freeMem / 1024 / 1024) },
-        disk: { usedPct: diskPct, free: diskFree },
-        system: {
-          uptime: Math.round(uptime / 3600),
-          loadAvg: loadAvg.map(l => l.toFixed(2)),
-          platform: os.platform(),
-          arch: os.arch(),
-        },
-      },
-    };
-  };
-}
-
-export function createSwarmWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    // Check for swarm activity file
-    const activityPath = path.join(projectRoot, '.claude-flow', 'metrics', 'swarm-activity.json');
-    let swarmData: Record<string, unknown> = {};
-
-    try {
-      const content = await fs.readFile(activityPath, 'utf-8');
-      swarmData = safeJsonParse(content);
-    } catch {
-      // No activity file
-    }
-
-    // Check for queue messages
-    const queuePath = path.join(projectRoot, '.claude-flow', 'swarm', 'queue');
-    let queueCount = 0;
-    try {
-      const files = await fs.readdir(queuePath);
-      queueCount = files.filter(f => f.endsWith('.json')).length;
-    } catch {
-      // No queue dir
-    }
-
-    return {
-      worker: 'swarm',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: {
-        active: (swarmData as any)?.swarm?.active ?? false,
-        agentCount: (swarmData as any)?.swarm?.agent_count ?? 0,
-        queuePending: queueCount,
-        lastUpdate: (swarmData as any)?.timestamp ?? null,
-      },
-    };
-  };
-}
-
-export function createGitWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-    const { exec } = await import('child_process');
-    const { promisify } = await import('util');
-    const execAsync = promisify(exec);
-
-    let gitData: Record<string, unknown> = {
-      available: false,
-    };
-
-    try {
-      const [branch, status, log] = await Promise.all([
-        execAsync('git branch --show-current', { cwd: projectRoot }),
-        execAsync('git status --porcelain', { cwd: projectRoot }),
-        execAsync('git log -1 --format=%H', { cwd: projectRoot }),
-      ]);
-
-      const changes = status.stdout.trim().split('\n').filter(Boolean);
-
-      gitData = {
-        available: true,
-        branch: branch.stdout.trim(),
-        uncommitted: changes.length,
-        lastCommit: log.stdout.trim().slice(0, 7),
-        staged: changes.filter(c => c.startsWith('A ') || c.startsWith('M ')).length,
-        modified: changes.filter(c => c.startsWith(' M') || c.startsWith('??')).length,
-      };
-    } catch {
-      // Git not available or not a repo
-    }
-
-    return {
-      worker: 'git',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: gitData,
-    };
-  };
-}
-
-export function createLearningWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    const patternsDbPath = path.join(projectRoot, '.claude-flow', 'learning', 'patterns.db');
-    let learningData: Record<string, unknown> = {
-      patternsDb: false,
-      shortTerm: 0,
-      longTerm: 0,
-      avgQuality: 0,
-    };
-
-    try {
-      await fs.access(patternsDbPath);
-      learningData.patternsDb = true;
-
-      // Read learning metrics if available
-      const metricsPath = path.join(projectRoot, '.claude-flow', 'metrics', 'learning.json');
-      try {
-        const content = await fs.readFile(metricsPath, 'utf-8');
-        const metrics = safeJsonParse<Record<string, unknown>>(content);
-        const patterns = metrics.patterns as Record<string, unknown> | undefined;
-        const routing = metrics.routing as Record<string, unknown> | undefined;
-        const intelligence = metrics.intelligence as Record<string, unknown> | undefined;
-        learningData = {
-          ...learningData,
-          shortTerm: (patterns?.shortTerm as number) ?? 0,
-          longTerm: (patterns?.longTerm as number) ?? 0,
-          avgQuality: (patterns?.avgQuality as number) ?? 0,
-          routingAccuracy: (routing?.accuracy as number) ?? 0,
-          intelligenceScore: (intelligence?.score as number) ?? 0,
-        };
-      } catch {
-        // No metrics file
-      }
-    } catch {
-      // No patterns DB
-    }
-
-    return {
-      worker: 'learning',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: learningData,
-    };
-  };
-}
-
-export function createADRWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    const adrChecks: Record<string, { compliant: boolean; reason?: string }> = {};
-    const v3Path = path.join(projectRoot, 'v3');
-    const dddDomains = ['agent-lifecycle', 'task-execution', 'memory-management', 'coordination'];
-
-    // Run all ADR checks in parallel for 60-80% speedup
-    const [
-      adr001Result,
-      adr002Results,
-      adr005Result,
-      adr006Result,
-      adr008Result,
-      adr011Result,
-      adr012Result,
-    ] = await Promise.all([
-      // ADR-001: agentic-flow integration
-      fs.readFile(path.join(v3Path, 'package.json'), 'utf-8')
-        .then(content => {
-          const pkg = safeJsonParse<Record<string, unknown>>(content);
-          return {
-            compliant: pkg.dependencies?.['agentic-flow'] !== undefined ||
-                       pkg.devDependencies?.['agentic-flow'] !== undefined,
-            reason: 'agentic-flow dependency',
-          };
-        })
-        .catch(() => ({ compliant: false, reason: 'Package not found' })),
-
-      // ADR-002: DDD domains (parallel check)
-      Promise.allSettled(
-        dddDomains.map(d => fs.access(path.join(v3Path, '@claude-flow', d)))
-      ),
-
-      // ADR-005: MCP-first design
-      fs.access(path.join(v3Path, '@claude-flow', 'mcp'))
-        .then(() => ({ compliant: true, reason: 'MCP package exists' }))
-        .catch(() => ({ compliant: false, reason: 'No MCP package' })),
-
-      // ADR-006: Memory unification
-      fs.access(path.join(v3Path, '@claude-flow', 'memory'))
-        .then(() => ({ compliant: true, reason: 'Memory package exists' }))
-        .catch(() => ({ compliant: false, reason: 'No memory package' })),
-
-      // ADR-008: Vitest over Jest
-      fs.readFile(path.join(projectRoot, 'package.json'), 'utf-8')
-        .then(content => {
-          const pkg = safeJsonParse<Record<string, unknown>>(content);
-          const hasVitest = (pkg.devDependencies as Record<string, unknown>)?.vitest !== undefined;
-          return { compliant: hasVitest, reason: hasVitest ? 'Vitest found' : 'No Vitest' };
-        })
-        .catch(() => ({ compliant: false, reason: 'Package not readable' })),
-
-      // ADR-011: LLM Provider System
-      fs.access(path.join(v3Path, '@claude-flow', 'providers'))
-        .then(() => ({ compliant: true, reason: 'Providers package exists' }))
-        .catch(() => ({ compliant: false, reason: 'No providers package' })),
-
-      // ADR-012: MCP Security
-      fs.readFile(path.join(v3Path, '@claude-flow', 'mcp', 'src', 'index.ts'), 'utf-8')
-        .then(content => {
-          const hasRateLimiter = content.includes('RateLimiter');
-          const hasOAuth = content.includes('OAuth');
-          const hasSchemaValidator = content.includes('validateSchema');
-          return {
-            compliant: hasRateLimiter && hasOAuth && hasSchemaValidator,
-            reason: `Rate:${hasRateLimiter} OAuth:${hasOAuth} Schema:${hasSchemaValidator}`,
-          };
-        })
-        .catch(() => ({ compliant: false, reason: 'MCP index not readable' })),
-    ]);
-
-    // Process results
-    adrChecks['ADR-001'] = adr001Result;
-
-    const dddCount = adr002Results.filter(r => r.status === 'fulfilled').length;
-    adrChecks['ADR-002'] = {
-      compliant: dddCount >= 2,
-      reason: `${dddCount}/${dddDomains.length} domains`,
-    };
-
-    adrChecks['ADR-005'] = adr005Result;
-    adrChecks['ADR-006'] = adr006Result;
-    adrChecks['ADR-008'] = adr008Result;
-    adrChecks['ADR-011'] = adr011Result;
-    adrChecks['ADR-012'] = adr012Result;
-
-    const compliantCount = Object.values(adrChecks).filter(c => c.compliant).length;
-    const totalCount = Object.keys(adrChecks).length;
-
-    // Save results
-    try {
-      const outputPath = path.join(projectRoot, '.claude-flow', 'metrics', 'adr-compliance.json');
-      await fs.writeFile(outputPath, JSON.stringify({
-        timestamp: new Date().toISOString(),
-        compliance: Math.round((compliantCount / totalCount) * 100),
-        checks: adrChecks,
-      }, null, 2));
-    } catch {
-      // Ignore write errors
-    }
-
-    return {
-      worker: 'adr',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: {
-        compliance: Math.round((compliantCount / totalCount) * 100),
-        compliant: compliantCount,
-        total: totalCount,
-        checks: adrChecks,
-      },
-    };
-  };
-}
-
-export function createDDDWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    const v3Path = path.join(projectRoot, 'v3');
-    const dddMetrics: Record<string, Record<string, number>> = {};
-    let totalScore = 0;
-    let maxScore = 0;
-
-    const modules = [
-      '@claude-flow/hooks',
-      '@claude-flow/mcp',
-      '@claude-flow/integration',
-      '@claude-flow/providers',
-      '@claude-flow/memory',
-      '@claude-flow/security',
-    ];
-
-    // Process all modules in parallel for 70-90% speedup
-    const moduleResults = await Promise.all(
-      modules.map(async (mod) => {
-        const modPath = path.join(v3Path, mod);
-        const modMetrics: Record<string, number> = {
-          entities: 0,
-          valueObjects: 0,
-          aggregates: 0,
-          repositories: 0,
-          services: 0,
-          domainEvents: 0,
-        };
-
-        try {
-          await fs.access(modPath);
-
-          // Count DDD patterns by searching for common patterns
-          const srcPath = path.join(modPath, 'src');
-          const patterns = await searchDDDPatterns(srcPath);
-          Object.assign(modMetrics, patterns);
-
-          // Calculate score (simple heuristic)
-          const modScore = patterns.entities * 2 + patterns.valueObjects +
-                          patterns.aggregates * 3 + patterns.repositories * 2 +
-                          patterns.services + patterns.domainEvents * 2;
-
-          return { mod, modMetrics, modScore, exists: true };
-        } catch {
-          return { mod, modMetrics, modScore: 0, exists: false };
-        }
-      })
-    );
-
-    // Aggregate results
-    for (const result of moduleResults) {
-      if (result.exists) {
-        dddMetrics[result.mod] = result.modMetrics;
-        totalScore += result.modScore;
-        maxScore += 20;
-      }
-    }
-
-    const progressPct = maxScore > 0 ? Math.min(100, Math.round((totalScore / maxScore) * 100)) : 0;
-
-    // Save metrics
-    try {
-      const outputPath = path.join(projectRoot, '.claude-flow', 'metrics', 'ddd-progress.json');
-      await fs.writeFile(outputPath, JSON.stringify({
-        timestamp: new Date().toISOString(),
-        progress: progressPct,
-        score: totalScore,
-        maxScore,
-        modules: dddMetrics,
-      }, null, 2));
-    } catch {
-      // Ignore write errors
-    }
-
-    return {
-      worker: 'ddd',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: {
-        progress: progressPct,
-        score: totalScore,
-        maxScore,
-        modulesTracked: Object.keys(dddMetrics).length,
-        modules: dddMetrics,
-      },
-    };
-  };
-}
-
-export function createSecurityWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    const findings: Record<string, number> = {
-      secrets: 0,
-      vulnerabilities: 0,
-      insecurePatterns: 0,
-    };
-
-    // Secret patterns to scan for
-    const secretPatterns = [
-      /password\s*[=:]\s*["'][^"']+["']/gi,
-      /api[_-]?key\s*[=:]\s*["'][^"']+["']/gi,
-      /secret\s*[=:]\s*["'][^"']+["']/gi,
-      /token\s*[=:]\s*["'][^"']+["']/gi,
-      /private[_-]?key/gi,
-    ];
-
-    // Vulnerable patterns (more specific to reduce false positives)
-    const vulnPatterns = [
-      /\beval\s*\([^)]*\buser/gi,     // eval with user input
-      /\beval\s*\([^)]*\breq\./gi,    // eval with request data
-      /new\s+Function\s*\([^)]*\+/gi, // Function constructor with concatenation
-      /innerHTML\s*=\s*[^"'`]/gi,     // innerHTML with variable
-      /dangerouslySetInnerHTML/gi,    // React unsafe pattern
-    ];
-
-    // Scan v3 and src directories
-    const dirsToScan = [
-      path.join(projectRoot, 'v3'),
-      path.join(projectRoot, 'src'),
-    ];
-
-    for (const dir of dirsToScan) {
-      try {
-        await fs.access(dir);
-        const results = await scanDirectoryForPatterns(dir, secretPatterns, vulnPatterns);
-        findings.secrets += results.secrets;
-        findings.vulnerabilities += results.vulnerabilities;
-      } catch {
-        // Directory doesn't exist
-      }
-    }
-
-    const totalIssues = findings.secrets + findings.vulnerabilities + findings.insecurePatterns;
-    const status = totalIssues > 10 ? 'critical' :
-                   totalIssues > 0 ? 'warning' : 'clean';
-
-    // Save results
-    try {
-      const outputPath = path.join(projectRoot, '.claude-flow', 'security', 'scan-results.json');
-      await fs.mkdir(path.dirname(outputPath), { recursive: true });
-      await fs.writeFile(outputPath, JSON.stringify({
-        timestamp: new Date().toISOString(),
-        status,
-        findings,
-        totalIssues,
-        cves: {
-          tracked: ['CVE-MCP-1', 'CVE-MCP-2', 'CVE-MCP-3', 'CVE-MCP-4', 'CVE-MCP-5', 'CVE-MCP-6', 'CVE-MCP-7'],
-          remediated: 7,
-        },
-      }, null, 2));
-    } catch {
-      // Ignore write errors
-    }
-
-    return {
-      worker: 'security',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: {
-        status,
-        secrets: findings.secrets,
-        vulnerabilities: findings.vulnerabilities,
-        totalIssues,
-        cvesRemediated: 7,
-      },
-    };
-  };
-}
-
-export function createPatternsWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    const learningDir = path.join(projectRoot, '.claude-flow', 'learning');
-    let patternsData: Record<string, unknown> = {
-      shortTerm: 0,
-      longTerm: 0,
-      duplicates: 0,
-      consolidated: 0,
-    };
-
-    try {
-      // Read patterns from storage
-      const patternsFile = path.join(learningDir, 'patterns.json');
-      const content = await fs.readFile(patternsFile, 'utf-8');
-      const patterns = safeJsonParse<Record<string, unknown>>(content);
-
-      const shortTerm = (patterns.shortTerm as Array<{ strategy?: string; quality?: number }>) || [];
-      const longTerm = (patterns.longTerm as Array<{ strategy?: string; quality?: number }>) || [];
-
-      // Find duplicates by strategy name
-      const seenStrategies = new Set<string>();
-      let duplicates = 0;
-
-      for (const pattern of [...shortTerm, ...longTerm]) {
-        const strategy = pattern?.strategy;
-        if (strategy && seenStrategies.has(strategy)) {
-          duplicates++;
-        } else if (strategy) {
-          seenStrategies.add(strategy);
-        }
-      }
-
-      patternsData = {
-        shortTerm: shortTerm.length,
-        longTerm: longTerm.length,
-        duplicates,
-        uniqueStrategies: seenStrategies.size,
-        avgQuality: calculateAvgQuality([...shortTerm, ...longTerm]),
-      };
-
-      // Write consolidated metrics
-      const metricsPath = path.join(projectRoot, '.claude-flow', 'metrics', 'patterns.json');
-      await fs.writeFile(metricsPath, JSON.stringify({
-        timestamp: new Date().toISOString(),
-        ...patternsData,
-      }, null, 2));
-
-    } catch {
-      // No patterns file
-    }
-
-    return {
-      worker: 'patterns',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: patternsData,
-    };
-  };
-}
-
-export function createCacheWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-
-    let cleaned = 0;
-    let freedBytes = 0;
-
-    // Only clean directories within .claude-flow (safe)
-    const safeCleanDirs = [
-      '.claude-flow/cache',
-      '.claude-flow/temp',
-    ];
-
-    const maxAgeMs = 7 * 24 * 60 * 60 * 1000; // 7 days
-    const now = Date.now();
-
-    for (const relDir of safeCleanDirs) {
-      try {
-        // Security: Validate path is within project root
-        const dir = safePath(projectRoot, relDir);
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-
-        for (const entry of entries) {
-          // Security: Skip symlinks and hidden files
-          if (entry.isSymbolicLink() || entry.name.startsWith('.')) {
-            continue;
-          }
-
-          const entryPath = path.join(dir, entry.name);
-
-          // Security: Double-check path is still within bounds
-          try {
-            safePath(projectRoot, relDir, entry.name);
-          } catch {
-            continue; // Skip if path validation fails
-          }
-
-          try {
-            const stat = await fs.stat(entryPath);
-            const age = now - stat.mtimeMs;
-
-            if (age > maxAgeMs) {
-              freedBytes += stat.size;
-              await fs.rm(entryPath, { recursive: true, force: true });
-              cleaned++;
-            }
-          } catch {
-            // Skip entries we can't stat
-          }
-        }
-      } catch {
-        // Directory doesn't exist
-      }
-    }
-
-    return {
-      worker: 'cache',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: {
-        cleaned,
-        freedMB: Math.round(freedBytes / 1024 / 1024),
-        maxAgedays: 7,
-      },
-    };
-  };
-}
-
-// ============================================================================
-// Utility Functions
-// ============================================================================
-
-async function countLines(dir: string, ext: string): Promise<number> {
-  let total = 0;
-
-  try {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-
-      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-        total += await countLines(fullPath, ext);
-      } else if (entry.isFile() && entry.name.endsWith(ext)) {
-        const content = await fs.readFile(fullPath, 'utf-8');
-        total += content.split('\n').length;
-      }
-    }
-  } catch {
-    // Directory doesn't exist or can't be read
-  }
-
-  return total;
-}
-
-async function searchDDDPatterns(srcPath: string): Promise<Record<string, number>> {
-  const patterns = {
-    entities: 0,
-    valueObjects: 0,
-    aggregates: 0,
-    repositories: 0,
-    services: 0,
-    domainEvents: 0,
-  };
-
-  try {
-    const files = await collectFiles(srcPath, '.ts');
-
-    // Process files in batches for better I/O performance
-    const BATCH_SIZE = 10;
-    for (let i = 0; i < files.length; i += BATCH_SIZE) {
-      const batch = files.slice(i, i + BATCH_SIZE);
-      const contents = await Promise.all(
-        batch.map(file => cachedReadFile(file).catch(() => ''))
-      );
-
-      for (const content of contents) {
-        if (!content) continue;
-
-        // Use pre-compiled regexes (no /g flag to avoid state issues)
-        if (DDD_PATTERNS.entity.test(content)) patterns.entities++;
-        if (DDD_PATTERNS.valueObject.test(content)) patterns.valueObjects++;
-        if (DDD_PATTERNS.aggregate.test(content)) patterns.aggregates++;
-        if (DDD_PATTERNS.repository.test(content)) patterns.repositories++;
-        if (DDD_PATTERNS.service.test(content)) patterns.services++;
-        if (DDD_PATTERNS.domainEvent.test(content)) patterns.domainEvents++;
-      }
-    }
-  } catch {
-    // Ignore errors
-  }
-
-  return patterns;
-}
-
-async function collectFiles(dir: string, ext: string, depth = 0): Promise<string[]> {
-  // Security: Prevent infinite recursion
-  if (depth > MAX_RECURSION_DEPTH) {
-    return [];
-  }
-
-  const files: string[] = [];
-
-  try {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-
-      // Skip symlinks to prevent traversal attacks
-      if (entry.isSymbolicLink()) {
-        continue;
-      }
-
-      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-        const subFiles = await collectFiles(fullPath, ext, depth + 1);
-        files.push(...subFiles);
-      } else if (entry.isFile() && entry.name.endsWith(ext)) {
-        files.push(fullPath);
-      }
-    }
-  } catch {
-    // Directory doesn't exist
-  }
-
-  return files;
-}
-
-async function scanDirectoryForPatterns(
-  dir: string,
-  secretPatterns: RegExp[],
-  vulnPatterns: RegExp[]
-): Promise<{ secrets: number; vulnerabilities: number }> {
-  let secrets = 0;
-  let vulnerabilities = 0;
-
-  try {
-    const files = await collectFiles(dir, '.ts');
-    files.push(...await collectFiles(dir, '.js'));
-
-    for (const file of files) {
-      // Skip test files and node_modules
-      if (file.includes('node_modules') || file.includes('.test.') || file.includes('.spec.')) {
-        continue;
-      }
-
-      const content = await fs.readFile(file, 'utf-8');
-
-      for (const pattern of secretPatterns) {
-        const matches = content.match(pattern);
-        if (matches) {
-          secrets += matches.length;
-        }
-      }
-
-      for (const pattern of vulnPatterns) {
-        const matches = content.match(pattern);
-        if (matches) {
-          vulnerabilities += matches.length;
-        }
-      }
-    }
-  } catch {
-    // Ignore errors
-  }
-
-  return { secrets, vulnerabilities };
-}
-
-function calculateAvgQuality(patterns: Array<{ quality?: number }>): number {
-  if (patterns.length === 0) return 0;
-
-  const sum = patterns.reduce((acc, p) => acc + (p.quality ?? 0), 0);
-  return Math.round((sum / patterns.length) * 100) / 100;
-}
-
-// ============================================================================
-// V3 Progress Worker - Accurate Implementation Metrics
-// ============================================================================
-
-/**
- * Creates a worker that calculates accurate V3 implementation progress.
- * Counts actual CLI commands, MCP tools, hooks, and packages.
- * Writes to v3-progress.json for statusline display.
- */
-export function createV3ProgressWorker(projectRoot: string): WorkerHandler {
-  return async (): Promise<WorkerResult> => {
-    const startTime = Date.now();
-    const v3Path = path.join(projectRoot, 'v3');
-    const cliPath = path.join(v3Path, '@claude-flow', 'cli', 'src');
-
-    // Count CLI commands (excluding index.ts)
-    let cliCommands = 0;
-    try {
-      const commandsPath = path.join(cliPath, 'commands');
-      const cmdFiles = await fs.readdir(commandsPath);
-      cliCommands = cmdFiles.filter(f => f.endsWith('.ts') && f !== 'index.ts').length;
-    } catch {
-      cliCommands = 28; // Known count from audit
-    }
-
-    // Count MCP tools
-    let mcpTools = 0;
-    try {
-      const toolsPath = path.join(cliPath, 'mcp-tools');
-      const toolFiles = await fs.readdir(toolsPath);
-      const toolModules = toolFiles.filter(f => f.endsWith('-tools.ts'));
-
-      // Count actual tool exports in each module
-      for (const toolFile of toolModules) {
-        const content = await fs.readFile(path.join(toolsPath, toolFile), 'utf-8');
-        // Count tool definitions by name patterns
-        const toolMatches = content.match(/name:\s*['"`][^'"`]+['"`]/g);
-        if (toolMatches) mcpTools += toolMatches.length;
-      }
-    } catch {
-      mcpTools = 119; // Known count from audit
-    }
-
-    // Count hooks subcommands
-    let hooksSubcommands = 0;
-    try {
-      const hooksPath = path.join(cliPath, 'commands', 'hooks.ts');
-      const content = await fs.readFile(hooksPath, 'utf-8');
-      // Count subcommand definitions
-      const subcmdMatches = content.match(/subcommands\s*:\s*\[[\s\S]*?\]/);
-      if (subcmdMatches) {
-        const nameMatches = subcmdMatches[0].match(/name:\s*['"`][^'"`]+['"`]/g);
-        hooksSubcommands = nameMatches ? nameMatches.length : 20;
-      }
-    } catch {
-      hooksSubcommands = 20; // Known count
-    }
-
-    // Count @claude-flow packages (excluding hidden directories)
-    let packages = 0;
-    const packageDirs: string[] = [];
-    try {
-      const packagesPath = path.join(v3Path, '@claude-flow');
-      const dirs = await fs.readdir(packagesPath, { withFileTypes: true });
-      for (const dir of dirs) {
-        if (dir.isDirectory() && !dir.name.startsWith('.')) {
-          packages++;
-          packageDirs.push(dir.name);
-        }
-      }
-    } catch {
-      packages = 17; // Known count from audit
-    }
-
-    // Count DDD layers (domain/, application/ folders in packages)
-    // Utility/service packages follow DDD differently - their services ARE the application layer
-    const utilityPackages = new Set([
-      'cli', 'hooks', 'mcp', 'shared', 'testing', 'agents', 'integration',
-      'embeddings', 'deployment', 'performance', 'plugins', 'providers'
-    ]);
-    let packagesWithDDD = 0;
-    for (const pkg of packageDirs) {
-      // Skip hidden packages
-      if (pkg.startsWith('.')) continue;
-
-      try {
-        const srcPath = path.join(v3Path, '@claude-flow', pkg, 'src');
-        const srcDirs = await fs.readdir(srcPath, { withFileTypes: true });
-        const hasDomain = srcDirs.some(d => d.isDirectory() && d.name === 'domain');
-        const hasApp = srcDirs.some(d => d.isDirectory() && d.name === 'application');
-        // Count as DDD if has explicit layers OR is a utility package (DDD by design)
-        if (hasDomain || hasApp || utilityPackages.has(pkg)) {
-          packagesWithDDD++;
-        }
-      } catch {
-        // Package doesn't have src - check if it's a utility package
-        if (utilityPackages.has(pkg)) packagesWithDDD++;
-      }
-    }
-
-    // Count total TS files and lines
-    let totalFiles = 0;
-    let totalLines = 0;
-    try {
-      const v3ClaudeFlow = path.join(v3Path, '@claude-flow');
-      totalFiles = await countFilesRecursive(v3ClaudeFlow, '.ts');
-      totalLines = await countLines(v3ClaudeFlow, '.ts');
-    } catch {
-      totalFiles = 419;
-      totalLines = 290913;
-    }
-
-    // Calculate progress based on actual implementation metrics
-    // Weights: CLI (25%), MCP (25%), Hooks (20%), Packages (15%), DDD Layers (15%)
-    const cliProgress = Math.min(100, (cliCommands / 28) * 100);
-    const mcpProgress = Math.min(100, (mcpTools / 100) * 100); // 100 is target baseline
-    const hooksProgress = Math.min(100, (hooksSubcommands / 20) * 100);
-    const pkgProgress = Math.min(100, (packages / 17) * 100); // 17 packages in v3
-    const dddProgress = Math.min(100, (packagesWithDDD / packages) * 100); // DDD relative to actual packages
-
-    const overallProgress = Math.round(
-      (cliProgress * 0.25) +
-      (mcpProgress * 0.25) +
-      (hooksProgress * 0.20) +
-      (pkgProgress * 0.15) +
-      (dddProgress * 0.15)
-    );
-
-    // Build metrics object
-    const metrics = {
-      domains: {
-        completed: packagesWithDDD,
-        total: packages,
-      },
-      ddd: {
-        progress: overallProgress,
-        modules: packages,
-        totalFiles,
-        totalLines,
-      },
-      cli: {
-        commands: cliCommands,
-        progress: Math.round(cliProgress),
-      },
-      mcp: {
-        tools: mcpTools,
-        progress: Math.round(mcpProgress),
-      },
-      hooks: {
-        subcommands: hooksSubcommands,
-        progress: Math.round(hooksProgress),
-      },
-      packages: {
-        total: packages,
-        withDDD: packagesWithDDD,
-        list: packageDirs,
-      },
-      swarm: {
-        activeAgents: 0,
-        totalAgents: 15,
-      },
-      lastUpdated: new Date().toISOString(),
-      source: 'v3progress-worker',
-    };
-
-    // Write to v3-progress.json
-    try {
-      const metricsDir = path.join(projectRoot, '.claude-flow', 'metrics');
-      await fs.mkdir(metricsDir, { recursive: true });
-      const outputPath = path.join(metricsDir, 'v3-progress.json');
-      await fs.writeFile(outputPath, JSON.stringify(metrics, null, 2));
-    } catch (error) {
-      // Log but don't fail
-      console.error('Failed to write v3-progress.json:', error);
-    }
-
-    return {
-      worker: 'v3progress',
-      success: true,
-      duration: Date.now() - startTime,
-      timestamp: new Date(),
-      data: {
-        progress: overallProgress,
-        cli: cliCommands,
-        mcp: mcpTools,
-        hooks: hooksSubcommands,
-        packages,
-        packagesWithDDD,
-        totalFiles,
-        totalLines,
-      },
-    };
-  };
-}
-
-/**
- * Count files recursively with extension
- */
-async function countFilesRecursive(dir: string, ext: string): Promise<number> {
-  let count = 0;
-  try {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-        count += await countFilesRecursive(fullPath, ext);
-      } else if (entry.isFile() && entry.name.endsWith(ext)) {
-        count++;
-      }
-    }
-  } catch {
-    // Ignore
-  }
-  return count;
-}
-
-// ============================================================================
-// Factory
-// ============================================================================
-
-export function createWorkerManager(projectRoot?: string): WorkerManager {
-  const root = projectRoot || process.cwd();
-  const manager = new WorkerManager(root);
-
-  // Register all built-in workers
-  manager.register('performance', createPerformanceWorker(root));
-  manager.register('health', createHealthWorker(root));
-  manager.register('swarm', createSwarmWorker(root));
-  manager.register('git', createGitWorker(root));
-  manager.register('learning', createLearningWorker(root));
-  manager.register('adr', createADRWorker(root));
-  manager.register('ddd', createDDDWorker(root));
-  manager.register('security', createSecurityWorker(root));
-  manager.register('patterns', createPatternsWorker(root));
-  manager.register('cache', createCacheWorker(root));
-  manager.register('v3progress', createV3ProgressWorker(root));
-
-  return manager;
-}
-
-// Default instance
-export const workerManager = createWorkerManager();