@lov3kaizen/agentsea-crews 0.5.1

package/dist/chunk-QMK3HWFX.mjs

@@ -0,0 +1,4584 @@
+// src/core/Role.ts
+var Role = class _Role {
+  name;
+  description;
+  capabilities;
+  systemPrompt;
+  goals;
+  constraints;
+  backstory;
+  canDelegate;
+  canReceiveDelegation;
+  maxConcurrentTasks;
+  capabilityMap;
+  constructor(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.capabilities = config.capabilities;
+    this.systemPrompt = config.systemPrompt;
+    this.goals = config.goals ?? [];
+    this.constraints = config.constraints ?? [];
+    this.backstory = config.backstory ?? "";
+    this.canDelegate = config.canDelegate ?? false;
+    this.canReceiveDelegation = config.canReceiveDelegation ?? true;
+    this.maxConcurrentTasks = config.maxConcurrentTasks ?? 1;
+    this.capabilityMap = /* @__PURE__ */ new Map();
+    for (const cap of this.capabilities) {
+      this.capabilityMap.set(cap.name.toLowerCase(), cap);
+    }
+  }
+  /**
+   * Generate a complete system prompt incorporating all role aspects
+   */
+  generateSystemPrompt() {
+    const parts = [];
+    parts.push(this.systemPrompt);
+    parts.push(`
+
+You are acting as a ${this.name}: ${this.description}`);
+    if (this.backstory) {
+      parts.push(`
+
+Background: ${this.backstory}`);
+    }
+    if (this.goals.length > 0) {
+      parts.push("\n\nYour goals:");
+      for (const goal of this.goals) {
+        parts.push(`- ${goal}`);
+      }
+    }
+    if (this.constraints.length > 0) {
+      parts.push("\n\nConstraints you must respect:");
+      for (const constraint of this.constraints) {
+        parts.push(`- ${constraint}`);
+      }
+    }
+    if (this.capabilities.length > 0) {
+      parts.push("\n\nYour capabilities:");
+      for (const cap of this.capabilities) {
+        parts.push(`- ${cap.name} (${cap.proficiency}): ${cap.description}`);
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Check if this role has a specific capability
+   */
+  hasCapability(name) {
+    return this.capabilityMap.has(name.toLowerCase());
+  }
+  /**
+   * Get a specific capability by name
+   */
+  getCapability(name) {
+    return this.capabilityMap.get(name.toLowerCase());
+  }
+  /**
+   * Get proficiency level for a capability
+   */
+  getProficiency(name) {
+    const cap = this.getCapability(name);
+    return cap?.proficiency;
+  }
+  /**
+   * Get proficiency score (0-1) for a capability
+   */
+  getProficiencyScore(name) {
+    const cap = this.getCapability(name);
+    if (!cap) return 0;
+    const weights = {
+      novice: 0.25,
+      intermediate: 0.5,
+      expert: 0.75,
+      master: 1
+    };
+    return weights[cap.proficiency];
+  }
+  /**
+   * Get all tools required by this role's capabilities
+   */
+  getRequiredTools() {
+    const tools = /* @__PURE__ */ new Set();
+    for (const cap of this.capabilities) {
+      if (cap.tools) {
+        for (const tool of cap.tools) {
+          tools.add(tool);
+        }
+      }
+    }
+    return Array.from(tools);
+  }
+  /**
+   * Get all keywords from this role's capabilities
+   */
+  getKeywords() {
+    const keywords = /* @__PURE__ */ new Set();
+    for (const cap of this.capabilities) {
+      if (cap.keywords) {
+        for (const keyword of cap.keywords) {
+          keywords.add(keyword.toLowerCase());
+        }
+      }
+    }
+    return Array.from(keywords);
+  }
+  /**
+   * Match required capabilities against this role
+   */
+  matchCapabilities(required) {
+    const matched = [];
+    const missing = [];
+    for (const req of required) {
+      const available = this.getCapability(req.name);
+      if (available) {
+        matched.push(available);
+      } else {
+        missing.push(req);
+      }
+    }
+    const score = required.length > 0 ? matched.length / required.length : 1;
+    const canExecute = missing.length === 0;
+    return {
+      matched,
+      missing,
+      score,
+      canExecute
+    };
+  }
+  /**
+   * Calculate relevance score for a task description
+   */
+  calculateRelevanceScore(taskDescription) {
+    const descLower = taskDescription.toLowerCase();
+    const keywords = this.getKeywords();
+    if (keywords.length === 0) {
+      let matchCount2 = 0;
+      for (const cap of this.capabilities) {
+        if (descLower.includes(cap.name.toLowerCase())) {
+          matchCount2++;
+        }
+      }
+      return this.capabilities.length > 0 ? matchCount2 / this.capabilities.length : 0;
+    }
+    let matchCount = 0;
+    for (const keyword of keywords) {
+      if (descLower.includes(keyword)) {
+        matchCount++;
+      }
+    }
+    return keywords.length > 0 ? matchCount / keywords.length : 0;
+  }
+  /**
+   * Serialize to JSON
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      description: this.description,
+      capabilities: this.capabilities,
+      systemPrompt: this.systemPrompt,
+      goals: this.goals.length > 0 ? this.goals : void 0,
+      constraints: this.constraints.length > 0 ? this.constraints : void 0,
+      backstory: this.backstory || void 0,
+      canDelegate: this.canDelegate,
+      canReceiveDelegation: this.canReceiveDelegation,
+      maxConcurrentTasks: this.maxConcurrentTasks
+    };
+  }
+  /**
+   * Create from JSON
+   */
+  static fromJSON(json) {
+    return new _Role(json);
+  }
+  /**
+   * Create a simple role with minimal configuration
+   */
+  static simple(name, description, systemPrompt, capabilities = []) {
+    return new _Role({
+      name,
+      description,
+      systemPrompt,
+      capabilities: capabilities.map((cap) => ({
+        name: cap,
+        description: cap,
+        proficiency: "intermediate"
+      }))
+    });
+  }
+};
+function createRole(config) {
+  return new Role(config);
+}
+
+// src/core/Task.ts
+import { nanoid } from "nanoid";
+var Task = class _Task {
+  id;
+  description;
+  expectedOutput;
+  priority;
+  dependencies;
+  deadline;
+  context;
+  assignTo;
+  requiredCapabilities;
+  estimatedTokens;
+  maxRetries;
+  timeoutMs;
+  tags;
+  _status;
+  _assignedAgent;
+  _result;
+  _metadata;
+  constructor(config) {
+    this.id = config.id ?? nanoid();
+    this.description = config.description;
+    this.expectedOutput = config.expectedOutput;
+    this.priority = config.priority ?? "medium";
+    this.dependencies = config.dependencies ?? [];
+    this.deadline = config.deadline;
+    this.context = config.context ?? {};
+    this.assignTo = config.assignTo;
+    this.requiredCapabilities = config.requiredCapabilities ?? [];
+    this.estimatedTokens = config.estimatedTokens;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.timeoutMs = config.timeoutMs;
+    this.tags = config.tags ?? [];
+    this._status = "pending";
+    this._assignedAgent = void 0;
+    this._result = void 0;
+    this._metadata = {
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      attempts: 0,
+      statusHistory: [{ status: "pending", timestamp: /* @__PURE__ */ new Date() }]
+    };
+  }
+  // ============ Getters ============
+  get status() {
+    return this._status;
+  }
+  get assignedAgent() {
+    return this._assignedAgent;
+  }
+  get result() {
+    return this._result;
+  }
+  get metadata() {
+    return { ...this._metadata };
+  }
+  get isCompleted() {
+    return this._status === "completed";
+  }
+  get isFailed() {
+    return this._status === "failed";
+  }
+  get isPending() {
+    return this._status === "pending";
+  }
+  get isBlocked() {
+    return this._status === "blocked";
+  }
+  get isInProgress() {
+    return this._status === "in_progress";
+  }
+  get isAssigned() {
+    return this._status === "assigned";
+  }
+  get attempts() {
+    return this._metadata.attempts;
+  }
+  // ============ Lifecycle Methods ============
+  /**
+   * Assign the task to an agent
+   */
+  assign(agentName) {
+    if (this._status !== "pending" && this._status !== "blocked") {
+      throw new Error(`Cannot assign task in status: ${this._status}`);
+    }
+    this._assignedAgent = agentName;
+    this.updateStatus("assigned");
+    this._metadata.assignedAt = /* @__PURE__ */ new Date();
+    this._metadata.attempts++;
+  }
+  /**
+   * Start task execution
+   */
+  start() {
+    if (this._status !== "assigned") {
+      throw new Error(`Cannot start task in status: ${this._status}`);
+    }
+    this.updateStatus("in_progress");
+    this._metadata.startedAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Complete the task with a result
+   */
+  complete(result) {
+    if (this._status !== "in_progress") {
+      throw new Error(`Cannot complete task in status: ${this._status}`);
+    }
+    this._result = {
+      ...result,
+      completedAt: /* @__PURE__ */ new Date(),
+      completedBy: this._assignedAgent
+    };
+    this._metadata.actualDuration = this._metadata.startedAt ? Date.now() - this._metadata.startedAt.getTime() : void 0;
+    this.updateStatus("completed");
+  }
+  /**
+   * Mark the task as failed
+   */
+  fail(error) {
+    if (this._status !== "in_progress" && this._status !== "assigned") {
+      throw new Error(`Cannot fail task in status: ${this._status}`);
+    }
+    this._result = {
+      output: "",
+      completedAt: /* @__PURE__ */ new Date(),
+      completedBy: this._assignedAgent || "unknown",
+      iterations: 0,
+      tokensUsed: 0,
+      error
+    };
+    this.updateStatus("failed");
+  }
+  /**
+   * Block the task (e.g., due to unmet dependencies)
+   */
+  block(reason) {
+    this.updateStatus("blocked", reason);
+  }
+  /**
+   * Unblock the task
+   */
+  unblock() {
+    if (this._status !== "blocked") {
+      throw new Error(`Cannot unblock task in status: ${this._status}`);
+    }
+    this.updateStatus("pending");
+  }
+  /**
+   * Cancel the task
+   */
+  cancel(reason) {
+    if (this._status === "completed") {
+      throw new Error("Cannot cancel completed task");
+    }
+    this.updateStatus("cancelled", reason);
+  }
+  /**
+   * Reset the task for retry
+   */
+  reset() {
+    if (this._status !== "failed") {
+      throw new Error("Can only reset failed tasks");
+    }
+    this._status = "pending";
+    this._assignedAgent = void 0;
+    this._result = void 0;
+    this._metadata.statusHistory?.push({
+      status: "pending",
+      timestamp: /* @__PURE__ */ new Date(),
+      reason: "reset for retry"
+    });
+    this._metadata.updatedAt = /* @__PURE__ */ new Date();
+  }
+  // ============ Query Methods ============
+  /**
+   * Check if the task can start (dependencies satisfied)
+   */
+  canStart(completedTaskIds = /* @__PURE__ */ new Set()) {
+    if (this._status !== "pending" && this._status !== "blocked") {
+      return false;
+    }
+    for (const depId of this.dependencies) {
+      if (!completedTaskIds.has(depId)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Check if all dependencies are satisfied
+   */
+  dependenciesSatisfied(completedTaskIds) {
+    for (const depId of this.dependencies) {
+      if (!completedTaskIds.has(depId)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Check if task can be retried
+   */
+  canRetry() {
+    return this._status === "failed" && this._metadata.attempts < this.maxRetries;
+  }
+  /**
+   * Check if task is past deadline
+   */
+  isPastDeadline() {
+    if (!this.deadline) return false;
+    return /* @__PURE__ */ new Date() > this.deadline;
+  }
+  /**
+   * Get time remaining until deadline (ms)
+   */
+  getTimeRemaining() {
+    if (!this.deadline) return null;
+    return Math.max(0, this.deadline.getTime() - Date.now());
+  }
+  /**
+   * Get priority weight for queue ordering
+   */
+  getPriorityWeight() {
+    const weights = {
+      critical: 100,
+      high: 75,
+      medium: 50,
+      low: 25
+    };
+    return weights[this.priority];
+  }
+  /**
+   * Compare to another task for priority ordering
+   */
+  compareTo(other) {
+    const priorityDiff = other.getPriorityWeight() - this.getPriorityWeight();
+    if (priorityDiff !== 0) return priorityDiff;
+    if (this.deadline && other.deadline) {
+      return this.deadline.getTime() - other.deadline.getTime();
+    }
+    if (this.deadline) return -1;
+    if (other.deadline) return 1;
+    return this._metadata.createdAt.getTime() - other._metadata.createdAt.getTime();
+  }
+  // ============ Private Methods ============
+  updateStatus(status, reason) {
+    this._status = status;
+    this._metadata.updatedAt = /* @__PURE__ */ new Date();
+    this._metadata.statusHistory?.push({
+      status,
+      timestamp: /* @__PURE__ */ new Date(),
+      reason
+    });
+  }
+  // ============ Serialization ============
+  /**
+   * Get the full task state
+   */
+  getState() {
+    return {
+      config: this.toConfig(),
+      status: this._status,
+      assignedAgent: this._assignedAgent,
+      result: this._result,
+      metadata: { ...this._metadata }
+    };
+  }
+  /**
+   * Convert to config object
+   */
+  toConfig() {
+    return {
+      id: this.id,
+      description: this.description,
+      expectedOutput: this.expectedOutput,
+      priority: this.priority,
+      dependencies: this.dependencies.length > 0 ? this.dependencies : void 0,
+      deadline: this.deadline,
+      context: Object.keys(this.context).length > 0 ? this.context : void 0,
+      assignTo: this.assignTo,
+      requiredCapabilities: this.requiredCapabilities.length > 0 ? this.requiredCapabilities : void 0,
+      estimatedTokens: this.estimatedTokens,
+      maxRetries: this.maxRetries,
+      timeoutMs: this.timeoutMs,
+      tags: this.tags.length > 0 ? this.tags : void 0
+    };
+  }
+  /**
+   * Serialize to JSON
+   */
+  toJSON() {
+    return this.getState();
+  }
+  /**
+   * Create from state
+   */
+  static fromState(state) {
+    const task = new _Task(state.config);
+    task._status = state.status;
+    task._assignedAgent = state.assignedAgent;
+    task._result = state.result;
+    task._metadata = state.metadata;
+    return task;
+  }
+};
+function createTask(config) {
+  return new Task(config);
+}
+
+// src/core/TaskQueue.ts
+var TaskQueue = class {
+  tasks = [];
+  taskMap = /* @__PURE__ */ new Map();
+  maxSize;
+  autoSort;
+  dirty = false;
+  constructor(config = {}) {
+    this.maxSize = config.maxSize ?? Infinity;
+    this.autoSort = config.autoSort ?? true;
+  }
+  // ============ Basic Operations ============
+  /**
+   * Add a task to the queue
+   */
+  enqueue(task) {
+    if (this.taskMap.has(task.id)) {
+      throw new Error(`Task ${task.id} already in queue`);
+    }
+    if (this.tasks.length >= this.maxSize) {
+      throw new Error("Queue is full");
+    }
+    this.tasks.push(task);
+    this.taskMap.set(task.id, task);
+    this.dirty = true;
+    if (this.autoSort) {
+      this.sort();
+    }
+  }
+  /**
+   * Add multiple tasks to the queue
+   */
+  enqueueMany(tasks) {
+    for (const task of tasks) {
+      if (!this.taskMap.has(task.id)) {
+        if (this.tasks.length < this.maxSize) {
+          this.tasks.push(task);
+          this.taskMap.set(task.id, task);
+        }
+      }
+    }
+    this.dirty = true;
+    if (this.autoSort) {
+      this.sort();
+    }
+  }
+  /**
+   * Remove and return the highest priority task
+   */
+  dequeue() {
+    if (this.dirty && this.autoSort) {
+      this.sort();
+    }
+    const task = this.tasks.shift();
+    if (task) {
+      this.taskMap.delete(task.id);
+    }
+    return task;
+  }
+  /**
+   * Peek at the highest priority task without removing
+   */
+  peek() {
+    if (this.dirty && this.autoSort) {
+      this.sort();
+    }
+    return this.tasks[0];
+  }
+  /**
+   * Get a specific task by ID
+   */
+  get(id) {
+    return this.taskMap.get(id);
+  }
+  /**
+   * Remove a specific task by ID
+   */
+  remove(id) {
+    const task = this.taskMap.get(id);
+    if (task) {
+      this.tasks = this.tasks.filter((t) => t.id !== id);
+      this.taskMap.delete(id);
+    }
+    return task;
+  }
+  /**
+   * Check if a task is in the queue
+   */
+  has(id) {
+    return this.taskMap.has(id);
+  }
+  /**
+   * Clear all tasks from the queue
+   */
+  clear() {
+    this.tasks = [];
+    this.taskMap.clear();
+    this.dirty = false;
+  }
+  // ============ Query Methods ============
+  /**
+   * Get tasks by status
+   */
+  getByStatus(status) {
+    return this.tasks.filter((t) => t.status === status);
+  }
+  /**
+   * Get tasks by priority
+   */
+  getByPriority(priority) {
+    return this.tasks.filter((t) => t.priority === priority);
+  }
+  /**
+   * Get tasks that are ready to start (dependencies satisfied)
+   */
+  getReadyTasks(completedTaskIds = /* @__PURE__ */ new Set()) {
+    return this.tasks.filter((t) => t.canStart(completedTaskIds));
+  }
+  /**
+   * Get tasks assigned to a specific agent
+   */
+  getByAgent(agentName) {
+    return this.tasks.filter((t) => t.assignedAgent === agentName);
+  }
+  /**
+   * Get tasks with a specific tag
+   */
+  getByTag(tag) {
+    return this.tasks.filter((t) => t.tags.includes(tag));
+  }
+  /**
+   * Get pending tasks
+   */
+  getPending() {
+    return this.getByStatus("pending");
+  }
+  /**
+   * Get blocked tasks
+   */
+  getBlocked() {
+    return this.getByStatus("blocked");
+  }
+  /**
+   * Get in-progress tasks
+   */
+  getInProgress() {
+    return this.getByStatus("in_progress");
+  }
+  /**
+   * Get failed tasks
+   */
+  getFailed() {
+    return this.getByStatus("failed");
+  }
+  /**
+   * Get tasks that can be retried
+   */
+  getRetryable() {
+    return this.tasks.filter((t) => t.canRetry());
+  }
+  /**
+   * Get tasks past their deadline
+   */
+  getOverdue() {
+    return this.tasks.filter((t) => t.isPastDeadline());
+  }
+  /**
+   * Get the next N ready tasks
+   */
+  getNextReady(n, completedTaskIds = /* @__PURE__ */ new Set()) {
+    if (this.dirty && this.autoSort) {
+      this.sort();
+    }
+    const ready = [];
+    for (const task of this.tasks) {
+      if (ready.length >= n) break;
+      if (task.canStart(completedTaskIds)) {
+        ready.push(task);
+      }
+    }
+    return ready;
+  }
+  // ============ State Methods ============
+  /**
+   * Get queue size
+   */
+  get size() {
+    return this.tasks.length;
+  }
+  /**
+   * Check if queue is empty
+   */
+  isEmpty() {
+    return this.tasks.length === 0;
+  }
+  /**
+   * Check if queue is full
+   */
+  isFull() {
+    return this.tasks.length >= this.maxSize;
+  }
+  /**
+   * Get all tasks (copy)
+   */
+  getAll() {
+    return [...this.tasks];
+  }
+  /**
+   * Get all task IDs
+   */
+  getAllIds() {
+    return this.tasks.map((t) => t.id);
+  }
+  /**
+   * Get queue statistics
+   */
+  getStats() {
+    const byStatus = {
+      pending: 0,
+      assigned: 0,
+      in_progress: 0,
+      completed: 0,
+      failed: 0,
+      blocked: 0,
+      cancelled: 0
+    };
+    const byPriority = {
+      critical: 0,
+      high: 0,
+      medium: 0,
+      low: 0
+    };
+    for (const task of this.tasks) {
+      byStatus[task.status]++;
+      byPriority[task.priority]++;
+    }
+    return {
+      total: this.tasks.length,
+      byStatus,
+      byPriority,
+      overdue: this.getOverdue().length,
+      retryable: this.getRetryable().length
+    };
+  }
+  // ============ Manipulation Methods ============
+  /**
+   * Sort the queue by priority
+   */
+  sort() {
+    this.tasks.sort((a, b) => a.compareTo(b));
+    this.dirty = false;
+  }
+  /**
+   * Update blocked status for tasks based on completed dependencies
+   */
+  updateBlockedTasks(completedTaskIds) {
+    let unblocked = 0;
+    for (const task of this.tasks) {
+      if (task.isBlocked && task.dependenciesSatisfied(completedTaskIds)) {
+        task.unblock();
+        unblocked++;
+      }
+    }
+    return unblocked;
+  }
+  /**
+   * Block tasks with unmet dependencies
+   */
+  blockDependentTasks(failedTaskId) {
+    let blocked = 0;
+    for (const task of this.tasks) {
+      if (task.dependencies.includes(failedTaskId) && task.isPending) {
+        task.block(`Dependency ${failedTaskId} failed`);
+        blocked++;
+      }
+    }
+    return blocked;
+  }
+  /**
+   * Reprioritize a task
+   */
+  reprioritize(taskId, _newPriority) {
+    const task = this.taskMap.get(taskId);
+    if (task) {
+      this.dirty = true;
+      return true;
+    }
+    return false;
+  }
+  // ============ Iterator ============
+  /**
+   * Iterate over tasks
+   */
+  *[Symbol.iterator]() {
+    for (const task of this.tasks) {
+      yield task;
+    }
+  }
+  /**
+   * For each task
+   */
+  forEach(callback) {
+    this.tasks.forEach(callback);
+  }
+  /**
+   * Filter tasks
+   */
+  filter(predicate) {
+    return this.tasks.filter(predicate);
+  }
+  /**
+   * Find a task
+   */
+  find(predicate) {
+    return this.tasks.find(predicate);
+  }
+};
+function createTaskQueue(config) {
+  return new TaskQueue(config);
+}
+
+// src/core/ExecutionContext.ts
+import EventEmitter from "eventemitter3";
+import { nanoid as nanoid2 } from "nanoid";
+var ExecutionContext = class {
+  crewId;
+  crewName;
+  state;
+  completedTasks;
+  agentStates;
+  variables;
+  eventEmitter;
+  eventBuffer;
+  bufferEvents;
+  maxBufferSize;
+  abortController;
+  status;
+  startTime;
+  endTime;
+  constructor(config) {
+    this.crewId = config.crewId ?? nanoid2();
+    this.crewName = config.crewName;
+    this.state = /* @__PURE__ */ new Map();
+    this.completedTasks = /* @__PURE__ */ new Map();
+    this.agentStates = /* @__PURE__ */ new Map();
+    this.variables = {};
+    this.eventEmitter = new EventEmitter();
+    this.eventBuffer = [];
+    this.bufferEvents = config.bufferEvents ?? false;
+    this.maxBufferSize = config.maxBufferSize ?? 1e3;
+    this.abortController = new AbortController();
+    this.status = "idle";
+    if (config.globalContext) {
+      for (const [key, value] of Object.entries(config.globalContext)) {
+        this.state.set(key, value);
+      }
+    }
+  }
+  // ============ State Management ============
+  /**
+   * Set a value in shared state
+   */
+  set(key, value) {
+    this.state.set(key, value);
+  }
+  /**
+   * Get a value from shared state
+   */
+  get(key) {
+    return this.state.get(key);
+  }
+  /**
+   * Check if a key exists in shared state
+   */
+  has(key) {
+    return this.state.has(key);
+  }
+  /**
+   * Delete a key from shared state
+   */
+  delete(key) {
+    return this.state.delete(key);
+  }
+  /**
+   * Get all state keys
+   */
+  keys() {
+    return Array.from(this.state.keys());
+  }
+  /**
+   * Get all state entries
+   */
+  entries() {
+    return Array.from(this.state.entries());
+  }
+  /**
+   * Clear all shared state
+   */
+  clearState() {
+    this.state.clear();
+  }
+  // ============ Variables ============
+  /**
+   * Set a variable
+   */
+  setVariable(name, value) {
+    this.variables[name] = value;
+  }
+  /**
+   * Get a variable
+   */
+  getVariable(name) {
+    return this.variables[name];
+  }
+  /**
+   * Get all variables
+   */
+  getVariables() {
+    return { ...this.variables };
+  }
+  // ============ Task Tracking ============
+  /**
+   * Mark a task as completed
+   */
+  markTaskCompleted(taskId, result) {
+    this.completedTasks.set(taskId, result);
+  }
+  /**
+   * Check if a task is completed
+   */
+  isTaskCompleted(taskId) {
+    return this.completedTasks.has(taskId);
+  }
+  /**
+   * Get a completed task result
+   */
+  getTaskResult(taskId) {
+    return this.completedTasks.get(taskId);
+  }
+  /**
+   * Get all completed tasks
+   */
+  getCompletedTasks() {
+    return new Map(this.completedTasks);
+  }
+  /**
+   * Get completed task IDs
+   */
+  getCompletedTaskIds() {
+    return new Set(this.completedTasks.keys());
+  }
+  /**
+   * Get completed task count
+   */
+  getCompletedTaskCount() {
+    return this.completedTasks.size;
+  }
+  // ============ Agent State ============
+  /**
+   * Set agent state
+   */
+  setAgentState(agentName, state) {
+    this.agentStates.set(agentName, state);
+  }
+  /**
+   * Get agent state
+   */
+  getAgentState(agentName) {
+    return this.agentStates.get(agentName);
+  }
+  /**
+   * Get all agent states
+   */
+  getAgentStates() {
+    return new Map(this.agentStates);
+  }
+  // ============ Event System ============
+  /**
+   * Emit an event
+   * Uses a permissive type that accepts any object with a `type` property
+   * to avoid TypeScript's strict excess property checking on union types
+   */
+  emit(event) {
+    const fullEvent = {
+      ...event,
+      crewName: this.crewName,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    if (this.bufferEvents) {
+      this.eventBuffer.push(fullEvent);
+      if (this.eventBuffer.length > this.maxBufferSize) {
+        this.eventBuffer.shift();
+      }
+    }
+    this.eventEmitter.emit(event.type, fullEvent);
+    this.eventEmitter.emit("*", fullEvent);
+  }
+  /**
+   * Subscribe to events of a specific type
+   */
+  on(type, handler) {
+    this.eventEmitter.on(type, handler);
+    return {
+      unsubscribe: () => this.eventEmitter.off(type, handler)
+    };
+  }
+  /**
+   * Subscribe to events once
+   */
+  once(type, handler) {
+    this.eventEmitter.once(type, handler);
+    return {
+      unsubscribe: () => this.eventEmitter.off(type, handler)
+    };
+  }
+  /**
+   * Remove all listeners for a type
+   */
+  off(type) {
+    this.eventEmitter.removeAllListeners(type);
+  }
+  /**
+   * Get buffered events
+   */
+  getEventBuffer() {
+    return [...this.eventBuffer];
+  }
+  /**
+   * Clear event buffer
+   */
+  clearEventBuffer() {
+    this.eventBuffer = [];
+  }
+  // ============ Lifecycle ============
+  /**
+   * Get abort signal
+   */
+  get signal() {
+    return this.abortController.signal;
+  }
+  /**
+   * Check if execution is aborted
+   */
+  get isAborted() {
+    return this.abortController.signal.aborted;
+  }
+  /**
+   * Abort execution
+   */
+  abort(reason) {
+    this.abortController.abort(reason);
+    this.status = "aborted";
+    this.endTime = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Set status
+   */
+  setStatus(status) {
+    this.status = status;
+    if (status === "running" && !this.startTime) {
+      this.startTime = /* @__PURE__ */ new Date();
+    }
+    if (status === "completed" || status === "failed" || status === "aborted") {
+      this.endTime = /* @__PURE__ */ new Date();
+    }
+  }
+  /**
+   * Get execution duration in milliseconds
+   */
+  getDuration() {
+    if (!this.startTime) return void 0;
+    const end = this.endTime ?? /* @__PURE__ */ new Date();
+    return end.getTime() - this.startTime.getTime();
+  }
+  // ============ Checkpointing ============
+  /**
+   * Create a checkpoint of current state
+   */
+  createCheckpoint() {
+    return {
+      id: nanoid2(),
+      timestamp: /* @__PURE__ */ new Date(),
+      crewId: this.crewId,
+      crewName: this.crewName,
+      state: new Map(this.state),
+      completedTasks: new Map(this.completedTasks),
+      agentStates: new Map(this.agentStates),
+      variables: { ...this.variables }
+    };
+  }
+  /**
+   * Restore from a checkpoint
+   */
+  restoreCheckpoint(checkpoint) {
+    this.state = new Map(checkpoint.state);
+    this.completedTasks = new Map(checkpoint.completedTasks);
+    this.agentStates = new Map(checkpoint.agentStates);
+    this.variables = { ...checkpoint.variables };
+  }
+  /**
+   * Export state for serialization
+   */
+  exportState() {
+    return {
+      crewId: this.crewId,
+      crewName: this.crewName,
+      status: this.status,
+      state: Object.fromEntries(this.state),
+      completedTasks: Object.fromEntries(
+        Array.from(this.completedTasks.entries())
+      ),
+      agentStates: Object.fromEntries(this.agentStates),
+      variables: this.variables,
+      startTime: this.startTime?.toISOString(),
+      endTime: this.endTime?.toISOString()
+    };
+  }
+  /**
+   * Import state from serialized data
+   */
+  importState(data) {
+    if (data.state && typeof data.state === "object") {
+      this.state = new Map(
+        Object.entries(data.state)
+      );
+    }
+    if (data.completedTasks && typeof data.completedTasks === "object") {
+      this.completedTasks = new Map(
+        Object.entries(data.completedTasks)
+      );
+    }
+    if (data.agentStates && typeof data.agentStates === "object") {
+      this.agentStates = new Map(
+        Object.entries(data.agentStates)
+      );
+    }
+    if (data.variables && typeof data.variables === "object") {
+      this.variables = data.variables;
+    }
+    if (data.status) {
+      this.status = data.status;
+    }
+    if (data.startTime) {
+      this.startTime = new Date(data.startTime);
+    }
+    if (data.endTime) {
+      this.endTime = new Date(data.endTime);
+    }
+  }
+  // ============ Reset ============
+  /**
+   * Reset context for new execution
+   */
+  reset() {
+    this.state.clear();
+    this.completedTasks.clear();
+    this.agentStates.clear();
+    this.variables = {};
+    this.eventBuffer = [];
+    this.abortController = new AbortController();
+    this.status = "idle";
+    this.startTime = void 0;
+    this.endTime = void 0;
+  }
+};
+function createExecutionContext(config) {
+  return new ExecutionContext(config);
+}
+
+// src/agents/AgentCapabilities.ts
+var PROFICIENCY_WEIGHTS = {
+  novice: 0.25,
+  intermediate: 0.5,
+  expert: 0.75,
+  master: 1
+};
+var AgentCapabilities = class {
+  /**
+   * Match required capabilities against available ones
+   */
+  static match(required, available) {
+    const availableMap = /* @__PURE__ */ new Map();
+    for (const cap of available) {
+      availableMap.set(cap.name.toLowerCase(), cap);
+    }
+    const matched = [];
+    const missing = [];
+    for (const req of required) {
+      const avail = availableMap.get(req.name.toLowerCase());
+      if (avail) {
+        matched.push(avail);
+      } else {
+        missing.push(req);
+      }
+    }
+    const score = required.length > 0 ? matched.length / required.length : 1;
+    const canExecute = missing.length === 0;
+    return {
+      matched,
+      missing,
+      score,
+      canExecute
+    };
+  }
+  /**
+   * Score a capability against a task
+   */
+  static score(capability, task) {
+    let score = PROFICIENCY_WEIGHTS[capability.proficiency];
+    if (capability.keywords && capability.keywords.length > 0) {
+      const descLower = task.description.toLowerCase();
+      let keywordMatches = 0;
+      for (const keyword of capability.keywords) {
+        if (descLower.includes(keyword.toLowerCase())) {
+          keywordMatches++;
+        }
+      }
+      const keywordBoost = keywordMatches / capability.keywords.length;
+      score = score * 0.7 + keywordBoost * 0.3;
+    }
+    return score;
+  }
+  /**
+   * Calculate overall capability score for an agent on a task
+   */
+  static calculateAgentScore(agent, task) {
+    if (agent.capabilities.length === 0) {
+      return 0;
+    }
+    if (task.requiredCapabilities && task.requiredCapabilities.length > 0) {
+      const requiredCaps = task.requiredCapabilities.map((name) => ({
+        name,
+        description: "",
+        proficiency: "intermediate"
+      }));
+      const match = this.match(requiredCaps, agent.capabilities);
+      if (!match.canExecute) {
+        return 0;
+      }
+      let totalScore = 0;
+      for (const cap of match.matched) {
+        totalScore += PROFICIENCY_WEIGHTS[cap.proficiency];
+      }
+      return totalScore / task.requiredCapabilities.length;
+    }
+    let maxScore = 0;
+    for (const cap of agent.capabilities) {
+      const capScore = this.score(cap, task);
+      maxScore = Math.max(maxScore, capScore);
+    }
+    return maxScore;
+  }
+  /**
+   * Rank agents by their suitability for a task
+   */
+  static rank(agents, task) {
+    const ranked = [];
+    for (const agent of agents) {
+      const requiredCaps = (task.requiredCapabilities ?? []).map((name) => ({
+        name,
+        description: "",
+        proficiency: "intermediate"
+      }));
+      const match = this.match(requiredCaps, agent.capabilities);
+      const score = this.calculateAgentScore(agent, task);
+      ranked.push({
+        agentName: agent.name,
+        score,
+        matchedCapabilities: match.matched,
+        missingCapabilities: match.missing
+      });
+    }
+    ranked.sort((a, b) => b.score - a.score);
+    return ranked;
+  }
+  /**
+   * Find the best matching agent for a task
+   */
+  static findBestMatch(agents, task) {
+    const ranked = this.rank(agents, task);
+    if (ranked.length === 0) return void 0;
+    const best = ranked[0];
+    if (best.score > 0 && best.missingCapabilities.length === 0) {
+      return best;
+    }
+    return ranked.find((r) => r.missingCapabilities.length === 0);
+  }
+  /**
+   * Find all agents that can handle a task
+   */
+  static findCapableAgents(agents, task) {
+    return this.rank(agents, task).filter(
+      (r) => r.missingCapabilities.length === 0
+    );
+  }
+  /**
+   * Check if any agent can handle a task
+   */
+  static canAnyHandle(agents, task) {
+    return this.findCapableAgents(agents, task).length > 0;
+  }
+  /**
+   * Calculate capability overlap between two agents
+   */
+  static calculateOverlap(agent1, agent2) {
+    const caps1 = new Set(agent1.capabilities.map((c) => c.name.toLowerCase()));
+    const caps2 = new Set(agent2.capabilities.map((c) => c.name.toLowerCase()));
+    let overlap = 0;
+    for (const cap of caps1) {
+      if (caps2.has(cap)) {
+        overlap++;
+      }
+    }
+    const totalUnique = caps1.size + caps2.size - overlap;
+    return totalUnique > 0 ? overlap / totalUnique : 0;
+  }
+  /**
+   * Get all unique capabilities across agents
+   */
+  static getAllCapabilities(agents) {
+    const capMap = /* @__PURE__ */ new Map();
+    for (const agent of agents) {
+      for (const cap of agent.capabilities) {
+        const key = cap.name.toLowerCase();
+        const existing = capMap.get(key);
+        if (!existing || PROFICIENCY_WEIGHTS[cap.proficiency] > PROFICIENCY_WEIGHTS[existing.proficiency]) {
+          capMap.set(key, cap);
+        }
+      }
+    }
+    return Array.from(capMap.values());
+  }
+  /**
+   * Get capabilities that only one agent has
+   */
+  static getUniqueCapabilities(agents) {
+    const capCounts = /* @__PURE__ */ new Map();
+    for (const agent of agents) {
+      for (const cap of agent.capabilities) {
+        const key = cap.name.toLowerCase();
+        const existing = capCounts.get(key);
+        if (existing) {
+          existing.agents.push(agent.name);
+        } else {
+          capCounts.set(key, { cap, agents: [agent.name] });
+        }
+      }
+    }
+    const unique = /* @__PURE__ */ new Map();
+    for (const [_key, { cap, agents: agentNames }] of capCounts) {
+      if (agentNames.length === 1) {
+        const existing = unique.get(agentNames[0]) ?? [];
+        existing.push(cap);
+        unique.set(agentNames[0], existing);
+      }
+    }
+    return unique;
+  }
+};
+
+// src/agents/CrewAgent.ts
+import { nanoid as nanoid3 } from "nanoid";
+var CrewAgent = class _CrewAgent {
+  id;
+  name;
+  role;
+  capabilities;
+  model;
+  provider;
+  tools;
+  temperature;
+  maxTokens;
+  maxIterations;
+  parallelCapable;
+  executeFunc;
+  currentTaskId;
+  tasksCompleted = 0;
+  tasksFailed = 0;
+  totalTokensUsed = 0;
+  constructor(options) {
+    const { config, execute } = options;
+    this.id = nanoid3();
+    this.name = config.name;
+    this.role = new Role(config.role);
+    this.capabilities = config.role.capabilities;
+    this.model = config.model;
+    this.provider = config.provider;
+    this.tools = config.tools ?? this.role.getRequiredTools();
+    this.temperature = config.temperature ?? 0.7;
+    this.maxTokens = config.maxTokens;
+    this.maxIterations = config.maxIterations ?? 10;
+    this.parallelCapable = config.parallelCapable ?? false;
+    this.executeFunc = execute;
+  }
+  // ============ Execution ============
+  /**
+   * Execute a task
+   */
+  async execute(input) {
+    if (!this.executeFunc) {
+      const mockResult = {
+        output: `[Mock response from ${this.name}]: ${input.slice(0, 100)}...`,
+        tokensUsed: Math.floor(Math.random() * 500) + 100,
+        latencyMs: Math.floor(Math.random() * 2e3) + 500,
+        iterations: 1
+      };
+      this.totalTokensUsed += mockResult.tokensUsed;
+      return mockResult;
+    }
+    const systemPrompt = this.role.generateSystemPrompt();
+    const result = await this.executeFunc(input, systemPrompt);
+    this.totalTokensUsed += result.tokensUsed;
+    return result;
+  }
+  /**
+   * Execute with task context
+   */
+  async executeTask(task) {
+    this.currentTaskId = task.id;
+    try {
+      const input = this.formatTaskInput(task);
+      const result = await this.execute(input);
+      this.tasksCompleted++;
+      return {
+        output: result.output,
+        completedAt: /* @__PURE__ */ new Date(),
+        completedBy: this.name,
+        iterations: result.iterations,
+        tokensUsed: result.tokensUsed,
+        metadata: {
+          latencyMs: result.latencyMs,
+          toolCalls: result.toolCalls
+        }
+      };
+    } catch (error) {
+      this.tasksFailed++;
+      throw error;
+    } finally {
+      this.currentTaskId = void 0;
+    }
+  }
+  /**
+   * Format task input for the agent
+   */
+  formatTaskInput(task) {
+    const parts = [];
+    parts.push(`# Task: ${task.description}`);
+    parts.push(`
+## Expected Output:
+${task.expectedOutput}`);
+    if (task.context && Object.keys(task.context).length > 0) {
+      parts.push(`
+## Context:
+${JSON.stringify(task.context, null, 2)}`);
+    }
+    if (task.deadline) {
+      parts.push(`
+## Deadline: ${task.deadline.toISOString()}`);
+    }
+    return parts.join("\n");
+  }
+  // ============ Capability Matching ============
+  /**
+   * Check if agent has a specific capability
+   */
+  hasCapability(name) {
+    return this.role.hasCapability(name);
+  }
+  /**
+   * Get proficiency score for a capability
+   */
+  getProficiencyScore(name) {
+    return this.role.getProficiencyScore(name);
+  }
+  /**
+   * Match required capabilities
+   */
+  matchesCapabilities(required) {
+    return AgentCapabilities.match(required, this.capabilities);
+  }
+  /**
+   * Calculate suitability score for a task
+   */
+  calculateTaskScore(task) {
+    return AgentCapabilities.calculateAgentScore(this, task);
+  }
+  // ============ Bidding ============
+  /**
+   * Generate a bid for a task
+   */
+  bidOnTask(task) {
+    const score = this.calculateTaskScore(task);
+    const hasRequired = this.hasRequiredCapabilities(task);
+    let confidence = score;
+    if (!hasRequired) {
+      confidence *= 0.5;
+    }
+    if (this.currentTaskId) {
+      confidence *= 0.7;
+    }
+    const matchedCaps = this.capabilities.filter(
+      (c) => task.requiredCapabilities?.some(
+        (req) => req.toLowerCase() === c.name.toLowerCase()
+      ) ?? true
+    ).map((c) => c.name);
+    const estimatedTime = this.estimateTaskTime(task);
+    const reasoning = this.generateBidReasoning(task, confidence, matchedCaps);
+    return Promise.resolve({
+      agentName: this.name,
+      taskId: task.id ?? "unknown",
+      confidence,
+      estimatedTime,
+      reasoning,
+      capabilities: matchedCaps
+    });
+  }
+  /**
+   * Check if agent has all required capabilities
+   */
+  hasRequiredCapabilities(task) {
+    if (!task.requiredCapabilities || task.requiredCapabilities.length === 0) {
+      return true;
+    }
+    for (const required of task.requiredCapabilities) {
+      if (!this.hasCapability(required)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Estimate time to complete a task
+   */
+  estimateTaskTime(task) {
+    let estimate = 3e4;
+    const outputWords = task.expectedOutput.split(" ").length;
+    estimate += outputWords * 100;
+    estimate += (task.requiredCapabilities?.length ?? 0) * 5e3;
+    return estimate;
+  }
+  /**
+   * Generate reasoning for a bid
+   */
+  generateBidReasoning(task, confidence, matchedCaps) {
+    const parts = [];
+    if (matchedCaps.length > 0) {
+      parts.push(`I have relevant capabilities: ${matchedCaps.join(", ")}`);
+    }
+    if (confidence > 0.8) {
+      parts.push("I am highly suited for this task");
+    } else if (confidence > 0.5) {
+      parts.push("I can handle this task adequately");
+    } else {
+      parts.push("This task is outside my primary expertise");
+    }
+    if (this.currentTaskId) {
+      parts.push("Note: I am currently working on another task");
+    }
+    return parts.join(". ") + ".";
+  }
+  // ============ Collaboration ============
+  /**
+   * Create a help request
+   */
+  createHelpRequest(taskId, request) {
+    return {
+      requestId: nanoid3(),
+      fromAgent: this.name,
+      taskId,
+      request
+    };
+  }
+  /**
+   * Respond to a help request
+   */
+  async respondToHelpRequest(request) {
+    const input = `
+Another agent needs help with their task.
+
+Their request: ${request.request}
+
+Please provide a helpful response based on your expertise as a ${this.role.name}.
+`;
+    const result = await this.execute(input);
+    return {
+      requestId: request.requestId,
+      fromAgent: this.name,
+      response: result.output,
+      helpful: true
+    };
+  }
+  /**
+   * Provide help for a task (called by CollaborationManager)
+   */
+  async provideHelp(task, question, _context) {
+    const score = this.calculateTaskScore(task);
+    const canHelp = score > 0.3;
+    if (!canHelp) {
+      return {
+        helpful: false,
+        response: `I may not be the best agent to help with this. My expertise in ${this.role.name} might not be directly applicable.`
+      };
+    }
+    const input = `
+# Help Request
+
+## Task Context:
+${task.description}
+
+## Question:
+${question}
+
+## Your Role:
+You are a ${this.role.name}. ${this.role.description}
+
+Please provide helpful guidance based on your expertise.
+`;
+    try {
+      const result = await this.execute(input);
+      const suggestions = this.extractSuggestions(result.output);
+      return {
+        helpful: true,
+        response: result.output,
+        suggestions: suggestions.length > 0 ? suggestions : void 0
+      };
+    } catch (error) {
+      return {
+        helpful: false,
+        response: `I encountered an error while trying to help: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Extract suggestions from help response
+   */
+  extractSuggestions(response) {
+    const suggestions = [];
+    const numberPattern = /^\d+\.\s+(.+)$/gm;
+    let match;
+    while ((match = numberPattern.exec(response)) !== null) {
+      suggestions.push(match[1].trim());
+    }
+    const bulletPattern = /^[-*]\s+(.+)$/gm;
+    while ((match = bulletPattern.exec(response)) !== null) {
+      suggestions.push(match[1].trim());
+    }
+    return suggestions.slice(0, 5);
+  }
+  // ============ State ============
+  /**
+   * Check if agent is busy
+   */
+  get isBusy() {
+    return this.currentTaskId !== void 0;
+  }
+  /**
+   * Get current task ID
+   */
+  getCurrentTask() {
+    return this.currentTaskId;
+  }
+  /**
+   * Get agent statistics
+   */
+  getStats() {
+    return {
+      name: this.name,
+      role: this.role.name,
+      tasksCompleted: this.tasksCompleted,
+      tasksFailed: this.tasksFailed,
+      totalTokensUsed: this.totalTokensUsed,
+      successRate: this.tasksCompleted + this.tasksFailed > 0 ? this.tasksCompleted / (this.tasksCompleted + this.tasksFailed) : 0,
+      isBusy: this.isBusy,
+      currentTask: this.currentTaskId
+    };
+  }
+  // ============ Serialization ============
+  /**
+   * Convert to config
+   */
+  toConfig() {
+    return {
+      name: this.name,
+      role: this.role.toJSON(),
+      model: this.model,
+      provider: this.provider,
+      tools: this.tools.length > 0 ? this.tools : void 0,
+      temperature: this.temperature,
+      maxTokens: this.maxTokens,
+      maxIterations: this.maxIterations,
+      parallelCapable: this.parallelCapable
+    };
+  }
+  /**
+   * Create from config
+   */
+  static fromConfig(config) {
+    return new _CrewAgent({ config });
+  }
+};
+function createCrewAgent(options) {
+  return new CrewAgent(options);
+}
+
+// src/agents/AgentRegistry.ts
+var AgentRegistry = class {
+  agents = /* @__PURE__ */ new Map();
+  allowDuplicates;
+  trackStats;
+  constructor(config = {}) {
+    this.allowDuplicates = config.allowDuplicates ?? false;
+    this.trackStats = config.trackStats ?? true;
+  }
+  // ============ Registration ============
+  /**
+   * Register an agent
+   */
+  register(agent, metadata) {
+    if (this.agents.has(agent.name) && !this.allowDuplicates) {
+      throw new Error(`Agent "${agent.name}" is already registered`);
+    }
+    this.agents.set(agent.name, {
+      agent,
+      status: "available",
+      registeredAt: /* @__PURE__ */ new Date(),
+      tasksCompleted: 0,
+      tasksFailed: 0,
+      metadata
+    });
+  }
+  /**
+   * Register multiple agents
+   */
+  registerMany(agents) {
+    for (const agent of agents) {
+      this.register(agent);
+    }
+  }
+  /**
+   * Unregister an agent
+   */
+  unregister(name) {
+    return this.agents.delete(name);
+  }
+  /**
+   * Check if an agent is registered
+   */
+  has(name) {
+    return this.agents.has(name);
+  }
+  // ============ Retrieval ============
+  /**
+   * Get an agent by name
+   */
+  get(name) {
+    return this.agents.get(name)?.agent;
+  }
+  /**
+   * Get registered agent entry
+   */
+  getEntry(name) {
+    return this.agents.get(name);
+  }
+  /**
+   * Get all agents
+   */
+  getAll() {
+    return Array.from(this.agents.values()).map((entry) => entry.agent);
+  }
+  /**
+   * Get all registered entries
+   */
+  getAllEntries() {
+    return Array.from(this.agents.values());
+  }
+  /**
+   * Get agent names
+   */
+  getNames() {
+    return Array.from(this.agents.keys());
+  }
+  /**
+   * Get agent count
+   */
+  get size() {
+    return this.agents.size;
+  }
+  // ============ Status Management ============
+  /**
+   * Get agent status
+   */
+  getStatus(name) {
+    return this.agents.get(name)?.status;
+  }
+  /**
+   * Set agent status
+   */
+  setStatus(name, status) {
+    const entry = this.agents.get(name);
+    if (entry) {
+      entry.status = status;
+      entry.lastActiveAt = /* @__PURE__ */ new Date();
+    }
+  }
+  /**
+   * Mark agent as busy with a task
+   */
+  markBusy(name, taskId) {
+    const entry = this.agents.get(name);
+    if (entry) {
+      entry.status = "busy";
+      entry.currentTask = taskId;
+      entry.lastActiveAt = /* @__PURE__ */ new Date();
+    }
+  }
+  /**
+   * Mark agent as available
+   */
+  markAvailable(name) {
+    const entry = this.agents.get(name);
+    if (entry) {
+      entry.status = "available";
+      entry.currentTask = void 0;
+      entry.lastActiveAt = /* @__PURE__ */ new Date();
+    }
+  }
+  /**
+   * Record task completion
+   */
+  recordTaskCompletion(name, success) {
+    const entry = this.agents.get(name);
+    if (entry && this.trackStats) {
+      if (success) {
+        entry.tasksCompleted++;
+      } else {
+        entry.tasksFailed++;
+      }
+      entry.currentTask = void 0;
+      entry.status = "available";
+      entry.lastActiveAt = /* @__PURE__ */ new Date();
+    }
+  }
+  // ============ Discovery ============
+  /**
+   * Find agents by capability
+   */
+  findByCapability(capabilityName) {
+    const results = [];
+    for (const entry of this.agents.values()) {
+      const hasCapability = entry.agent.capabilities.some(
+        (c) => c.name.toLowerCase() === capabilityName.toLowerCase()
+      );
+      if (hasCapability) {
+        results.push(entry.agent);
+      }
+    }
+    return results;
+  }
+  /**
+   * Find agents by role name
+   */
+  findByRole(roleName) {
+    const results = [];
+    for (const entry of this.agents.values()) {
+      const agent = entry.agent;
+      if (agent.role?.name?.toLowerCase() === roleName.toLowerCase()) {
+        results.push(entry.agent);
+      }
+    }
+    return results;
+  }
+  /**
+   * Find the best matching agent for a task
+   */
+  findBestMatch(task) {
+    const available = this.getAvailable();
+    if (available.length === 0) return void 0;
+    const result = AgentCapabilities.findBestMatch(available, task);
+    return result ? this.get(result.agentName) : void 0;
+  }
+  /**
+   * Rank agents for a task
+   */
+  rankForTask(task) {
+    return AgentCapabilities.rank(this.getAll(), task);
+  }
+  /**
+   * Find agents that can handle a task
+   */
+  findCapableAgents(task) {
+    const ranked = AgentCapabilities.findCapableAgents(this.getAll(), task);
+    return ranked.map((r) => this.get(r.agentName)).filter(Boolean);
+  }
+  // ============ Filtering ============
+  /**
+   * Get available agents
+   */
+  getAvailable() {
+    return Array.from(this.agents.values()).filter((entry) => entry.status === "available").map((entry) => entry.agent);
+  }
+  /**
+   * Get busy agents
+   */
+  getBusy() {
+    return Array.from(this.agents.values()).filter((entry) => entry.status === "busy").map((entry) => entry.agent);
+  }
+  /**
+   * Get agents by status
+   */
+  getByStatus(status) {
+    return Array.from(this.agents.values()).filter((entry) => entry.status === status).map((entry) => entry.agent);
+  }
+  /**
+   * Get available count
+   */
+  getAvailableCount() {
+    let count = 0;
+    for (const entry of this.agents.values()) {
+      if (entry.status === "available") count++;
+    }
+    return count;
+  }
+  /**
+   * Check if any agent is available
+   */
+  hasAvailable() {
+    for (const entry of this.agents.values()) {
+      if (entry.status === "available") return true;
+    }
+    return false;
+  }
+  // ============ Statistics ============
+  /**
+   * Get registry statistics
+   */
+  getStats() {
+    const stats = {
+      total: this.agents.size,
+      available: 0,
+      busy: 0,
+      unavailable: 0,
+      error: 0,
+      totalTasksCompleted: 0,
+      totalTasksFailed: 0
+    };
+    for (const entry of this.agents.values()) {
+      stats[entry.status]++;
+      stats.totalTasksCompleted += entry.tasksCompleted;
+      stats.totalTasksFailed += entry.tasksFailed;
+    }
+    return stats;
+  }
+  /**
+   * Get agent statistics
+   */
+  getAgentStats(name) {
+    const entry = this.agents.get(name);
+    if (!entry) return void 0;
+    return {
+      name: entry.agent.name,
+      status: entry.status,
+      currentTask: entry.currentTask,
+      tasksCompleted: entry.tasksCompleted,
+      tasksFailed: entry.tasksFailed,
+      successRate: entry.tasksCompleted + entry.tasksFailed > 0 ? entry.tasksCompleted / (entry.tasksCompleted + entry.tasksFailed) : 0,
+      registeredAt: entry.registeredAt,
+      lastActiveAt: entry.lastActiveAt
+    };
+  }
+  // ============ Iteration ============
+  /**
+   * Iterate over agents
+   */
+  *[Symbol.iterator]() {
+    for (const entry of this.agents.values()) {
+      yield entry.agent;
+    }
+  }
+  /**
+   * For each agent
+   */
+  forEach(callback) {
+    for (const [name, entry] of this.agents) {
+      callback(entry.agent, name);
+    }
+  }
+  // ============ Utilities ============
+  /**
+   * Clear all agents
+   */
+  clear() {
+    this.agents.clear();
+  }
+  /**
+   * Reset all agent statuses to available
+   */
+  resetAllStatuses() {
+    for (const entry of this.agents.values()) {
+      entry.status = "available";
+      entry.currentTask = void 0;
+    }
+  }
+};
+function createAgentRegistry(config) {
+  return new AgentRegistry(config);
+}
+
+// src/coordination/strategies/DelegationStrategy.ts
+var BaseDelegationStrategy = class {
+  /**
+   * Default batch assignment - sequential selection
+   */
+  async assignTasks(tasks, agents, context) {
+    const assignments = /* @__PURE__ */ new Map();
+    const availableAgents = [...agents];
+    for (const task of tasks) {
+      if (availableAgents.length === 0) {
+        break;
+      }
+      try {
+        const result = await this.selectAgent(task, availableAgents, context);
+        assignments.set(task.id, result.selectedAgent);
+        const assignedIndex = availableAgents.findIndex(
+          (a) => a.name === result.selectedAgent
+        );
+        if (assignedIndex >= 0 && !availableAgents[assignedIndex].parallelCapable) {
+          availableAgents.splice(assignedIndex, 1);
+        }
+      } catch {
+      }
+    }
+    return assignments;
+  }
+  /**
+   * Filter available agents (not busy)
+   */
+  filterAvailable(agents) {
+    return agents.filter((a) => !a.isBusy);
+  }
+  /**
+   * Create a failure result
+   */
+  createFailure(reason, agents) {
+    const failure = {
+      reason,
+      consideredAgents: agents.map((a) => a.name)
+    };
+    throw new DelegationError(failure);
+  }
+  reset() {
+  }
+};
+var DelegationError = class extends Error {
+  failure;
+  constructor(failureOrReason, agents, lastError) {
+    if (typeof failureOrReason === "string") {
+      const failure = {
+        reason: failureOrReason,
+        consideredAgents: agents?.map((a) => a.name) ?? [],
+        suggestions: lastError ? [`Last error: ${lastError}`] : void 0
+      };
+      super(failureOrReason);
+      this.failure = failure;
+    } else {
+      super(`Delegation failed: ${failureOrReason.reason}`);
+      this.failure = failureOrReason;
+    }
+    this.name = "DelegationError";
+  }
+};
+
+// src/coordination/strategies/RoundRobin.ts
+var RoundRobinStrategy = class extends BaseDelegationStrategy {
+  name = "round-robin";
+  currentIndex = 0;
+  skipBusy;
+  wrapAround;
+  constructor(config = {}) {
+    super();
+    this.skipBusy = config.skipBusy ?? true;
+    this.wrapAround = config.wrapAround ?? true;
+  }
+  async selectAgent(task, agents, _context) {
+    const startTime = Date.now();
+    if (agents.length === 0) {
+      this.createFailure("No agents available", []);
+    }
+    let available = this.skipBusy ? this.filterAvailable(agents) : agents;
+    if (available.length === 0) {
+      this.createFailure("All agents are busy", agents);
+    }
+    if (task.requiredCapabilities && task.requiredCapabilities.length > 0) {
+      available = available.filter((agent) => {
+        const requiredCaps = task.requiredCapabilities.map((name) => ({
+          name,
+          description: "",
+          proficiency: "intermediate"
+        }));
+        const match = AgentCapabilities.match(requiredCaps, agent.capabilities);
+        return match.canExecute;
+      });
+      if (available.length === 0) {
+        this.createFailure("No agents have all required capabilities", agents);
+      }
+    }
+    if (this.currentIndex >= available.length) {
+      if (this.wrapAround) {
+        this.currentIndex = 0;
+      } else {
+        this.createFailure("No more agents in rotation", agents);
+      }
+    }
+    const selectedAgent = available[this.currentIndex];
+    this.currentIndex = (this.currentIndex + 1) % available.length;
+    return Promise.resolve({
+      selectedAgent: selectedAgent.name,
+      reason: `Round-robin selection (position ${this.currentIndex})`,
+      confidence: 1,
+      // Round-robin is deterministic
+      alternativeAgents: available.filter((a) => a.name !== selectedAgent.name).map((a) => a.name),
+      decisionTimeMs: Date.now() - startTime,
+      metadata: {
+        strategy: "round-robin",
+        position: this.currentIndex,
+        totalAgents: available.length
+      }
+    });
+  }
+  /**
+   * Batch assignment with round-robin distribution
+   */
+  assignTasks(tasks, agents, _context) {
+    const assignments = /* @__PURE__ */ new Map();
+    const available = this.skipBusy ? this.filterAvailable(agents) : agents;
+    if (available.length === 0) {
+      return Promise.resolve(assignments);
+    }
+    for (const task of tasks) {
+      const agent = available[this.currentIndex % available.length];
+      assignments.set(task.id, agent.name);
+      this.currentIndex++;
+    }
+    return Promise.resolve(assignments);
+  }
+  /**
+   * Reset the rotation
+   */
+  reset() {
+    this.currentIndex = 0;
+  }
+  /**
+   * Get current position in rotation
+   */
+  getCurrentPosition() {
+    return this.currentIndex;
+  }
+  /**
+   * Set position in rotation
+   */
+  setPosition(position) {
+    this.currentIndex = position;
+  }
+};
+function createRoundRobinStrategy(config) {
+  return new RoundRobinStrategy(config);
+}
+
+// src/coordination/strategies/BestMatch.ts
+var BestMatchStrategy = class extends BaseDelegationStrategy {
+  name = "best-match";
+  minimumScore;
+  useKeywordMatching;
+  capabilityWeight;
+  preferAvailable;
+  constructor(config = {}) {
+    super();
+    this.minimumScore = config.minimumScore ?? 0;
+    this.useKeywordMatching = config.useKeywordMatching ?? true;
+    this.capabilityWeight = config.capabilityWeight ?? 0.7;
+    this.preferAvailable = config.preferAvailable ?? true;
+  }
+  async selectAgent(task, agents, _context) {
+    const startTime = Date.now();
+    if (agents.length === 0) {
+      this.createFailure("No agents available", []);
+    }
+    const ranked = this.rankAgents(task, agents);
+    if (ranked.length === 0) {
+      this.createFailure("No agents can handle this task", agents);
+    }
+    const hasRequirements = task.requiredCapabilities && task.requiredCapabilities.length > 0;
+    const qualified = ranked.filter(
+      (r) => r.score >= this.minimumScore && (!hasRequirements || r.missingCapabilities.length === 0)
+    );
+    if (qualified.length === 0) {
+      if (hasRequirements) {
+        this.createFailure("No agents have all required capabilities", agents);
+      }
+      this.createFailure(
+        `No agents meet minimum score threshold (${this.minimumScore})`,
+        agents
+      );
+    }
+    let selected = qualified[0];
+    if (this.preferAvailable) {
+      const availableQualified = qualified.filter(
+        (r) => !agents.find((a) => a.name === r.agentName)?.isBusy
+      );
+      if (availableQualified.length > 0) {
+        selected = availableQualified[0];
+      }
+    }
+    const reason = this.buildReason(selected, task);
+    return Promise.resolve({
+      selectedAgent: selected.agentName,
+      reason,
+      confidence: selected.score,
+      alternativeAgents: qualified.filter((r) => r.agentName !== selected.agentName).slice(0, 3).map((r) => r.agentName),
+      decisionTimeMs: Date.now() - startTime,
+      metadata: {
+        strategy: "best-match",
+        score: selected.score,
+        matchedCapabilities: selected.matchedCapabilities.map((c) => c.name),
+        missingCapabilities: selected.missingCapabilities.map((c) => c.name),
+        rankedCount: qualified.length
+      }
+    });
+  }
+  /**
+   * Rank agents for a task
+   */
+  rankAgents(task, agents) {
+    const rankings = [];
+    for (const agent of agents) {
+      const capScore = AgentCapabilities.calculateAgentScore(agent, task);
+      let finalScore = capScore;
+      if (this.useKeywordMatching) {
+        const keywordScore = agent.role.calculateRelevanceScore(
+          task.description
+        );
+        finalScore = capScore * this.capabilityWeight + keywordScore * (1 - this.capabilityWeight);
+      }
+      if (agent.isBusy) {
+        finalScore *= 0.5;
+      }
+      const requiredCaps = (task.requiredCapabilities ?? []).map((name) => ({
+        name,
+        description: "",
+        proficiency: "intermediate"
+      }));
+      const match = AgentCapabilities.match(requiredCaps, agent.capabilities);
+      rankings.push({
+        agentName: agent.name,
+        score: finalScore,
+        matchedCapabilities: match.matched,
+        missingCapabilities: match.missing
+      });
+    }
+    rankings.sort((a, b) => b.score - a.score);
+    return rankings;
+  }
+  /**
+   * Build explanation for selection
+   */
+  buildReason(selected, _task) {
+    const parts = [];
+    parts.push(`Best match with score ${(selected.score * 100).toFixed(1)}%`);
+    if (selected.matchedCapabilities.length > 0) {
+      const capNames = selected.matchedCapabilities.map((c) => c.name).join(", ");
+      parts.push(`Matched capabilities: ${capNames}`);
+    }
+    if (selected.missingCapabilities.length > 0) {
+      const missingNames = selected.missingCapabilities.map((c) => c.name).join(", ");
+      parts.push(`Missing: ${missingNames}`);
+    }
+    return parts.join(". ");
+  }
+  /**
+   * Find agents that can definitely handle a task
+   */
+  findCapableAgents(task, agents) {
+    const ranked = this.rankAgents(task, agents);
+    return ranked.filter(
+      (r) => r.missingCapabilities.length === 0 && r.score >= this.minimumScore
+    ).map((r) => agents.find((a) => a.name === r.agentName)).filter(Boolean);
+  }
+};
+function createBestMatchStrategy(config) {
+  return new BestMatchStrategy(config);
+}
+
+// src/coordination/strategies/Auction.ts
+var AuctionStrategy = class extends BaseDelegationStrategy {
+  name = "auction";
+  biddingTimeMs;
+  minimumBid;
+  selectionCriteria;
+  allowRebidding;
+  bidTimeoutMs;
+  constructor(config = {}) {
+    super();
+    this.biddingTimeMs = config.biddingTimeMs ?? 5e3;
+    this.minimumBid = config.minimumBid ?? 0.1;
+    this.selectionCriteria = config.selectionCriteria ?? "confidence";
+    this.allowRebidding = config.allowRebidding ?? false;
+    this.bidTimeoutMs = config.bidTimeoutMs ?? 2e3;
+  }
+  async selectAgent(task, agents, context) {
+    const startTime = Date.now();
+    if (agents.length === 0) {
+      this.createFailure("No agents available", []);
+    }
+    let available = this.filterAvailable(agents);
+    if (available.length === 0) {
+      this.createFailure("All agents are busy", agents);
+    }
+    if (task.requiredCapabilities && task.requiredCapabilities.length > 0) {
+      available = available.filter((agent) => {
+        const requiredCaps = task.requiredCapabilities.map((name) => ({
+          name,
+          description: "",
+          proficiency: "intermediate"
+        }));
+        const match = AgentCapabilities.match(requiredCaps, agent.capabilities);
+        return match.canExecute;
+      });
+      if (available.length === 0) {
+        this.createFailure("No agents have all required capabilities", agents);
+      }
+    }
+    const bids = await this.collectBids(task, available);
+    if (bids.length === 0) {
+      this.createFailure("No agents submitted bids", agents);
+    }
+    const qualifiedBids = bids.filter((b) => b.confidence >= this.minimumBid);
+    if (qualifiedBids.length === 0) {
+      this.createFailure(
+        `No bids met minimum threshold (${this.minimumBid})`,
+        agents
+      );
+    }
+    const winner = this.selectWinner(qualifiedBids);
+    context.emit({
+      type: "delegation:decision",
+      taskId: task.id,
+      toAgent: winner.agentName,
+      strategy: "auction",
+      reason: `Won auction with confidence ${winner.confidence.toFixed(2)}`,
+      confidence: winner.confidence,
+      alternatives: qualifiedBids.filter((b) => b.agentName !== winner.agentName).map((b) => b.agentName)
+    });
+    return {
+      selectedAgent: winner.agentName,
+      reason: this.buildReason(winner, qualifiedBids),
+      confidence: winner.confidence,
+      alternativeAgents: qualifiedBids.filter((b) => b.agentName !== winner.agentName).map((b) => b.agentName),
+      decisionTimeMs: Date.now() - startTime,
+      metadata: {
+        strategy: "auction",
+        totalBids: bids.length,
+        qualifiedBids: qualifiedBids.length,
+        winningBid: winner,
+        allBids: bids
+      }
+    };
+  }
+  /**
+   * Collect bids from agents
+   */
+  async collectBids(task, agents) {
+    const bidPromises = agents.map(
+      (agent) => this.getBidWithTimeout(agent, task)
+    );
+    const results = await Promise.allSettled(bidPromises);
+    const bids = [];
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value) {
+        bids.push(result.value);
+      }
+    }
+    return bids;
+  }
+  /**
+   * Get a bid from an agent with timeout
+   */
+  async getBidWithTimeout(agent, task) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => resolve(null), this.bidTimeoutMs);
+      agent.bidOnTask(task).then((bid) => {
+        clearTimeout(timeout);
+        resolve(bid);
+      }).catch(() => {
+        clearTimeout(timeout);
+        resolve(null);
+      });
+    });
+  }
+  /**
+   * Select the winning bid
+   */
+  selectWinner(bids) {
+    switch (this.selectionCriteria) {
+      case "fastest":
+        return bids.reduce((best, bid) => {
+          const bestTime = best.estimatedTime ?? Infinity;
+          const bidTime = bid.estimatedTime ?? Infinity;
+          return bidTime < bestTime ? bid : best;
+        }, bids[0]);
+      case "cheapest":
+        return bids.reduce((best, bid) => {
+          const bestTime = best.estimatedTime ?? Infinity;
+          const bidTime = bid.estimatedTime ?? Infinity;
+          return bidTime < bestTime ? bid : best;
+        }, bids[0]);
+      case "confidence":
+      default:
+        return bids.reduce(
+          (best, bid) => bid.confidence > best.confidence ? bid : best,
+          bids[0]
+        );
+    }
+  }
+  /**
+   * Build explanation for auction result
+   */
+  buildReason(winner, allBids) {
+    const parts = [];
+    parts.push(`Won auction (${this.selectionCriteria} criteria)`);
+    parts.push(`Confidence: ${(winner.confidence * 100).toFixed(1)}%`);
+    if (winner.estimatedTime) {
+      parts.push(`Est. time: ${winner.estimatedTime}ms`);
+    }
+    parts.push(`Capabilities: ${winner.capabilities.join(", ")}`);
+    if (allBids.length > 1) {
+      parts.push(`Competed against ${allBids.length - 1} other bid(s)`);
+    }
+    return parts.join(". ");
+  }
+  /**
+   * Run a multi-round auction with rebidding
+   */
+  async runMultiRoundAuction(task, agents, rounds = 2) {
+    let currentBids = await this.collectBids(task, agents);
+    if (!this.allowRebidding || rounds <= 1) {
+      return currentBids;
+    }
+    for (let round = 1; round < rounds; round++) {
+      const currentBest = currentBids.reduce(
+        (best, bid) => bid.confidence > best.confidence ? bid : best,
+        currentBids[0]
+      );
+      const rebidPromises = agents.map(async (agent) => {
+        const currentBid = currentBids.find((b) => b.agentName === agent.name);
+        if (!currentBid) return null;
+        if (currentBid.agentName === currentBest.agentName) {
+          return currentBid;
+        }
+        return this.getBidWithTimeout(agent, task);
+      });
+      const results = await Promise.allSettled(rebidPromises);
+      currentBids = results.filter((r) => r.status === "fulfilled" && r.value).map((r) => r.value);
+    }
+    return currentBids;
+  }
+};
+function createAuctionStrategy(config) {
+  return new AuctionStrategy(config);
+}
+
+// src/coordination/strategies/Hierarchical.ts
+var HierarchicalStrategy = class extends BaseDelegationStrategy {
+  name = "hierarchical";
+  hierarchy;
+  managersCanExecute;
+  escalateToManager;
+  useCapabilityMatching;
+  /** Role priority order (for array-based hierarchy) */
+  rolePriority = [];
+  constructor(config = {}) {
+    super();
+    if (Array.isArray(config.hierarchy)) {
+      this.rolePriority = config.hierarchy;
+      this.hierarchy = {
+        managers: [],
+        workers: /* @__PURE__ */ new Map()
+      };
+    } else {
+      this.hierarchy = config.hierarchy ?? {
+        managers: [],
+        workers: /* @__PURE__ */ new Map()
+      };
+    }
+    this.managersCanExecute = config.managersCanExecute ?? false;
+    this.escalateToManager = config.escalateToManager ?? true;
+    this.useCapabilityMatching = config.useCapabilityMatching ?? true;
+  }
+  /**
+   * Set the hierarchy
+   */
+  setHierarchy(hierarchy) {
+    this.hierarchy = hierarchy;
+  }
+  /**
+   * Add a manager
+   */
+  addManager(managerName, workers = []) {
+    if (!this.hierarchy.managers.includes(managerName)) {
+      this.hierarchy.managers.push(managerName);
+    }
+    this.hierarchy.workers.set(managerName, workers);
+  }
+  /**
+   * Add a worker to a manager
+   */
+  addWorker(managerName, workerName) {
+    const workers = this.hierarchy.workers.get(managerName) ?? [];
+    if (!workers.includes(workerName)) {
+      workers.push(workerName);
+      this.hierarchy.workers.set(managerName, workers);
+    }
+  }
+  async selectAgent(task, agents, _context) {
+    const startTime = Date.now();
+    if (agents.length === 0) {
+      this.createFailure("No agents available", []);
+    }
+    if (this.rolePriority.length > 0) {
+      return this.selectByRolePriority(task, agents, startTime);
+    }
+    const agentMap = /* @__PURE__ */ new Map();
+    for (const agent of agents) {
+      agentMap.set(agent.name, agent);
+    }
+    if (this.hierarchy.managers.length === 0) {
+      this.autoDetectHierarchy(agents);
+    }
+    const manager = this.findManagerForTask(task, agents);
+    if (!manager) {
+      return this.fallbackSelection(task, agents, startTime);
+    }
+    const workerNames = this.hierarchy.workers.get(manager.name) ?? [];
+    const workers = workerNames.map((name) => agentMap.get(name)).filter((w) => w !== void 0);
+    const availableWorkers = workers.filter((w) => !w.isBusy);
+    if (availableWorkers.length > 0) {
+      const selectedWorker = this.selectWorker(task, availableWorkers);
+      return {
+        selectedAgent: selectedWorker.name,
+        reason: `Delegated by ${manager.name} (hierarchical)`,
+        confidence: AgentCapabilities.calculateAgentScore(selectedWorker, task),
+        alternativeAgents: availableWorkers.filter((w) => w.name !== selectedWorker.name).map((w) => w.name),
+        decisionTimeMs: Date.now() - startTime,
+        metadata: {
+          strategy: "hierarchical",
+          manager: manager.name,
+          delegatedTo: selectedWorker.name,
+          totalWorkers: workers.length,
+          availableWorkers: availableWorkers.length
+        }
+      };
+    }
+    if (this.managersCanExecute && !manager.isBusy) {
+      return {
+        selectedAgent: manager.name,
+        reason: "No workers available, manager handling directly",
+        confidence: AgentCapabilities.calculateAgentScore(manager, task),
+        decisionTimeMs: Date.now() - startTime,
+        metadata: {
+          strategy: "hierarchical",
+          manager: manager.name,
+          escalated: true,
+          reason: "no_available_workers"
+        }
+      };
+    }
+    if (this.escalateToManager) {
+      for (const managerName of this.hierarchy.managers) {
+        if (managerName === manager.name) continue;
+        const otherManager = agentMap.get(managerName);
+        if (otherManager && !otherManager.isBusy) {
+          const otherWorkerNames = this.hierarchy.workers.get(managerName) ?? [];
+          const otherWorkers = otherWorkerNames.map((name) => agentMap.get(name)).filter((w) => w !== void 0 && !w.isBusy);
+          if (otherWorkers.length > 0) {
+            const selectedWorker = this.selectWorker(task, otherWorkers);
+            return {
+              selectedAgent: selectedWorker.name,
+              reason: `Escalated to ${managerName}, delegated to ${selectedWorker.name}`,
+              confidence: AgentCapabilities.calculateAgentScore(
+                selectedWorker,
+                task
+              ),
+              decisionTimeMs: Date.now() - startTime,
+              metadata: {
+                strategy: "hierarchical",
+                originalManager: manager.name,
+                escalatedTo: managerName,
+                delegatedTo: selectedWorker.name
+              }
+            };
+          }
+        }
+      }
+    }
+    this.createFailure("No available agents in hierarchy", agents);
+  }
+  /**
+   * Auto-detect hierarchy based on agent roles
+   */
+  autoDetectHierarchy(agents) {
+    const managers = [];
+    const workers = [];
+    for (const agent of agents) {
+      const roleName = agent.role.name.toLowerCase();
+      const isManager = roleName.includes("manager") || roleName.includes("lead") || roleName.includes("supervisor") || roleName.includes("director") || agent.role.canDelegate;
+      if (isManager) {
+        managers.push(agent.name);
+      } else {
+        workers.push(agent.name);
+      }
+    }
+    if (managers.length === 0 && agents.length > 0) {
+      managers.push(agents[0].name);
+      workers.splice(workers.indexOf(agents[0].name), 1);
+    }
+    this.hierarchy = {
+      managers,
+      workers: /* @__PURE__ */ new Map([[managers[0], workers]])
+    };
+  }
+  /**
+   * Find the best manager for a task
+   */
+  findManagerForTask(task, agents) {
+    const agentMap = /* @__PURE__ */ new Map();
+    for (const agent of agents) {
+      agentMap.set(agent.name, agent);
+    }
+    let bestManager;
+    let bestScore = 0;
+    for (const managerName of this.hierarchy.managers) {
+      const manager = agentMap.get(managerName);
+      if (!manager) continue;
+      const workerNames = this.hierarchy.workers.get(managerName) ?? [];
+      let totalScore = 0;
+      for (const workerName of workerNames) {
+        const worker = agentMap.get(workerName);
+        if (worker) {
+          totalScore += AgentCapabilities.calculateAgentScore(worker, task);
+        }
+      }
+      const avgScore = workerNames.length > 0 ? totalScore / workerNames.length : 0;
+      if (avgScore > bestScore) {
+        bestScore = avgScore;
+        bestManager = manager;
+      }
+    }
+    return bestManager;
+  }
+  /**
+   * Select the best worker for a task
+   */
+  selectWorker(task, workers) {
+    if (!this.useCapabilityMatching) {
+      return workers[0];
+    }
+    const ranked = AgentCapabilities.rank(workers, task);
+    if (ranked.length > 0) {
+      const best = workers.find((w) => w.name === ranked[0].agentName);
+      if (best) return best;
+    }
+    return workers[0];
+  }
+  /**
+   * Fallback to simple best-match selection
+   */
+  fallbackSelection(task, agents, startTime) {
+    const available = this.filterAvailable(agents);
+    if (available.length === 0) {
+      this.createFailure("No available agents", agents);
+    }
+    const ranked = AgentCapabilities.rank(available, task);
+    const selected = available.find((a) => a.name === ranked[0]?.agentName) ?? available[0];
+    return Promise.resolve({
+      selectedAgent: selected.name,
+      reason: "No hierarchy defined, using best match",
+      confidence: AgentCapabilities.calculateAgentScore(selected, task),
+      alternativeAgents: available.filter((a) => a.name !== selected.name).map((a) => a.name),
+      decisionTimeMs: Date.now() - startTime,
+      metadata: {
+        strategy: "hierarchical",
+        fallback: true
+      }
+    });
+  }
+  /**
+   * Select agent based on role priority order
+   */
+  selectByRolePriority(task, agents, startTime) {
+    let available = this.filterAvailable(agents);
+    if (task.requiredCapabilities && task.requiredCapabilities.length > 0) {
+      available = available.filter((agent) => {
+        const requiredCaps = task.requiredCapabilities.map((name) => ({
+          name,
+          description: "",
+          proficiency: "intermediate"
+        }));
+        const match = AgentCapabilities.match(requiredCaps, agent.capabilities);
+        return match.canExecute;
+      });
+      if (available.length === 0) {
+        this.createFailure("No agents have all required capabilities", agents);
+      }
+    }
+    const sortedAgents = [...available].sort((a, b) => {
+      const aRoleName = a.role.name.toLowerCase();
+      const bRoleName = b.role.name.toLowerCase();
+      const aPriority = this.rolePriority.findIndex(
+        (r) => r.toLowerCase() === aRoleName
+      );
+      const bPriority = this.rolePriority.findIndex(
+        (r) => r.toLowerCase() === bRoleName
+      );
+      const aScore = aPriority === -1 ? Infinity : aPriority;
+      const bScore = bPriority === -1 ? Infinity : bPriority;
+      return aScore - bScore;
+    });
+    if (sortedAgents.length === 0) {
+      this.createFailure("No available agents", agents);
+    }
+    const selected = sortedAgents[0];
+    return Promise.resolve({
+      selectedAgent: selected.name,
+      reason: `Selected by role priority (${selected.role.name})`,
+      confidence: AgentCapabilities.calculateAgentScore(selected, task),
+      alternativeAgents: sortedAgents.slice(1, 4).map((a) => a.name),
+      decisionTimeMs: Date.now() - startTime,
+      metadata: {
+        strategy: "hierarchical",
+        rolePriority: this.rolePriority,
+        selectedRole: selected.role.name
+      }
+    });
+  }
+  reset() {
+  }
+  /**
+   * Get current hierarchy
+   */
+  getHierarchy() {
+    return {
+      managers: [...this.hierarchy.managers],
+      workers: new Map(this.hierarchy.workers)
+    };
+  }
+};
+function createHierarchicalStrategy(config) {
+  return new HierarchicalStrategy(config);
+}
+
+// src/coordination/strategies/Consensus.ts
+var ConsensusStrategy = class extends BaseDelegationStrategy {
+  name = "consensus";
+  requiredAgreement;
+  maxRounds;
+  tieBreaker;
+  voteTimeoutMs;
+  weightedVoting;
+  minimumVotes;
+  constructor(config = {}) {
+    super();
+    this.requiredAgreement = config.requiredAgreement ?? 0.5;
+    this.maxRounds = config.maxRounds ?? 3;
+    this.tieBreaker = config.tieBreaker ?? "highest-capability";
+    this.voteTimeoutMs = config.voteTimeoutMs ?? 3e3;
+    this.weightedVoting = config.weightedVoting ?? false;
+    this.minimumVotes = config.minimumVotes ?? 1;
+  }
+  async selectAgent(task, agents, context) {
+    const startTime = Date.now();
+    if (agents.length === 0) {
+      this.createFailure("No agents available", []);
+    }
+    const candidates = this.filterAvailable(agents);
+    if (candidates.length === 0) {
+      this.createFailure("All agents are busy", agents);
+    }
+    if (candidates.length === 1) {
+      return {
+        selectedAgent: candidates[0].name,
+        reason: "Only one candidate available",
+        confidence: 1,
+        decisionTimeMs: Date.now() - startTime,
+        metadata: {
+          strategy: "consensus",
+          noVotingNeeded: true
+        }
+      };
+    }
+    context.emit({
+      type: "consensus:requested",
+      taskId: task.id,
+      candidates: candidates.map((c) => c.name),
+      voters: agents.map((a) => a.name)
+    });
+    let finalResult;
+    const allRounds = [];
+    for (let round = 1; round <= this.maxRounds; round++) {
+      const roundResult = await this.runVotingRound(
+        round,
+        task,
+        agents,
+        candidates,
+        context
+      );
+      allRounds.push(roundResult);
+      if (roundResult.consensusReached || roundResult.winner) {
+        finalResult = roundResult;
+        break;
+      }
+    }
+    if (!finalResult?.winner) {
+      const lastRound = allRounds[allRounds.length - 1];
+      const winner = this.breakTie(lastRound.tally, candidates, task);
+      context.emit({
+        type: "consensus:reached",
+        taskId: task.id,
+        winner: winner.name,
+        rounds: allRounds.length,
+        consensusReached: false,
+        tieBreaker: this.tieBreaker
+      });
+      return {
+        selectedAgent: winner.name,
+        reason: `No consensus after ${this.maxRounds} rounds, resolved by ${this.tieBreaker}`,
+        confidence: lastRound.agreementRatio,
+        alternativeAgents: candidates.filter((c) => c.name !== winner.name).map((c) => c.name),
+        decisionTimeMs: Date.now() - startTime,
+        metadata: {
+          strategy: "consensus",
+          rounds: allRounds.length,
+          consensusReached: false,
+          tieBreaker: this.tieBreaker,
+          finalTally: Object.fromEntries(lastRound.tally)
+        }
+      };
+    }
+    context.emit({
+      type: "consensus:reached",
+      taskId: task.id,
+      winner: finalResult.winner,
+      rounds: allRounds.length,
+      consensusReached: true,
+      agreementRatio: finalResult.agreementRatio
+    });
+    return {
+      selectedAgent: finalResult.winner,
+      reason: `Consensus reached in round ${finalResult.round} with ${(finalResult.agreementRatio * 100).toFixed(1)}% agreement`,
+      confidence: finalResult.agreementRatio,
+      alternativeAgents: candidates.filter((c) => c.name !== finalResult.winner).map((c) => c.name),
+      decisionTimeMs: Date.now() - startTime,
+      metadata: {
+        strategy: "consensus",
+        rounds: allRounds.length,
+        consensusReached: true,
+        finalRound: finalResult,
+        allRounds
+      }
+    };
+  }
+  /**
+   * Run a single voting round
+   */
+  async runVotingRound(round, task, voters, candidates, _context) {
+    const votes = await this.collectVotes(task, voters, candidates);
+    const tally = this.tallyVotes(votes);
+    const totalWeight = votes.reduce((sum, v) => sum + v.weight, 0);
+    const maxVotes = Math.max(...Array.from(tally.values()));
+    const agreementRatio = totalWeight > 0 ? maxVotes / totalWeight : 0;
+    const consensusReached = agreementRatio >= this.requiredAgreement;
+    let winner;
+    if (consensusReached) {
+      for (const [candidate, voteCount] of tally) {
+        if (voteCount === maxVotes) {
+          winner = candidate;
+          break;
+        }
+      }
+    }
+    return {
+      round,
+      votes,
+      tally,
+      winner,
+      consensusReached,
+      agreementRatio
+    };
+  }
+  /**
+   * Collect votes from agents
+   */
+  async collectVotes(task, voters, candidates) {
+    const votes = [];
+    const candidateNames = candidates.map((c) => c.name);
+    for (const voter of voters) {
+      const vote = await this.getVote(voter, task, candidateNames);
+      if (vote) {
+        votes.push(vote);
+      }
+    }
+    return votes;
+  }
+  /**
+   * Get a vote from an agent
+   */
+  getVote(voter, task, candidates) {
+    const scores = [];
+    for (const candidateName of candidates) {
+      if (candidateName === voter.name) {
+        scores.push({ name: candidateName, score: 0.7 });
+      } else {
+        const randomFactor = 0.8 + Math.random() * 0.4;
+        scores.push({
+          name: candidateName,
+          score: Math.random() * randomFactor
+        });
+      }
+    }
+    scores.sort((a, b) => b.score - a.score);
+    const selected = scores[0];
+    if (!selected) return Promise.resolve(null);
+    let weight = 1;
+    if (this.weightedVoting) {
+      weight = voter.calculateTaskScore(task) || 0.5;
+    }
+    return Promise.resolve({
+      voter: voter.name,
+      candidate: selected.name,
+      weight,
+      reasoning: `Selected based on perceived suitability (score: ${selected.score.toFixed(2)})`
+    });
+  }
+  /**
+   * Tally votes
+   */
+  tallyVotes(votes) {
+    const tally = /* @__PURE__ */ new Map();
+    for (const vote of votes) {
+      const current = tally.get(vote.candidate) ?? 0;
+      tally.set(vote.candidate, current + vote.weight);
+    }
+    return tally;
+  }
+  /**
+   * Break a tie between candidates
+   */
+  breakTie(tally, candidates, task) {
+    const maxVotes = Math.max(...Array.from(tally.values()));
+    const tied = candidates.filter(
+      (c) => (tally.get(c.name) ?? 0) === maxVotes
+    );
+    if (tied.length === 1) {
+      return tied[0];
+    }
+    switch (this.tieBreaker) {
+      case "random":
+        return tied[Math.floor(Math.random() * tied.length)];
+      case "first":
+        return tied[0];
+      case "manager":
+        for (const candidate of tied) {
+          if (candidate.role.canDelegate) {
+            return candidate;
+          }
+        }
+        return tied[0];
+      case "highest-capability":
+      default: {
+        const ranked = AgentCapabilities.rank(tied, task);
+        if (ranked.length > 0) {
+          const best = tied.find((c) => c.name === ranked[0].agentName);
+          if (best) return best;
+        }
+        return tied[0];
+      }
+    }
+  }
+  /**
+   * Run a full consensus process with deliberation
+   */
+  async runWithDeliberation(task, agents, context) {
+    const startTime = Date.now();
+    const candidates = this.filterAvailable(agents);
+    const allRounds = [];
+    let consensusReached = false;
+    for (let round = 1; round <= this.maxRounds; round++) {
+      const roundResult = await this.runVotingRound(
+        round,
+        task,
+        agents,
+        candidates,
+        context
+      );
+      allRounds.push(roundResult);
+      context.emit({
+        type: "delegation:decision",
+        taskId: task.id,
+        toAgent: roundResult.winner ?? "",
+        strategy: "consensus",
+        reason: `Round ${round}: ${roundResult.consensusReached ? "consensus" : "no consensus"}`,
+        confidence: roundResult.agreementRatio
+      });
+      if (roundResult.consensusReached && roundResult.winner) {
+        consensusReached = true;
+        break;
+      }
+    }
+    const lastRound = allRounds[allRounds.length - 1];
+    const winner = lastRound.winner ?? this.breakTie(lastRound.tally, candidates, task).name;
+    return {
+      result: {
+        selectedAgent: winner,
+        reason: consensusReached ? `Consensus reached after ${allRounds.length} round(s)` : `No consensus, resolved by ${this.tieBreaker}`,
+        confidence: lastRound.agreementRatio,
+        decisionTimeMs: Date.now() - startTime,
+        metadata: {
+          strategy: "consensus",
+          rounds: allRounds.length,
+          consensusReached
+        }
+      },
+      deliberation: allRounds,
+      consensus: consensusReached
+    };
+  }
+};
+function createConsensusStrategy(config) {
+  return new ConsensusStrategy(config);
+}
+
+// src/coordination/strategies/index.ts
+function createStrategy(type, config) {
+  switch (type) {
+    case "round-robin":
+      return new RoundRobinStrategy(config);
+    case "best-match":
+      return new BestMatchStrategy(config);
+    case "auction":
+      return new AuctionStrategy(config);
+    case "hierarchical":
+      return new HierarchicalStrategy(config);
+    case "consensus":
+      return new ConsensusStrategy(config);
+    default:
+      throw new Error(`Unknown delegation strategy type: ${String(type)}`);
+  }
+}
+var STRATEGY_TYPES = [
+  "round-robin",
+  "best-match",
+  "auction",
+  "hierarchical",
+  "consensus"
+];
+
+// src/coordination/Delegation.ts
+var DelegationCoordinator = class {
+  strategies = /* @__PURE__ */ new Map();
+  defaultStrategy;
+  enableFallback;
+  fallbackOrder;
+  maxAttempts;
+  trackHistory;
+  history = [];
+  constructor(config = {}) {
+    this.defaultStrategy = config.defaultStrategy ?? "best-match";
+    this.enableFallback = config.enableFallback ?? true;
+    this.fallbackOrder = config.fallbackOrder ?? [
+      "best-match",
+      "round-robin",
+      "auction"
+    ];
+    this.maxAttempts = config.maxAttempts ?? 3;
+    this.trackHistory = config.trackHistory ?? true;
+    for (const type of STRATEGY_TYPES) {
+      const strategyConfig = config.strategyConfigs?.[type] ?? {};
+      this.strategies.set(type, createStrategy(type, strategyConfig));
+    }
+  }
+  /**
+   * Register a custom strategy
+   */
+  registerStrategy(type, strategy) {
+    this.strategies.set(type, strategy);
+  }
+  /**
+   * Get a strategy by type
+   */
+  getStrategy(type) {
+    return this.strategies.get(type);
+  }
+  /**
+   * Delegate a task to an agent
+   */
+  async delegate(task, agents, context, strategyType) {
+    const strategy = strategyType ?? this.defaultStrategy;
+    let lastError;
+    let attempt = 0;
+    const strategyOrder = this.buildStrategyOrder(strategy);
+    for (const currentStrategy of strategyOrder) {
+      attempt++;
+      if (attempt > this.maxAttempts) {
+        break;
+      }
+      const delegationStrategy = this.strategies.get(currentStrategy);
+      if (!delegationStrategy) {
+        continue;
+      }
+      try {
+        const result = await delegationStrategy.selectAgent(
+          task,
+          agents,
+          context
+        );
+        if (this.trackHistory) {
+          this.history.push({
+            taskId: task.id,
+            strategy: currentStrategy,
+            result,
+            timestamp: /* @__PURE__ */ new Date(),
+            attempt
+          });
+        }
+        context.emit({
+          type: "delegation:decision",
+          taskId: task.id,
+          toAgent: result.selectedAgent,
+          strategy: currentStrategy,
+          reason: result.reason,
+          confidence: result.confidence,
+          alternatives: result.alternativeAgents
+        });
+        return result;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        context.emit({
+          type: "delegation:failed",
+          taskId: task.id,
+          strategy: currentStrategy,
+          reason: lastError.message,
+          willRetry: this.enableFallback && attempt < this.maxAttempts
+        });
+        if (!this.enableFallback) {
+          throw error;
+        }
+      }
+    }
+    throw new DelegationError(
+      `Failed to delegate task after ${attempt} attempts`,
+      agents,
+      lastError?.message
+    );
+  }
+  /**
+   * Delegate multiple tasks at once
+   */
+  async delegateBatch(tasks, agents, context, strategyType) {
+    const results = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      try {
+        const result = await this.delegate(task, agents, context, strategyType);
+        results.set(task.id, result);
+      } catch (error) {
+        results.set(task.id, {
+          selectedAgent: "",
+          reason: error instanceof Error ? error.message : String(error),
+          confidence: 0,
+          decisionTimeMs: 0,
+          metadata: {
+            failed: true,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Find the best agent for a task without delegating
+   */
+  async findBestAgent(task, agents, context) {
+    try {
+      const result = await this.delegate(task, agents, context, "best-match");
+      return agents.find((a) => a.name === result.selectedAgent);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get delegation recommendations for a task
+   */
+  async getRecommendations(task, agents, context, limit = 3) {
+    const recommendations = [];
+    for (const [strategyType, strategy] of this.strategies) {
+      try {
+        const result = await strategy.selectAgent(task, agents, context);
+        const agent = agents.find((a) => a.name === result.selectedAgent);
+        if (agent) {
+          const existing = recommendations.find(
+            (r) => r.agent.name === agent.name
+          );
+          if (!existing) {
+            recommendations.push({
+              agent,
+              score: result.confidence,
+              reason: `${strategyType}: ${result.reason}`
+            });
+          } else {
+            if (result.confidence > existing.score) {
+              existing.score = result.confidence;
+              existing.reason = `${strategyType}: ${result.reason}`;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return recommendations.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  /**
+   * Get delegation history
+   */
+  getHistory(taskId) {
+    if (taskId) {
+      return this.history.filter((h) => h.taskId === taskId);
+    }
+    return [...this.history];
+  }
+  /**
+   * Get delegation statistics
+   */
+  getStatistics() {
+    const byStrategy = {};
+    let totalConfidence = 0;
+    let totalAttempts = 0;
+    for (const entry of this.history) {
+      byStrategy[entry.strategy] = (byStrategy[entry.strategy] ?? 0) + 1;
+      totalConfidence += entry.result.confidence;
+      totalAttempts += entry.attempt;
+    }
+    return {
+      totalDelegations: this.history.length,
+      byStrategy,
+      averageConfidence: this.history.length > 0 ? totalConfidence / this.history.length : 0,
+      averageAttempts: this.history.length > 0 ? totalAttempts / this.history.length : 0
+    };
+  }
+  /**
+   * Clear delegation history
+   */
+  clearHistory() {
+    this.history.length = 0;
+  }
+  /**
+   * Reset all strategies
+   */
+  reset() {
+    for (const strategy of this.strategies.values()) {
+      strategy.reset?.();
+    }
+    this.clearHistory();
+  }
+  /**
+   * Build the strategy order for delegation
+   */
+  buildStrategyOrder(primary) {
+    const order = [primary];
+    if (this.enableFallback) {
+      for (const fallback of this.fallbackOrder) {
+        if (!order.includes(fallback)) {
+          order.push(fallback);
+        }
+      }
+    }
+    return order;
+  }
+};
+function createDelegationCoordinator(config) {
+  return new DelegationCoordinator(config);
+}
+
+// src/coordination/Collaboration.ts
+var CollaborationManager = class {
+  agents = /* @__PURE__ */ new Map();
+  channels = /* @__PURE__ */ new Map();
+  pendingHelpRequests = /* @__PURE__ */ new Map();
+  knowledge = [];
+  config;
+  messageCounter = 0;
+  constructor(config = {}) {
+    this.config = {
+      persistMessages: config.persistMessages ?? true,
+      maxMessagesPerChannel: config.maxMessagesPerChannel ?? 1e3,
+      helpRequestTimeoutMs: config.helpRequestTimeoutMs ?? 3e4,
+      autoExtractKnowledge: config.autoExtractKnowledge ?? false
+    };
+    this.createChannel("broadcast", []);
+  }
+  /**
+   * Register an agent for collaboration
+   */
+  registerAgent(agent) {
+    this.agents.set(agent.name, agent);
+  }
+  /**
+   * Unregister an agent
+   */
+  unregisterAgent(agentName) {
+    this.agents.delete(agentName);
+  }
+  /**
+   * Create a collaboration channel
+   */
+  createChannel(name, participants) {
+    const channel = {
+      name,
+      participants,
+      messages: [],
+      created: /* @__PURE__ */ new Date()
+    };
+    this.channels.set(name, channel);
+    return channel;
+  }
+  /**
+   * Send a message between agents
+   */
+  sendMessage(from, to, content, context, options = {}) {
+    const message = {
+      id: `msg-${++this.messageCounter}`,
+      type: options.type ?? "request",
+      from,
+      to,
+      content,
+      metadata: options.metadata,
+      replyTo: options.replyTo,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    if (this.config.persistMessages) {
+      const channelName = to === "all" ? "broadcast" : `${from}-${to}`;
+      let channel = this.channels.get(channelName);
+      if (!channel) {
+        channel = this.createChannel(channelName, [from, to]);
+      }
+      channel.messages.push(message);
+      if (channel.messages.length > this.config.maxMessagesPerChannel) {
+        channel.messages = channel.messages.slice(
+          -this.config.maxMessagesPerChannel
+        );
+      }
+    }
+    context.emit({
+      type: "collaboration:message",
+      from,
+      to,
+      messageType: message.type,
+      content
+    });
+    return Promise.resolve(message);
+  }
+  /**
+   * Broadcast a message to all agents
+   */
+  async broadcast(from, content, context) {
+    return this.sendMessage(from, "all", content, context, {
+      type: "broadcast"
+    });
+  }
+  /**
+   * Request help from other agents
+   */
+  async requestHelp(requester, task, question, context, priority = "normal") {
+    const request = {
+      id: `help-${++this.messageCounter}`,
+      requester,
+      task,
+      question,
+      priority,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.pendingHelpRequests.set(request.id, request);
+    context.emit({
+      type: "collaboration:help_request",
+      requestId: request.id,
+      requester,
+      taskId: task.id,
+      question
+    });
+    const responses = [];
+    const otherAgents = Array.from(this.agents.values()).filter(
+      (a) => a.name !== requester && !a.isBusy
+    );
+    const helpPromises = otherAgents.map(async (agent) => {
+      try {
+        const response = await this.getHelpFromAgent(agent, request, context);
+        return response;
+      } catch {
+        return null;
+      }
+    });
+    const results = await Promise.race([
+      Promise.allSettled(helpPromises),
+      new Promise(
+        (resolve) => setTimeout(() => resolve([]), this.config.helpRequestTimeoutMs)
+      )
+    ]);
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value) {
+        responses.push(result.value);
+        context.emit({
+          type: "collaboration:help_response",
+          requestId: request.id,
+          responder: result.value.responder,
+          helpful: result.value.helpful
+        });
+      }
+    }
+    this.pendingHelpRequests.delete(request.id);
+    return responses;
+  }
+  /**
+   * Get help from a specific agent
+   */
+  async getHelpFromAgent(agent, request, context) {
+    const response = await agent.provideHelp(
+      request.task,
+      request.question,
+      context
+    );
+    return {
+      requestId: request.id,
+      responder: agent.name,
+      helpful: response.helpful,
+      response: response.response,
+      suggestions: response.suggestions,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Share knowledge with the crew
+   */
+  shareKnowledge(contributor, type, content, tags, context, confidence = 0.8) {
+    const knowledge = {
+      id: `know-${++this.messageCounter}`,
+      contributor,
+      type,
+      content,
+      tags,
+      confidence,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.knowledge.push(knowledge);
+    context.emit({
+      type: "collaboration:knowledge_shared",
+      contributor,
+      knowledgeId: knowledge.id,
+      knowledgeType: type
+    });
+    return knowledge;
+  }
+  /**
+   * Search shared knowledge
+   */
+  searchKnowledge(query, limit = 10) {
+    const queryLower = query.toLowerCase();
+    const results = [];
+    for (const item of this.knowledge) {
+      let score = 0;
+      if (item.content.toLowerCase().includes(queryLower)) {
+        score += 0.5;
+      }
+      for (const tag of item.tags) {
+        if (tag.toLowerCase().includes(queryLower)) {
+          score += 0.3;
+        }
+      }
+      if (score > 0) {
+        results.push({ knowledge: item, score: score * item.confidence });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, limit).map((r) => r.knowledge);
+  }
+  /**
+   * Get knowledge by type
+   */
+  getKnowledgeByType(type) {
+    return this.knowledge.filter((k) => k.type === type);
+  }
+  /**
+   * Get knowledge by contributor
+   */
+  getKnowledgeByContributor(contributor) {
+    return this.knowledge.filter((k) => k.contributor === contributor);
+  }
+  /**
+   * Get conversation history between agents
+   */
+  getConversation(agent1, agent2) {
+    const channelName1 = `${agent1}-${agent2}`;
+    const channelName2 = `${agent2}-${agent1}`;
+    const messages = [];
+    const channel1 = this.channels.get(channelName1);
+    if (channel1) {
+      messages.push(...channel1.messages);
+    }
+    const channel2 = this.channels.get(channelName2);
+    if (channel2) {
+      messages.push(...channel2.messages);
+    }
+    return messages.sort(
+      (a, b) => a.timestamp.getTime() - b.timestamp.getTime()
+    );
+  }
+  /**
+   * Get all channels an agent participates in
+   */
+  getAgentChannels(agentName) {
+    return Array.from(this.channels.values()).filter(
+      (c) => c.participants.includes(agentName) || c.name === "broadcast"
+    );
+  }
+  /**
+   * Clear all collaboration data
+   */
+  clear() {
+    this.channels.clear();
+    this.pendingHelpRequests.clear();
+    this.knowledge.length = 0;
+    this.createChannel("broadcast", []);
+  }
+  /**
+   * Get collaboration statistics
+   */
+  getStatistics() {
+    const messagesByAgent = {};
+    const knowledgeByType = {};
+    let totalMessages = 0;
+    for (const channel of this.channels.values()) {
+      for (const message of channel.messages) {
+        totalMessages++;
+        messagesByAgent[message.from] = (messagesByAgent[message.from] ?? 0) + 1;
+      }
+    }
+    for (const item of this.knowledge) {
+      knowledgeByType[item.type] = (knowledgeByType[item.type] ?? 0) + 1;
+    }
+    return {
+      totalMessages,
+      totalChannels: this.channels.size,
+      totalKnowledge: this.knowledge.length,
+      messagesByAgent,
+      knowledgeByType
+    };
+  }
+};
+function createCollaborationManager(config) {
+  return new CollaborationManager(config);
+}
+
+// src/coordination/ConflictResolution.ts
+var ConflictResolver = class {
+  config;
+  history = [];
+  conflictCounts = /* @__PURE__ */ new Map();
+  conflictCounter = 0;
+  constructor(config = {}) {
+    this.config = {
+      defaultStrategy: config.defaultStrategy ?? "highest-confidence",
+      autoResolveThreshold: config.autoResolveThreshold ?? 0.3,
+      autoDetect: config.autoDetect ?? true,
+      escalateOnRepeated: config.escalateOnRepeated ?? 3,
+      trackHistory: config.trackHistory ?? true
+    };
+  }
+  /**
+   * Detect conflicts between agent responses
+   */
+  detectConflict(responses, task, context) {
+    if (responses.length < 2) {
+      return null;
+    }
+    const disagreement = this.detectDisagreement(responses);
+    if (disagreement) {
+      const conflict = this.createConflict(
+        "disagreement",
+        disagreement.description,
+        responses,
+        task,
+        disagreement.severity
+      );
+      context.emit({
+        type: "conflict:detected",
+        conflictId: conflict.id,
+        conflictType: "disagreement",
+        participants: conflict.participants,
+        taskId: task.id
+      });
+      return conflict;
+    }
+    const contradiction = this.detectContradiction(responses);
+    if (contradiction) {
+      const conflict = this.createConflict(
+        "assertion",
+        contradiction.description,
+        responses,
+        task,
+        contradiction.severity
+      );
+      context.emit({
+        type: "conflict:detected",
+        conflictId: conflict.id,
+        conflictType: "assertion",
+        participants: conflict.participants,
+        taskId: task.id
+      });
+      return conflict;
+    }
+    return null;
+  }
+  /**
+   * Resolve a conflict
+   */
+  async resolve(conflict, context, strategy) {
+    const resolveStrategy = strategy ?? this.config.defaultStrategy;
+    const conflictKey = `${conflict.type}-${conflict.participants.sort().join(",")}`;
+    const repeatCount = (this.conflictCounts.get(conflictKey) ?? 0) + 1;
+    this.conflictCounts.set(conflictKey, repeatCount);
+    if (repeatCount >= this.config.escalateOnRepeated) {
+      return this.escalate(
+        conflict,
+        context,
+        "Repeated conflicts between same agents"
+      );
+    }
+    let resolution;
+    switch (resolveStrategy) {
+      case "voting":
+        resolution = await this.resolveByVoting(conflict, context);
+        break;
+      case "authority":
+        resolution = await this.resolveByAuthority(conflict, context);
+        break;
+      case "consensus":
+        resolution = await this.resolveByConsensus(conflict, context);
+        break;
+      case "merge":
+        resolution = await this.resolveByMerge(conflict, context);
+        break;
+      case "human":
+        resolution = await this.escalate(
+          conflict,
+          context,
+          "Human resolution requested"
+        );
+        break;
+      case "newest":
+        resolution = this.resolveByNewest(conflict);
+        break;
+      case "highest-confidence":
+      default:
+        resolution = this.resolveByConfidence(conflict);
+        break;
+    }
+    if (this.config.trackHistory) {
+      this.history.push(resolution);
+    }
+    context.emit({
+      type: "conflict:resolved",
+      conflictId: conflict.id,
+      strategy: resolveStrategy,
+      winner: resolution.winner?.agentName,
+      escalated: resolution.escalated
+    });
+    return resolution;
+  }
+  /**
+   * Create a conflict object
+   */
+  createConflict(type, description, responses, task, severity) {
+    return {
+      id: `conflict-${++this.conflictCounter}`,
+      type,
+      description,
+      participants: responses.map((r) => r.agentName),
+      responses,
+      task,
+      severity,
+      detected: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Detect disagreement between responses
+   */
+  detectDisagreement(responses) {
+    const contents = responses.map((r) => r.content.toLowerCase());
+    const lengths = contents.map((c) => c.length);
+    const avgLength = lengths.reduce((a, b) => a + b, 0) / lengths.length;
+    const maxDiff = Math.max(...lengths.map((l) => Math.abs(l - avgLength)));
+    if (maxDiff > avgLength * 0.5) {
+      return {
+        description: "Responses have significantly different lengths",
+        severity: "low"
+      };
+    }
+    const contradictoryPairs = [
+      ["yes", "no"],
+      ["true", "false"],
+      ["correct", "incorrect"],
+      ["should", "should not"],
+      ["can", "cannot"],
+      ["will", "will not"],
+      ["agree", "disagree"]
+    ];
+    for (const [word1, word2] of contradictoryPairs) {
+      const hasWord1 = contents.some((c) => c.includes(word1));
+      const hasWord2 = contents.some((c) => c.includes(word2));
+      if (hasWord1 && hasWord2) {
+        return {
+          description: `Contradictory statements detected (${word1} vs ${word2})`,
+          severity: "medium"
+        };
+      }
+    }
+    const confidences = responses.map((r) => r.confidence);
+    const minConfidence = Math.min(...confidences);
+    const maxConfidence = Math.max(...confidences);
+    if (maxConfidence - minConfidence > this.config.autoResolveThreshold) {
+      return {
+        description: "Large confidence spread between responses",
+        severity: "low"
+      };
+    }
+    return null;
+  }
+  /**
+   * Detect contradictory assertions
+   */
+  detectContradiction(responses) {
+    for (let i = 0; i < responses.length; i++) {
+      for (let j = i + 1; j < responses.length; j++) {
+        const r1 = responses[i];
+        const r2 = responses[j];
+        const assertions1 = r1.metadata?.assertions;
+        const assertions2 = r2.metadata?.assertions;
+        if (assertions1 && assertions2) {
+          for (const a1 of assertions1) {
+            for (const a2 of assertions2) {
+              if (this.areContradictory(a1, a2)) {
+                return {
+                  description: `Contradictory assertions: "${a1}" vs "${a2}"`,
+                  severity: "high"
+                };
+              }
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if two assertions are contradictory
+   */
+  areContradictory(a1, a2) {
+    const norm1 = a1.toLowerCase().trim();
+    const norm2 = a2.toLowerCase().trim();
+    if (norm1.startsWith("not ") && norm1.slice(4) === norm2) return true;
+    if (norm2.startsWith("not ") && norm2.slice(4) === norm1) return true;
+    return false;
+  }
+  /**
+   * Resolve by highest confidence
+   */
+  resolveByConfidence(conflict) {
+    const sorted = [...conflict.responses].sort(
+      (a, b) => b.confidence - a.confidence
+    );
+    const winner = sorted[0];
+    return {
+      conflictId: conflict.id,
+      strategy: "highest-confidence",
+      winner,
+      explanation: `Selected response with highest confidence (${(winner.confidence * 100).toFixed(1)}%)`,
+      successful: true,
+      escalated: false,
+      resolved: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Resolve by newest response
+   */
+  resolveByNewest(conflict) {
+    const winner = conflict.responses[conflict.responses.length - 1];
+    return {
+      conflictId: conflict.id,
+      strategy: "newest",
+      winner,
+      explanation: "Selected most recent response",
+      successful: true,
+      escalated: false,
+      resolved: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Resolve by voting
+   */
+  resolveByVoting(conflict, _context) {
+    const votes = /* @__PURE__ */ new Map();
+    for (const response of conflict.responses) {
+      const key = response.content.substring(0, 100);
+      const current = votes.get(key) ?? 0;
+      votes.set(key, current + response.confidence);
+    }
+    let maxVotes = 0;
+    let winningKey = "";
+    for (const [key, voteCount] of votes) {
+      if (voteCount > maxVotes) {
+        maxVotes = voteCount;
+        winningKey = key;
+      }
+    }
+    const winner = conflict.responses.find(
+      (r) => r.content.substring(0, 100) === winningKey
+    );
+    return Promise.resolve({
+      conflictId: conflict.id,
+      strategy: "voting",
+      winner,
+      explanation: `Selected by weighted voting (${maxVotes.toFixed(2)} total weight)`,
+      successful: !!winner,
+      escalated: false,
+      resolved: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Resolve by authority
+   */
+  resolveByAuthority(conflict, _context) {
+    return Promise.resolve(this.resolveByConfidence(conflict));
+  }
+  /**
+   * Resolve by consensus
+   */
+  resolveByConsensus(conflict, _context) {
+    const contentGroups = /* @__PURE__ */ new Map();
+    for (const response of conflict.responses) {
+      const key = response.content.substring(0, 100);
+      const group = contentGroups.get(key) ?? [];
+      group.push(response);
+      contentGroups.set(key, group);
+    }
+    let largestGroup = [];
+    for (const group of contentGroups.values()) {
+      if (group.length > largestGroup.length) {
+        largestGroup = group;
+      }
+    }
+    if (largestGroup.length > conflict.responses.length / 2) {
+      const winner = largestGroup.reduce(
+        (best, r) => r.confidence > best.confidence ? r : best
+      );
+      return Promise.resolve({
+        conflictId: conflict.id,
+        strategy: "consensus",
+        winner,
+        explanation: `Consensus reached with ${largestGroup.length}/${conflict.responses.length} agreement`,
+        successful: true,
+        escalated: false,
+        resolved: /* @__PURE__ */ new Date()
+      });
+    }
+    return Promise.resolve({
+      ...this.resolveByConfidence(conflict),
+      strategy: "consensus",
+      explanation: "No consensus reached, fell back to highest confidence"
+    });
+  }
+  /**
+   * Resolve by merging responses
+   */
+  resolveByMerge(conflict, _context) {
+    const mergedParts = [];
+    const usedResponses = [];
+    for (const response of conflict.responses) {
+      const contentLower = response.content.toLowerCase();
+      const isNew = !mergedParts.some(
+        (part) => part.toLowerCase().includes(contentLower) || contentLower.includes(part.toLowerCase())
+      );
+      if (isNew) {
+        mergedParts.push(response.content);
+        usedResponses.push(response.agentName);
+      }
+    }
+    if (mergedParts.length > 1) {
+      return Promise.resolve({
+        conflictId: conflict.id,
+        strategy: "merge",
+        merged: mergedParts.join("\n\n"),
+        explanation: `Merged responses from ${usedResponses.join(", ")}`,
+        successful: true,
+        escalated: false,
+        resolved: /* @__PURE__ */ new Date()
+      });
+    }
+    return Promise.resolve({
+      ...this.resolveByConfidence(conflict),
+      strategy: "merge",
+      explanation: "Could not merge responses, fell back to highest confidence"
+    });
+  }
+  /**
+   * Escalate to human
+   */
+  escalate(conflict, context, reason) {
+    context.emit({
+      type: "conflict:escalated",
+      conflictId: conflict.id,
+      reason,
+      participants: conflict.participants
+    });
+    return Promise.resolve({
+      conflictId: conflict.id,
+      strategy: "human",
+      explanation: `Escalated to human: ${reason}`,
+      successful: false,
+      escalated: true,
+      resolved: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Get resolution history
+   */
+  getHistory(conflictId) {
+    if (conflictId) {
+      return this.history.filter((r) => r.conflictId === conflictId);
+    }
+    return [...this.history];
+  }
+  /**
+   * Get resolution statistics
+   */
+  getStatistics() {
+    const byStrategy = {};
+    let successful = 0;
+    let escalated = 0;
+    for (const resolution of this.history) {
+      byStrategy[resolution.strategy] = (byStrategy[resolution.strategy] ?? 0) + 1;
+      if (resolution.successful) successful++;
+      if (resolution.escalated) escalated++;
+    }
+    return {
+      totalConflicts: this.history.length,
+      byStrategy,
+      successRate: this.history.length > 0 ? successful / this.history.length : 0,
+      escalationRate: this.history.length > 0 ? escalated / this.history.length : 0
+    };
+  }
+  /**
+   * Clear history and counts
+   */
+  clear() {
+    this.history.length = 0;
+    this.conflictCounts.clear();
+  }
+};
+function createConflictResolver(config) {
+  return new ConflictResolver(config);
+}
+
+// src/core/Crew.ts
+import { nanoid as nanoid4 } from "nanoid";
+var Crew = class {
+  id;
+  name;
+  description;
+  config;
+  agents;
+  taskQueue;
+  delegation;
+  collaboration;
+  conflictResolver;
+  context;
+  state = "idle";
+  startTime;
+  endTime;
+  currentIteration = 0;
+  maxIterations;
+  timeline = [];
+  results = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.id = nanoid4();
+    this.name = config.name;
+    this.description = config.description;
+    this.config = config;
+    this.maxIterations = config.maxIterations ?? 100;
+    this.agents = new AgentRegistry();
+    this.taskQueue = new TaskQueue({ defaultPriority: "medium" });
+    this.delegation = new DelegationCoordinator({
+      defaultStrategy: config.delegationStrategy
+    });
+    this.collaboration = new CollaborationManager();
+    this.conflictResolver = new ConflictResolver();
+    this.initializeAgents();
+  }
+  // ============ Agent Management ============
+  /**
+   * Initialize agents from config
+   */
+  initializeAgents() {
+    for (const agentConfig of this.config.agents) {
+      const agent = createCrewAgent({ config: agentConfig });
+      this.addAgent(agent);
+    }
+  }
+  /**
+   * Add an agent to the crew
+   */
+  addAgent(agent) {
+    this.agents.register(agent);
+    this.collaboration.registerAgent(agent);
+  }
+  /**
+   * Remove an agent from the crew
+   */
+  removeAgent(name) {
+    this.agents.unregister(name);
+    this.collaboration.unregisterAgent(name);
+  }
+  /**
+   * Get an agent by name
+   */
+  getAgent(name) {
+    return this.agents.get(name);
+  }
+  /**
+   * Get all agents
+   */
+  getAgents() {
+    return this.agents.getAll();
+  }
+  // ============ Task Management ============
+  /**
+   * Add a task to the crew
+   */
+  addTask(taskConfig) {
+    const task = new Task(taskConfig);
+    this.taskQueue.enqueue(task);
+    return task;
+  }
+  /**
+   * Add multiple tasks
+   */
+  addTasks(tasks) {
+    return tasks.map((t) => this.addTask(t));
+  }
+  /**
+   * Get task by ID
+   */
+  getTask(taskId) {
+    return this.taskQueue.get(taskId);
+  }
+  /**
+   * Get all tasks
+   */
+  getTasks() {
+    return this.taskQueue.getAll();
+  }
+  // ============ Execution ============
+  /**
+   * Start crew execution
+   */
+  async kickoff(options = {}) {
+    const events = [];
+    for await (const event of this.kickoffStream(options)) {
+      events.push(event);
+    }
+    const taskResults = Array.from(this.results.values());
+    return {
+      success: this.state === "completed",
+      taskResults,
+      metrics: this.getMetrics(),
+      timeline: [...this.timeline],
+      finalOutput: this.buildFinalOutput(taskResults),
+      events
+    };
+  }
+  /**
+   * Start crew execution with streaming events
+   */
+  async *kickoffStream(options = {}) {
+    this.context = new ExecutionContext({
+      crewName: this.name
+    });
+    if (options.context) {
+      for (const [key, value] of Object.entries(options.context)) {
+        this.context.set(key, value);
+      }
+    }
+    if (options.input) {
+      this.context.set("input", options.input);
+    }
+    const eventQueue = [];
+    this.context.on("*", (event) => {
+      eventQueue.push(event);
+    });
+    this.state = "running";
+    this.startTime = /* @__PURE__ */ new Date();
+    this.currentIteration = 0;
+    yield this.createEvent({
+      type: "crew:started",
+      agentCount: this.agents.getAll().length,
+      taskCount: this.taskQueue.size,
+      strategy: this.config.delegationStrategy
+    });
+    this.addTimelineEntry("crew_started", this.name);
+    let timeoutId;
+    if (options.timeoutMs) {
+      timeoutId = setTimeout(() => {
+        this.abort();
+      }, options.timeoutMs);
+    }
+    try {
+      while (this.state === "running" && this.currentIteration < this.maxIterations) {
+        this.currentIteration++;
+        const readyTasks = this.taskQueue.getReadyTasks(
+          this.context.getCompletedTaskIds()
+        );
+        if (readyTasks.length === 0) {
+          if (this.taskQueue.getByStatus("pending").length === 0 && this.taskQueue.getByStatus("assigned").length === 0 && this.taskQueue.getByStatus("in_progress").length === 0) {
+            break;
+          }
+          await this.sleep(100);
+          continue;
+        }
+        for (const task of readyTasks) {
+          if (this.state !== "running") break;
+          const delegationResult = await this.delegateTask(task, options);
+          yield this.createEvent({
+            type: "task:assigned",
+            taskId: task.id,
+            agentName: delegationResult.selectedAgent,
+            reason: delegationResult.reason,
+            strategy: this.config.delegationStrategy
+          });
+          const taskResult = await this.executeTask(task, delegationResult);
+          yield this.createEvent({
+            type: "task:completed",
+            taskId: task.id,
+            result: taskResult,
+            agentName: delegationResult.selectedAgent,
+            durationMs: taskResult.latencyMs ?? 0
+          });
+          while (eventQueue.length > 0) {
+            yield eventQueue.shift();
+          }
+        }
+        while (this.state === "paused") {
+          await this.sleep(100);
+        }
+      }
+      if (this.state === "aborted") {
+      } else {
+        const failedTasks = this.taskQueue.getByStatus("failed");
+        if (failedTasks.length > 0) {
+          this.state = "failed";
+          yield this.createEvent({
+            type: "crew:error",
+            error: `${failedTasks.length} task(s) failed`,
+            fatal: true
+          });
+        } else {
+          this.state = "completed";
+        }
+      }
+    } catch (error) {
+      if (this.state !== "aborted") {
+        this.state = "failed";
+      }
+      yield this.createEvent({
+        type: "crew:error",
+        error: error instanceof Error ? error.message : String(error),
+        fatal: true
+      });
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      this.endTime = /* @__PURE__ */ new Date();
+    }
+    yield this.createEvent({
+      type: "crew:completed",
+      metrics: this.getMetrics(),
+      success: this.state === "completed",
+      results: Array.from(this.results.values())
+    });
+    this.addTimelineEntry("crew_completed", this.name);
+  }
+  /**
+   * Delegate a task to an agent
+   */
+  async delegateTask(task, options) {
+    const agents = this.agents.getAll();
+    const strategy = options.delegationStrategy ?? this.config.delegationStrategy;
+    const result = await this.delegation.delegate(
+      task.toConfig(),
+      agents,
+      this.context,
+      strategy
+    );
+    task.assign(result.selectedAgent);
+    this.addTimelineEntry("task_delegated", task.id, {
+      agent: result.selectedAgent,
+      strategy
+    });
+    return result;
+  }
+  /**
+   * Execute a task with assigned agent
+   */
+  async executeTask(task, delegation) {
+    const agent = this.agents.get(delegation.selectedAgent);
+    if (!agent) {
+      const error = new Error(`Agent ${delegation.selectedAgent} not found`);
+      task.fail(error.message);
+      throw error;
+    }
+    task.start();
+    this.addTimelineEntry("task_started", task.id, { agent: agent.name });
+    this.context.emit({
+      type: "task:started",
+      taskId: task.id,
+      agentName: agent.name
+    });
+    try {
+      const result = await agent.executeTask(task.toConfig());
+      task.complete(result);
+      this.results.set(task.id, result);
+      this.context.markTaskCompleted(task.id, result);
+      this.agents.recordTaskCompletion(agent.name, true);
+      this.addTimelineEntry("task_completed", task.id, {
+        agent: agent.name,
+        success: true
+      });
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (task.canRetry()) {
+        this.addTimelineEntry("task_retried", task.id, {
+          agent: agent.name,
+          error: errorMsg
+        });
+        this.context.emit({
+          type: "task:retried",
+          taskId: task.id,
+          agentName: agent.name,
+          attempt: task.attempts,
+          maxAttempts: task.maxRetries + 1,
+          reason: errorMsg
+        });
+        task.reset();
+        return this.executeTask(task, delegation);
+      }
+      task.fail(errorMsg);
+      this.agents.recordTaskCompletion(agent.name, false);
+      this.addTimelineEntry("task_failed", task.id, {
+        agent: agent.name,
+        error: errorMsg
+      });
+      throw error;
+    }
+  }
+  /**
+   * Build final output from task results
+   */
+  buildFinalOutput(results) {
+    if (results.length === 0) {
+      return "";
+    }
+    if (results.length === 1) {
+      return results[0].output;
+    }
+    return results.map((r, i) => `## Task ${i + 1} Result
+
+${r.output}`).join("\n\n---\n\n");
+  }
+  // ============ Control ============
+  /**
+   * Pause crew execution
+   */
+  pause() {
+    if (this.state === "running") {
+      this.state = "paused";
+      this.context.emit({
+        type: "crew:paused",
+        pendingTasks: this.taskQueue.getByStatus("pending").length
+      });
+      this.addTimelineEntry("crew_paused", this.name);
+    }
+  }
+  /**
+   * Resume crew execution
+   */
+  resume() {
+    if (this.state === "paused") {
+      this.state = "running";
+      this.context.emit({
+        type: "crew:resumed"
+      });
+      this.addTimelineEntry("crew_resumed", this.name);
+    }
+  }
+  /**
+   * Abort crew execution
+   */
+  abort() {
+    if (this.state === "running" || this.state === "paused") {
+      this.state = "aborted";
+      this.context.abort();
+      this.context.emit({
+        type: "crew:aborted",
+        reason: "User requested abort",
+        completedTasks: this.taskQueue.getByStatus("completed").length,
+        pendingTasks: this.taskQueue.getByStatus("pending").length
+      });
+      this.addTimelineEntry("crew_aborted", this.name);
+    }
+  }
+  // ============ State & Metrics ============
+  /**
+   * Get current crew status
+   */
+  getStatus() {
+    return {
+      state: this.state,
+      currentIteration: this.currentIteration,
+      maxIterations: this.maxIterations,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      tasksPending: this.taskQueue.getByStatus("pending").length,
+      tasksInProgress: this.taskQueue.getByStatus("in_progress").length,
+      tasksCompleted: this.taskQueue.getByStatus("completed").length,
+      tasksFailed: this.taskQueue.getByStatus("failed").length,
+      agentsBusy: this.agents.getAll().filter((a) => a.isBusy).length,
+      agentsAvailable: this.agents.getAll().filter((a) => !a.isBusy).length
+    };
+  }
+  /**
+   * Get crew metrics
+   */
+  getMetrics() {
+    const allTasks = this.taskQueue.getAll();
+    const completedTasks = this.taskQueue.getByStatus("completed");
+    const failedTasks = this.taskQueue.getByStatus("failed");
+    const agents = this.agents.getAll();
+    const totalExecutionTimeMs = this.startTime && this.endTime ? this.endTime.getTime() - this.startTime.getTime() : 0;
+    let totalTokens = 0;
+    for (const result of this.results.values()) {
+      totalTokens += result.tokensUsed ?? 0;
+    }
+    const agentMetrics = {};
+    for (const agent of agents) {
+      const stats = agent.getStats();
+      agentMetrics[agent.name] = {
+        tasksAssigned: stats.tasksCompleted + stats.tasksFailed,
+        tasksCompleted: stats.tasksCompleted,
+        tasksFailed: stats.tasksFailed,
+        tokensUsed: stats.totalTokensUsed,
+        averageLatencyMs: 0
+        // Would need to track this separately
+      };
+    }
+    const delegationStats = this.delegation.getStatistics();
+    return {
+      totalTasks: allTasks.length,
+      completedTasks: completedTasks.length,
+      failedTasks: failedTasks.length,
+      totalExecutionTimeMs,
+      averageTaskTimeMs: completedTasks.length > 0 ? totalExecutionTimeMs / completedTasks.length : 0,
+      totalIterations: this.currentIteration,
+      totalTokens,
+      agentMetrics,
+      delegationStats: {
+        totalDelegations: delegationStats.totalDelegations,
+        byStrategy: delegationStats.byStrategy,
+        averageConfidence: delegationStats.averageConfidence
+      }
+    };
+  }
+  /**
+   * Get crew progress
+   */
+  getProgress() {
+    const allTasks = this.taskQueue.getAll();
+    const completed = this.taskQueue.getByStatus("completed").length;
+    const total = allTasks.length;
+    return {
+      percentage: total > 0 ? completed / total * 100 : 0,
+      tasksCompleted: completed,
+      totalTasks: total,
+      currentTask: this.taskQueue.getByStatus("in_progress")[0]?.description,
+      estimatedRemainingMs: 0
+      // Would need historical data
+    };
+  }
+  /**
+   * Get timeline
+   */
+  getTimeline() {
+    return [...this.timeline];
+  }
+  // ============ Checkpointing ============
+  /**
+   * Create a checkpoint of current state
+   */
+  createCheckpoint() {
+    return {
+      id: nanoid4(),
+      crewId: this.id,
+      crewName: this.name,
+      timestamp: /* @__PURE__ */ new Date(),
+      state: this.state,
+      contextState: this.context ? this.context.exportState() : void 0,
+      taskQueue: this.taskQueue.getAll().map((t) => t.toConfig()),
+      results: Object.fromEntries(this.results),
+      timeline: [...this.timeline],
+      iteration: this.currentIteration
+    };
+  }
+  /**
+   * Restore from checkpoint
+   */
+  restoreCheckpoint(checkpoint) {
+    if (this.state !== "idle") {
+      throw new Error("Cannot restore checkpoint while crew is running");
+    }
+    this.taskQueue.clear();
+    this.results.clear();
+    this.timeline.length = 0;
+    if (checkpoint.taskQueue) {
+      for (const taskConfig of checkpoint.taskQueue) {
+        this.addTask(taskConfig);
+      }
+    }
+    if (checkpoint.results) {
+      for (const [taskId, result] of Object.entries(checkpoint.results)) {
+        this.results.set(taskId, result);
+      }
+    }
+    if (checkpoint.timeline) {
+      this.timeline.push(...checkpoint.timeline);
+    }
+    this.currentIteration = checkpoint.iteration ?? 0;
+  }
+  // ============ Utilities ============
+  /**
+   * Add a timeline entry
+   */
+  addTimelineEntry(event, entityId, data) {
+    this.timeline.push({
+      timestamp: /* @__PURE__ */ new Date(),
+      event,
+      entityId,
+      data
+    });
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Create a properly typed event
+   */
+  createEvent(event) {
+    return {
+      ...event,
+      crewName: this.name,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Reset crew for re-execution
+   */
+  reset() {
+    if (this.state === "running" || this.state === "paused") {
+      throw new Error("Cannot reset while crew is running");
+    }
+    this.state = "idle";
+    this.startTime = void 0;
+    this.endTime = void 0;
+    this.currentIteration = 0;
+    this.timeline.length = 0;
+    this.results.clear();
+    this.taskQueue.clear();
+    this.delegation.reset();
+    this.collaboration.clear();
+    this.conflictResolver.clear();
+  }
+  // ============ Serialization ============
+  /**
+   * Get crew configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+function createCrew(config) {
+  return new Crew(config);
+}
+
+export {
+  Role,
+  createRole,
+  Task,
+  createTask,
+  TaskQueue,
+  createTaskQueue,
+  ExecutionContext,
+  createExecutionContext,
+  AgentCapabilities,
+  CrewAgent,
+  createCrewAgent,
+  AgentRegistry,
+  createAgentRegistry,
+  BaseDelegationStrategy,
+  DelegationError,
+  RoundRobinStrategy,
+  createRoundRobinStrategy,
+  BestMatchStrategy,
+  createBestMatchStrategy,
+  AuctionStrategy,
+  createAuctionStrategy,
+  HierarchicalStrategy,
+  createHierarchicalStrategy,
+  ConsensusStrategy,
+  createConsensusStrategy,
+  createStrategy,
+  STRATEGY_TYPES,
+  DelegationCoordinator,
+  createDelegationCoordinator,
+  CollaborationManager,
+  createCollaborationManager,
+  ConflictResolver,
+  createConflictResolver,
+  Crew,
+  createCrew
+};