@stackmemoryai/stackmemory 1.2.1 → 1.2.4

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
+      )
     };
   }
 }

package/dist/src/integrations/ralph/swarm/git-workflow-manager.js

@@ -195,7 +195,9 @@ class GitWorkflowManager {
   // Private helper methods
   getCurrentBranch() {
     try {
-      return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
+      return execSync("git rev-parse --abbrev-ref HEAD", {
+        encoding: "utf8"
+      }).trim();
     } catch (error) {
       logger.warn("Failed to get current branch", error);
       return "main";
@@ -229,7 +231,9 @@ class GitWorkflowManager {
   createBranch(branchName) {
     try {
       try {
-        const currentBranch = execSync("git branch --show-current", { encoding: "utf8" }).trim();
+        const currentBranch = execSync("git branch --show-current", {
+          encoding: "utf8"
+        }).trim();
         if (currentBranch === branchName) {
           try {
             execSync("git checkout main", { encoding: "utf8" });
@@ -238,17 +242,26 @@ class GitWorkflowManager {
           }
         }
         try {
-          const worktrees = execSync("git worktree list --porcelain", { encoding: "utf8" });
+          const worktrees = execSync("git worktree list --porcelain", {
+            encoding: "utf8"
+          });
           const lines = worktrees.split("\n");
           for (let i = 0; i < lines.length; i++) {
             if (lines[i].startsWith("branch ") && lines[i].includes(branchName)) {
               const worktreetPath = lines[i - 1].replace("worktree ", "");
-              execSync(`git worktree remove --force "${worktreetPath}"`, { encoding: "utf8" });
-              logger.info(`Removed worktree at ${worktreetPath} for branch ${branchName}`);
+              execSync(`git worktree remove --force "${worktreetPath}"`, {
+                encoding: "utf8"
+              });
+              logger.info(
+                `Removed worktree at ${worktreetPath} for branch ${branchName}`
+              );
             }
           }
         } catch (worktreeError) {
-          logger.warn("Failed to check/remove worktrees", worktreeError);
+          logger.warn(
+            "Failed to check/remove worktrees",
+            worktreeError
+          );
         }
         execSync(`git branch -D ${branchName}`, { encoding: "utf8" });
         logger.info(`Deleted existing branch ${branchName} for fresh start`);
@@ -257,7 +270,9 @@ class GitWorkflowManager {
       execSync(`git checkout -b ${branchName}`, { encoding: "utf8" });
     } catch (error) {
       logger.error(`Failed to create branch ${branchName}`, error);
-      throw new GitWorkflowError(`Failed to create branch: ${branchName}`, { branchName });
+      throw new GitWorkflowError(`Failed to create branch: ${branchName}`, {
+        branchName
+      });
     }
   }
   checkoutBranch(branchName) {
@@ -265,7 +280,9 @@ class GitWorkflowManager {
       execSync(`git checkout ${branchName}`, { encoding: "utf8" });
     } catch (error) {
       logger.error(`Failed to checkout branch ${branchName}`, error);
-      throw new GitWorkflowError(`Failed to checkout branch: ${branchName}`, { branchName });
+      throw new GitWorkflowError(`Failed to checkout branch: ${branchName}`, {
+        branchName
+      });
     }
   }
   branchExists(branchName) {

package/dist/src/integrations/ralph/swarm/swarm-coordinator.js

@@ -907,10 +907,15 @@ You are a PROJECT COORDINATOR. Your role is to:
           await fs.rmdir(agent.workingDirectory, { recursive: true });
           logger.debug(`Cleaned up working directory for agent ${agent.id}`);
         } catch (error) {
-          logger.warn(`Could not clean up directory for agent ${agent.id}`, error);
+          logger.warn(
+            `Could not clean up directory for agent ${agent.id}`,
+            error
+          );
         }
       }
-      await this.gitWorkflowManager.coordinateMerges(Array.from(this.activeAgents.values()));
+      await this.gitWorkflowManager.coordinateMerges(
+        Array.from(this.activeAgents.values())
+      );
       this.activeAgents.clear();
       this.swarmState = {
         id: uuidv4(),
@@ -932,7 +937,10 @@ You are a PROJECT COORDINATOR. Your role is to:
       logger.info("Swarm cleanup completed successfully");
     } catch (error) {
       logger.error("Failed to cleanup completed swarm", error);
-      throw new SwarmCoordinationError("Cleanup failed", { swarmId: this.swarmState.id, error });
+      throw new SwarmCoordinationError("Cleanup failed", {
+        swarmId: this.swarmState.id,
+        error
+      });
     }
   }
   /**
@@ -958,14 +966,18 @@ You are a PROJECT COORDINATOR. Your role is to:
    * Get swarm resource usage and cleanup recommendations
    */
   getResourceUsage() {
-    const workingDirs = Array.from(this.activeAgents.values()).map((a) => a.workingDirectory);
+    const workingDirs = Array.from(this.activeAgents.values()).map(
+      (a) => a.workingDirectory
+    );
     const memoryEstimate = this.activeAgents.size * 50;
     const isStale = Date.now() - this.swarmState.startTime > 36e5;
     const hasCompletedTasks = this.swarmState.completedTaskCount > 0 && this.swarmState.activeTaskCount === 0;
     const recommendations = [];
     let cleanupRecommended = false;
     if (isStale) {
-      recommendations.push("Swarm has been running for over 1 hour - consider cleanup");
+      recommendations.push(
+        "Swarm has been running for over 1 hour - consider cleanup"
+      );
       cleanupRecommended = true;
     }
     if (hasCompletedTasks) {

package/dist/src/integrations/ralph/visualization/ralph-debugger.js

@@ -27,7 +27,10 @@ class RalphDebugger {
       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("Debugger initialized successfully");
     } catch (error) {
@@ -111,7 +114,10 @@ class RalphDebugger {
         contextSize: iter.contextSize,
         phase: iter.phase
       })),
-      totalDuration: session.performance.iterationTimes.reduce((sum, time) => sum + time, 0)
+      totalDuration: session.performance.iterationTimes.reduce(
+        (sum, time) => sum + time,
+        0
+      )
     };
     const html = await this.generateTimelineHTML(timeline);
     const timelinePath = path.join(".ralph-debug", `timeline-${loopId}.html`);
@@ -165,7 +171,10 @@ class RalphDebugger {
     diagram.metrics = {
       totalNodes: diagram.nodes.length,
       totalEdges: diagram.edges.length,
-      avgContextSize: session.performance.contextSizes.length > 0 ? session.performance.contextSizes.reduce((sum, size) => sum + size, 0) / session.performance.contextSizes.length : 0,
+      avgContextSize: session.performance.contextSizes.length > 0 ? session.performance.contextSizes.reduce(
+        (sum, size) => sum + size,
+        0
+      ) / session.performance.contextSizes.length : 0,
       maxContextSize: Math.max(...session.performance.contextSizes)
     };
     return diagram;
@@ -230,15 +239,24 @@ class RalphDebugger {
   async updatePerformanceMetrics(session) {
     const currentMemory = process.memoryUsage().heapUsed;
     session.performance.memoryUsage.push(currentMemory);
-    session.performance.peakMemory = Math.max(session.performance.peakMemory, currentMemory);
+    session.performance.peakMemory = Math.max(
+      session.performance.peakMemory,
+      currentMemory
+    );
     const contextSize = await this.calculateContextSize(session.ralphDir);
     session.performance.contextSizes.push(contextSize);
     if (session.performance.iterationTimes.length > 0) {
-      session.performance.averageIterationTime = session.performance.iterationTimes.reduce((sum, time) => sum + time, 0) / session.performance.iterationTimes.length;
+      session.performance.averageIterationTime = session.performance.iterationTimes.reduce(
+        (sum, time) => sum + time,
+        0
+      ) / session.performance.iterationTimes.length;
     }
     if (session.performance.contextSizes.length > 0) {
       const avgContextSize = session.performance.contextSizes.reduce((sum, size) => sum + size, 0) / session.performance.contextSizes.length;
-      session.performance.contextEfficiency = Math.max(0, 1 - avgContextSize / 1e4);
+      session.performance.contextEfficiency = Math.max(
+        0,
+        1 - avgContextSize / 1e4
+      );
     }
   }
   /**
@@ -246,8 +264,13 @@ class RalphDebugger {
    */
   async generateSummary(session) {
     const totalIterations = session.iterations.length;
-    const successfulIterations = session.iterations.filter((i) => i.success).length;
-    const totalDuration = session.performance.iterationTimes.reduce((sum, time) => sum + time, 0);
+    const successfulIterations = session.iterations.filter(
+      (i) => i.success
+    ).length;
+    const totalDuration = session.performance.iterationTimes.reduce(
+      (sum, time) => sum + time,
+      0
+    );
     return {
       loopId: session.loopId,
       totalIterations,
@@ -271,18 +294,26 @@ class RalphDebugger {
     const avgDuration = durations.reduce((sum, d) => sum + d, 0) / durations.length;
     if (durations.some((d) => d > avgDuration * 2)) {
       patterns.push("Variable iteration times detected");
-      insights.push("Some iterations took significantly longer than average - investigate bottlenecks");
+      insights.push(
+        "Some iterations took significantly longer than average - investigate bottlenecks"
+      );
     }
-    const consecutiveFailures = this.findConsecutiveFailures(session.iterations);
+    const consecutiveFailures = this.findConsecutiveFailures(
+      session.iterations
+    );
     if (consecutiveFailures.length > 2) {
       patterns.push("Multiple consecutive failures detected");
-      insights.push("Consider adjusting approach or criteria after consecutive failures");
+      insights.push(
+        "Consider adjusting approach or criteria after consecutive failures"
+      );
     }
     if (session.performance.contextSizes.length > 1) {
       const contextGrowth = session.performance.contextSizes[session.performance.contextSizes.length - 1] - session.performance.contextSizes[0];
       if (contextGrowth > 1e3) {
         patterns.push("Significant context growth");
-        insights.push("Context is growing rapidly - consider context pruning strategies");
+        insights.push(
+          "Context is growing rapidly - consider context pruning strategies"
+        );
       }
     }
     return { patterns, insights };
@@ -292,9 +323,14 @@ class RalphDebugger {
    */
   async analyzeContextFlow(session) {
     return {
-      avgContextSize: session.performance.contextSizes.length > 0 ? session.performance.contextSizes.reduce((sum, size) => sum + size, 0) / session.performance.contextSizes.length : 0,
+      avgContextSize: session.performance.contextSizes.length > 0 ? session.performance.contextSizes.reduce(
+        (sum, size) => sum + size,
+        0
+      ) / session.performance.contextSizes.length : 0,
       maxContextSize: Math.max(...session.performance.contextSizes),
-      contextGrowthRate: this.calculateGrowthRate(session.performance.contextSizes),
+      contextGrowthRate: this.calculateGrowthRate(
+        session.performance.contextSizes
+      ),
       efficiency: session.performance.contextEfficiency
     };
   }
@@ -303,7 +339,9 @@ class RalphDebugger {
    */
   async analyzePerformance(session) {
     return {
-      memoryEfficiency: this.calculateMemoryEfficiency(session.performance.memoryUsage),
+      memoryEfficiency: this.calculateMemoryEfficiency(
+        session.performance.memoryUsage
+      ),
       iterationEfficiency: session.performance.averageIterationTime,
       resourceUtilization: {
         cpu: "N/A",
@@ -318,7 +356,10 @@ class RalphDebugger {
    */
   async generateVisualization(session) {
     const htmlContent = await this.generateVisualizationHTML(session);
-    const vizPath = path.join(".ralph-debug", `visualization-${session.loopId}.html`);
+    const vizPath = path.join(
+      ".ralph-debug",
+      `visualization-${session.loopId}.html`
+    );
     await fs.mkdir(path.dirname(vizPath), { recursive: true });
     await fs.writeFile(vizPath, htmlContent);
     return {
@@ -343,17 +384,25 @@ class RalphDebugger {
   async generateRecommendations(session) {
     const recommendations = [];
     if (session.performance.averageIterationTime > 3e4) {
-      recommendations.push("Consider breaking down complex tasks into smaller iterations");
+      recommendations.push(
+        "Consider breaking down complex tasks into smaller iterations"
+      );
     }
     if (session.performance.contextEfficiency < 0.7) {
-      recommendations.push("Optimize context management - consider using context budgeting");
+      recommendations.push(
+        "Optimize context management - consider using context budgeting"
+      );
     }
     const successRate = session.iterations.filter((i) => i.success).length / Math.max(1, session.iterations.length);
     if (successRate < 0.5) {
-      recommendations.push("Low success rate detected - review task criteria and approach");
+      recommendations.push(
+        "Low success rate detected - review task criteria and approach"
+      );
     }
     if (session.performance.peakMemory > 500 * 1024 * 1024) {
-      recommendations.push("High memory usage detected - investigate memory leaks");
+      recommendations.push(
+        "High memory usage detected - investigate memory leaks"
+      );
     }
     return recommendations;
   }
@@ -450,14 +499,16 @@ class RalphDebugger {
 <body>
     <h1>${timeline.title}</h1>
     <div class="timeline">
-        ${timeline.iterations.map((iter) => `
+        ${timeline.iterations.map(
+      (iter) => `
             <div class="iteration ${iter.success ? "success" : "failure"}">
                 <h3>Iteration ${iter.iteration}</h3>
                 <p>Duration: ${iter.duration}ms</p>
                 <p>Changes: ${iter.changes} | Errors: ${iter.errors}</p>
                 <p>Context Size: ${iter.contextSize}</p>
             </div>
-        `).join("")}
+        `
+    ).join("")}
     </div>
 </body>
 </html>