@stackmemoryai/stackmemory 1.2.2 → 1.2.6

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

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) {