@stackmemoryai/stackmemory 1.12.0 → 1.14.0

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

@@ -1,1005 +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 { v4 as uuidv4 } from "uuid";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { logger } from "../../../core/monitoring/logger.js";
-import { FrameManager } from "../../../core/context/index.js";
-import { sessionManager } from "../../../core/session/index.js";
-import { RalphStackMemoryBridge } from "../bridge/ralph-stackmemory-bridge.js";
-import { GitWorkflowManager } from "./git-workflow-manager.js";
-import { SwarmRegistry } from "../monitoring/swarm-registry.js";
-class SwarmCoordinationError extends Error {
-  constructor(message, context) {
-    super(message);
-    this.context = context;
-    this.name = "SwarmCoordinationError";
-  }
-}
-class AgentExecutionError extends Error {
-  constructor(message, agentId, taskId, context) {
-    super(message);
-    this.agentId = agentId;
-    this.taskId = taskId;
-    this.context = context;
-    this.name = "AgentExecutionError";
-  }
-}
-class TaskAllocationError extends Error {
-  constructor(message, taskId, context) {
-    super(message);
-    this.taskId = taskId;
-    this.context = context;
-    this.name = "TaskAllocationError";
-  }
-}
-class SwarmCoordinator {
-  frameManager;
-  activeAgents = /* @__PURE__ */ new Map();
-  swarmState;
-  config;
-  coordinationTimer;
-  plannerWakeupQueue = /* @__PURE__ */ new Map();
-  gitWorkflowManager;
-  registeredSwarmId;
-  get swarmId() {
-    return this.registeredSwarmId;
-  }
-  get agents() {
-    return Array.from(this.activeAgents.values());
-  }
-  constructor(config) {
-    this.config = {
-      maxAgents: 10,
-      coordinationInterval: 3e4,
-      // 30 seconds
-      driftDetectionThreshold: 5,
-      // 5 failed iterations before considering drift
-      freshStartInterval: 36e5,
-      // 1 hour
-      conflictResolutionStrategy: "expertise",
-      enableDynamicPlanning: true,
-      pathologicalBehaviorDetection: true,
-      ...config
-    };
-    this.swarmState = {
-      id: uuidv4(),
-      status: "idle",
-      startTime: Date.now(),
-      activeTaskCount: 0,
-      completedTaskCount: 0,
-      coordination: {
-        events: [],
-        conflicts: [],
-        resolutions: []
-      },
-      performance: {
-        throughput: 0,
-        efficiency: 0,
-        coordination_overhead: 0
-      }
-    };
-    this.gitWorkflowManager = new GitWorkflowManager({
-      enableGitWorkflow: true,
-      branchStrategy: "agent",
-      autoCommit: true,
-      commitFrequency: 5,
-      mergStrategy: "squash"
-    });
-    logger.info("Swarm coordinator initialized", this.config);
-  }
-  async initialize() {
-    try {
-      await sessionManager.initialize();
-      const session = await sessionManager.getOrCreateSession({});
-      if (session.database) {
-        this.frameManager = new FrameManager(
-          session.database,
-          session.projectId
-        );
-      }
-      this.startCoordinationLoop();
-      const registry = SwarmRegistry.getInstance();
-      this.registeredSwarmId = registry.registerSwarm(
-        this,
-        `Swarm ${this.swarmState.id.substring(0, 8)}`
-      );
-      logger.info("Swarm coordinator initialized successfully");
-    } catch (error) {
-      logger.error("Failed to initialize swarm coordinator", error);
-      throw error;
-    }
-  }
-  /**
-   * Launch a swarm of agents to work on a complex project
-   */
-  async launchSwarm(projectDescription, agents, _coordination) {
-    logger.info("Launching swarm", {
-      project: projectDescription.substring(0, 100),
-      agentCount: agents.length
-    });
-    const swarmId = uuidv4();
-    try {
-      if (agents.length > this.config.maxAgents) {
-        throw new Error(
-          `Too many agents requested: ${agents.length} > ${this.config.maxAgents}`
-        );
-      }
-      const swarmTasks = await this.decomposeProjectIntoSwarmTasks(projectDescription);
-      const initializedAgents = await this.initializeSpecializedAgents(
-        agents,
-        swarmTasks
-      );
-      const allocation = await this.allocateTasksToAgents(
-        swarmTasks,
-        initializedAgents
-      );
-      this.swarmState = {
-        ...this.swarmState,
-        id: swarmId,
-        status: "active",
-        activeTaskCount: swarmTasks.length,
-        project: projectDescription,
-        agents: initializedAgents,
-        tasks: swarmTasks,
-        allocation
-      };
-      await this.executeSwarmTasks(allocation);
-      logger.info("Swarm launched successfully", {
-        swarmId,
-        agentCount: initializedAgents.length
-      });
-      return swarmId;
-    } catch (error) {
-      logger.error("Failed to launch swarm", error);
-      throw error;
-    }
-  }
-  /**
-   * Decompose project into tasks suitable for swarm execution
-   */
-  async decomposeProjectIntoSwarmTasks(projectDescription) {
-    const tasks = [];
-    const complexity = this.analyzeProjectComplexity(projectDescription);
-    if (complexity.needsArchitecture) {
-      tasks.push({
-        id: uuidv4(),
-        type: "architecture",
-        title: "System Architecture Design",
-        description: "Design overall system architecture and component relationships",
-        priority: 1,
-        estimatedEffort: "high",
-        requiredRoles: ["architect", "system_designer"],
-        dependencies: [],
-        acceptanceCriteria: [
-          "Architecture diagram created",
-          "Component interfaces defined",
-          "Data flow documented"
-        ]
-      });
-    }
-    const coreFeatures = this.extractCoreFeatures(projectDescription);
-    for (const feature of coreFeatures) {
-      tasks.push({
-        id: uuidv4(),
-        type: "implementation",
-        title: `Implement ${feature.name}`,
-        description: feature.description,
-        priority: 2,
-        estimatedEffort: feature.complexity,
-        requiredRoles: ["developer", feature.specialization || "fullstack"],
-        dependencies: complexity.needsArchitecture ? [tasks[0].id] : [],
-        acceptanceCriteria: feature.criteria
-      });
-    }
-    if (complexity.needsTesting) {
-      tasks.push({
-        id: uuidv4(),
-        type: "testing",
-        title: "Comprehensive Testing Suite",
-        description: "Create unit, integration, and end-to-end tests",
-        priority: 3,
-        estimatedEffort: "medium",
-        requiredRoles: ["qa_engineer", "test_automation"],
-        dependencies: tasks.filter((t) => t.type === "implementation").map((t) => t.id),
-        acceptanceCriteria: [
-          "Unit tests achieve >90% coverage",
-          "Integration tests pass",
-          "Performance benchmarks met"
-        ]
-      });
-    }
-    if (complexity.needsDocumentation) {
-      tasks.push({
-        id: uuidv4(),
-        type: "documentation",
-        title: "Documentation and Examples",
-        description: "Create user documentation, API docs, and usage examples",
-        priority: 4,
-        estimatedEffort: "low",
-        requiredRoles: ["technical_writer", "developer"],
-        dependencies: [],
-        // Can run in parallel
-        acceptanceCriteria: [
-          "README with setup instructions",
-          "API documentation complete",
-          "Usage examples provided"
-        ]
-      });
-    }
-    return tasks;
-  }
-  /**
-   * Initialize specialized agents with role-specific configurations
-   */
-  async initializeSpecializedAgents(specifications, _tasks) {
-    const agents = [];
-    for (const spec of specifications) {
-      const agent = {
-        id: uuidv4(),
-        role: spec.role,
-        specialization: spec,
-        status: "initializing",
-        capabilities: this.defineCapabilities(spec.role),
-        workingDirectory: `.swarm/${spec.role}-${Date.now()}`,
-        currentTask: null,
-        performance: {
-          tasksCompleted: 0,
-          successRate: 1,
-          averageTaskTime: 0,
-          driftDetected: false,
-          lastFreshStart: Date.now()
-        },
-        coordination: {
-          communicationStyle: this.defineCommuncationStyle(spec.role),
-          conflictResolution: spec.conflictResolution || "defer_to_expertise",
-          collaborationPreferences: spec.collaborationPreferences || []
-        }
-      };
-      await this.setupAgentEnvironment(agent);
-      await this.configureAgentPrompts(agent);
-      agents.push(agent);
-      this.activeAgents.set(agent.id, agent);
-    }
-    logger.info(`Initialized ${agents.length} specialized agents`);
-    return agents;
-  }
-  /**
-   * Allocate tasks to agents based on specialization and workload
-   */
-  async allocateTasksToAgents(tasks, agents) {
-    const allocation = {
-      assignments: /* @__PURE__ */ new Map(),
-      loadBalancing: "capability_based",
-      conflictResolution: this.config.conflictResolutionStrategy
-    };
-    const sortedTasks = this.topologicalSort(tasks);
-    for (const task of sortedTasks) {
-      const suitableAgents = agents.filter(
-        (agent) => task.requiredRoles.some((role) => this.agentCanHandle(agent, role))
-      );
-      if (suitableAgents.length === 0) {
-        logger.warn(`No suitable agents found for task: ${task.title}`);
-        continue;
-      }
-      const selectedAgent = this.selectOptimalAgent(suitableAgents, task);
-      allocation.assignments.set(task.id, {
-        agentId: selectedAgent.id,
-        taskId: task.id,
-        assignedAt: Date.now(),
-        estimatedCompletion: Date.now() + this.estimateTaskDuration(task),
-        coordination: {
-          collaborators: this.findCollaborators(selectedAgent, task, agents),
-          reviewers: this.findReviewers(selectedAgent, task, agents)
-        }
-      });
-      selectedAgent.currentTask = task.id;
-    }
-    return allocation;
-  }
-  /**
-   * Execute swarm tasks with coordination
-   */
-  async executeSwarmTasks(allocation) {
-    const executionPromises = [];
-    for (const [taskId, assignment] of allocation.assignments) {
-      const agent = this.activeAgents.get(assignment.agentId);
-      const task = this.swarmState.tasks?.find((t) => t.id === taskId);
-      if (!agent || !task) continue;
-      const executionPromise = this.executeAgentTask(agent, task, assignment);
-      executionPromises.push(executionPromise);
-    }
-    await Promise.allSettled(executionPromises);
-  }
-  /**
-   * Execute a single agent task with coordination
-   */
-  async executeAgentTask(agent, task, assignment) {
-    logger.info(`Agent ${agent.role} starting task: ${task.title}`);
-    try {
-      agent.status = "active";
-      await this.gitWorkflowManager.initializeAgentWorkflow(agent, task);
-      const ralph = new RalphStackMemoryBridge({
-        baseDir: path.join(agent.workingDirectory, task.id),
-        maxIterations: this.calculateMaxIterations(task),
-        useStackMemory: true
-      });
-      const contextualPrompt = await this.synthesizeContextualPrompt(
-        agent,
-        task
-      );
-      await ralph.initialize({
-        task: contextualPrompt,
-        criteria: task.acceptanceCriteria.join("\n")
-      });
-      this.setupAgentCoordination(agent, ralph, assignment);
-      let iteration = 1;
-      const maxIterations = this.calculateMaxIterations(task);
-      while (iteration <= maxIterations) {
-        try {
-          const result = await ralph.runWorkerIteration();
-          if (result.isComplete) {
-            logger.info(`Task completed in ${iteration} iterations`);
-            break;
-          }
-          iteration++;
-        } catch (error) {
-          logger.error(`Iteration ${iteration} failed:`, error);
-          if (iteration >= maxIterations) {
-            throw error;
-          }
-          iteration++;
-        }
-      }
-      await this.gitWorkflowManager.commitAgentWork(agent, task);
-      this.updateAgentPerformance(agent, true);
-      await this.gitWorkflowManager.mergeAgentWork(agent, task);
-      await this.notifyTaskCompletion(agent, task, true);
-      agent.status = "idle";
-      logger.info(`Agent ${agent.role} completed task: ${task.title}`);
-    } catch (error) {
-      logger.error(
-        `Agent ${agent.role} failed task: ${task.title}`,
-        error
-      );
-      this.updateAgentPerformance(agent, false);
-      await this.handleTaskFailure(agent, task, error);
-      agent.status = "error";
-    }
-  }
-  /**
-   * Synthesize contextual prompt incorporating swarm knowledge
-   */
-  async synthesizeContextualPrompt(agent, task) {
-    const basePrompt = task.description;
-    const roleSpecificInstructions = this.getRoleSpecificInstructions(
-      agent.role
-    );
-    const swarmContext = await this.getSwarmContext(task);
-    const coordinationInstructions = this.getCoordinationInstructions(agent);
-    return `
-${roleSpecificInstructions}
-
-TASK: ${basePrompt}
-
-SWARM CONTEXT:
-${swarmContext}
-
-COORDINATION GUIDELINES:
-${coordinationInstructions}
-
-Remember:
-- You are part of a swarm working on: ${this.swarmState.project}
-- Other agents are working on related tasks
-- Communicate findings through StackMemory shared context
-- Focus on your specialization while being aware of the bigger picture
-- Detect and avoid pathological behaviors (infinite loops, tunnel vision)
-- Request fresh starts if you detect drift in your approach
-
-ACCEPTANCE CRITERIA:
-${task.acceptanceCriteria.map((c) => `- ${c}`).join("\n")}
-`;
-  }
-  /**
-   * Start coordination monitoring loop
-   */
-  startCoordinationLoop() {
-    this.coordinationTimer = setInterval(() => {
-      this.performCoordinationCycle().catch((error) => {
-        logger.error("Coordination cycle failed", error);
-      });
-    }, this.config.coordinationInterval);
-  }
-  /**
-   * Perform coordination cycle
-   */
-  async performCoordinationCycle() {
-    if (this.swarmState.status !== "active") return;
-    logger.debug("Performing coordination cycle");
-    if (this.config.pathologicalBehaviorDetection) {
-      await this.detectPathologicalBehaviors();
-    }
-    if (this.config.enableDynamicPlanning) {
-      await this.wakeUpPlanners();
-    }
-    await this.resolveActiveConflicts();
-    await this.rebalanceWorkload();
-    await this.triggerFreshStartsIfNeeded();
-    this.updateSwarmMetrics();
-  }
-  /**
-   * Detect pathological behaviors in agents
-   */
-  async detectPathologicalBehaviors() {
-    for (const agent of this.activeAgents.values()) {
-      if (agent.status !== "active") continue;
-      if (agent.performance.driftDetected) {
-        logger.warn(
-          `Drift detected in agent ${agent.role}, triggering fresh start`
-        );
-        await this.triggerFreshStart(agent);
-        continue;
-      }
-      if (await this.detectTunnelVision(agent)) {
-        logger.warn(
-          `Tunnel vision detected in agent ${agent.role}, providing alternative approach`
-        );
-        await this.provideAlternativeApproach(agent);
-      }
-      if (await this.detectExcessiveRuntime(agent)) {
-        logger.warn(
-          `Excessive runtime detected in agent ${agent.role}, requesting checkpoint`
-        );
-        await this.requestCheckpoint(agent);
-      }
-    }
-  }
-  /**
-   * Wake up planners when their tasks complete
-   */
-  async wakeUpPlanners() {
-    for (const [agentId, wakeupCallback] of this.plannerWakeupQueue) {
-      const agent = this.activeAgents.get(agentId);
-      if (!agent || agent.status !== "idle") continue;
-      logger.info(`Waking up planner agent: ${agent.role}`);
-      wakeupCallback();
-      this.plannerWakeupQueue.delete(agentId);
-    }
-  }
-  /**
-   * Get status of a specific swarm
-   */
-  getSwarmStatus(swarmId) {
-    const registry = SwarmRegistry.getInstance();
-    const swarm = registry.getSwarm(swarmId);
-    if (!swarm) {
-      return null;
-    }
-    return {
-      id: swarmId,
-      state: swarm.status || "running",
-      activeAgents: swarm.agents?.length || 0,
-      startTime: swarm.startTime || Date.now(),
-      agents: swarm.agents?.map((agent) => ({
-        role: agent.role,
-        status: agent.status || "active",
-        task: agent.task || "Working"
-      }))
-    };
-  }
-  /**
-   * Get all active swarms
-   */
-  getAllActiveSwarms() {
-    const registry = SwarmRegistry.getInstance();
-    const activeSwarms = registry.listActiveSwarms();
-    return activeSwarms.map((swarm) => ({
-      id: swarm.id,
-      description: swarm.description,
-      agentCount: swarm.agents?.length || 0,
-      status: swarm.status || "running",
-      startTime: swarm.startTime || Date.now()
-    }));
-  }
-  /**
-   * Stop a specific swarm gracefully
-   */
-  async stopSwarm(swarmId) {
-    const targetId = swarmId || this.swarmId;
-    if (!targetId) {
-      throw new Error("No swarm ID provided");
-    }
-    logger.info("Stopping swarm", { swarmId: targetId });
-    for (const agent of this.agents) {
-      try {
-        await this.stopAgent(agent);
-      } catch (error) {
-        logger.error("Failed to stop agent", {
-          agent: agent.id,
-          error: error.message
-        });
-      }
-    }
-    if (this.gitWorkflowManager) {
-      try {
-        await this.gitWorkflowManager.cleanup();
-      } catch (error) {
-        logger.error("Git cleanup failed", { error: error.message });
-      }
-    }
-    const registry = SwarmRegistry.getInstance();
-    registry.unregisterSwarm(targetId);
-    logger.info("Swarm stopped", { swarmId: targetId });
-  }
-  /**
-   * Force stop a swarm without saving state
-   */
-  async forceStopSwarm(swarmId) {
-    logger.info("Force stopping swarm", { swarmId });
-    const registry = SwarmRegistry.getInstance();
-    registry.unregisterSwarm(swarmId);
-    this.activeAgents.clear();
-    logger.info("Swarm force stopped", { swarmId });
-  }
-  /**
-   * Cleanup all resources
-   */
-  async cleanup() {
-    logger.info("Cleaning up SwarmCoordinator resources");
-    const activeSwarms = this.getAllActiveSwarms();
-    for (const swarm of activeSwarms) {
-      try {
-        await this.stopSwarm(swarm.id);
-      } catch (error) {
-        logger.error("Failed to stop swarm during cleanup", {
-          swarmId: swarm.id,
-          error: error.message
-        });
-      }
-    }
-    const registry = SwarmRegistry.getInstance();
-    registry.cleanup();
-    this.activeAgents.clear();
-    logger.info("SwarmCoordinator cleanup completed");
-  }
-  /**
-   * Stop an individual agent
-   */
-  async stopAgent(agent) {
-    logger.debug("Stopping agent", { agentId: agent.id, role: agent.role });
-    agent.status = "stopped";
-    if (agent.ralphBridge) {
-      try {
-        await agent.ralphBridge.cleanup();
-      } catch (error) {
-        logger.error("Failed to cleanup agent bridge", {
-          error: error.message
-        });
-      }
-    }
-  }
-  // Helper methods for role specialization and coordination
-  defineCapabilities(role) {
-    const capabilityMap = {
-      architect: [
-        "system_design",
-        "component_modeling",
-        "architecture_validation"
-      ],
-      planner: [
-        "task_decomposition",
-        "dependency_analysis",
-        "resource_planning"
-      ],
-      developer: ["code_implementation", "debugging", "refactoring"],
-      reviewer: [
-        "code_review",
-        "quality_assessment",
-        "best_practice_enforcement"
-      ],
-      tester: ["test_design", "automation", "validation"],
-      optimizer: [
-        "performance_analysis",
-        "resource_optimization",
-        "bottleneck_identification"
-      ],
-      documenter: [
-        "technical_writing",
-        "api_documentation",
-        "example_creation"
-      ],
-      coordinator: [
-        "task_coordination",
-        "conflict_resolution",
-        "progress_tracking"
-      ]
-    };
-    return capabilityMap[role] || [];
-  }
-  defineCommuncationStyle(role) {
-    const styleMap = {
-      architect: "high_level_design_focused",
-      planner: "structured_and_methodical",
-      developer: "implementation_focused",
-      reviewer: "quality_focused_constructive",
-      tester: "validation_focused",
-      optimizer: "performance_metrics_focused",
-      documenter: "clarity_focused",
-      coordinator: "facilitative_and_diplomatic"
-    };
-    return styleMap[role] || "collaborative";
-  }
-  getRoleSpecificInstructions(role) {
-    const instructionMap = {
-      architect: `
-You are a SYSTEM ARCHITECT. Your role is to:
-- Design high-level system architecture
-- Define component interfaces and relationships
-- Ensure architectural consistency across the project
-- Think in terms of scalability, maintainability, and extensibility
-- Collaborate with developers to validate feasibility`,
-      planner: `
-You are a PROJECT PLANNER. Your role is to:
-- Break down complex tasks into manageable steps
-- Identify dependencies and critical path
-- Coordinate with other agents on sequencing
-- Wake up when tasks complete to plan next steps
-- Adapt plans based on actual progress`,
-      developer: `
-You are a SPECIALIZED DEVELOPER. Your role is to:
-- Implement features according to specifications
-- Write clean, maintainable code
-- Follow established patterns and conventions
-- Integrate with other components
-- Communicate implementation details clearly`,
-      reviewer: `
-You are a CODE REVIEWER. Your role is to:
-- Review code for quality, correctness, and best practices
-- Provide constructive feedback
-- Ensure consistency with project standards
-- Identify potential issues before they become problems
-- Approve or request changes`,
-      tester: `
-You are a QA ENGINEER. Your role is to:
-- Design comprehensive test strategies
-- Implement automated tests
-- Validate functionality and performance
-- Report bugs clearly and reproducibly
-- Ensure quality gates are met`,
-      optimizer: `
-You are a PERFORMANCE OPTIMIZER. Your role is to:
-- Analyze system performance and identify bottlenecks
-- Implement optimizations
-- Monitor resource usage
-- Establish performance benchmarks
-- Ensure scalability requirements are met`,
-      documenter: `
-You are a TECHNICAL WRITER. Your role is to:
-- Create clear, comprehensive documentation
-- Write API documentation and usage examples
-- Ensure documentation stays up-to-date
-- Focus on user experience and clarity
-- Collaborate with developers to understand features`,
-      coordinator: `
-You are a PROJECT COORDINATOR. Your role is to:
-- Facilitate communication between agents
-- Resolve conflicts and blockers
-- Track overall project progress
-- Ensure no tasks fall through cracks
-- Maintain project timeline and quality`
-    };
-    return instructionMap[role] || "You are a specialized agent contributing to a larger project.";
-  }
-  // Additional helper methods would be implemented here...
-  analyzeProjectComplexity(description) {
-    return {
-      needsArchitecture: description.length > 500 || description.includes("system") || description.includes("platform"),
-      needsTesting: true,
-      // Almost all projects need testing
-      needsDocumentation: description.includes("API") || description.includes("library"),
-      complexity: "medium"
-    };
-  }
-  extractCoreFeatures(_description) {
-    return [
-      {
-        name: "Core Feature",
-        description: "Main functionality implementation",
-        complexity: "medium",
-        criteria: [
-          "Feature works correctly",
-          "Handles edge cases",
-          "Follows coding standards"
-        ]
-      }
-    ];
-  }
-  // Implement remaining helper methods...
-  async setupAgentEnvironment(agent) {
-    try {
-      await fs.mkdir(agent.workingDirectory, { recursive: true });
-      logger.debug(
-        `Created working directory for agent ${agent.id}: ${agent.workingDirectory}`
-      );
-    } catch (error) {
-      logger.warn(
-        `Could not create working directory for agent ${agent.id}`,
-        error
-      );
-    }
-  }
-  async configureAgentPrompts(agent) {
-    logger.debug(`Configured prompts for agent ${agent.role}`);
-  }
-  topologicalSort(tasks) {
-    const sorted = [];
-    const visited = /* @__PURE__ */ new Set();
-    const visiting = /* @__PURE__ */ new Set();
-    const visit = (task) => {
-      if (visited.has(task.id)) return;
-      if (visiting.has(task.id)) {
-        logger.warn(`Circular dependency detected for task: ${task.id}`);
-        return;
-      }
-      visiting.add(task.id);
-      for (const depId of task.dependencies) {
-        const depTask = tasks.find((t) => t.id === depId);
-        if (depTask) visit(depTask);
-      }
-      visiting.delete(task.id);
-      visited.add(task.id);
-      sorted.push(task);
-    };
-    tasks.forEach(visit);
-    return sorted;
-  }
-  agentCanHandle(agent, role) {
-    return agent.role === role || agent.capabilities.includes(role);
-  }
-  selectOptimalAgent(agents, _task) {
-    return agents.reduce((best, current) => {
-      const bestLoad = best.currentTask ? 1 : 0;
-      const currentLoad = current.currentTask ? 1 : 0;
-      return currentLoad < bestLoad ? current : best;
-    });
-  }
-  estimateTaskDuration(task) {
-    const durations = {
-      low: 6e4,
-      // 1 minute
-      medium: 3e5,
-      // 5 minutes
-      high: 9e5
-      // 15 minutes
-    };
-    return durations[task.estimatedEffort] || 3e5;
-  }
-  findCollaborators(agent, task, agents) {
-    return agents.filter((a) => a.id !== agent.id && a.currentTask).map((a) => a.id).slice(0, 2);
-  }
-  findReviewers(agent, task, agents) {
-    return agents.filter((a) => a.role === "reviewer" && a.id !== agent.id).map((a) => a.id);
-  }
-  calculateMaxIterations(task) {
-    const iterations = {
-      low: 5,
-      medium: 10,
-      high: 20
-    };
-    return iterations[task.estimatedEffort] || 10;
-  }
-  async getSwarmContext(_task) {
-    const relatedTasks = Array.from(this.activeAgents.values()).filter((a) => a.currentTask).map((a) => `- Agent ${a.role} is working on task ${a.currentTask}`).join("\n");
-    return relatedTasks || "No other agents currently active";
-  }
-  getCoordinationInstructions(_agent) {
-    return `
-- Save progress to shared context regularly
-- Check for updates from collaborators
-- Request help if blocked for more than 2 iterations
-- Report completion immediately`;
-  }
-  setupAgentCoordination(agent, _ralph, _assignment) {
-    logger.debug(`Setting up coordination for agent ${agent.id}`);
-  }
-  updateAgentPerformance(agent, success) {
-    agent.performance.tasksCompleted++;
-    if (!success) {
-      agent.performance.successRate = agent.performance.successRate * (agent.performance.tasksCompleted - 1) / agent.performance.tasksCompleted;
-    }
-  }
-  async notifyTaskCompletion(agent, task, success) {
-    const event = {
-      type: "task_completion",
-      agentId: agent.id,
-      timestamp: Date.now(),
-      data: {
-        taskId: task.id,
-        success,
-        agent: agent.role
-      }
-    };
-    this.swarmState.coordination?.events.push(event);
-    logger.info(
-      `Task ${task.id} completed by agent ${agent.role}: ${success ? "SUCCESS" : "FAILED"}`
-    );
-  }
-  async handleTaskFailure(agent, task, error) {
-    logger.error(`Agent ${agent.role} failed task ${task.id}`, error);
-    if (this.swarmState.coordination) {
-      this.swarmState.coordination.conflicts.push({
-        type: "task_failure",
-        agents: [agent.id],
-        timestamp: Date.now(),
-        description: error.message
-      });
-    }
-  }
-  async detectTunnelVision(_agent) {
-    return false;
-  }
-  async provideAlternativeApproach(agent) {
-    logger.info(`Providing alternative approach to agent ${agent.role}`);
-  }
-  async detectExcessiveRuntime(agent) {
-    if (!agent.performance.lastFreshStart) return false;
-    return Date.now() - agent.performance.lastFreshStart > 36e5;
-  }
-  async requestCheckpoint(agent) {
-    logger.info(`Requesting checkpoint from agent ${agent.role}`);
-  }
-  async triggerFreshStart(agent) {
-    logger.info(`Triggering fresh start for agent ${agent.role}`);
-    agent.performance.lastFreshStart = Date.now();
-    agent.performance.driftDetected = false;
-  }
-  async resolveActiveConflicts() {
-    if (this.swarmState.coordination?.conflicts.length) {
-      logger.debug(
-        `Resolving ${this.swarmState.coordination.conflicts.length} conflicts`
-      );
-    }
-  }
-  async rebalanceWorkload() {
-    const activeAgents = Array.from(this.activeAgents.values()).filter(
-      (a) => a.status === "active"
-    );
-    if (activeAgents.length > 0) {
-      logger.debug(
-        `Rebalancing workload among ${activeAgents.length} active agents`
-      );
-    }
-  }
-  async triggerFreshStartsIfNeeded() {
-    for (const agent of this.activeAgents.values()) {
-      if (agent.performance.driftDetected) {
-        await this.triggerFreshStart(agent);
-      }
-    }
-  }
-  updateSwarmMetrics() {
-    if (!this.swarmState.performance) return;
-    const activeCount = Array.from(this.activeAgents.values()).filter(
-      (a) => a.status === "active"
-    ).length;
-    this.swarmState.performance.throughput = this.swarmState.completedTaskCount / ((Date.now() - this.swarmState.startTime) / 1e3);
-    this.swarmState.performance.efficiency = activeCount > 0 ? this.swarmState.completedTaskCount / activeCount : 0;
-  }
-  /**
-   * Cleanup completed swarms and their resources
-   */
-  async cleanupCompletedSwarms() {
-    if (this.swarmState.status !== "completed") {
-      return;
-    }
-    try {
-      logger.info("Cleaning up completed swarm resources");
-      if (this.coordinationTimer) {
-        clearInterval(this.coordinationTimer);
-        this.coordinationTimer = void 0;
-      }
-      for (const agent of this.activeAgents.values()) {
-        try {
-          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
-          );
-        }
-      }
-      await this.gitWorkflowManager.coordinateMerges(
-        Array.from(this.activeAgents.values())
-      );
-      this.activeAgents.clear();
-      this.swarmState = {
-        id: uuidv4(),
-        status: "idle",
-        startTime: Date.now(),
-        activeTaskCount: 0,
-        completedTaskCount: 0,
-        coordination: {
-          events: [],
-          conflicts: [],
-          resolutions: []
-        },
-        performance: {
-          throughput: 0,
-          efficiency: 0,
-          coordination_overhead: 0
-        }
-      };
-      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
-      });
-    }
-  }
-  /**
-   * Force cleanup of a swarm (for emergency situations)
-   */
-  async forceCleanup() {
-    logger.warn("Force cleanup initiated");
-    try {
-      if (this.coordinationTimer) {
-        clearInterval(this.coordinationTimer);
-        this.coordinationTimer = void 0;
-      }
-      for (const agent of this.activeAgents.values()) {
-        agent.status = "stopped";
-      }
-      this.swarmState.status = "stopped";
-      await this.cleanupCompletedSwarms();
-    } catch (error) {
-      logger.error("Force cleanup failed", error);
-    }
-  }
-  /**
-   * Get swarm resource usage and cleanup recommendations
-   */
-  getResourceUsage() {
-    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"
-      );
-      cleanupRecommended = true;
-    }
-    if (hasCompletedTasks) {
-      recommendations.push("All tasks completed - cleanup is recommended");
-      cleanupRecommended = true;
-    }
-    if (this.activeAgents.size > 5) {
-      recommendations.push("High agent count - monitor resource usage");
-    }
-    return {
-      activeAgents: this.activeAgents.size,
-      workingDirectories: workingDirs,
-      memoryEstimate,
-      cleanupRecommended,
-      recommendations
-    };
-  }
-  [Symbol.toStringTag] = "SwarmCoordinator";
-}
-const swarmCoordinator = new SwarmCoordinator();
-export {
-  AgentExecutionError,
-  SwarmCoordinationError,
-  SwarmCoordinator,
-  TaskAllocationError,
-  swarmCoordinator
-};