@stackmemoryai/stackmemory 0.5.59 → 0.5.61

package/dist/integrations/ralph/learning/pattern-learner.js

@@ -1,401 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { logger } from "../../../core/monitoring/logger.js";
-import { FrameManager } from "../../../core/context/index.js";
-import { sharedContextLayer } from "../../../core/context/shared-context-layer.js";
-import { sessionManager } from "../../../core/session/index.js";
-class PatternLearner {
-  frameManager;
-  config;
-  constructor(config) {
-    this.config = {
-      minLoopCountForPattern: 3,
-      confidenceThreshold: 0.7,
-      maxPatternsPerType: 10,
-      analysisDepth: "deep",
-      ...config
-    };
-    logger.info("Pattern learner initialized", this.config);
-  }
-  async initialize() {
-    try {
-      await sessionManager.initialize();
-      await sharedContextLayer.initialize();
-      const session = await sessionManager.getOrCreateSession({});
-      if (session.database) {
-        this.frameManager = new FrameManager(session.database, session.projectId);
-      }
-      logger.info("Pattern learner initialized successfully");
-    } catch (error) {
-      logger.error("Failed to initialize pattern learner", error);
-      throw error;
-    }
-  }
-  /**
-   * Learn patterns from all completed Ralph loops
-   */
-  async learnFromCompletedLoops() {
-    logger.info("Starting pattern learning from completed loops");
-    try {
-      const completedLoops = await this.getCompletedRalphLoops();
-      logger.info(`Found ${completedLoops.length} completed loops for analysis`);
-      if (completedLoops.length < this.config.minLoopCountForPattern) {
-        logger.info("Not enough loops for pattern extraction");
-        return [];
-      }
-      const patterns = [];
-      const successPatterns = await this.extractSuccessPatterns(completedLoops);
-      patterns.push(...successPatterns);
-      const failurePatterns = await this.extractFailurePatterns(completedLoops);
-      patterns.push(...failurePatterns);
-      const iterationPatterns = await this.extractIterationPatterns(completedLoops);
-      patterns.push(...iterationPatterns);
-      const taskPatterns = await this.extractTaskPatterns(completedLoops);
-      patterns.push(...taskPatterns);
-      await this.saveLearnedPatterns(patterns);
-      logger.info(`Learned ${patterns.length} patterns from ${completedLoops.length} loops`);
-      return patterns;
-    } catch (error) {
-      logger.error("Failed to learn patterns", error);
-      throw error;
-    }
-  }
-  /**
-   * Learn patterns specific to a task type
-   */
-  async learnForTaskType(taskType) {
-    logger.info(`Learning patterns for task type: ${taskType}`);
-    const completedLoops = await this.getCompletedRalphLoops();
-    const relevantLoops = completedLoops.filter(
-      (loop) => this.classifyTaskType(loop.task) === taskType
-    );
-    if (relevantLoops.length < this.config.minLoopCountForPattern) {
-      return [];
-    }
-    return this.extractSpecializedPatterns(relevantLoops, taskType);
-  }
-  /**
-   * Get all completed Ralph loops from StackMemory
-   */
-  async getCompletedRalphLoops() {
-    if (!this.frameManager) {
-      throw new Error("Frame manager not initialized");
-    }
-    try {
-      const ralphFrames = await this.frameManager.searchFrames({
-        type: "task",
-        namePattern: "ralph-*",
-        state: "closed"
-      });
-      const analyses = [];
-      for (const frame of ralphFrames) {
-        try {
-          const analysis = await this.analyzeCompletedLoop(frame);
-          if (analysis) {
-            analyses.push(analysis);
-          }
-        } catch (error) {
-          logger.warn(`Failed to analyze loop ${frame.frame_id}`, error);
-        }
-      }
-      return analyses;
-    } catch (error) {
-      logger.error("Failed to get completed loops", error);
-      return [];
-    }
-  }
-  /**
-   * Analyze a completed loop for patterns
-   */
-  async analyzeCompletedLoop(ralphFrame) {
-    if (!this.frameManager) return null;
-    try {
-      const loopState = ralphFrame.inputs;
-      const iterationFrames = await this.frameManager.searchFrames({
-        type: "subtask",
-        namePattern: "iteration-*",
-        parentId: ralphFrame.frame_id
-      });
-      const successMetrics = this.calculateSuccessMetrics(iterationFrames);
-      const iterationAnalysis = this.analyzeIterations(iterationFrames);
-      const outcome = this.determineLoopOutcome(ralphFrame, iterationFrames);
-      return {
-        loopId: loopState.loopId,
-        task: loopState.task,
-        criteria: loopState.criteria,
-        taskType: this.classifyTaskType(loopState.task),
-        iterationCount: iterationFrames.length,
-        outcome,
-        successMetrics,
-        iterationAnalysis,
-        duration: ralphFrame.updated_at - ralphFrame.created_at,
-        startTime: ralphFrame.created_at,
-        endTime: ralphFrame.updated_at
-      };
-    } catch (error) {
-      logger.error("Failed to analyze loop", error);
-      return null;
-    }
-  }
-  /**
-   * Extract patterns from successful loops
-   */
-  async extractSuccessPatterns(loops) {
-    const successfulLoops = loops.filter((l) => l.outcome === "success");
-    if (successfulLoops.length < this.config.minLoopCountForPattern) {
-      return [];
-    }
-    const patterns = [];
-    const avgIterations = successfulLoops.reduce((sum, l) => sum + l.iterationCount, 0) / successfulLoops.length;
-    patterns.push({
-      id: "optimal-iterations",
-      type: "iteration_strategy",
-      pattern: `Successful tasks typically complete in ${Math.round(avgIterations)} iterations`,
-      confidence: this.calculateConfidence(successfulLoops.length),
-      frequency: successfulLoops.length,
-      strategy: `Target ${Math.round(avgIterations)} iterations for similar tasks`,
-      examples: successfulLoops.slice(0, 3).map((l) => l.task),
-      metadata: {
-        avgIterations,
-        minIterations: Math.min(...successfulLoops.map((l) => l.iterationCount)),
-        maxIterations: Math.max(...successfulLoops.map((l) => l.iterationCount))
-      }
-    });
-    const criteriaPatterns = this.extractCriteriaPatterns(successfulLoops);
-    patterns.push(...criteriaPatterns);
-    const successFactors = this.extractSuccessFactors(successfulLoops);
-    patterns.push(...successFactors);
-    return patterns.filter((p) => p.confidence >= this.config.confidenceThreshold);
-  }
-  /**
-   * Extract patterns from failed loops to avoid
-   */
-  async extractFailurePatterns(loops) {
-    const failedLoops = loops.filter((l) => l.outcome === "failure");
-    if (failedLoops.length < this.config.minLoopCountForPattern) {
-      return [];
-    }
-    const patterns = [];
-    const commonFailures = this.analyzeFailurePoints(failedLoops);
-    for (const failure of commonFailures) {
-      patterns.push({
-        id: `avoid-${failure.type}`,
-        type: "failure_avoidance",
-        pattern: `Avoid: ${failure.pattern}`,
-        confidence: this.calculateConfidence(failure.frequency),
-        frequency: failure.frequency,
-        strategy: failure.avoidanceStrategy,
-        examples: failure.examples,
-        metadata: { failureType: failure.type }
-      });
-    }
-    return patterns.filter((p) => p.confidence >= this.config.confidenceThreshold);
-  }
-  /**
-   * Extract iteration-specific patterns
-   */
-  async extractIterationPatterns(loops) {
-    const patterns = [];
-    const iterationSequences = this.analyzeIterationSequences(loops);
-    for (const sequence of iterationSequences) {
-      if (sequence.frequency >= this.config.minLoopCountForPattern) {
-        patterns.push({
-          id: `iteration-sequence-${sequence.id}`,
-          type: "iteration_sequence",
-          pattern: sequence.description,
-          confidence: this.calculateConfidence(sequence.frequency),
-          frequency: sequence.frequency,
-          strategy: sequence.strategy,
-          examples: sequence.examples,
-          metadata: { sequenceType: sequence.type }
-        });
-      }
-    }
-    return patterns;
-  }
-  /**
-   * Extract task-specific patterns
-   */
-  async extractTaskPatterns(loops) {
-    const taskGroups = this.groupByTaskType(loops);
-    const patterns = [];
-    for (const [taskType, taskLoops] of Object.entries(taskGroups)) {
-      if (taskLoops.length >= this.config.minLoopCountForPattern) {
-        const taskSpecificPatterns = await this.extractSpecializedPatterns(taskLoops, taskType);
-        patterns.push(...taskSpecificPatterns);
-      }
-    }
-    return patterns;
-  }
-  /**
-   * Extract specialized patterns for specific task types
-   */
-  async extractSpecializedPatterns(loops, taskType) {
-    const patterns = [];
-    const successful = loops.filter((l) => l.outcome === "success");
-    if (successful.length === 0) return patterns;
-    patterns.push({
-      id: `${taskType}-success-pattern`,
-      type: "task_specific",
-      pattern: `${taskType} tasks: ${this.summarizeSuccessPattern(successful)}`,
-      confidence: this.calculateConfidence(successful.length),
-      frequency: successful.length,
-      strategy: this.generateTaskStrategy(successful),
-      examples: successful.slice(0, 2).map((l) => l.task),
-      metadata: { taskType, totalAttempts: loops.length }
-    });
-    return patterns;
-  }
-  /**
-   * Calculate success metrics for iterations
-   */
-  calculateSuccessMetrics(iterations) {
-    const total = iterations.length;
-    const successful = iterations.filter((i) => i.outputs?.success).length;
-    return {
-      iterationCount: total,
-      successRate: total > 0 ? successful / total : 0,
-      averageProgress: this.calculateAverageProgress(iterations),
-      timeToCompletion: total > 0 ? iterations[total - 1].updated_at - iterations[0].created_at : 0
-    };
-  }
-  /**
-   * Classify task type based on description
-   */
-  classifyTaskType(task) {
-    const taskLower = task.toLowerCase();
-    if (taskLower.includes("test") || taskLower.includes("unit")) return "testing";
-    if (taskLower.includes("fix") || taskLower.includes("bug")) return "bugfix";
-    if (taskLower.includes("refactor")) return "refactoring";
-    if (taskLower.includes("add") || taskLower.includes("implement")) return "feature";
-    if (taskLower.includes("document")) return "documentation";
-    if (taskLower.includes("optimize") || taskLower.includes("performance")) return "optimization";
-    return "general";
-  }
-  /**
-   * Determine loop outcome
-   */
-  determineLoopOutcome(ralphFrame, iterations) {
-    if (ralphFrame.digest_json?.status === "completed") return "success";
-    if (iterations.length === 0) return "unknown";
-    const lastIteration = iterations[iterations.length - 1];
-    if (lastIteration.outputs?.success) return "success";
-    return "failure";
-  }
-  /**
-   * Calculate confidence based on frequency
-   */
-  calculateConfidence(frequency) {
-    return Math.min(0.95, Math.log(frequency + 1) / Math.log(10));
-  }
-  /**
-   * Save learned patterns to shared context
-   */
-  async saveLearnedPatterns(patterns) {
-    try {
-      const context = await sharedContextLayer.getSharedContext();
-      if (!context) return;
-      const contextPatterns = patterns.map((p) => ({
-        pattern: p.pattern,
-        type: this.mapPatternType(p.type),
-        frequency: p.frequency,
-        lastSeen: Date.now(),
-        resolution: p.strategy
-      }));
-      context.globalPatterns.push(...contextPatterns);
-      context.globalPatterns.sort((a, b) => b.frequency - a.frequency);
-      context.globalPatterns = context.globalPatterns.slice(0, 100);
-      await sharedContextLayer.updateSharedContext(context);
-      logger.info(`Saved ${patterns.length} patterns to shared context`);
-    } catch (error) {
-      logger.error("Failed to save patterns", error);
-    }
-  }
-  /**
-   * Map pattern types to shared context types
-   */
-  mapPatternType(patternType) {
-    switch (patternType) {
-      case "failure_avoidance":
-        return "error";
-      case "success_strategy":
-        return "success";
-      case "task_specific":
-        return "learning";
-      default:
-        return "learning";
-    }
-  }
-  // Additional helper methods for pattern analysis
-  analyzeIterations(iterations) {
-    return {
-      avgDuration: iterations.length > 0 ? iterations.reduce((sum, i) => sum + (i.updated_at - i.created_at), 0) / iterations.length : 0,
-      progressPattern: this.extractProgressPattern(iterations),
-      commonIssues: this.extractCommonIssues(iterations)
-    };
-  }
-  extractProgressPattern(iterations) {
-    const progressSteps = iterations.map((_, i) => {
-      const progress = i / iterations.length;
-      return Math.round(progress * 100);
-    });
-    return progressSteps.join(" \u2192 ") + "%";
-  }
-  extractCommonIssues(iterations) {
-    return iterations.filter((i) => i.outputs?.errors?.length > 0).flatMap((i) => i.outputs.errors).slice(0, 3);
-  }
-  extractCriteriaPatterns(loops) {
-    const criteriaWords = loops.flatMap((l) => l.criteria.toLowerCase().split(/\s+/));
-    const wordCounts = criteriaWords.reduce((acc, word) => {
-      acc[word] = (acc[word] || 0) + 1;
-      return acc;
-    }, {});
-    const commonCriteria = Object.entries(wordCounts).filter(([_, count]) => count >= this.config.minLoopCountForPattern).sort((a, b) => b[1] - a[1]).slice(0, 3);
-    return commonCriteria.map(([word, count]) => ({
-      id: `criteria-${word}`,
-      type: "success_strategy",
-      pattern: `Successful tasks often include "${word}" in completion criteria`,
-      confidence: this.calculateConfidence(count),
-      frequency: count,
-      strategy: `Consider including "${word}" in task completion criteria`,
-      examples: loops.filter((l) => l.criteria.toLowerCase().includes(word)).slice(0, 2).map((l) => l.task),
-      metadata: { criteriaWord: word }
-    }));
-  }
-  extractSuccessFactors(loops) {
-    return [];
-  }
-  analyzeFailurePoints(loops) {
-    return [];
-  }
-  analyzeIterationSequences(loops) {
-    return [];
-  }
-  groupByTaskType(loops) {
-    return loops.reduce((acc, loop) => {
-      const type = loop.taskType;
-      if (!acc[type]) acc[type] = [];
-      acc[type].push(loop);
-      return acc;
-    }, {});
-  }
-  summarizeSuccessPattern(loops) {
-    const avgIterations = loops.reduce((sum, l) => sum + l.iterationCount, 0) / loops.length;
-    return `typically complete in ${Math.round(avgIterations)} iterations with ${Math.round(loops[0]?.successMetrics?.successRate * 100 || 0)}% success rate`;
-  }
-  generateTaskStrategy(loops) {
-    const avgIterations = loops.reduce((sum, l) => sum + l.iterationCount, 0) / loops.length;
-    return `Plan for approximately ${Math.round(avgIterations)} iterations and focus on iterative improvement`;
-  }
-  calculateAverageProgress(iterations) {
-    return iterations.length > 0 ? iterations.length / 10 : 0;
-  }
-}
-const patternLearner = new PatternLearner();
-export {
-  PatternLearner,
-  patternLearner
-};
-//# sourceMappingURL=pattern-learner.js.map

package/dist/integrations/ralph/learning/pattern-learner.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/integrations/ralph/learning/pattern-learner.ts"],
-  "sourcesContent": ["/**\n * Pattern Learning Engine for Ralph Loops\n * Analyzes completed loops to extract reusable patterns and strategies\n */\n\nimport { logger } from '../../../core/monitoring/logger.js';\nimport { FrameManager } from '../../../core/context/index.js';\nimport { sharedContextLayer } from '../../../core/context/shared-context-layer.js';\nimport { sessionManager } from '../../../core/session/index.js';\nimport {\n  LearnedPattern,\n  LoopAnalysis,\n  PatternType,\n  SuccessMetrics,\n  FailureAnalysis,\n  RalphLoopState\n} from '../types.js';\n\nexport interface PatternLearningConfig {\n  minLoopCountForPattern: number;\n  confidenceThreshold: number;\n  maxPatternsPerType: number;\n  analysisDepth: 'shallow' | 'deep' | 'comprehensive';\n}\n\nexport class PatternLearner {\n  private frameManager?: FrameManager;\n  private config: PatternLearningConfig;\n\n  constructor(config?: Partial<PatternLearningConfig>) {\n    this.config = {\n      minLoopCountForPattern: 3,\n      confidenceThreshold: 0.7,\n      maxPatternsPerType: 10,\n      analysisDepth: 'deep',\n      ...config\n    };\n\n    logger.info('Pattern learner initialized', this.config);\n  }\n\n  async initialize(): Promise<void> {\n    try {\n      await sessionManager.initialize();\n      await sharedContextLayer.initialize();\n\n      const session = await sessionManager.getOrCreateSession({});\n      if (session.database) {\n        this.frameManager = new FrameManager(session.database, session.projectId);\n      }\n\n      logger.info('Pattern learner initialized successfully');\n    } catch (error: unknown) {\n      logger.error('Failed to initialize pattern learner', error as Error);\n      throw error;\n    }\n  }\n\n  /**\n   * Learn patterns from all completed Ralph loops\n   */\n  async learnFromCompletedLoops(): Promise<LearnedPattern[]> {\n    logger.info('Starting pattern learning from completed loops');\n\n    try {\n      const completedLoops = await this.getCompletedRalphLoops();\n      logger.info(`Found ${completedLoops.length} completed loops for analysis`);\n\n      if (completedLoops.length < this.config.minLoopCountForPattern) {\n        logger.info('Not enough loops for pattern extraction');\n        return [];\n      }\n\n      const patterns: LearnedPattern[] = [];\n\n      // Learn success patterns\n      const successPatterns = await this.extractSuccessPatterns(completedLoops);\n      patterns.push(...successPatterns);\n\n      // Learn failure patterns (to avoid)\n      const failurePatterns = await this.extractFailurePatterns(completedLoops);\n      patterns.push(...failurePatterns);\n\n      // Learn iteration patterns\n      const iterationPatterns = await this.extractIterationPatterns(completedLoops);\n      patterns.push(...iterationPatterns);\n\n      // Learn task-specific patterns\n      const taskPatterns = await this.extractTaskPatterns(completedLoops);\n      patterns.push(...taskPatterns);\n\n      // Save patterns to shared context\n      await this.saveLearnedPatterns(patterns);\n\n      logger.info(`Learned ${patterns.length} patterns from ${completedLoops.length} loops`);\n      return patterns;\n\n    } catch (error: unknown) {\n      logger.error('Failed to learn patterns', error as Error);\n      throw error;\n    }\n  }\n\n  /**\n   * Learn patterns specific to a task type\n   */\n  async learnForTaskType(taskType: string): Promise<LearnedPattern[]> {\n    logger.info(`Learning patterns for task type: ${taskType}`);\n\n    const completedLoops = await this.getCompletedRalphLoops();\n    const relevantLoops = completedLoops.filter(loop => \n      this.classifyTaskType(loop.task) === taskType\n    );\n\n    if (relevantLoops.length < this.config.minLoopCountForPattern) {\n      return [];\n    }\n\n    return this.extractSpecializedPatterns(relevantLoops, taskType);\n  }\n\n  /**\n   * Get all completed Ralph loops from StackMemory\n   */\n  private async getCompletedRalphLoops(): Promise<LoopAnalysis[]> {\n    if (!this.frameManager) {\n      throw new Error('Frame manager not initialized');\n    }\n\n    try {\n      // Get all Ralph loop frames\n      const ralphFrames = await this.frameManager.searchFrames({\n        type: 'task',\n        namePattern: 'ralph-*',\n        state: 'closed'\n      });\n\n      const analyses: LoopAnalysis[] = [];\n\n      for (const frame of ralphFrames) {\n        try {\n          const analysis = await this.analyzeCompletedLoop(frame);\n          if (analysis) {\n            analyses.push(analysis);\n          }\n        } catch (error: unknown) {\n          logger.warn(`Failed to analyze loop ${frame.frame_id}`, error as Error);\n        }\n      }\n\n      return analyses;\n\n    } catch (error: unknown) {\n      logger.error('Failed to get completed loops', error as Error);\n      return [];\n    }\n  }\n\n  /**\n   * Analyze a completed loop for patterns\n   */\n  private async analyzeCompletedLoop(ralphFrame: any): Promise<LoopAnalysis | null> {\n    if (!this.frameManager) return null;\n\n    try {\n      // Get loop state from frame inputs\n      const loopState = ralphFrame.inputs as RalphLoopState;\n      \n      // Get all iteration frames for this loop\n      const iterationFrames = await this.frameManager.searchFrames({\n        type: 'subtask',\n        namePattern: 'iteration-*',\n        parentId: ralphFrame.frame_id\n      });\n\n      // Calculate success metrics\n      const successMetrics = this.calculateSuccessMetrics(iterationFrames);\n      \n      // Analyze iteration patterns\n      const iterationAnalysis = this.analyzeIterations(iterationFrames);\n      \n      // Determine outcome\n      const outcome = this.determineLoopOutcome(ralphFrame, iterationFrames);\n\n      return {\n        loopId: loopState.loopId,\n        task: loopState.task,\n        criteria: loopState.criteria,\n        taskType: this.classifyTaskType(loopState.task),\n        iterationCount: iterationFrames.length,\n        outcome,\n        successMetrics,\n        iterationAnalysis,\n        duration: ralphFrame.updated_at - ralphFrame.created_at,\n        startTime: ralphFrame.created_at,\n        endTime: ralphFrame.updated_at\n      };\n\n    } catch (error: unknown) {\n      logger.error('Failed to analyze loop', error as Error);\n      return null;\n    }\n  }\n\n  /**\n   * Extract patterns from successful loops\n   */\n  private async extractSuccessPatterns(loops: LoopAnalysis[]): Promise<LearnedPattern[]> {\n    const successfulLoops = loops.filter(l => l.outcome === 'success');\n    \n    if (successfulLoops.length < this.config.minLoopCountForPattern) {\n      return [];\n    }\n\n    const patterns: LearnedPattern[] = [];\n\n    // Pattern: Optimal iteration count\n    const avgIterations = successfulLoops.reduce((sum, l) => sum + l.iterationCount, 0) / successfulLoops.length;\n    patterns.push({\n      id: 'optimal-iterations',\n      type: 'iteration_strategy',\n      pattern: `Successful tasks typically complete in ${Math.round(avgIterations)} iterations`,\n      confidence: this.calculateConfidence(successfulLoops.length),\n      frequency: successfulLoops.length,\n      strategy: `Target ${Math.round(avgIterations)} iterations for similar tasks`,\n      examples: successfulLoops.slice(0, 3).map(l => l.task),\n      metadata: {\n        avgIterations,\n        minIterations: Math.min(...successfulLoops.map(l => l.iterationCount)),\n        maxIterations: Math.max(...successfulLoops.map(l => l.iterationCount))\n      }\n    });\n\n    // Pattern: Task completion criteria\n    const criteriaPatterns = this.extractCriteriaPatterns(successfulLoops);\n    patterns.push(...criteriaPatterns);\n\n    // Pattern: Common success factors\n    const successFactors = this.extractSuccessFactors(successfulLoops);\n    patterns.push(...successFactors);\n\n    return patterns.filter(p => p.confidence >= this.config.confidenceThreshold);\n  }\n\n  /**\n   * Extract patterns from failed loops to avoid\n   */\n  private async extractFailurePatterns(loops: LoopAnalysis[]): Promise<LearnedPattern[]> {\n    const failedLoops = loops.filter(l => l.outcome === 'failure');\n    \n    if (failedLoops.length < this.config.minLoopCountForPattern) {\n      return [];\n    }\n\n    const patterns: LearnedPattern[] = [];\n\n    // Pattern: Common failure points\n    const commonFailures = this.analyzeFailurePoints(failedLoops);\n    for (const failure of commonFailures) {\n      patterns.push({\n        id: `avoid-${failure.type}`,\n        type: 'failure_avoidance',\n        pattern: `Avoid: ${failure.pattern}`,\n        confidence: this.calculateConfidence(failure.frequency),\n        frequency: failure.frequency,\n        strategy: failure.avoidanceStrategy,\n        examples: failure.examples,\n        metadata: { failureType: failure.type }\n      });\n    }\n\n    return patterns.filter(p => p.confidence >= this.config.confidenceThreshold);\n  }\n\n  /**\n   * Extract iteration-specific patterns\n   */\n  private async extractIterationPatterns(loops: LoopAnalysis[]): Promise<LearnedPattern[]> {\n    const patterns: LearnedPattern[] = [];\n\n    // Analyze iteration sequences\n    const iterationSequences = this.analyzeIterationSequences(loops);\n    \n    for (const sequence of iterationSequences) {\n      if (sequence.frequency >= this.config.minLoopCountForPattern) {\n        patterns.push({\n          id: `iteration-sequence-${sequence.id}`,\n          type: 'iteration_sequence',\n          pattern: sequence.description,\n          confidence: this.calculateConfidence(sequence.frequency),\n          frequency: sequence.frequency,\n          strategy: sequence.strategy,\n          examples: sequence.examples,\n          metadata: { sequenceType: sequence.type }\n        });\n      }\n    }\n\n    return patterns;\n  }\n\n  /**\n   * Extract task-specific patterns\n   */\n  private async extractTaskPatterns(loops: LoopAnalysis[]): Promise<LearnedPattern[]> {\n    const taskGroups = this.groupByTaskType(loops);\n    const patterns: LearnedPattern[] = [];\n\n    for (const [taskType, taskLoops] of Object.entries(taskGroups)) {\n      if (taskLoops.length >= this.config.minLoopCountForPattern) {\n        const taskSpecificPatterns = await this.extractSpecializedPatterns(taskLoops, taskType);\n        patterns.push(...taskSpecificPatterns);\n      }\n    }\n\n    return patterns;\n  }\n\n  /**\n   * Extract specialized patterns for specific task types\n   */\n  private async extractSpecializedPatterns(loops: LoopAnalysis[], taskType: string): Promise<LearnedPattern[]> {\n    const patterns: LearnedPattern[] = [];\n    const successful = loops.filter(l => l.outcome === 'success');\n\n    if (successful.length === 0) return patterns;\n\n    // Task-specific success pattern\n    patterns.push({\n      id: `${taskType}-success-pattern`,\n      type: 'task_specific',\n      pattern: `${taskType} tasks: ${this.summarizeSuccessPattern(successful)}`,\n      confidence: this.calculateConfidence(successful.length),\n      frequency: successful.length,\n      strategy: this.generateTaskStrategy(successful),\n      examples: successful.slice(0, 2).map(l => l.task),\n      metadata: { taskType, totalAttempts: loops.length }\n    });\n\n    return patterns;\n  }\n\n  /**\n   * Calculate success metrics for iterations\n   */\n  private calculateSuccessMetrics(iterations: any[]): SuccessMetrics {\n    const total = iterations.length;\n    const successful = iterations.filter(i => i.outputs?.success).length;\n    \n    return {\n      iterationCount: total,\n      successRate: total > 0 ? successful / total : 0,\n      averageProgress: this.calculateAverageProgress(iterations),\n      timeToCompletion: total > 0 ? iterations[total - 1].updated_at - iterations[0].created_at : 0\n    };\n  }\n\n  /**\n   * Classify task type based on description\n   */\n  private classifyTaskType(task: string): string {\n    const taskLower = task.toLowerCase();\n    \n    if (taskLower.includes('test') || taskLower.includes('unit')) return 'testing';\n    if (taskLower.includes('fix') || taskLower.includes('bug')) return 'bugfix';\n    if (taskLower.includes('refactor')) return 'refactoring';\n    if (taskLower.includes('add') || taskLower.includes('implement')) return 'feature';\n    if (taskLower.includes('document')) return 'documentation';\n    if (taskLower.includes('optimize') || taskLower.includes('performance')) return 'optimization';\n    \n    return 'general';\n  }\n\n  /**\n   * Determine loop outcome\n   */\n  private determineLoopOutcome(ralphFrame: any, iterations: any[]): 'success' | 'failure' | 'unknown' {\n    if (ralphFrame.digest_json?.status === 'completed') return 'success';\n    if (iterations.length === 0) return 'unknown';\n    \n    const lastIteration = iterations[iterations.length - 1];\n    if (lastIteration.outputs?.success) return 'success';\n    \n    return 'failure';\n  }\n\n  /**\n   * Calculate confidence based on frequency\n   */\n  private calculateConfidence(frequency: number): number {\n    // Simple confidence calculation based on sample size\n    return Math.min(0.95, Math.log(frequency + 1) / Math.log(10));\n  }\n\n  /**\n   * Save learned patterns to shared context\n   */\n  private async saveLearnedPatterns(patterns: LearnedPattern[]): Promise<void> {\n    try {\n      const context = await sharedContextLayer.getSharedContext();\n      if (!context) return;\n\n      // Convert to shared context format\n      const contextPatterns = patterns.map(p => ({\n        pattern: p.pattern,\n        type: this.mapPatternType(p.type),\n        frequency: p.frequency,\n        lastSeen: Date.now(),\n        resolution: p.strategy\n      }));\n\n      // Add to global patterns\n      context.globalPatterns.push(...contextPatterns);\n\n      // Keep only the most relevant patterns\n      context.globalPatterns.sort((a, b) => b.frequency - a.frequency);\n      context.globalPatterns = context.globalPatterns.slice(0, 100);\n\n      await sharedContextLayer.updateSharedContext(context);\n      \n      logger.info(`Saved ${patterns.length} patterns to shared context`);\n\n    } catch (error: unknown) {\n      logger.error('Failed to save patterns', error as Error);\n    }\n  }\n\n  /**\n   * Map pattern types to shared context types\n   */\n  private mapPatternType(patternType: PatternType): 'error' | 'success' | 'decision' | 'learning' {\n    switch (patternType) {\n      case 'failure_avoidance': return 'error';\n      case 'success_strategy': return 'success';\n      case 'task_specific': return 'learning';\n      default: return 'learning';\n    }\n  }\n\n  // Additional helper methods for pattern analysis\n  private analyzeIterations(iterations: any[]): any {\n    return {\n      avgDuration: iterations.length > 0 ? \n        iterations.reduce((sum, i) => sum + (i.updated_at - i.created_at), 0) / iterations.length : 0,\n      progressPattern: this.extractProgressPattern(iterations),\n      commonIssues: this.extractCommonIssues(iterations)\n    };\n  }\n\n  private extractProgressPattern(iterations: any[]): string {\n    // Analyze how progress typically unfolds\n    const progressSteps = iterations.map((_, i) => {\n      const progress = i / iterations.length;\n      return Math.round(progress * 100);\n    });\n    \n    return progressSteps.join(' \u2192 ') + '%';\n  }\n\n  private extractCommonIssues(iterations: any[]): string[] {\n    // Extract common error patterns from iteration outputs\n    return iterations\n      .filter(i => i.outputs?.errors?.length > 0)\n      .flatMap(i => i.outputs.errors)\n      .slice(0, 3);\n  }\n\n  private extractCriteriaPatterns(loops: LoopAnalysis[]): LearnedPattern[] {\n    // Analyze common successful completion criteria\n    const criteriaWords = loops.flatMap(l => l.criteria.toLowerCase().split(/\\s+/));\n    const wordCounts = criteriaWords.reduce((acc, word) => {\n      acc[word] = (acc[word] || 0) + 1;\n      return acc;\n    }, {} as Record<string, number>);\n\n    const commonCriteria = Object.entries(wordCounts)\n      .filter(([_, count]) => count >= this.config.minLoopCountForPattern)\n      .sort((a, b) => b[1] - a[1])\n      .slice(0, 3);\n\n    return commonCriteria.map(([word, count]) => ({\n      id: `criteria-${word}`,\n      type: 'success_strategy' as PatternType,\n      pattern: `Successful tasks often include \"${word}\" in completion criteria`,\n      confidence: this.calculateConfidence(count),\n      frequency: count,\n      strategy: `Consider including \"${word}\" in task completion criteria`,\n      examples: loops.filter(l => l.criteria.toLowerCase().includes(word)).slice(0, 2).map(l => l.task),\n      metadata: { criteriaWord: word }\n    }));\n  }\n\n  private extractSuccessFactors(loops: LoopAnalysis[]): LearnedPattern[] {\n    // Placeholder for success factor analysis\n    return [];\n  }\n\n  private analyzeFailurePoints(loops: LoopAnalysis[]): FailureAnalysis[] {\n    // Placeholder for failure analysis\n    return [];\n  }\n\n  private analyzeIterationSequences(loops: LoopAnalysis[]): any[] {\n    // Placeholder for iteration sequence analysis\n    return [];\n  }\n\n  private groupByTaskType(loops: LoopAnalysis[]): Record<string, LoopAnalysis[]> {\n    return loops.reduce((acc, loop) => {\n      const type = loop.taskType;\n      if (!acc[type]) acc[type] = [];\n      acc[type].push(loop);\n      return acc;\n    }, {} as Record<string, LoopAnalysis[]>);\n  }\n\n  private summarizeSuccessPattern(loops: LoopAnalysis[]): string {\n    const avgIterations = loops.reduce((sum, l) => sum + l.iterationCount, 0) / loops.length;\n    return `typically complete in ${Math.round(avgIterations)} iterations with ${Math.round(loops[0]?.successMetrics?.successRate * 100 || 0)}% success rate`;\n  }\n\n  private generateTaskStrategy(loops: LoopAnalysis[]): string {\n    const avgIterations = loops.reduce((sum, l) => sum + l.iterationCount, 0) / loops.length;\n    return `Plan for approximately ${Math.round(avgIterations)} iterations and focus on iterative improvement`;\n  }\n\n  private calculateAverageProgress(iterations: any[]): number {\n    // Simple progress calculation\n    return iterations.length > 0 ? iterations.length / 10 : 0; // Assume 10 iterations is 100% progress\n  }\n}\n\n// Export default instance\nexport const patternLearner = new PatternLearner();"],
-  "mappings": "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",
-  "names": []
-}