claude-flow-novice 2.18.5 → 2.18.7

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/task-analyzer.js

@@ -1,305 +0,0 @@
-"use strict";
-/**
- * Task Analyzer
- *
- * Analyzes task complexity to determine optimal agent configuration.
- *
- * Migrated from:
- * - analyze-task-complexity.sh (277 lines)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskAnalyzer = void 0;
-const types_1 = require("./types");
-class TaskAnalyzer {
-    redis;
-    logger;
-    constructor(redis, logger) {
-        this.redis = redis;
-        this.logger = logger;
-    }
-    /**
-     * Analyze task complexity and suggest agent configuration
-     */
-    analyzeComplexity(taskDescription, difficulty) {
-        if (!taskDescription || taskDescription.trim().length === 0) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, 'Task description cannot be empty');
-        }
-        let complexityScore = 0;
-        const detectedDomains = new Set();
-        let reasoning = '';
-        const lowerDescription = taskDescription.toLowerCase();
-        // 1. Word count analysis
-        const wordCount = taskDescription.split(/\s+/).length;
-        let wordScore = 0;
-        if (wordCount < 5) {
-            wordScore = 1;
-        }
-        else if (wordCount < 10) {
-            wordScore = 2;
-        }
-        else if (wordCount < 20) {
-            wordScore = 3;
-        }
-        else {
-            wordScore = 4;
-        }
-        complexityScore += wordScore;
-        // 2. Domain detection
-        const domainPatterns = {
-            frontend: /react|frontend|ui|component|dashboard|vue|angular|html|css/i,
-            backend: /api|backend|server|endpoint|rest|graphql|service/i,
-            database: /database|db|sql|postgres|mongo|redis|cache/i,
-            infrastructure: /deploy|infra|docker|k8s|kubernetes|aws|cloud|gcp|azure/i,
-            security: /auth|security|encrypt|permission|rbac|oauth|jwt|ssl/i,
-            testing: /test|unit|integration|e2e|coverage|mock|stub/i,
-            devops: /ci|cd|pipeline|jenkins|github|gitlab|build|release/i,
-            machine_learning: /ml|ai|model|predict|train|neural|algorithm/i,
-            performance: /performance|optimize|cache|speed|latency|throughput/i,
-            migration: /migrate|upgrade|refactor|legacy|deprecat/i
-        };
-        for (const [domain, pattern] of Object.entries(domainPatterns)) {
-            if (pattern.test(lowerDescription)) {
-                detectedDomains.add(domain);
-            }
-        }
-        const domainCount = detectedDomains.size;
-        complexityScore += Math.min(domainCount * 2, 10);
-        // 3. Difficulty keywords
-        const difficultyKeywords = {
-            simple: /simple|basic|easy|trivial|straightforward|minor|patch/i,
-            standard: /implement|add|create|build|update|modify|fix/i,
-            complex: /complex|sophisticated|intricate|critical|major|rewrite|redesign/i,
-            enterprise: /enterprise|scalability|distributed|fault.?tolerant|multi.?tenant|compliance/i
-        };
-        // 4. Complexity phrases
-        const complexPhrases = {
-            'multiple components': 3,
-            'distributed system': 4,
-            'real-time': 2,
-            'batch process': 1,
-            'high performance': 3,
-            'high availability': 3,
-            'disaster recovery': 3,
-            'zero downtime': 3,
-            'multi-region': 4,
-            'async': 2
-        };
-        for (const [phrase, score] of Object.entries(complexPhrases)) {
-            if (lowerDescription.includes(phrase)) {
-                complexityScore += score;
-            }
-        }
-        // Cap score at 20
-        complexityScore = Math.min(complexityScore, 20);
-        // 5. Determine difficulty level
-        let finalDifficulty = difficulty || 'standard';
-        if (!difficulty) {
-            if (complexityScore <= 4) {
-                finalDifficulty = 'simple';
-            }
-            else if (complexityScore <= 9) {
-                finalDifficulty = 'standard';
-            }
-            else if (complexityScore <= 12) {
-                finalDifficulty = 'complex';
-            }
-            else {
-                finalDifficulty = 'enterprise';
-            }
-        }
-        // 6. Suggest agent counts and duration
-        const agentConfig = this.suggestAgentConfiguration(finalDifficulty, domainCount, wordCount);
-        // 7. Build reasoning
-        const reasons = [];
-        if (domainCount > 1) {
-            reasons.push(`Multi-domain task (${Array.from(detectedDomains).join(', ')})`);
-        }
-        if (wordCount > 20) {
-            reasons.push('Long description suggests complex scope');
-        }
-        if (complexityScore >= 10) {
-            reasons.push('High complexity score indicates sophisticated implementation');
-        }
-        if (complexPhrases[Object.keys(complexPhrases).find(phrase => lowerDescription.includes(phrase))]) {
-            reasons.push('Contains complex architectural patterns');
-        }
-        reasoning = reasons.length > 0
-            ? reasons.join('; ')
-            : `Determined to be ${finalDifficulty} complexity`;
-        const analysis = {
-            taskDescription,
-            complexityScore,
-            difficulty: finalDifficulty,
-            domains: Array.from(detectedDomains),
-            suggestedAgents: agentConfig,
-            reasoning,
-            timestamp: new Date().toISOString()
-        };
-        this.logger.info(`📊 Task Analysis: ${finalDifficulty} (score: ${complexityScore}/20), ` +
-            `Domains: ${Array.from(detectedDomains).join(', ')} or 'none'}, ` +
-            `Suggested: ${agentConfig.loop3Count} Loop3 + ${agentConfig.loop2Count} Loop2 agents`);
-        return analysis;
-    }
-    /**
-     * Suggest agent counts based on difficulty and domains
-     */
-    suggestAgentConfiguration(difficulty, domainCount, wordCount) {
-        let loop3Count = 1;
-        let loop2Count = 1;
-        let duration = 5;
-        // Base counts by difficulty
-        switch (difficulty) {
-            case 'simple':
-                loop3Count = 1;
-                loop2Count = 1;
-                duration = 5;
-                break;
-            case 'standard':
-                loop3Count = 2;
-                loop2Count = 2;
-                duration = 15;
-                break;
-            case 'complex':
-                loop3Count = 3;
-                loop2Count = 3;
-                duration = 30;
-                break;
-            case 'enterprise':
-                loop3Count = 5;
-                loop2Count = 4;
-                duration = 60;
-                break;
-        }
-        // Adjust for domain count
-        if (domainCount > 1) {
-            loop3Count = Math.min(loop3Count + domainCount - 1, 7);
-            loop2Count = Math.min(loop2Count + 1, 5);
-        }
-        // Adjust for description length
-        if (wordCount > 50) {
-            duration += 15;
-        }
-        return {
-            loop3Count,
-            loop2Count,
-            estimatedDurationMinutes: duration
-        };
-    }
-    /**
-     * Calculate priority/score for task scheduling
-     */
-    calculatePriority(analysis) {
-        // Higher complexity = higher priority
-        const baseScore = analysis.complexityScore;
-        // Boost for specific domain combinations
-        const domainBoosts = {
-            'security': 2,
-            'infrastructure': 1.5,
-            'machine_learning': 1.5,
-            'database': 1
-        };
-        let boost = 0;
-        for (const domain of analysis.domains) {
-            boost += domainBoosts[domain] || 0;
-        }
-        const priority = baseScore + boost;
-        return priority;
-    }
-    /**
-     * Store analysis in Redis
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis
-     */
-    async storeAnalysis(taskId, analysis) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Task analysis not stored (no Redis)');
-            return;
-        }
-        // CLI Mode: Store in Redis
-        const key = `swarm:${taskId}:analysis`;
-        try {
-            const data = {
-                taskDescription: analysis.taskDescription,
-                complexityScore: String(analysis.complexityScore),
-                difficulty: analysis.difficulty,
-                domains: JSON.stringify(analysis.domains),
-                loop3Count: String(analysis.suggestedAgents.loop3Count),
-                loop2Count: String(analysis.suggestedAgents.loop2Count),
-                estimatedDuration: String(analysis.suggestedAgents.estimatedDurationMinutes),
-                reasoning: analysis.reasoning,
-                timestamp: analysis.timestamp
-            };
-            await this.redis.hset(key, ...Object.entries(data).flat());
-            // Set TTL (24 hours)
-            await this.redis.expire(key, 86400);
-            this.logger.info(`✅ Task analysis stored for: ${taskId}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to store task analysis', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to store task analysis: ${error.message}`);
-        }
-    }
-    /**
-     * Get stored analysis from Redis
-     */
-    async getAnalysis(taskId) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: No task analysis available in Redis');
-            return null;
-        }
-        // CLI Mode: Retrieve from Redis
-        const key = `swarm:${taskId}:analysis`;
-        try {
-            const data = await this.redis.hgetall(key);
-            if (!data || Object.keys(data).length === 0) {
-                this.logger.warn(`No task analysis found: ${taskId}`);
-                return null;
-            }
-            const analysis = {
-                taskId,
-                taskDescription: data.taskDescription || '',
-                complexityScore: parseFloat(data.complexityScore || '0'),
-                difficulty: data.difficulty || 'standard',
-                domains: data.domains ? JSON.parse(data.domains) : [],
-                suggestedAgents: {
-                    loop3Count: parseInt(data.loop3Count || '1', 10),
-                    loop2Count: parseInt(data.loop2Count || '1', 10),
-                    estimatedDurationMinutes: parseInt(data.estimatedDuration || '15', 10)
-                },
-                reasoning: data.reasoning || '',
-                timestamp: data.timestamp || new Date().toISOString()
-            };
-            return analysis;
-        }
-        catch (error) {
-            this.logger.error('Failed to get task analysis', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to retrieve task analysis: ${error.message}`);
-        }
-    }
-    /**
-     * Suggest execution mode based on analysis
-     */
-    suggestMode(analysis) {
-        // Map difficulty to execution mode
-        const modeMap = {
-            simple: 'mvp',
-            standard: 'standard',
-            complex: 'standard',
-            enterprise: 'enterprise'
-        };
-        return modeMap[analysis.difficulty];
-    }
-}
-exports.TaskAnalyzer = TaskAnalyzer;
-//# sourceMappingURL=task-analyzer.js.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/task-executor.d.ts

@@ -1,97 +0,0 @@
-/**
- * Task Executor
- *
- * Main entry point for CFN Loop task execution and orchestration.
- *
- * Migrated from:
- * - cfn-loop-exec.sh (468 lines)
- * - cfn-loop-relaunch.sh (29 lines)
- */
-import type { TaskId, TaskContext, Logger } from './types';
-import { RedisCoordinator } from './redis-client';
-import { DifficultyLevel } from './task-analyzer';
-export interface ExecutionConfig {
-    taskId: TaskId;
-    taskDescription: string;
-    context?: TaskContext;
-    mode?: 'mvp' | 'standard' | 'enterprise';
-    maxIterations?: number;
-    timeoutMinutes?: number;
-    difficulty?: DifficultyLevel;
-}
-export interface ExecutionResult {
-    taskId: TaskId;
-    status: 'success' | 'failed' | 'timeout' | 'cancelled';
-    iterations: number;
-    finalConfidence: number;
-    deliverables: string[];
-    errors: string[];
-    startTime: string;
-    endTime: string;
-    durationMinutes: number;
-}
-export interface ExecutionProgress {
-    taskId: TaskId;
-    currentIteration: number;
-    status: 'running' | 'paused' | 'completed' | 'failed';
-    progress: number;
-    estimatedTimeRemaining: number;
-    agentsActive: number;
-    lastUpdate: string;
-}
-export declare class TaskExecutor {
-    private redis;
-    private logger;
-    private contextManager;
-    private analyzer;
-    private startTime?;
-    private currentIteration;
-    constructor(redis: RedisCoordinator, logger: Logger);
-    /**
-     * Execute a CFN Loop task
-     *
-     * Coordinates task analysis, context setup, and orchestration.
-     */
-    executeTask(config: ExecutionConfig): Promise<ExecutionResult>;
-    /**
-     * Relaunch a task for the next iteration
-     *
-     * Used by orchestrator to continue loop iterations.
-     */
-    relaunchtask(taskId: TaskId, iteration: number, agentChanges?: {
-        addAgents?: string[];
-        removeAgents?: string[];
-    }): Promise<void>;
-    /**
-     * Get execution progress
-     */
-    getProgress(taskId: TaskId): Promise<ExecutionProgress>;
-    /**
-     * Cancel task execution
-     */
-    cancelTask(taskId: TaskId, reason?: string): Promise<void>;
-    /**
-     * Analyze task complexity and store analysis
-     */
-    private analyzeTaskComplexity;
-    /**
-     * Get max iterations for execution mode
-     */
-    private getMaxIterations;
-    /**
-     * Get timeout in minutes for execution mode
-     */
-    private getTimeoutMinutes;
-    /**
-     * Validate execution configuration
-     */
-    validateConfig(config: ExecutionConfig): {
-        valid: boolean;
-        errors: string[];
-    };
-    /**
-     * Clean up task resources
-     */
-    cleanupTask(taskId: TaskId): Promise<void>;
-}
-//# sourceMappingURL=task-executor.d.ts.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/task-executor.js

@@ -1,283 +0,0 @@
-"use strict";
-/**
- * Task Executor
- *
- * Main entry point for CFN Loop task execution and orchestration.
- *
- * Migrated from:
- * - cfn-loop-exec.sh (468 lines)
- * - cfn-loop-relaunch.sh (29 lines)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskExecutor = void 0;
-const types_1 = require("./types");
-const context_manager_1 = require("./context-manager");
-const task_analyzer_1 = require("./task-analyzer");
-class TaskExecutor {
-    redis;
-    logger;
-    contextManager;
-    analyzer;
-    startTime;
-    currentIteration = 0;
-    constructor(redis, logger) {
-        this.redis = redis;
-        this.logger = logger;
-        this.contextManager = new context_manager_1.ContextManager(redis, logger);
-        this.analyzer = new task_analyzer_1.TaskAnalyzer(redis, logger);
-    }
-    /**
-     * Execute a CFN Loop task
-     *
-     * Coordinates task analysis, context setup, and orchestration.
-     */
-    async executeTask(config) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(config.taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${config.taskId}`);
-        }
-        if (!config.taskDescription || config.taskDescription.trim().length === 0) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, 'Task description cannot be empty');
-        }
-        this.startTime = new Date();
-        this.currentIteration = 0;
-        const startTime = this.startTime.toISOString();
-        const result = {
-            taskId: config.taskId,
-            status: 'success',
-            iterations: 0,
-            finalConfidence: 0,
-            deliverables: [],
-            errors: [],
-            startTime,
-            endTime: '',
-            durationMinutes: 0
-        };
-        try {
-            this.logger.info(`🚀 Starting CFN Loop execution: ${config.taskId}`);
-            this.logger.info(`   Task: ${config.taskDescription}`);
-            // Step 1: Analyze task complexity
-            const analysis = await this.analyzeTaskComplexity(config.taskDescription, config.difficulty);
-            // Step 2: Determine execution mode
-            const mode = config.mode || this.analyzer.suggestMode(analysis);
-            this.logger.info(`📋 Execution mode: ${mode}`);
-            // Step 3: Store context
-            const context = config.context || {
-                taskId: config.taskId,
-                epic: config.taskDescription,
-                mode
-            };
-            await this.contextManager.storeContext(config.taskId, context);
-            // Step 4: Initialize execution
-            const maxIterations = config.maxIterations || this.getMaxIterations(mode);
-            const timeoutMinutes = config.timeoutMinutes || this.getTimeoutMinutes(mode);
-            this.logger.info(`⚙️ Configuration: Max Iterations=${maxIterations}, Timeout=${timeoutMinutes}m`);
-            // Step 5: Run orchestration loop
-            // Note: In actual implementation, this would spawn orchestrator via CLI
-            this.logger.info(`📡 Would spawn orchestrator for task: ${config.taskId}`);
-            this.logger.info(`   Analysis: ${analysis.difficulty} complexity (${analysis.complexityScore}/20)`);
-            this.logger.info(`   Domains: ${analysis.domains.join(', ') || 'none'}`);
-            this.logger.info(`   Suggested: ${analysis.suggestedAgents.loop3Count} Loop3 + ${analysis.suggestedAgents.loop2Count} Loop2 agents`);
-            // Simulate successful execution for foundation validation
-            result.status = 'success';
-            result.iterations = 1;
-            result.finalConfidence = 0.95;
-            result.deliverables = ['task_completed', 'context_stored', 'analysis_completed'];
-            return result;
-        }
-        catch (error) {
-            result.status = 'failed';
-            result.errors.push(error.message);
-            this.logger.error('Task execution failed', error);
-            throw error;
-        }
-        finally {
-            // Finalize result
-            const endTime = new Date();
-            result.endTime = endTime.toISOString();
-            result.durationMinutes = Math.round((endTime.getTime() - this.startTime.getTime()) / 60000);
-            this.logger.info(`📊 Execution Summary:`);
-            this.logger.info(`   Status: ${result.status}`);
-            this.logger.info(`   Duration: ${result.durationMinutes}m`);
-            this.logger.info(`   Iterations: ${result.iterations}`);
-            this.logger.info(`   Final Confidence: ${(result.finalConfidence * 100).toFixed(1)}%`);
-        }
-    }
-    /**
-     * Relaunch a task for the next iteration
-     *
-     * Used by orchestrator to continue loop iterations.
-     */
-    async relaunchtask(taskId, iteration, agentChanges) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (iteration < 1 || iteration > 50) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid iteration number: ${iteration}. Must be between 1 and 50.`);
-        }
-        try {
-            this.logger.info(`🔄 Relaunching task for iteration ${iteration}: ${taskId}`);
-            // Retrieve current context
-            const context = await this.contextManager.getContext(taskId);
-            if (!context) {
-                throw new types_1.CoordinationError(types_1.CoordinationErrorType.MISSING_CONTEXT, `No context found for task: ${taskId}`);
-            }
-            // Update iteration in context
-            context.iteration = iteration;
-            // Store updated context
-            await this.contextManager.storeContext(taskId, context);
-            // Log agent changes if provided
-            if (agentChanges?.addAgents && agentChanges.addAgents.length > 0) {
-                this.logger.info(`   Adding agents: ${agentChanges.addAgents.join(', ')}`);
-            }
-            if (agentChanges?.removeAgents && agentChanges.removeAgents.length > 0) {
-                this.logger.info(`   Removing agents: ${agentChanges.removeAgents.join(', ')}`);
-            }
-            this.logger.info(`✅ Task relaunched for iteration ${iteration}`);
-        }
-        catch (error) {
-            this.logger.error('Task relaunch failed', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to relaunch task: ${error.message}`);
-        }
-    }
-    /**
-     * Get execution progress
-     */
-    async getProgress(taskId) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        // In a real implementation, this would retrieve from Redis
-        // For now, return base progress
-        return {
-            taskId,
-            currentIteration: this.currentIteration,
-            status: 'running',
-            progress: 0,
-            estimatedTimeRemaining: 0,
-            agentsActive: 0,
-            lastUpdate: new Date().toISOString()
-        };
-    }
-    /**
-     * Cancel task execution
-     */
-    async cancelTask(taskId, reason = 'user_requested') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        try {
-            this.logger.info(`🛑 Cancelling task execution: ${taskId}`);
-            this.logger.info(`   Reason: ${reason}`);
-            // In a real implementation, this would signal all agents
-            // via Redis to stop and exit gracefully
-            this.logger.info(`✅ Task cancellation signal sent`);
-        }
-        catch (error) {
-            this.logger.error('Task cancellation failed', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to cancel task: ${error.message}`);
-        }
-    }
-    /**
-     * Analyze task complexity and store analysis
-     */
-    async analyzeTaskComplexity(taskDescription, difficulty) {
-        try {
-            this.logger.info('🔍 Analyzing task complexity...');
-            const analysis = this.analyzer.analyzeComplexity(taskDescription, difficulty);
-            this.logger.info(`   Complexity Score: ${analysis.complexityScore}/20`);
-            this.logger.info(`   Difficulty: ${analysis.difficulty}`);
-            this.logger.info(`   Domains: ${analysis.domains.join(', ') || 'none'}`);
-            this.logger.info(`   Agents: ${analysis.suggestedAgents.loop3Count} Loop3 + ${analysis.suggestedAgents.loop2Count} Loop2`);
-            this.logger.info(`   Est. Duration: ${analysis.suggestedAgents.estimatedDurationMinutes}m`);
-            return analysis;
-        }
-        catch (error) {
-            this.logger.error('Task complexity analysis failed', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Failed to analyze task complexity: ${error.message}`);
-        }
-    }
-    /**
-     * Get max iterations for execution mode
-     */
-    getMaxIterations(mode) {
-        const maxByMode = {
-            mvp: 3,
-            standard: 10,
-            enterprise: 15
-        };
-        return maxByMode[mode];
-    }
-    /**
-     * Get timeout in minutes for execution mode
-     */
-    getTimeoutMinutes(mode) {
-        const timeoutByMode = {
-            mvp: 30,
-            standard: 120,
-            enterprise: 300
-        };
-        return timeoutByMode[mode];
-    }
-    /**
-     * Validate execution configuration
-     */
-    validateConfig(config) {
-        const errors = [];
-        if (!(0, types_1.isValidTaskId)(config.taskId)) {
-            errors.push(`Invalid task ID: ${config.taskId}`);
-        }
-        if (!config.taskDescription || config.taskDescription.trim().length === 0) {
-            errors.push('Task description cannot be empty');
-        }
-        if (config.maxIterations !== undefined) {
-            if (config.maxIterations < 1 || config.maxIterations > 50) {
-                errors.push('Max iterations must be between 1 and 50');
-            }
-        }
-        if (config.timeoutMinutes !== undefined) {
-            if (config.timeoutMinutes < 1 || config.timeoutMinutes > 1440) {
-                errors.push('Timeout must be between 1 and 1440 minutes');
-            }
-        }
-        if (config.mode && !['mvp', 'standard', 'enterprise'].includes(config.mode)) {
-            errors.push(`Invalid execution mode: ${config.mode}`);
-        }
-        if (config.difficulty && !['simple', 'standard', 'complex', 'enterprise'].includes(config.difficulty)) {
-            errors.push(`Invalid difficulty level: ${config.difficulty}`);
-        }
-        return {
-            valid: errors.length === 0,
-            errors
-        };
-    }
-    /**
-     * Clean up task resources
-     */
-    async cleanupTask(taskId) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        try {
-            this.logger.info(`🧹 Cleaning up task resources: ${taskId}`);
-            // Clear context
-            await this.contextManager.clearContext(taskId);
-            // In a real implementation, would also clean up:
-            // - Agent results
-            // - Swarm metadata
-            // - Logs
-            // etc.
-            this.logger.info(`✅ Task cleanup complete`);
-        }
-        catch (error) {
-            this.logger.error('Task cleanup failed', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to cleanup task: ${error.message}`);
-        }
-    }
-}
-exports.TaskExecutor = TaskExecutor;
-//# sourceMappingURL=task-executor.js.map