gthinking 1.0.0

package/planning.ts

@@ -0,0 +1,1028 @@
+/**
+ * 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']
+  }]
+});
+*/