@stackmemoryai/stackmemory 1.2.2 → 1.2.4

package/dist/src/integrations/ralph/context/stackmemory-context-loader.js

@@ -46,7 +46,10 @@ class StackMemoryContextLoader {
       await sharedContextLayer.initialize();
       const session = await sessionManager.getOrCreateSession({});
       if (session.database) {
-        this.frameManager = new FrameManager(session.database, session.projectId);
+        this.frameManager = new FrameManager(
+          session.database,
+          session.projectId
+        );
         this.contextRetriever = new ContextRetriever(session.database);
       }
       logger.info("Context loader initialized successfully");
@@ -115,17 +118,25 @@ class StackMemoryContextLoader {
         totalTokens += sources[sources.length - 1].tokens;
       }
       const budgetedSources = this.budgetManager.allocateBudget({ sources });
-      const synthesizedContext = this.synthesizeContext(budgetedSources.sources);
+      const synthesizedContext = this.synthesizeContext(
+        budgetedSources.sources
+      );
       logger.info("Context loaded successfully", {
         totalSources: sources.length,
         totalTokens,
-        budgetedTokens: budgetedSources.sources.reduce((sum, s) => sum + s.tokens, 0)
+        budgetedTokens: budgetedSources.sources.reduce(
+          (sum, s) => sum + s.tokens,
+          0
+        )
       });
       return {
         context: synthesizedContext,
         sources: budgetedSources.sources,
         metadata: {
-          totalTokens: budgetedSources.sources.reduce((sum, s) => sum + s.tokens, 0),
+          totalTokens: budgetedSources.sources.reduce(
+            (sum, s) => sum + s.tokens,
+            0
+          ),
           sourcesCount: budgetedSources.sources.length,
           patterns: request.usePatterns ? patterns : [],
           similarTasks: request.useSimilarTasks ? similarTasks : []
@@ -144,16 +155,22 @@ class StackMemoryContextLoader {
       return [];
     }
     try {
-      const searchResults = await this.contextRetriever.search(taskDescription, {
-        maxResults: 10,
-        types: ["task", "subtask"],
-        timeFilter: {
-          days: this.config.lookbackDays
+      const searchResults = await this.contextRetriever.search(
+        taskDescription,
+        {
+          maxResults: 10,
+          types: ["task", "subtask"],
+          timeFilter: {
+            days: this.config.lookbackDays
+          }
         }
-      });
+      );
       const similarities = [];
       for (const result of searchResults) {
-        const similarity = this.calculateTaskSimilarity(taskDescription, result.content);
+        const similarity = this.calculateTaskSimilarity(
+          taskDescription,
+          result.content
+        );
         if (similarity >= this.config.similarityThreshold) {
           similarities.push({
             frameId: result.frameId,
@@ -184,7 +201,10 @@ class StackMemoryContextLoader {
       if (!context) return [];
       const relevantPatterns = [];
       for (const pattern of context.globalPatterns) {
-        const relevance = this.calculatePatternRelevance(taskDescription, pattern.pattern);
+        const relevance = this.calculatePatternRelevance(
+          taskDescription,
+          pattern.pattern
+        );
         if (relevance >= 0.5) {
           relevantPatterns.push({
             pattern: pattern.pattern,
@@ -197,7 +217,9 @@ class StackMemoryContextLoader {
           });
         }
       }
-      return relevantPatterns.sort((a, b) => b.relevance * Math.log(b.frequency + 1) - a.relevance * Math.log(a.frequency + 1)).slice(0, 8);
+      return relevantPatterns.sort(
+        (a, b) => b.relevance * Math.log(b.frequency + 1) - a.relevance * Math.log(a.frequency + 1)
+      ).slice(0, 8);
     } catch (error) {
       logger.error("Failed to extract patterns", error);
       return [];
@@ -270,12 +292,14 @@ class StackMemoryContextLoader {
     const contextParts = [];
     contextParts.push("Similar tasks from history:");
     for (const sim of similarities) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Task: ${sim.task}
 Outcome: ${sim.outcome}
 Similarity: ${Math.round(sim.similarity * 100)}%
 ${sim.outcome === "success" ? "\u2705 Successfully completed" : "\u274C Had issues"}
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -286,13 +310,15 @@ ${sim.outcome === "success" ? "\u2705 Successfully completed" : "\u274C Had issu
     const contextParts = [];
     contextParts.push("Relevant patterns from experience:");
     for (const pattern of patterns2) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Pattern: ${pattern.pattern}
 Type: ${pattern.type}
 Frequency: ${pattern.frequency} occurrences
 ${pattern.resolution ? `Resolution: ${pattern.resolution}` : ""}
 Relevance: ${Math.round(pattern.relevance * 100)}%
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -303,11 +329,13 @@ Relevance: ${Math.round(pattern.relevance * 100)}%
     const contextParts = [];
     contextParts.push("Recent successful decisions:");
     for (const decision of decisions) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Decision: ${decision.decision}
 Reasoning: ${decision.reasoning}
 Date: ${new Date(decision.timestamp).toLocaleDateString()}
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -322,11 +350,15 @@ Date: ${new Date(decision.timestamp).toLocaleDateString()}
     contextParts.push("Context from StackMemory:");
     const sortedSources = sources.sort((a, b) => b.weight - a.weight);
     for (const source of sortedSources) {
-      contextParts.push(`
---- ${source.type.replace("_", " ").toUpperCase()} ---`);
+      contextParts.push(
+        `
+--- ${source.type.replace("_", " ").toUpperCase()} ---`
+      );
       contextParts.push(source.content);
     }
-    contextParts.push("\nUse this context to inform your approach to the current task.");
+    contextParts.push(
+      "\nUse this context to inform your approach to the current task."
+    );
     return contextParts.join("\n");
   }
   /**

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

@@ -25,7 +25,10 @@ class PatternLearner {
       await sharedContextLayer.initialize();
       const session = await sessionManager.getOrCreateSession({});
       if (session.database) {
-        this.frameManager = new FrameManager(session.database, session.projectId);
+        this.frameManager = new FrameManager(
+          session.database,
+          session.projectId
+        );
       }
       logger.info("Pattern learner initialized successfully");
     } catch (error) {
@@ -40,7 +43,9 @@ class PatternLearner {
     logger.info("Starting pattern learning from completed loops");
     try {
       const completedLoops = await this.getCompletedRalphLoops();
-      logger.info(`Found ${completedLoops.length} completed loops for analysis`);
+      logger.info(
+        `Found ${completedLoops.length} completed loops for analysis`
+      );
       if (completedLoops.length < this.config.minLoopCountForPattern) {
         logger.info("Not enough loops for pattern extraction");
         return [];
@@ -55,7 +60,9 @@ class PatternLearner {
       const taskPatterns = await this.extractTaskPatterns(completedLoops);
       patterns.push(...taskPatterns);
       await this.saveLearnedPatterns(patterns);
-      logger.info(`Learned ${patterns.length} patterns from ${completedLoops.length} loops`);
+      logger.info(
+        `Learned ${patterns.length} patterns from ${completedLoops.length} loops`
+      );
       return patterns;
     } catch (error) {
       logger.error("Failed to learn patterns", error);
@@ -97,7 +104,10 @@ class PatternLearner {
             analyses.push(analysis);
           }
         } catch (error) {
-          logger.warn(`Failed to analyze loop ${frame.frame_id}`, error);
+          logger.warn(
+            `Failed to analyze loop ${frame.frame_id}`,
+            error
+          );
         }
       }
       return analyses;
@@ -159,15 +169,21 @@ class PatternLearner {
       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))
+        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);
+    return patterns.filter(
+      (p) => p.confidence >= this.config.confidenceThreshold
+    );
   }
   /**
    * Extract patterns from failed loops to avoid
@@ -191,7 +207,9 @@ class PatternLearner {
         metadata: { failureType: failure.type }
       });
     }
-    return patterns.filter((p) => p.confidence >= this.config.confidenceThreshold);
+    return patterns.filter(
+      (p) => p.confidence >= this.config.confidenceThreshold
+    );
   }
   /**
    * Extract iteration-specific patterns
@@ -223,7 +241,10 @@ class PatternLearner {
     const patterns = [];
     for (const [taskType, taskLoops] of Object.entries(taskGroups)) {
       if (taskLoops.length >= this.config.minLoopCountForPattern) {
-        const taskSpecificPatterns = await this.extractSpecializedPatterns(taskLoops, taskType);
+        const taskSpecificPatterns = await this.extractSpecializedPatterns(
+          taskLoops,
+          taskType
+        );
         patterns.push(...taskSpecificPatterns);
       }
     }
@@ -266,12 +287,15 @@ class PatternLearner {
    */
   classifyTaskType(task) {
     const taskLower = task.toLowerCase();
-    if (taskLower.includes("test") || taskLower.includes("unit")) return "testing";
+    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("add") || taskLower.includes("implement"))
+      return "feature";
     if (taskLower.includes("document")) return "documentation";
-    if (taskLower.includes("optimize") || taskLower.includes("performance")) return "optimization";
+    if (taskLower.includes("optimize") || taskLower.includes("performance"))
+      return "optimization";
     return "general";
   }
   /**
@@ -331,7 +355,10 @@ class PatternLearner {
   // 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,
+      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)
     };
@@ -347,11 +374,16 @@ class PatternLearner {
     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 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}`,
@@ -374,12 +406,15 @@ class PatternLearner {
     return [];
   }
   groupByTaskType(loops) {
-    return loops.reduce((acc, loop) => {
-      const type = loop.taskType;
-      if (!acc[type]) acc[type] = [];
-      acc[type].push(loop);
-      return acc;
-    }, {});
+    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;

package/dist/src/integrations/ralph/orchestration/multi-loop-orchestrator.js

@@ -29,7 +29,10 @@ class MultiLoopOrchestrator {
       await sessionManager.initialize();
       const session = await sessionManager.getOrCreateSession({});
       if (session.database) {
-        this.frameManager = new FrameManager(session.database, session.projectId);
+        this.frameManager = new FrameManager(
+          session.database,
+          session.projectId
+        );
       }
       logger.info("Orchestrator initialized successfully");
     } catch (error) {
@@ -92,11 +95,15 @@ class MultiLoopOrchestrator {
       results: /* @__PURE__ */ new Map(),
       sharedState: coordination?.sharedState || {}
     };
-    const promises = tasks.map((task) => this.executeParallelTask(task, execution));
+    const promises = tasks.map(
+      (task) => this.executeParallelTask(task, execution)
+    );
     try {
       await Promise.allSettled(promises);
       execution.endTime = Date.now();
-      execution.status = Array.from(execution.results.values()).every((r) => r.success) ? "success" : "partial";
+      execution.status = Array.from(execution.results.values()).every(
+        (r) => r.success
+      ) ? "success" : "partial";
       return execution;
     } catch (error) {
       logger.error("Parallel execution failed", error);
@@ -111,16 +118,18 @@ class MultiLoopOrchestrator {
   async analyzeAndBreakdownTask(description, criteria) {
     const complexity = this.assessTaskComplexity(description);
     if (complexity.score < 5) {
-      return [{
-        id: uuidv4(),
-        title: description,
-        description,
-        criteria,
-        priority: 1,
-        estimatedIterations: 3,
-        dependencies: [],
-        type: "single"
-      }];
+      return [
+        {
+          id: uuidv4(),
+          title: description,
+          description,
+          criteria,
+          priority: 1,
+          estimatedIterations: 3,
+          dependencies: [],
+          type: "single"
+        }
+      ];
     }
     const subtasks = [];
     if (this.needsSetup(description)) {
@@ -141,7 +150,9 @@ class MultiLoopOrchestrator {
         id: uuidv4(),
         title: "Core Implementation",
         description: coreTask,
-        criteria: criteria.filter((c) => c.toLowerCase().includes("function") || c.toLowerCase().includes("implement")),
+        criteria: criteria.filter(
+          (c) => c.toLowerCase().includes("function") || c.toLowerCase().includes("implement")
+        ),
         priority: 2,
         estimatedIterations: 5,
         dependencies: subtasks.length > 0 ? [subtasks[0].id] : [],
@@ -172,16 +183,18 @@ class MultiLoopOrchestrator {
         type: "documentation"
       });
     }
-    return subtasks.length > 0 ? subtasks : [{
-      id: uuidv4(),
-      title: description,
-      description,
-      criteria,
-      priority: 1,
-      estimatedIterations: Math.min(8, Math.max(3, complexity.score)),
-      dependencies: [],
-      type: "single"
-    }];
+    return subtasks.length > 0 ? subtasks : [
+      {
+        id: uuidv4(),
+        title: description,
+        description,
+        criteria,
+        priority: 1,
+        estimatedIterations: Math.min(8, Math.max(3, complexity.score)),
+        dependencies: [],
+        type: "single"
+      }
+    ];
   }
   /**
    * Create execution plan from breakdown
@@ -225,14 +238,19 @@ class MultiLoopOrchestrator {
     try {
       task.status = "executing";
       for (const phase of task.executionPlan.phases) {
-        logger.info(`Executing phase ${phase.id} with ${phase.tasks.length} tasks`);
+        logger.info(
+          `Executing phase ${phase.id} with ${phase.tasks.length} tasks`
+        );
         if (phase.parallelExecution && phase.tasks.length > 1) {
           const parallelResult = await this.executeParallelLoops(phase.tasks);
           for (const [taskId, taskResult] of parallelResult.results) {
             if (taskResult.success) {
               result.completedLoops.push(taskResult.loopId);
             } else {
-              result.failedLoops.push({ loopId: taskResult.loopId, error: taskResult.error || "Unknown error" });
+              result.failedLoops.push({
+                loopId: taskResult.loopId,
+                error: taskResult.error || "Unknown error"
+              });
             }
           }
         } else {
@@ -244,7 +262,10 @@ class MultiLoopOrchestrator {
                 await this.updateSharedContext(task, loopResult);
               }
             } else {
-              result.failedLoops.push({ loopId: loopResult.loopId, error: loopResult.error || "Unknown error" });
+              result.failedLoops.push({
+                loopId: loopResult.loopId,
+                error: loopResult.error || "Unknown error"
+              });
               if (this.config.fallbackStrategy === "abort") {
                 throw new Error(`Task failed: ${loopResult.error}`);
               }
@@ -302,7 +323,11 @@ class MultiLoopOrchestrator {
         loopInfo.endTime = Date.now();
       }
       this.activeLoops.delete(taskBreakdown.id);
-      return { success: false, loopId: taskBreakdown.id, error: error.message };
+      return {
+        success: false,
+        loopId: taskBreakdown.id,
+        error: error.message
+      };
     }
   }
   /**
@@ -314,7 +339,11 @@ class MultiLoopOrchestrator {
         id: execution.id,
         description: `Parallel task: ${task.title}`,
         breakdown: [task],
-        executionPlan: { phases: [], totalEstimatedTime: 0, parallelizable: false },
+        executionPlan: {
+          phases: [],
+          totalEstimatedTime: 0,
+          parallelizable: false
+        },
         status: "executing",
         startTime: execution.startTime,
         loops: /* @__PURE__ */ new Map(),
@@ -333,7 +362,10 @@ class MultiLoopOrchestrator {
    * Update shared context between tasks
    */
   async updateSharedContext(orchestratedTask, loopResult) {
-    logger.debug("Updating shared context", { orchestrationId: orchestratedTask.id, loopId: loopResult.loopId });
+    logger.debug("Updating shared context", {
+      orchestrationId: orchestratedTask.id,
+      loopId: loopResult.loopId
+    });
   }
   /**
    * Generate insights from orchestration
@@ -342,12 +374,16 @@ class MultiLoopOrchestrator {
     const insights = [];
     const avgLoopDuration = Array.from(task.loops.values()).filter((l) => l.endTime && l.startTime).map((l) => l.endTime - l.startTime).reduce((sum, duration) => sum + duration, 0) / task.loops.size;
     if (avgLoopDuration > 0) {
-      insights.push(`Average loop duration: ${Math.round(avgLoopDuration / 1e3)}s`);
+      insights.push(
+        `Average loop duration: ${Math.round(avgLoopDuration / 1e3)}s`
+      );
     }
     const successRate = result.completedLoops.length / (result.completedLoops.length + result.failedLoops.length);
     insights.push(`Success rate: ${Math.round(successRate * 100)}%`);
     if (task.breakdown.length > 3) {
-      insights.push("Complex task benefited from breakdown into multiple loops");
+      insights.push(
+        "Complex task benefited from breakdown into multiple loops"
+      );
     }
     return insights;
   }
@@ -378,8 +414,16 @@ class MultiLoopOrchestrator {
     return { score, factors };
   }
   needsSetup(description) {
-    const setupKeywords = ["project", "initialize", "setup", "scaffold", "create structure"];
-    return setupKeywords.some((keyword) => description.toLowerCase().includes(keyword));
+    const setupKeywords = [
+      "project",
+      "initialize",
+      "setup",
+      "scaffold",
+      "create structure"
+    ];
+    return setupKeywords.some(
+      (keyword) => description.toLowerCase().includes(keyword)
+    );
   }
   needsTesting(criteria) {
     return criteria.some((c) => c.toLowerCase().includes("test"));
@@ -389,7 +433,9 @@ class MultiLoopOrchestrator {
   }
   extractCoreTask(description) {
     const sentences = description.split(".");
-    return sentences.find((s) => s.toLowerCase().includes("implement") || s.toLowerCase().includes("create") || s.toLowerCase().includes("add")) || null;
+    return sentences.find(
+      (s) => s.toLowerCase().includes("implement") || s.toLowerCase().includes("create") || s.toLowerCase().includes("add")
+    ) || null;
   }
   canExecuteInParallel(breakdown) {
     return breakdown.some((task) => task.dependencies.length === 0);

package/dist/src/integrations/ralph/patterns/compounding-engineering-pattern.js

@@ -160,7 +160,9 @@ class CompoundingEngineeringManager {
       }
     }
     if (sessionData.codeStructure) {
-      const structurePattern = this.analyzeCodeStructurePattern(sessionData.codeStructure);
+      const structurePattern = this.analyzeCodeStructurePattern(
+        sessionData.codeStructure
+      );
       if (structurePattern) {
         patterns.push(structurePattern);
       }
@@ -228,7 +230,9 @@ class CompoundingEngineeringManager {
    * Update compounded knowledge with new learning
    */
   async updateCompoundedKnowledge(learning) {
-    this.knowledgeBase.learningsByCategory[learning.developmentPhase].push(learning);
+    this.knowledgeBase.learningsByCategory[learning.developmentPhase].push(
+      learning
+    );
     this.knowledgeBase.totalFeatures++;
     await this.updateBestPractices(learning);
     await this.updateMetrics(learning);
@@ -246,7 +250,9 @@ class CompoundingEngineeringManager {
    * Generate automation hooks
    */
   async generateHooks() {
-    const allOpportunities = Object.values(this.knowledgeBase.learningsByCategory).flat().flatMap((learning) => learning.automationOpportunities).filter((opp) => opp.implementation === "hook");
+    const allOpportunities = Object.values(
+      this.knowledgeBase.learningsByCategory
+    ).flat().flatMap((learning) => learning.automationOpportunities).filter((opp) => opp.implementation === "hook");
     const hookCounts = /* @__PURE__ */ new Map();
     for (const opp of allOpportunities) {
       hookCounts.set(opp.task, (hookCounts.get(opp.task) || 0) + 1);
@@ -305,7 +311,9 @@ export async function ${hookName.replace(/-/g, "")}Hook() {
    * Get current compounding metrics
    */
   getCompoundingMetrics() {
-    const totalLearnings = Object.values(this.knowledgeBase.learningsByCategory).flat().length;
+    const totalLearnings = Object.values(
+      this.knowledgeBase.learningsByCategory
+    ).flat().length;
     const automationLevel = this.knowledgeBase.automatedHooks.length / Math.max(totalLearnings, 1);
     const recentLearnings = totalLearnings > 5 ? totalLearnings / 5 : totalLearnings;
     return {

package/dist/src/integrations/ralph/patterns/extended-coherence-sessions.js

@@ -35,7 +35,9 @@ class ExtendedCoherenceManager {
    */
   async startCoherenceSession(agentConfig, taskConfig, sessionConfig) {
     const sessionId = uuidv4();
-    const defaultConfig = this.generateConfigForComplexity(taskConfig.complexity);
+    const defaultConfig = this.generateConfigForComplexity(
+      taskConfig.complexity
+    );
     const config = { ...defaultConfig, ...sessionConfig };
     const session = {
       id: sessionId,
@@ -150,7 +152,11 @@ class ExtendedCoherenceManager {
       duration: metrics.duration
     });
     if (overallCoherence < session.config.coherenceThreshold) {
-      await this.interventeInSession(session, "coherence_degradation", overallCoherence);
+      await this.interventeInSession(
+        session,
+        "coherence_degradation",
+        overallCoherence
+      );
     }
     const timeSinceCheckpoint = Date.now() - session.state.lastCheckpoint;
     const checkpointDue = timeSinceCheckpoint > session.config.checkpointInterval * 60 * 1e3;
@@ -166,10 +172,16 @@ class ExtendedCoherenceManager {
     const duration = (now - session.metrics[0]?.startTime || now) / (1e3 * 60);
     const recentOutputs = await this.getRecentAgentOutputs(session);
     const outputQuality = this.assessOutputQuality(recentOutputs);
-    const contextRetention = this.assessContextRetention(recentOutputs, session.task);
+    const contextRetention = this.assessContextRetention(
+      recentOutputs,
+      session.task
+    );
     const taskRelevance = this.assessTaskRelevance(recentOutputs, session.task);
     const repetitionRate = this.calculateRepetitionRate(recentOutputs);
-    const divergenceRate = this.calculateDivergenceRate(recentOutputs, session.task);
+    const divergenceRate = this.calculateDivergenceRate(
+      recentOutputs,
+      session.task
+    );
     const errorRate = this.calculateErrorRate(recentOutputs);
     const progressRate = this.calculateProgressRate(session);
     return {
@@ -186,7 +198,9 @@ class ExtendedCoherenceManager {
       errorRate,
       memoryUsage: await this.getMemoryUsage(session),
       contextWindowUsage: await this.getContextWindowUsage(session),
-      stateCheckpoints: session.interventions.filter((i) => i.type === "checkpoint").length
+      stateCheckpoints: session.interventions.filter(
+        (i) => i.type === "checkpoint"
+      ).length
     };
   }
   /**
@@ -293,7 +307,9 @@ class ExtendedCoherenceManager {
    * Restart session from last good checkpoint
    */
   async restartSession(session) {
-    logger.info("Restarting session from checkpoint", { sessionId: session.id });
+    logger.info("Restarting session from checkpoint", {
+      sessionId: session.id
+    });
     const checkpoint = await this.loadLatestCheckpoint(session);
     if (checkpoint) {
       session.state = { ...checkpoint.state };
@@ -455,13 +471,20 @@ Begin your extended coherence work session now.
   getCoherenceCapabilities() {
     const activeSessions = Array.from(this.activeSessions.values());
     return {
-      maxSessionDuration: Math.max(...activeSessions.map((s) => s.config.maxDuration)),
-      activeSessionCount: activeSessions.filter((s) => s.state.status === "active").length,
+      maxSessionDuration: Math.max(
+        ...activeSessions.map((s) => s.config.maxDuration)
+      ),
+      activeSessionCount: activeSessions.filter(
+        (s) => s.state.status === "active"
+      ).length,
       averageCoherence: activeSessions.reduce((sum, s) => {
         const recent = s.metrics.slice(-1)[0];
         return sum + (recent ? this.calculateOverallCoherence(recent) : 0);
       }, 0) / activeSessions.length,
-      totalInterventions: activeSessions.reduce((sum, s) => sum + s.interventions.length, 0)
+      totalInterventions: activeSessions.reduce(
+        (sum, s) => sum + s.interventions.length,
+        0
+      )
     };
   }
 }