gthinking 1.2.1 → 2.1.1

package/planning.ts

@@ -1,1028 +0,0 @@
-/**
- * Planning Module
- * Task decomposition, prioritization, resource allocation, and progress tracking
- */
-
-import {
-  Plan,
-  Task,
-  Milestone,
-  Resource,
-  Timeline,
-  Phase,
-  ProgressReport,
-  Risk,
-  Priority,
-  TaskStatus,
-  ThinkingEvent,
-  ThinkingError,
-  ThinkingStage
-} from './types';
-import { EventEmitter } from 'events';
-
-// ============================================================================
-// TASK DECOMPOSITION ENGINE
-// ============================================================================
-
-interface DecompositionRule {
-  pattern: RegExp;
-  subtasks: string[];
-  dependencies: string[][];
-}
-
-class TaskDecompositionEngine {
-  private decompositionRules: DecompositionRule[] = [
-    {
-      pattern: /build|create|develop|implement/i,
-      subtasks: [
-        'Research and requirements gathering',
-        'Design and architecture',
-        'Implementation',
-        'Testing and validation',
-        'Deployment'
-      ],
-      dependencies: [[], ['0'], ['1'], ['2'], ['3']]
-    },
-    {
-      pattern: /analyze|research|investigate/i,
-      subtasks: [
-        'Define scope and objectives',
-        'Gather existing data',
-        'Conduct analysis',
-        'Document findings',
-        'Present recommendations'
-      ],
-      dependencies: [[], ['0'], ['1'], ['2'], ['3']]
-    },
-    {
-      pattern: /optimize|improve|enhance/i,
-      subtasks: [
-        'Current state assessment',
-        'Identify improvement areas',
-        'Design improvements',
-        'Implement changes',
-        'Measure results'
-      ],
-      dependencies: [[], ['0'], ['1'], ['2'], ['3']]
-    }
-  ];
-
-  decompose(goal: string): { subtasks: string[]; dependencies: string[][] } {
-    // Find matching decomposition rule
-    for (const rule of this.decompositionRules) {
-      if (rule.pattern.test(goal)) {
-        return {
-          subtasks: rule.subtasks,
-          dependencies: rule.dependencies
-        };
-      }
-    }
-
-    // Default decomposition
-    return {
-      subtasks: [
-        'Understand requirements',
-        'Plan approach',
-        'Execute plan',
-        'Review and validate'
-      ],
-      dependencies: [[], ['0'], ['1'], ['2']]
-    };
-  }
-
-  estimateComplexity(task: string): number {
-    // Estimate complexity based on keywords
-    const complexityIndicators = [
-      { keywords: ['complex', 'difficult', 'challenging', 'advanced'], weight: 0.9 },
-      { keywords: ['simple', 'easy', 'basic', 'straightforward'], weight: 0.3 },
-      { keywords: ['research', 'analysis', 'investigation'], weight: 0.7 },
-      { keywords: ['implement', 'build', 'develop'], weight: 0.8 }
-    ];
-
-    const taskLower = task.toLowerCase();
-    let complexity = 0.5; // Default
-
-    complexityIndicators.forEach(indicator => {
-      if (indicator.keywords.some(kw => taskLower.includes(kw))) {
-        complexity = indicator.weight;
-      }
-    });
-
-    // Adjust based on task length (longer tasks tend to be more complex)
-    const wordCount = task.split(/\s+/).length;
-    complexity += Math.min(0.2, wordCount * 0.01);
-
-    return Math.min(1, complexity);
-  }
-
-  estimateDuration(task: string, complexity: number): number {
-    // Duration in minutes
-    const baseDuration = 30;
-    const complexityMultiplier = 1 + complexity * 4; // 1x to 5x
-    
-    return Math.round(baseDuration * complexityMultiplier);
-  }
-}
-
-// ============================================================================
-// PRIORITIZATION ENGINE
-// ============================================================================
-
-interface PrioritizationCriteria {
-  urgency: number;
-  importance: number;
-  effort: number;
-  risk: number;
-  dependencies: number;
-}
-
-class PrioritizationEngine {
-  private weights = {
-    urgency: 0.25,
-    importance: 0.3,
-    effort: 0.2,
-    risk: 0.15,
-    dependencies: 0.1
-  };
-
-  prioritize(tasks: Task[]): Task[] {
-    const scoredTasks = tasks.map(task => ({
-      task,
-      score: this.calculatePriorityScore(task)
-    }));
-
-    return scoredTasks
-      .sort((a, b) => b.score - a.score)
-      .map(({ task }) => task);
-  }
-
-  private calculatePriorityScore(task: Task): number {
-    const criteria = this.assessCriteria(task);
-    
-    // Calculate weighted score
-    let score = 0;
-    score += criteria.urgency * this.weights.urgency;
-    score += criteria.importance * this.weights.importance;
-    score += (1 - criteria.effort) * this.weights.effort; // Lower effort = higher priority
-    score += (1 - criteria.risk) * this.weights.risk; // Lower risk = higher priority
-    score += (1 - criteria.dependencies) * this.weights.dependencies; // Fewer deps = higher priority
-
-    return score;
-  }
-
-  private assessCriteria(task: Task): PrioritizationCriteria {
-    return {
-      urgency: this.assessUrgency(task),
-      importance: this.assessImportance(task),
-      effort: this.assessEffort(task),
-      risk: this.assessRisk(task),
-      dependencies: this.assessDependencies(task)
-    };
-  }
-
-  private assessUrgency(task: Task): number {
-    const urgencyKeywords = ['urgent', 'asap', 'immediate', 'critical', 'deadline'];
-    const taskText = `${task.title} ${task.description}`.toLowerCase();
-    
-    if (task.priority === Priority.CRITICAL) return 1;
-    if (task.priority === Priority.HIGH) return 0.8;
-    
-    const matches = urgencyKeywords.filter(kw => taskText.includes(kw)).length;
-    return Math.min(1, matches * 0.3 + (task.priority === Priority.MEDIUM ? 0.3 : task.priority === Priority.LOW ? 0.2 : 0.1));
-  }
-
-  private assessImportance(task: Task): number {
-    const importanceKeywords = ['essential', 'crucial', 'key', 'important', 'core'];
-    const taskText = `${task.title} ${task.description}`.toLowerCase();
-    
-    if (task.tags.includes('critical')) return 1;
-    
-    const matches = importanceKeywords.filter(kw => taskText.includes(kw)).length;
-    return Math.min(1, matches * 0.25 + 0.3);
-  }
-
-  private assessEffort(task: Task): number {
-    // Normalize estimated duration (assuming max 8 hours)
-    return Math.min(1, task.estimatedDuration / 480);
-  }
-
-  private assessRisk(task: Task): number {
-    const riskKeywords = ['risk', 'uncertain', 'unknown', 'complex', 'difficult'];
-    const taskText = `${task.title} ${task.description}`.toLowerCase();
-    
-    const matches = riskKeywords.filter(kw => taskText.includes(kw)).length;
-    return Math.min(1, matches * 0.3);
-  }
-
-  private assessDependencies(task: Task): number {
-    return Math.min(1, task.dependencies.length / 5);
-  }
-
-  /**
-   * Calculate critical path
-   */
-  calculateCriticalPath(tasks: Task[]): string[] {
-    const taskMap = new Map(tasks.map(t => [t.id, t]));
-    const visited = new Set<string>();
-    const path: string[] = [];
-
-    const visit = (taskId: string, currentPath: string[] = []): number => {
-      if (visited.has(taskId)) return 0;
-      if (currentPath.includes(taskId)) return 0; // Cycle detected
-
-      const task = taskMap.get(taskId);
-      if (!task) return 0;
-
-      let maxPathDuration = task.estimatedDuration;
-
-      for (const depId of task.dependencies) {
-        const depDuration = visit(depId, [...currentPath, taskId]);
-        maxPathDuration = Math.max(maxPathDuration, task.estimatedDuration + depDuration);
-      }
-
-      visited.add(taskId);
-      path.push(taskId);
-
-      return maxPathDuration;
-    };
-
-    // Find the longest path
-    let maxDuration = 0;
-    let criticalPath: string[] = [];
-
-    for (const task of tasks) {
-      visited.clear();
-      path.length = 0;
-      const duration = visit(task.id);
-      
-      if (duration > maxDuration) {
-        maxDuration = duration;
-        criticalPath = [...path];
-      }
-    }
-
-    return criticalPath;
-  }
-}
-
-// ============================================================================
-// RESOURCE ALLOCATOR
-// ============================================================================
-
-class ResourceAllocator {
-  private resources: Map<string, Resource> = new Map();
-
-  addResource(resource: Resource): void {
-    this.resources.set(resource.id, resource);
-  }
-
-  allocate(tasks: Task[]): Map<string, string[]> {
-    const allocation = new Map<string, string[]>();
-    const resourceAvailability = new Map<string, number>();
-
-    // Initialize availability
-    this.resources.forEach((resource, id) => {
-      resourceAvailability.set(id, resource.availability);
-    });
-
-    // Allocate resources to tasks
-    for (const task of tasks) {
-      const suitableResources = this.findSuitableResources(task);
-      const allocated: string[] = [];
-
-      for (const resource of suitableResources) {
-        const available = resourceAvailability.get(resource.id) || 0;
-        if (available > 0) {
-          allocated.push(resource.id);
-          resourceAvailability.set(resource.id, available - 1);
-        }
-      }
-
-      allocation.set(task.id, allocated);
-    }
-
-    return allocation;
-  }
-
-  private findSuitableResources(task: Task): Resource[] {
-    return Array.from(this.resources.values())
-      .filter(resource => {
-        // Check if resource skills match task requirements
-        if (task.tags.length > 0 && resource.skills) {
-          return task.tags.some(tag => 
-            resource.skills!.some(skill => 
-              skill.toLowerCase().includes(tag.toLowerCase()) ||
-              tag.toLowerCase().includes(skill.toLowerCase())
-            )
-          );
-        }
-        return true;
-      })
-      .sort((a, b) => b.availability - a.availability);
-  }
-
-  checkOverallocation(): Array<{ resourceId: string; overallocation: number }> {
-    const overallocations: Array<{ resourceId: string; overallocation: number }> = [];
-
-    this.resources.forEach((resource, id) => {
-      if (resource.availability < 0) {
-        overallocations.push({
-          resourceId: id,
-          overallocation: Math.abs(resource.availability)
-        });
-      }
-    });
-
-    return overallocations;
-  }
-
-  getResourceUtilization(): Map<string, number> {
-    const utilization = new Map<string, number>();
-
-    this.resources.forEach((resource, id) => {
-      // Calculate utilization (simplified)
-      utilization.set(id, 1 - resource.availability);
-    });
-
-    return utilization;
-  }
-}
-
-// ============================================================================
-// PROGRESS TRACKER
-// ============================================================================
-
-class ProgressTracker {
-  private taskHistory: Map<string, Array<{ timestamp: Date; status: TaskStatus; progress: number }>> = new Map();
-
-  recordProgress(taskId: string, status: TaskStatus, progress: number): void {
-    if (!this.taskHistory.has(taskId)) {
-      this.taskHistory.set(taskId, []);
-    }
-
-    this.taskHistory.get(taskId)!.push({
-      timestamp: new Date(),
-      status,
-      progress: Math.min(100, Math.max(0, progress))
-    });
-  }
-
-  getProgress(taskId: string): number {
-    const history = this.taskHistory.get(taskId);
-    if (!history || history.length === 0) return 0;
-    return history[history.length - 1].progress;
-  }
-
-  calculateVelocity(taskId: string): number {
-    const history = this.taskHistory.get(taskId);
-    if (!history || history.length < 2) return 0;
-
-    const first = history[0];
-    const last = history[history.length - 1];
-    const timeDiff = last.timestamp.getTime() - first.timestamp.getTime();
-    const progressDiff = last.progress - first.progress;
-
-    return timeDiff > 0 ? (progressDiff / timeDiff) * 3600000 : 0; // Progress per hour
-  }
-
-  predictCompletion(taskId: string, totalWork: number): Date | null {
-    const velocity = this.calculateVelocity(taskId);
-    const currentProgress = this.getProgress(taskId);
-
-    if (velocity <= 0 || currentProgress >= 100) return null;
-
-    const remainingWork = totalWork * (1 - currentProgress / 100);
-    const hoursRemaining = remainingWork / velocity;
-
-    return new Date(Date.now() + hoursRemaining * 3600000);
-  }
-
-  getProgressTrend(taskId: string): 'improving' | 'stable' | 'declining' {
-    const history = this.taskHistory.get(taskId);
-    if (!history || history.length < 3) return 'stable';
-
-    const recent = history.slice(-3);
-    const velocities: number[] = [];
-
-    for (let i = 1; i < recent.length; i++) {
-      const timeDiff = recent[i].timestamp.getTime() - recent[i - 1].timestamp.getTime();
-      const progressDiff = recent[i].progress - recent[i - 1].progress;
-      velocities.push(timeDiff > 0 ? progressDiff / timeDiff : 0);
-    }
-
-    const avgVelocity = velocities.reduce((a, b) => a + b, 0) / velocities.length;
-    const firstVelocity = velocities[0];
-
-    if (avgVelocity > firstVelocity * 1.2) return 'improving';
-    if (avgVelocity < firstVelocity * 0.8) return 'declining';
-    return 'stable';
-  }
-}
-
-// ============================================================================
-// RISK ANALYZER
-// ============================================================================
-
-class RiskAnalyzer {
-  private knownRisks: Map<string, Risk> = new Map();
-
-  analyzeRisks(tasks: Task[], resources: Resource[]): Risk[] {
-    const risks: Risk[] = [];
-
-    // Analyze task-related risks
-    tasks.forEach(task => {
-      const taskRisks = this.identifyTaskRisks(task);
-      risks.push(...taskRisks);
-    });
-
-    // Analyze resource-related risks
-    const resourceRisks = this.identifyResourceRisks(tasks, resources);
-    risks.push(...resourceRisks);
-
-    // Analyze schedule-related risks
-    const scheduleRisks = this.identifyScheduleRisks(tasks);
-    risks.push(...scheduleRisks);
-
-    // Sort by risk score (probability * impact)
-    return risks
-      .map(risk => ({ ...risk, riskScore: risk.probability * risk.impact }))
-      .sort((a, b) => (b as any).riskScore - (a as any).riskScore);
-  }
-
-  private identifyTaskRisks(task: Task): Risk[] {
-    const risks: Risk[] = [];
-
-    // Complexity risk
-    if (task.estimatedDuration > 240) { // > 4 hours
-      risks.push({
-        id: `risk_complexity_${task.id}`,
-        description: `Task "${task.title}" is complex and may take longer than estimated`,
-        probability: 0.6,
-        impact: 0.7,
-        mitigation: 'Break down into smaller subtasks',
-        status: 'identified'
-      });
-    }
-
-    // Dependency risk
-    if (task.dependencies.length > 3) {
-      risks.push({
-        id: `risk_deps_${task.id}`,
-        description: `Task "${task.title}" has many dependencies`,
-        probability: 0.5,
-        impact: 0.6,
-        mitigation: 'Monitor dependencies closely and have backup plans',
-        status: 'identified'
-      });
-    }
-
-    // Uncertainty risk
-    const uncertaintyKeywords = ['unclear', 'unknown', 'uncertain', 'tbd', 'tba'];
-    const taskText = `${task.title} ${task.description}`.toLowerCase();
-    if (uncertaintyKeywords.some(kw => taskText.includes(kw))) {
-      risks.push({
-        id: `risk_uncertainty_${task.id}`,
-        description: `Task "${task.title}" has unclear requirements`,
-        probability: 0.7,
-        impact: 0.5,
-        mitigation: 'Clarify requirements before starting',
-        status: 'identified'
-      });
-    }
-
-    return risks;
-  }
-
-  private identifyResourceRisks(tasks: Task[], resources: Resource[]): Risk[] {
-    const risks: Risk[] = [];
-
-    // Resource availability risk
-    const totalAvailability = resources.reduce((sum, r) => sum + r.availability, 0);
-    const totalWork = tasks.reduce((sum, t) => sum + t.estimatedDuration, 0);
-
-    if (totalWork > totalAvailability * 480) { // Assuming 8 hours per availability unit
-      risks.push({
-        id: 'risk_resource_availability',
-        description: 'Insufficient resources for planned work',
-        probability: 0.8,
-        impact: 0.9,
-        mitigation: 'Add more resources or extend timeline',
-        status: 'identified'
-      });
-    }
-
-    return risks;
-  }
-
-  private identifyScheduleRisks(tasks: Task[]): Risk[] {
-    const risks: Risk[] = [];
-
-    // Check for tight schedules
-    const criticalTasks = tasks.filter(t => t.priority === Priority.CRITICAL);
-    if (criticalTasks.length > tasks.length * 0.3) {
-      risks.push({
-        id: 'risk_tight_schedule',
-        description: 'Too many critical tasks may lead to schedule slip',
-        probability: 0.6,
-        impact: 0.7,
-        mitigation: 'Re-prioritize and stagger critical tasks',
-        status: 'identified'
-      });
-    }
-
-    return risks;
-  }
-
-  updateRiskStatus(riskId: string, status: Risk['status']): void {
-    const risk = this.knownRisks.get(riskId);
-    if (risk) {
-      risk.status = status;
-    }
-  }
-}
-
-// ============================================================================
-// MAIN PLANNING ENGINE
-// ============================================================================
-
-export class PlanningEngine extends EventEmitter {
-  private decompositionEngine: TaskDecompositionEngine;
-  private prioritizationEngine: PrioritizationEngine;
-  private resourceAllocator: ResourceAllocator;
-  private progressTracker: ProgressTracker;
-  private riskAnalyzer: RiskAnalyzer;
-  private plans: Map<string, Plan> = new Map();
-
-  constructor() {
-    super();
-    this.decompositionEngine = new TaskDecompositionEngine();
-    this.prioritizationEngine = new PrioritizationEngine();
-    this.resourceAllocator = new ResourceAllocator();
-    this.progressTracker = new ProgressTracker();
-    this.riskAnalyzer = new RiskAnalyzer();
-  }
-
-  /**
-   * Create a comprehensive plan
-   */
-  createPlan(
-    goal: string,
-    options: {
-      resources?: Resource[];
-      deadline?: Date;
-      constraints?: string[];
-    } = {}
-  ): Plan {
-    const planId = this.generateId();
-    const createdAt = new Date();
-
-    this.emit('planning_start', {
-      id: planId,
-      stage: ThinkingStage.PLANNING,
-      timestamp: createdAt,
-      data: { goal }
-    } as ThinkingEvent);
-
-    // Decompose goal into tasks
-    const { subtasks, dependencies } = this.decompositionEngine.decompose(goal);
-
-    // Create tasks
-    const tasks: Task[] = subtasks.map((description, index) => {
-      const complexity = this.decompositionEngine.estimateComplexity(description);
-      const duration = this.decompositionEngine.estimateDuration(description, complexity);
-
-      return {
-        id: `task_${planId}_${index}`,
-        title: description,
-        description,
-        priority: this.inferPriority(description, index),
-        status: TaskStatus.PENDING,
-        estimatedDuration: duration,
-        dependencies: dependencies[index].map(i => `task_${planId}_${i}`),
-        subtasks: [],
-        tags: []
-      };
-    });
-
-    // Prioritize tasks
-    const prioritizedTasks = this.prioritizationEngine.prioritize(tasks);
-
-    // Add resources if provided
-    if (options.resources) {
-      options.resources.forEach(r => this.resourceAllocator.addResource(r));
-    }
-
-    // Allocate resources
-    const resourceAllocation = this.resourceAllocator.allocate(prioritizedTasks);
-
-    // Assign resources to tasks
-    prioritizedTasks.forEach(task => {
-      const allocated = resourceAllocation.get(task.id) || [];
-      if (allocated.length > 0) {
-        task.assignedTo = allocated[0];
-      }
-    });
-
-    // Create milestones
-    const milestones = this.createMilestones(prioritizedTasks, goal);
-
-    // Create timeline
-    const timeline = this.createTimeline(prioritizedTasks, milestones, options.deadline);
-
-    // Analyze risks
-    const risks = this.riskAnalyzer.analyzeRisks(
-      prioritizedTasks,
-      options.resources || []
-    );
-
-    const plan: Plan = {
-      id: planId,
-      goal,
-      tasks: prioritizedTasks,
-      milestones,
-      resources: options.resources || [],
-      timeline,
-      status: TaskStatus.PENDING,
-      createdAt,
-      updatedAt: createdAt
-    };
-
-    this.plans.set(planId, plan);
-
-    this.emit('planning_complete', {
-      id: planId,
-      stage: ThinkingStage.PLANNING,
-      timestamp: new Date(),
-      data: { 
-        plan,
-        taskCount: tasks.length,
-        riskCount: risks.length
-      }
-    } as ThinkingEvent);
-
-    return plan;
-  }
-
-  /**
-   * Update task progress
-   */
-  updateTaskProgress(
-    planId: string,
-    taskId: string,
-    progress: number,
-    status?: TaskStatus
-  ): void {
-    const plan = this.plans.get(planId);
-    if (!plan) throw new Error(`Plan ${planId} not found`);
-
-    const task = plan.tasks.find(t => t.id === taskId);
-    if (!task) throw new Error(`Task ${taskId} not found`);
-
-    const newStatus = status || (progress >= 100 ? TaskStatus.COMPLETED : progress > 0 ? TaskStatus.IN_PROGRESS : TaskStatus.PENDING);
-    
-    task.status = newStatus;
-    if (newStatus === TaskStatus.COMPLETED) {
-      task.endTime = new Date();
-    } else if (newStatus === TaskStatus.IN_PROGRESS && !task.startTime) {
-      task.startTime = new Date();
-    }
-
-    this.progressTracker.recordProgress(taskId, newStatus, progress);
-
-    // Update plan status
-    this.updatePlanStatus(plan);
-    plan.updatedAt = new Date();
-
-    this.emit('task_progress', {
-      id: taskId,
-      stage: ThinkingStage.PLANNING,
-      timestamp: new Date(),
-      data: { planId, taskId, progress, status: newStatus }
-    } as ThinkingEvent);
-  }
-
-  /**
-   * Generate progress report
-   */
-  generateProgressReport(planId: string): ProgressReport {
-    const plan = this.plans.get(planId);
-    if (!plan) throw new Error(`Plan ${planId} not found`);
-
-    const completedTasks = plan.tasks.filter(t => t.status === TaskStatus.COMPLETED).length;
-    const totalTasks = plan.tasks.length;
-    const overallProgress = totalTasks > 0 ? (completedTasks / totalTasks) * 100 : 0;
-
-    // Calculate if on track
-    const onTrack = this.isOnTrack(plan);
-
-    // Get risks
-    const risks = this.riskAnalyzer.analyzeRisks(plan.tasks, plan.resources);
-
-    // Determine next actions
-    const nextActions = this.determineNextActions(plan);
-
-    return {
-      planId,
-      timestamp: new Date(),
-      overallProgress,
-      completedTasks,
-      totalTasks,
-      onTrack,
-      risks,
-      nextActions
-    };
-  }
-
-  /**
-   * Adjust plan based on changes
-   */
-  adjustPlan(
-    planId: string,
-    changes: {
-      addTasks?: Omit<Task, 'id'>[];
-      removeTasks?: string[];
-      updateTasks?: Partial<Task>[];
-      newDeadline?: Date;
-    }
-  ): Plan {
-    const plan = this.plans.get(planId);
-    if (!plan) throw new Error(`Plan ${planId} not found`);
-
-    // Add new tasks
-    if (changes.addTasks) {
-      const newTasks = changes.addTasks.map((task, index) => ({
-        ...task,
-        id: `task_${planId}_new_${Date.now()}_${index}`
-      }));
-      plan.tasks.push(...newTasks);
-    }
-
-    // Remove tasks
-    if (changes.removeTasks) {
-      plan.tasks = plan.tasks.filter(t => !changes.removeTasks!.includes(t.id));
-    }
-
-    // Update tasks
-    if (changes.updateTasks) {
-      changes.updateTasks.forEach(update => {
-        const task = plan.tasks.find(t => t.id === (update as any).id);
-        if (task) {
-          Object.assign(task, update);
-        }
-      });
-    }
-
-    // Re-prioritize
-    plan.tasks = this.prioritizationEngine.prioritize(plan.tasks);
-
-    // Update timeline if new deadline
-    if (changes.newDeadline) {
-      plan.timeline.endDate = changes.newDeadline;
-    }
-
-    plan.updatedAt = new Date();
-
-    this.emit('plan_adjusted', {
-      id: planId,
-      stage: ThinkingStage.PLANNING,
-      timestamp: new Date(),
-      data: { changes }
-    } as ThinkingEvent);
-
-    return plan;
-  }
-
-  /**
-   * Get plan by ID
-   */
-  getPlan(planId: string): Plan | undefined {
-    return this.plans.get(planId);
-  }
-
-  /**
-   * Get all plans
-   */
-  getAllPlans(): Plan[] {
-    return Array.from(this.plans.values());
-  }
-
-  // Private helper methods
-  private generateId(): string {
-    return `plan_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  private inferPriority(description: string, index: number): Priority {
-    const lower = description.toLowerCase();
-    
-    if (lower.includes('critical') || lower.includes('urgent')) return Priority.CRITICAL;
-    if (lower.includes('important') || lower.includes('key')) return Priority.HIGH;
-    if (index < 2) return Priority.HIGH; // First tasks are usually important
-    if (lower.includes('optional') || lower.includes('nice to have')) return Priority.LOW;
-    
-    return Priority.MEDIUM;
-  }
-
-  private createMilestones(tasks: Task[], goal: string): Milestone[] {
-    const milestones: Milestone[] = [];
-    const totalTasks = tasks.length;
-
-    if (totalTasks >= 3) {
-      milestones.push({
-        id: `milestone_${Date.now()}_1`,
-        title: 'Phase 1 Complete',
-        description: 'Initial phase completed',
-        criteria: [`Complete ${Math.ceil(totalTasks * 0.25)} tasks`],
-        status: TaskStatus.PENDING
-      });
-    }
-
-    if (totalTasks >= 5) {
-      milestones.push({
-        id: `milestone_${Date.now()}_2`,
-        title: 'Halfway Point',
-        description: '50% of tasks completed',
-        criteria: [`Complete ${Math.ceil(totalTasks * 0.5)} tasks`],
-        status: TaskStatus.PENDING
-      });
-    }
-
-    milestones.push({
-      id: `milestone_${Date.now()}_final`,
-      title: 'Goal Achieved',
-      description: goal,
-      criteria: ['All tasks completed'],
-      status: TaskStatus.PENDING
-    });
-
-    return milestones;
-  }
-
-  private createTimeline(
-    tasks: Task[],
-    milestones: Milestone[],
-    deadline?: Date
-  ): Timeline {
-    const startDate = new Date();
-    const criticalPath = this.prioritizationEngine.calculateCriticalPath(tasks);
-    
-    // Calculate end date based on tasks
-    const totalDuration = tasks.reduce((sum, t) => sum + t.estimatedDuration, 0);
-    const calculatedEndDate = new Date(startDate.getTime() + totalDuration * 60000);
-
-    const endDate = deadline || calculatedEndDate;
-
-    // Create phases
-    const phases = this.createPhases(tasks);
-
-    return {
-      startDate,
-      endDate,
-      phases,
-      criticalPath,
-      buffer: deadline ? 
-        (deadline.getTime() - calculatedEndDate.getTime()) / 60000 : 
-        totalDuration * 0.2 // 20% buffer
-    };
-  }
-
-  private createPhases(tasks: Task[]): Phase[] {
-    const phases: Phase[] = [];
-    const phaseNames = ['Planning', 'Execution', 'Review'];
-    const tasksPerPhase = Math.ceil(tasks.length / phaseNames.length);
-
-    let currentDate = new Date();
-
-    phaseNames.forEach((name, index) => {
-      const phaseTasks = tasks.slice(index * tasksPerPhase, (index + 1) * tasksPerPhase);
-      const phaseDuration = phaseTasks.reduce((sum, t) => sum + t.estimatedDuration, 0);
-
-      const phase: Phase = {
-        id: `phase_${Date.now()}_${index}`,
-        name,
-        startDate: new Date(currentDate),
-        endDate: new Date(currentDate.getTime() + phaseDuration * 60000),
-        tasks: phaseTasks.map(t => t.id),
-        dependencies: index > 0 ? [`phase_${Date.now()}_${index - 1}`] : []
-      };
-
-      phases.push(phase);
-      currentDate = phase.endDate;
-    });
-
-    return phases;
-  }
-
-  private updatePlanStatus(plan: Plan): void {
-    const completed = plan.tasks.filter(t => t.status === TaskStatus.COMPLETED).length;
-    const inProgress = plan.tasks.filter(t => t.status === TaskStatus.IN_PROGRESS).length;
-    const failed = plan.tasks.filter(t => t.status === TaskStatus.FAILED).length;
-
-    if (failed > 0 && failed > plan.tasks.length * 0.3) {
-      plan.status = TaskStatus.FAILED;
-    } else if (completed === plan.tasks.length) {
-      plan.status = TaskStatus.COMPLETED;
-    } else if (inProgress > 0 || completed > 0) {
-      plan.status = TaskStatus.IN_PROGRESS;
-    }
-  }
-
-  private isOnTrack(plan: Plan): boolean {
-    if (!plan.timeline.endDate) return true;
-
-    const elapsed = Date.now() - plan.timeline.startDate.getTime();
-    const total = plan.timeline.endDate.getTime() - plan.timeline.startDate.getTime();
-    const expectedProgress = elapsed / total;
-
-    const completedTasks = plan.tasks.filter(t => t.status === TaskStatus.COMPLETED).length;
-    const actualProgress = completedTasks / plan.tasks.length;
-
-    return actualProgress >= expectedProgress * 0.8; // Allow 20% slack
-  }
-
-  private determineNextActions(plan: Plan): string[] {
-    const actions: string[] = [];
-
-    // Find pending tasks with no incomplete dependencies
-    const readyTasks = plan.tasks.filter(t => {
-      if (t.status !== TaskStatus.PENDING) return false;
-      return t.dependencies.every(depId => 
-        plan.tasks.find(t => t.id === depId)?.status === TaskStatus.COMPLETED
-      );
-    });
-
-    if (readyTasks.length > 0) {
-      actions.push(`Start task: ${readyTasks[0].title}`);
-    }
-
-    // Check for at-risk tasks
-    const inProgressTasks = plan.tasks.filter(t => t.status === TaskStatus.IN_PROGRESS);
-    inProgressTasks.forEach(task => {
-      const trend = this.progressTracker.getProgressTrend(task.id);
-      if (trend === 'declining') {
-        actions.push(`Review task: ${task.title} (progress declining)`);
-      }
-    });
-
-    return actions;
-  }
-}
-
-// ============================================================================
-// EXPORT SINGLETON INSTANCE
-// ============================================================================
-
-export const planningEngine = new PlanningEngine();
-
-// ============================================================================
-// EXAMPLE USAGE
-// ============================================================================
-
-/*
-// Create a plan
-const plan = planningEngine.createPlan(
-  'Build a scalable microservices architecture with AI capabilities',
-  {
-    resources: [
-      {
-        id: 'dev1',
-        type: 'human',
-        name: 'Senior Developer',
-        availability: 0.8,
-        skills: ['backend', 'microservices', 'typescript']
-      },
-      {
-        id: 'dev2',
-        type: 'human',
-        name: 'ML Engineer',
-        availability: 0.6,
-        skills: ['machine_learning', 'python', 'tensorflow']
-      }
-    ],
-    deadline: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) // 30 days
-  }
-);
-
-// Update task progress
-planningEngine.updateTaskProgress(plan.id, plan.tasks[0].id, 50, TaskStatus.IN_PROGRESS);
-planningEngine.updateTaskProgress(plan.id, plan.tasks[0].id, 100, TaskStatus.COMPLETED);
-
-// Generate progress report
-const report = planningEngine.generateProgressReport(plan.id);
-console.log(`Progress: ${report.overallProgress}%`);
-console.log(`On track: ${report.onTrack}`);
-console.log(`Next actions: ${report.nextActions.join(', ')}`);
-
-// Adjust plan
-const adjustedPlan = planningEngine.adjustPlan(plan.id, {
-  addTasks: [{
-    title: 'Security audit',
-    description: 'Perform security review',
-    priority: Priority.HIGH,
-    status: TaskStatus.PENDING,
-    estimatedDuration: 120,
-    dependencies: [],
-    subtasks: [],
-    tags: ['security']
-  }]
-});
-*/