ccjk 14.2.2 → 15.0.0

package/dist/chunks/agents.mjs

@@ -1,3783 +0,0 @@
-import a from './index5.mjs';
-import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
-import ora from './index8.mjs';
-import { c as contextLoader, S as SessionIntelligence, g as getGlobalConvoyManager } from './session-manager.mjs';
-import { EventEmitter } from 'node:events';
-import { c as resolve } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import { e as executionTracer } from '../shared/ccjk.DlTXS9rP.mjs';
-import { t as taskPersistence } from '../shared/ccjk.CNhnT6uQ.mjs';
-import '../shared/ccjk.BAGoDD49.mjs';
-import 'node:crypto';
-import 'node:process';
-import '../shared/ccjk.Cjgrln_h.mjs';
-import '../shared/ccjk.DeWpAShp.mjs';
-import 'node:fs';
-import 'node:os';
-import './main.mjs';
-import 'module';
-import 'node:child_process';
-import 'node:path';
-import 'node:stream';
-import 'node:readline';
-import 'tinyglobby';
-import '../shared/ccjk.wLJHO0Af.mjs';
-import 'node:fs/promises';
-import 'better-sqlite3';
-
-const DEFAULT_AGENT_TYPE_MAPPINGS = {
-  "typescript": "coder",
-  "typescript-cli": "coder",
-  "ts-cli-architect": "architect",
-  "ts-architect": "architect",
-  "i18n": "specialist",
-  "internationalization": "specialist",
-  "i18n-specialist": "specialist",
-  "tools": "specialist",
-  "integration": "specialist",
-  "tools-integration": "specialist",
-  "template": "specialist",
-  "templating": "specialist",
-  "template-engine": "specialist",
-  "config": "architect",
-  "configuration": "architect",
-  "config-architect": "architect",
-  "testing": "tester",
-  "test": "tester",
-  "testing-specialist": "tester",
-  "devops": "specialist",
-  "deployment": "specialist",
-  "devops-engineer": "specialist",
-  "code": "coder",
-  "general": "coordinator",
-  "default": "coordinator"
-};
-const DEFAULT_DISPATCHER_OPTIONS = {
-  defaultTimeout: 3e5,
-  maxParallelExecutions: 5,
-  enableLoadBalancing: true,
-  enableAgentCaching: true,
-  agentCacheTtl: 36e5,
-  // 1 hour
-  verbose: false,
-  agentTypeMappings: DEFAULT_AGENT_TYPE_MAPPINGS
-};
-class AgentDispatcher {
-  options;
-  agentRegistry = /* @__PURE__ */ new Map();
-  cloudAgents = /* @__PURE__ */ new Map();
-  activeExecutions = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    this.options = {
-      ...DEFAULT_DISPATCHER_OPTIONS,
-      ...options,
-      agentTypeMappings: {
-        ...DEFAULT_AGENT_TYPE_MAPPINGS,
-        ...options.agentTypeMappings
-      }
-    };
-  }
-  /**
-   * Register a cloud agent
-   *
-   * @param agentType - Agent type identifier
-   * @param agent - Cloud agent definition
-   */
-  registerCloudAgent(agentType, agent) {
-    this.cloudAgents.set(agentType, agent);
-    if (this.options.verbose) {
-      console.log(`[AgentDispatcher] Registered cloud agent: ${agentType}`);
-    }
-  }
-  /**
-   * Unregister a cloud agent
-   *
-   * @param agentType - Agent type identifier
-   */
-  unregisterCloudAgent(agentType) {
-    this.cloudAgents.delete(agentType);
-    if (this.options.verbose) {
-      console.log(`[AgentDispatcher] Unregistered cloud agent: ${agentType}`);
-    }
-  }
-  /**
-   * Dispatch a task to an agent based on skill configuration
-   *
-   * @param task - Task to execute
-   * @param skill - Skill file with agent configuration
-   * @param executeFn - Execution function
-   * @returns Dispatch result
-   */
-  async dispatch(task, skill, executeFn) {
-    const startTime = Date.now();
-    try {
-      const config = this.buildDispatchConfig(skill);
-      const agent = await this.selectAgent(config);
-      if (!agent) {
-        return {
-          success: false,
-          durationMs: Date.now() - startTime,
-          error: `No suitable agent found for type: ${config.agentType}`
-        };
-      }
-      agent.status = "busy";
-      agent.currentTask = task;
-      const result = await this.executeWithAgent(agent, task, config, executeFn);
-      agent.status = "idle";
-      agent.currentTask = void 0;
-      this.updateAgentMetrics(agent, task, result.success);
-      if (this.options.enableAgentCaching) {
-        this.cacheAgent(agent);
-      }
-      return {
-        success: result.success,
-        agent,
-        output: result.results?.aggregated,
-        durationMs: Date.now() - startTime,
-        metadata: {
-          agentType: config.agentType,
-          agentRole: config.agentRole,
-          sessionId: config.sessionId
-        }
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return {
-        success: false,
-        durationMs: Date.now() - startTime,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * Dispatch to multiple agents in parallel
-   *
-   * @param execution - Parallel execution configuration
-   * @param executeFn - Execution function
-   * @returns Parallel execution result
-   */
-  async dispatchParallel(execution, executeFn) {
-    const startTime = Date.now();
-    const results = [];
-    let successfulCount = 0;
-    let failedCount = 0;
-    const maxParallel = execution.maxParallel ?? this.options.maxParallelExecutions;
-    for (let i = 0; i < execution.tasks.length; i += maxParallel) {
-      const batch = execution.tasks.slice(i, i + maxParallel);
-      const batchResults = await Promise.allSettled(
-        batch.map(async ({ task, config }) => {
-          const result = await this.executeDispatch(task, config, executeFn);
-          if (result.success) {
-            successfulCount++;
-          } else {
-            failedCount++;
-            if (execution.stopOnError) {
-              throw new Error(`Execution failed: ${result.error}`);
-            }
-          }
-          return result;
-        })
-      );
-      for (const batchResult of batchResults) {
-        if (batchResult.status === "fulfilled") {
-          results.push(batchResult.value);
-        } else {
-          results.push({
-            success: false,
-            durationMs: Date.now() - startTime,
-            error: batchResult.reason?.message || "Unknown error"
-          });
-          failedCount++;
-        }
-      }
-    }
-    const success = failedCount === 0;
-    return {
-      id: execution.id,
-      success,
-      results,
-      durationMs: Date.now() - startTime,
-      successfulCount,
-      failedCount,
-      aggregatedOutput: execution.aggregateResults ? this.aggregateOutputs(results) : void 0
-    };
-  }
-  /**
-   * Execute a single dispatch
-   *
-   * @param task - Task to execute
-   * @param config - Dispatch configuration
-   * @param executeFn - Execution function
-   * @returns Dispatch result
-   */
-  async executeDispatch(task, config, executeFn) {
-    const startTime = Date.now();
-    try {
-      const agent = await this.selectAgent(config);
-      if (!agent) {
-        return {
-          success: false,
-          durationMs: Date.now() - startTime,
-          error: `No suitable agent found for type: ${config.agentType}`
-        };
-      }
-      agent.status = "busy";
-      agent.currentTask = task;
-      const result = await this.executeWithAgent(agent, task, config, executeFn);
-      agent.status = "idle";
-      agent.currentTask = void 0;
-      this.updateAgentMetrics(agent, task, result.success);
-      return {
-        success: result.success,
-        agent,
-        output: result.results?.aggregated,
-        durationMs: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        durationMs: Date.now() - startTime,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  /**
-   * Execute task with agent
-   *
-   * @param agent - Agent instance
-   * @param task - Task to execute
-   * @param config - Dispatch configuration
-   * @param executeFn - Execution function
-   * @returns Orchestration result
-   */
-  async executeWithAgent(agent, task, config, executeFn) {
-    const filteredConfig = this.applyToolFiltering(config);
-    const timeout = filteredConfig.timeout ?? this.options.defaultTimeout;
-    const softTimeout = Math.floor(timeout * 0.8);
-    const warningTimeout = Math.floor(timeout * 0.6);
-    const warningTimer = setTimeout(() => {
-      if (this.options.verbose) {
-        console.log(`
-\u{1F4AD} Agent ${agent.id} \u6B63\u5728\u6267\u884C\u4E2D\uFF0C\u8BF7\u7A0D\u5019...`);
-      }
-    }, warningTimeout);
-    const softTimer = setTimeout(() => {
-      console.log(`
-\u26A0\uFE0F \u4EFB\u52A1\u6267\u884C\u65F6\u95F4\u8F83\u957F (\u5DF2\u8D85\u8FC7 ${Math.floor(softTimeout / 1e3)}s)\uFF0C\u53EF\u80FD\u9700\u8981\uFF1A`);
-      console.log(`   1. \u7B49\u5F85\u5B8C\u6210\uFF08\u5269\u4F59\u7EA6 ${Math.floor((timeout - softTimeout) / 1e3)}s\uFF09`);
-      console.log("   2. \u4F7F\u7528 Ctrl+C \u4E2D\u65AD\u540E\u6267\u884C /compact \u6E05\u7406\u4E0A\u4E0B\u6587");
-      console.log("   3. \u5C06\u4EFB\u52A1\u5206\u89E3\u4E3A\u66F4\u5C0F\u7684\u6B65\u9AA4\n");
-    }, softTimeout);
-    try {
-      const result = await Promise.race([
-        executeFn(filteredConfig),
-        new Promise(
-          (_, reject) => setTimeout(() => {
-            reject(new Error("Agent execution timeout"));
-          }, timeout)
-        )
-      ]);
-      clearTimeout(warningTimer);
-      clearTimeout(softTimer);
-      return result;
-    } catch (error) {
-      clearTimeout(warningTimer);
-      clearTimeout(softTimer);
-      if (error instanceof Error && error.message === "Agent execution timeout") {
-        const friendlyError = new Error(
-          `\u4EFB\u52A1\u6267\u884C\u8D85\u65F6 (${Math.floor(timeout / 1e3)}s)\u3002\u5EFA\u8BAE\uFF1A
-  1. \u4F7F\u7528 /compact \u6E05\u7406\u4E0A\u4E0B\u6587\u540E\u91CD\u8BD5
-  2. \u5C06\u4EFB\u52A1\u5206\u89E3\u4E3A\u66F4\u5C0F\u7684\u6B65\u9AA4
-  3. \u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u662F\u5426\u7A33\u5B9A`
-        );
-        friendlyError.name = "TimeoutError";
-        throw friendlyError;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Build dispatch config from skill file
-   *
-   * @param skill - Skill file
-   * @returns Dispatch configuration
-   */
-  buildDispatchConfig(skill) {
-    const metadata = skill.metadata;
-    const agentType = metadata.agent || "default";
-    const agentRole = this.mapAgentTypeToRole(agentType);
-    return {
-      agentType,
-      agentRole,
-      mode: metadata.context || "inherit",
-      sessionId: this.generateSessionId(),
-      disallowedTools: this.extractDisallowedTools(metadata),
-      allowedTools: metadata.allowed_tools,
-      workingDirectory: process.cwd(),
-      env: { ...process.env },
-      timeout: metadata.timeout ? metadata.timeout * 1e3 : void 0,
-      verbose: false
-    };
-  }
-  /**
-   * Map agent type string to AgentRole
-   *
-   * @param agentType - Agent type string
-   * @returns Mapped agent role
-   */
-  mapAgentTypeToRole(agentType) {
-    if (this.options.agentTypeMappings[agentType]) {
-      return this.options.agentTypeMappings[agentType];
-    }
-    const lowerKey = agentType.toLowerCase();
-    if (this.options.agentTypeMappings[lowerKey]) {
-      return this.options.agentTypeMappings[lowerKey];
-    }
-    const validRoles = [
-      "researcher",
-      "architect",
-      "coder",
-      "debugger",
-      "tester",
-      "reviewer",
-      "writer",
-      "analyst",
-      "coordinator",
-      "specialist"
-    ];
-    if (validRoles.includes(agentType)) {
-      return agentType;
-    }
-    return void 0;
-  }
-  /**
-   * Extract disallowed tools from skill metadata
-   *
-   * @param metadata - Skill metadata
-   * @returns Disallowed tools array
-   */
-  extractDisallowedTools(metadata) {
-    if (metadata.allowed_tools) {
-      return void 0;
-    }
-    const skillData = metadata;
-    if (skillData.disallowed_tools && Array.isArray(skillData.disallowed_tools)) {
-      return skillData.disallowed_tools;
-    }
-    return void 0;
-  }
-  /**
-   * Apply tool filtering to dispatch config
-   *
-   * @param config - Original dispatch config
-   * @returns Filtered dispatch config
-   */
-  applyToolFiltering(config) {
-    const filtered = { ...config };
-    if (config.allowedTools && config.allowedTools.length > 0) {
-      filtered.allowedTools = config.allowedTools;
-    }
-    if (config.disallowedTools && config.disallowedTools.length > 0) {
-      filtered.disallowedTools = config.disallowedTools;
-    }
-    return filtered;
-  }
-  /**
-   * Select an agent for dispatch
-   *
-   * @param config - Dispatch configuration
-   * @returns Selected agent instance or null
-   */
-  async selectAgent(config) {
-    if (this.options.enableAgentCaching) {
-      const cached = this.getCachedAgent(config);
-      if (cached) {
-        return cached;
-      }
-    }
-    const cloudAgent = this.cloudAgents.get(config.agentType);
-    if (cloudAgent) {
-      return this.createAgentInstance(cloudAgent, config);
-    }
-    return this.createGenericAgent(config);
-  }
-  /**
-   * Create agent instance from cloud agent
-   *
-   * @param cloudAgent - Cloud agent definition
-   * @param config - Dispatch configuration
-   * @returns Agent instance
-   */
-  createAgentInstance(cloudAgent, config) {
-    const now = /* @__PURE__ */ new Date();
-    const capabilities = cloudAgent.definition.capabilities.map((cap, index) => ({
-      id: `${cloudAgent.id}-cap-${index}`,
-      name: cap,
-      model: "inherit",
-      specialties: [cap],
-      strength: 1,
-      costFactor: 1
-    }));
-    return {
-      id: nanoid(),
-      role: this.mapAgentTypeToRole(config.agentType) || "coordinator",
-      agent: cloudAgent,
-      status: "idle",
-      taskHistory: [],
-      capabilities,
-      metrics: this.createEmptyMetrics(),
-      createdAt: now.toISOString(),
-      config: {
-        maxConcurrentTasks: 1,
-        taskTimeout: config.timeout || this.options.defaultTimeout,
-        verboseLogging: config.verbose || false
-      }
-    };
-  }
-  /**
-   * Create a generic agent instance
-   *
-   * @param config - Dispatch configuration
-   * @returns Agent instance
-   */
-  createGenericAgent(config) {
-    const now = /* @__PURE__ */ new Date();
-    return {
-      id: nanoid(),
-      role: config.agentRole || "coordinator",
-      agent: {
-        id: config.agentType,
-        name: config.agentType,
-        version: "1.0.0",
-        definition: {
-          role: config.agentType,
-          systemPrompt: `You are a ${config.agentType} agent.`,
-          capabilities: [],
-          tools: [],
-          constraints: []
-        },
-        metadata: {
-          author: "CCJK",
-          description: { "en": config.agentType, "zh-CN": config.agentType },
-          category: "general",
-          createdAt: now.toISOString(),
-          updatedAt: now.toISOString(),
-          usageCount: 0,
-          rating: 0,
-          ratingCount: 0
-        },
-        privacy: "private"
-      },
-      status: "idle",
-      taskHistory: [],
-      capabilities: [],
-      metrics: this.createEmptyMetrics(),
-      createdAt: now.toISOString(),
-      config: {
-        maxConcurrentTasks: 1,
-        taskTimeout: config.timeout || this.options.defaultTimeout,
-        verboseLogging: config.verbose || false
-      }
-    };
-  }
-  /**
-   * Create empty metrics object
-   *
-   * @returns Empty metrics
-   */
-  createEmptyMetrics() {
-    return {
-      tasksExecuted: 0,
-      tasksSucceeded: 0,
-      tasksFailed: 0,
-      avgTaskDuration: 0,
-      successRate: 0,
-      totalExecutionTime: 0,
-      avgConfidence: 0,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  /**
-   * Update agent metrics after execution
-   *
-   * @param agent - Agent instance
-   * @param task - Executed task
-   * @param success - Whether execution succeeded
-   */
-  updateAgentMetrics(agent, task, success) {
-    const metrics = agent.metrics;
-    metrics.tasksExecuted++;
-    if (success) {
-      metrics.tasksSucceeded++;
-    } else {
-      metrics.tasksFailed++;
-    }
-    metrics.successRate = metrics.tasksSucceeded / metrics.tasksExecuted;
-    if (task.actualDuration) {
-      metrics.totalExecutionTime += task.actualDuration;
-      metrics.avgTaskDuration = metrics.totalExecutionTime / metrics.tasksExecuted;
-    }
-    metrics.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    agent.taskHistory.push({
-      taskId: task.id,
-      taskName: task.name,
-      status: task.status,
-      startedAt: task.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
-      completedAt: task.completedAt,
-      duration: task.actualDuration,
-      success
-    });
-  }
-  /**
-   * Cache an agent instance
-   *
-   * @param agent - Agent instance to cache
-   */
-  cacheAgent(agent) {
-    const key = `${agent.role}-${agent.id}`;
-    this.agentRegistry.set(key, {
-      agent,
-      lastUsed: /* @__PURE__ */ new Date(),
-      usageCount: 1,
-      expiresAt: new Date(Date.now() + this.options.agentCacheTtl)
-    });
-  }
-  /**
-   * Get cached agent
-   *
-   * @param config - Dispatch configuration
-   * @returns Cached agent or null
-   */
-  getCachedAgent(config) {
-    const role = config.agentRole || "system";
-    const registryEntries = Array.from(this.agentRegistry.entries());
-    for (const [key, entry] of registryEntries) {
-      if (entry.agent.role === role && entry.agent.status === "idle") {
-        if (entry.expiresAt && entry.expiresAt < /* @__PURE__ */ new Date()) {
-          this.agentRegistry.delete(key);
-          continue;
-        }
-        entry.lastUsed = /* @__PURE__ */ new Date();
-        entry.usageCount++;
-        if (this.options.verbose) {
-          console.log(`[AgentDispatcher] Using cached agent: ${key}`);
-        }
-        return entry.agent;
-      }
-    }
-    return null;
-  }
-  /**
-   * Aggregate outputs from multiple dispatch results
-   *
-   * @param results - Dispatch results
-   * @returns Aggregated output
-   */
-  aggregateOutputs(results) {
-    const successfulResults = results.filter((r) => r.success && r.output);
-    return {
-      data: {
-        results: successfulResults.map((r) => r.output?.data),
-        count: successfulResults.length,
-        total: results.length
-      },
-      files: successfulResults.flatMap((r) => r.output?.files || []),
-      logs: successfulResults.flatMap((r) => r.output?.logs || []),
-      confidence: successfulResults.length / results.length,
-      metadata: {
-        aggregatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        sourceResults: results.length
-      }
-    };
-  }
-  /**
-   * Generate a unique session ID
-   *
-   * @returns Session ID
-   */
-  generateSessionId() {
-    return `ccjk-dispatch-${Date.now()}-${nanoid(8)}`;
-  }
-  /**
-   * Filter available agents by criteria
-   *
-   * @param criteria - Filter criteria
-   * @returns Filtered agents
-   */
-  filterAgents(criteria) {
-    const agents = [];
-    const cloudAgentsEntries = Array.from(this.cloudAgents.entries());
-    for (const [type, cloudAgent] of cloudAgentsEntries) {
-      if (this.matchesCriteria(cloudAgent, criteria)) {
-        agents.push(this.createAgentInstance(cloudAgent, {
-          agentType: type,
-          agentRole: this.mapAgentTypeToRole(type),
-          mode: "inherit",
-          workingDirectory: process.cwd(),
-          env: {}
-        }));
-      }
-    }
-    const registryEntries = Array.from(this.agentRegistry.values());
-    for (const entry of registryEntries) {
-      if (this.matchesInstanceCriteria(entry.agent, criteria)) {
-        agents.push(entry.agent);
-      }
-    }
-    return agents;
-  }
-  /**
-   * Check if cloud agent matches criteria
-   *
-   * @param agent - Cloud agent
-   * @param criteria - Filter criteria
-   * @returns Whether agent matches
-   */
-  matchesCriteria(agent, criteria) {
-    if (criteria.capabilities && criteria.capabilities.length > 0) {
-      const hasAllCapabilities = criteria.capabilities.every((cap) => {
-        const capName = typeof cap === "string" ? cap : cap.name;
-        return agent.definition.capabilities.includes(capName);
-      });
-      if (!hasAllCapabilities) {
-        return false;
-      }
-    }
-    if (criteria.agentType) {
-      const pattern = new RegExp(criteria.agentType.replace(/\*/g, ".*"));
-      if (!pattern.test(agent.id)) {
-        return false;
-      }
-    }
-    if (criteria.hasTool) {
-      const hasTool = agent.definition.tools.includes(criteria.hasTool);
-      if (!hasTool) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Check if agent instance matches criteria
-   *
-   * @param agent - Agent instance
-   * @param criteria - Filter criteria
-   * @returns Whether agent matches
-   */
-  matchesInstanceCriteria(agent, criteria) {
-    if (criteria.agentRole && agent.role !== criteria.agentRole) {
-      return false;
-    }
-    if (criteria.minSuccessRate !== void 0) {
-      if (agent.metrics.successRate < criteria.minSuccessRate) {
-        return false;
-      }
-    }
-    if (criteria.maxCurrentLoad !== void 0) {
-      const load = agent.status === "busy" ? 1 : 0;
-      if (load > criteria.maxCurrentLoad) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Clear expired cached agents
-   *
-   * @returns Number of agents cleared
-   */
-  clearExpiredCache() {
-    const now = /* @__PURE__ */ new Date();
-    let cleared = 0;
-    const registryEntries = Array.from(this.agentRegistry.entries());
-    for (const [key, entry] of registryEntries) {
-      if (entry.expiresAt && entry.expiresAt < now) {
-        this.agentRegistry.delete(key);
-        cleared++;
-      }
-    }
-    if (this.options.verbose && cleared > 0) {
-      console.log(`[AgentDispatcher] Cleared ${cleared} expired cached agents`);
-    }
-    return cleared;
-  }
-  /**
-   * Get dispatcher statistics
-   *
-   * @returns Statistics
-   */
-  getStats() {
-    return {
-      registeredCloudAgents: this.cloudAgents.size,
-      cachedAgents: this.agentRegistry.size,
-      activeExecutions: this.activeExecutions.size,
-      totalExecutions: 0
-      // Would need tracking
-    };
-  }
-  /**
-   * Clean up resources
-   */
-  cleanup() {
-    this.agentRegistry.clear();
-    this.cloudAgents.clear();
-    this.activeExecutions.clear();
-  }
-}
-
-const DEFAULT_FORK_OPTIONS = {
-  defaultTimeout: 3e5,
-  // 5 minutes
-  maxConcurrentForks: 10,
-  enableTranscriptSaving: true,
-  transcriptDir: process.env.HOME ? resolve(process.env.HOME, ".claude", "fork-transcripts") : resolve(".claude", "fork-transcripts"),
-  enableHooks: true,
-  defaultHookTimeout: 30,
-  verbose: false
-};
-const SESSION_ID_ENV_VAR = "CLAUDE_SESSION_ID";
-function generateSessionId() {
-  return `ccjk-fork-${Date.now()}-${nanoid(8)}`;
-}
-function parseSkillForkConfig(skill) {
-  const config = {
-    skill
-  };
-  const metadata = skill.metadata;
-  if (metadata.context) {
-    config.mode = metadata.context;
-  }
-  if (metadata.agent) {
-    config.agentType = metadata.agent;
-  }
-  if (metadata.allowed_tools) {
-    config.allowedTools = metadata.allowed_tools;
-  }
-  if (metadata.hooks) {
-    config.hooks = metadata.hooks.map((h) => ({
-      type: h.type,
-      matcher: h.matcher,
-      command: h.command,
-      script: h.script,
-      timeout: h.timeout,
-      enabled: true
-    }));
-  }
-  if (metadata.timeout) {
-    config.timeout = metadata.timeout * 1e3;
-  }
-  return config;
-}
-class AgentForkManager {
-  options;
-  forks = /* @__PURE__ */ new Map();
-  listeners = /* @__PURE__ */ new Map();
-  activeForksCount = 0;
-  constructor(options = {}) {
-    this.options = { ...DEFAULT_FORK_OPTIONS, ...options };
-  }
-  /**
-   * Create a new fork context from a skill
-   *
-   * @param skill - Parsed SKILL.md file
-   * @param overrides - Optional configuration overrides
-   * @returns Fork context state
-   */
-  createFork(skill, overrides = {}) {
-    const skillConfig = parseSkillForkConfig(skill);
-    const config = {
-      id: overrides.id || nanoid(),
-      sessionId: overrides.sessionId || generateSessionId(),
-      workingDirectory: overrides.workingDirectory || skillConfig.workingDirectory || process.cwd(),
-      env: overrides.env || skillConfig.env || { ...process.env },
-      mode: overrides.mode || skillConfig.mode || "fork",
-      // Optional fields
-      ...overrides.parentId && { parentId: overrides.parentId },
-      ...skillConfig.agentType && { agentType: skillConfig.agentType },
-      ...skillConfig.agentRole && { agentRole: skillConfig.agentRole },
-      ...skillConfig.disallowedTools && { disallowedTools: skillConfig.disallowedTools },
-      ...skillConfig.allowedTools && { allowedTools: skillConfig.allowedTools },
-      ...skillConfig.timeout && { timeout: skillConfig.timeout },
-      ...skillConfig.hooks && { hooks: skillConfig.hooks },
-      ...overrides.verbose !== void 0 && { verbose: overrides.verbose },
-      ...skillConfig.metadata && { metadata: skillConfig.metadata },
-      ...overrides.metadata && { metadata: overrides.metadata }
-    };
-    config.env[SESSION_ID_ENV_VAR] = config.sessionId;
-    this.checkConcurrentLimit();
-    const fork = {
-      id: config.id,
-      status: "pending",
-      transcript: [],
-      startedAt: /* @__PURE__ */ new Date(),
-      children: []
-    };
-    this.forks.set(config.id, fork);
-    if (this.options.verbose) {
-      console.log(`[AgentForkManager] Created fork: ${config.id} (session: ${config.sessionId})`);
-    }
-    this.emit("created", fork);
-    return fork;
-  }
-  /**
-   * Execute a fork context
-   *
-   * @param forkId - Fork context ID
-   * @param task - Task to execute
-   * @param executeFn - Execution function
-   * @returns Execution result
-   */
-  async executeFork(forkId, task, executeFn) {
-    const fork = this.getForkOrThrow(forkId);
-    this.changeStatus(forkId, "running");
-    fork.task = task;
-    this.addTranscript(forkId, {
-      timestamp: /* @__PURE__ */ new Date(),
-      type: "system",
-      content: `Starting fork execution: ${task.name}`,
-      metadata: { taskId: task.id }
-    });
-    const startTime = Date.now();
-    const config = this.buildForkConfig(forkId);
-    try {
-      const timeout = config.timeout ?? this.options.defaultTimeout;
-      const result = await this.executeWithTimeout(
-        () => this.executeWithHooks(forkId, task, executeFn),
-        timeout
-      );
-      fork.endedAt = /* @__PURE__ */ new Date();
-      fork.result = {
-        success: true,
-        durationMs: Date.now() - startTime,
-        transcript: fork.transcript,
-        output: result.results
-      };
-      this.changeStatus(forkId, "completed");
-      this.emit("completed", fork, fork.result);
-      if (this.options.enableTranscriptSaving) {
-        this.saveTranscript(forkId);
-      }
-      return fork.result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      fork.endedAt = /* @__PURE__ */ new Date();
-      fork.error = errorMessage;
-      fork.result = {
-        success: false,
-        durationMs: Date.now() - startTime,
-        transcript: fork.transcript,
-        error: errorMessage
-      };
-      this.changeStatus(forkId, "failed");
-      this.emit("failed", fork, errorMessage);
-      if (this.options.enableTranscriptSaving) {
-        this.saveTranscript(forkId);
-      }
-      return fork.result;
-    }
-  }
-  /**
-   * Execute fork with hooks
-   *
-   * @param forkId - Fork context ID
-   * @param task - Task to execute
-   * @param executeFn - Execution function
-   * @returns Execution result
-   */
-  async executeWithHooks(forkId, task, executeFn) {
-    const config = this.buildForkConfig(forkId);
-    if (this.options.enableHooks && config.hooks) {
-      for (const hook of config.hooks) {
-        if (hook.type === "PreToolUse" && this.shouldExecuteHook(hook, "start")) {
-          await this.executeHook(forkId, hook, "start");
-        }
-      }
-    }
-    const result = await executeFn(config);
-    if (this.options.enableHooks && config.hooks) {
-      for (const hook of config.hooks) {
-        if (hook.type === "PostToolUse" && this.shouldExecuteHook(hook, "complete")) {
-          await this.executeHook(forkId, hook, "complete");
-        }
-      }
-    }
-    return result;
-  }
-  /**
-   * Execute a single hook
-   *
-   * @param forkId - Fork context ID
-   * @param hook - Hook to execute
-   * @param trigger - Trigger event
-   */
-  async executeHook(forkId, hook, trigger) {
-    if (hook.enabled === false) {
-      return;
-    }
-    this.getForkOrThrow(forkId);
-    const timeout = (hook.timeout ?? this.options.defaultHookTimeout) * 1e3;
-    this.addTranscript(forkId, {
-      timestamp: /* @__PURE__ */ new Date(),
-      type: "hook",
-      content: `Executing ${hook.type} hook`,
-      hookType: hook.type,
-      metadata: { trigger, matcher: hook.matcher }
-    });
-    try {
-      await this.executeWithTimeout(async () => {
-        if (hook.command) {
-          const { exec } = await import('./main.mjs');
-          const execOptions = { env: this.buildForkConfig(forkId).env };
-          await exec("sh", ["-c", hook.command], execOptions);
-        } else if (hook.script) {
-          const { exec } = await import('./main.mjs');
-          const execOptions = { env: this.buildForkConfig(forkId).env };
-          await exec("node", ["-e", hook.script], execOptions);
-        }
-      }, timeout);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.addTranscript(forkId, {
-        timestamp: /* @__PURE__ */ new Date(),
-        type: "error",
-        content: `Hook execution failed: ${message}`,
-        hookType: hook.type
-      });
-    }
-  }
-  /**
-   * Check if a hook should be executed
-   *
-   * @param hook - Hook definition
-   * @param trigger - Trigger event
-   * @returns Whether to execute
-   */
-  shouldExecuteHook(hook, trigger) {
-    if (!hook.matcher) {
-      return true;
-    }
-    const pattern = hook.matcher.replace(/\*/g, ".*");
-    const regex = new RegExp(pattern);
-    return regex.test(trigger);
-  }
-  /**
-   * Execute with timeout
-   *
-   * @param fn - Function to execute
-   * @param timeout - Timeout in milliseconds
-   * @returns Function result
-   */
-  async executeWithTimeout(fn, timeout) {
-    return Promise.race([
-      fn(),
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout)
-      )
-    ]);
-  }
-  /**
-   * Build fork configuration from state
-   *
-   * @param forkId - Fork context ID
-   * @returns Fork configuration
-   */
-  buildForkConfig(forkId) {
-    this.getForkOrThrow(forkId);
-    const skill = this.findSkillForFork(forkId);
-    return {
-      id: forkId,
-      sessionId: this.getSessionIdForFork(forkId),
-      skill,
-      workingDirectory: process.cwd(),
-      env: { ...process.env, [SESSION_ID_ENV_VAR]: this.getSessionIdForFork(forkId) },
-      mode: "fork"
-    };
-  }
-  /**
-   * Find the skill for a fork (placeholder implementation)
-   *
-   * @param forkId - Fork context ID
-   * @returns Skill file
-   */
-  findSkillForFork(_forkId) {
-    return {
-      metadata: {
-        name: "unknown",
-        description: "Unknown skill",
-        version: "1.0.0",
-        category: "custom",
-        triggers: [],
-        use_when: []
-      },
-      content: "",
-      filePath: ""
-    };
-  }
-  /**
-   * Get the session ID for a fork
-   *
-   * @param forkId - Fork context ID
-   * @returns Session ID
-   */
-  getSessionIdForFork(_forkId) {
-    return generateSessionId();
-  }
-  /**
-   * Add a transcript entry to a fork
-   *
-   * @param forkId - Fork context ID
-   * @param entry - Transcript entry
-   */
-  addTranscript(forkId, entry) {
-    const fork = this.getForkOrThrow(forkId);
-    const fullEntry = {
-      ...entry,
-      timestamp: entry.timestamp || /* @__PURE__ */ new Date()
-    };
-    fork.transcript.push(fullEntry);
-    if (this.options.verbose) {
-      console.log(`[AgentForkManager] Transcript [${forkId}] ${fullEntry.type}: ${fullEntry.content.substring(0, 100)}`);
-    }
-    this.emit("transcript", fork, fullEntry);
-  }
-  /**
-   * Save fork transcript to file
-   *
-   * @param forkId - Fork context ID
-   * @returns Saved file path
-   */
-  saveTranscript(forkId) {
-    const fork = this.getForkOrThrow(forkId);
-    const fs = require("node:fs/promises");
-    const { join } = require("pathe");
-    const filename = `fork-${fork.id}-${Date.now()}.json`;
-    const filePath = join(this.options.transcriptDir, filename);
-    fs.mkdir(this.options.transcriptDir, { recursive: true }).then(() => fs.writeFile(filePath, JSON.stringify({
-      forkId: fork.id,
-      status: fork.status,
-      transcript: fork.transcript,
-      startedAt: fork.startedAt,
-      endedAt: fork.endedAt,
-      result: fork.result
-    }, null, 2))).catch(console.error);
-    return filePath;
-  }
-  /**
-   * Get a fork context by ID
-   *
-   * @param forkId - Fork context ID
-   * @returns Fork state or null
-   */
-  getFork(forkId) {
-    return this.forks.get(forkId) || null;
-  }
-  /**
-   * Cancel a running fork
-   *
-   * @param forkId - Fork context ID
-   */
-  cancel(forkId) {
-    const fork = this.getForkOrThrow(forkId);
-    if (fork.status === "completed" || fork.status === "failed") {
-      throw new Error(`Cannot cancel fork ${forkId} with status: ${fork.status}`);
-    }
-    fork.endedAt = /* @__PURE__ */ new Date();
-    this.changeStatus(forkId, "cancelled");
-    if (this.options.verbose) {
-      console.log(`[AgentForkManager] Cancelled fork: ${forkId}`);
-    }
-    this.emit("cancelled", fork);
-  }
-  /**
-   * Remove a fork context
-   *
-   * @param forkId - Fork context ID
-   * @returns True if removed
-   */
-  remove(forkId) {
-    const fork = this.forks.get(forkId);
-    if (!fork) {
-      return false;
-    }
-    this.forks.delete(forkId);
-    this.activeForksCount--;
-    if (this.options.verbose) {
-      console.log(`[AgentForkManager] Removed fork: ${forkId}`);
-    }
-    return true;
-  }
-  /**
-   * Clear finished forks
-   *
-   * @returns Number cleared
-   */
-  clearFinished() {
-    const toRemove = Array.from(this.forks.values()).filter(
-      (f) => ["completed", "failed", "cancelled", "timeout"].includes(f.status)
-    );
-    toRemove.forEach((f) => this.remove(f.id));
-    if (this.options.verbose) {
-      console.log(`[AgentForkManager] Cleared ${toRemove.length} finished forks`);
-    }
-    return toRemove.length;
-  }
-  /**
-   * Get all forks
-   *
-   * @returns Array of fork states
-   */
-  listAll() {
-    return Array.from(this.forks.values());
-  }
-  /**
-   * Get active forks
-   *
-   * @returns Array of active fork states
-   */
-  listActive() {
-    return Array.from(this.forks.values()).filter(
-      (f) => f.status === "running" || f.status === "pending"
-    );
-  }
-  /**
-   * Get fork statistics
-   *
-   * @returns Statistics
-   */
-  getStats() {
-    const forks = Array.from(this.forks.values());
-    return {
-      total: forks.length,
-      pending: forks.filter((f) => f.status === "pending").length,
-      running: forks.filter((f) => f.status === "running").length,
-      completed: forks.filter((f) => f.status === "completed").length,
-      failed: forks.filter((f) => f.status === "failed").length,
-      timeout: forks.filter((f) => f.status === "timeout").length,
-      cancelled: forks.filter((f) => f.status === "cancelled").length,
-      active: forks.filter((f) => f.status === "running" || f.status === "pending").length
-    };
-  }
-  /**
-   * Register event listener
-   *
-   * @param event - Event name
-   * @param listener - Event listener
-   */
-  on(event, listener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(event).add(listener);
-  }
-  /**
-   * Unregister event listener
-   *
-   * @param event - Event name
-   * @param listener - Event listener
-   */
-  off(event, listener) {
-    const set = this.listeners.get(event);
-    if (set) {
-      set.delete(listener);
-    }
-  }
-  /**
-   * Emit event
-   *
-   * @param event - Event name
-   * @param args - Event arguments
-   */
-  emit(event, ...args) {
-    const set = this.listeners.get(event);
-    if (set) {
-      const listenersArray = Array.from(set);
-      for (const listener of listenersArray) {
-        try {
-          listener(...args);
-        } catch (error) {
-          console.error(`[AgentForkManager] Error in ${event} listener:`, error);
-        }
-      }
-    }
-  }
-  /**
-   * Change fork status and emit event
-   *
-   * @param forkId - Fork context ID
-   * @param newStatus - New status
-   */
-  changeStatus(forkId, newStatus) {
-    const fork = this.getForkOrThrow(forkId);
-    const oldStatus = fork.status;
-    fork.status = newStatus;
-    if (oldStatus === "pending" && newStatus === "running") {
-      this.activeForksCount++;
-    } else if (oldStatus === "running" && ["completed", "failed", "cancelled", "timeout"].includes(newStatus)) {
-      this.activeForksCount--;
-    }
-    this.emit("statusChange", fork, oldStatus, newStatus);
-  }
-  /**
-   * Check concurrent limit
-   *
-   * @throws Error if limit reached
-   */
-  checkConcurrentLimit() {
-    if (this.activeForksCount >= this.options.maxConcurrentForks) {
-      throw new Error(
-        `Maximum concurrent forks limit reached (${this.options.maxConcurrentForks}). Active: ${this.activeForksCount}`
-      );
-    }
-  }
-  /**
-   * Get fork or throw error
-   *
-   * @param forkId - Fork context ID
-   * @returns Fork state
-   * @throws Error if not found
-   */
-  getForkOrThrow(forkId) {
-    const fork = this.forks.get(forkId);
-    if (!fork) {
-      throw new Error(`Fork not found: ${forkId}`);
-    }
-    return fork;
-  }
-  /**
-   * Clean up all forks
-   */
-  cleanup() {
-    this.forks.clear();
-    this.listeners.clear();
-    this.activeForksCount = 0;
-  }
-}
-
-class ResultAggregator {
-  options;
-  validator;
-  constructor(options = {}) {
-    this.options = {
-      defaultStrategy: options.defaultStrategy ?? "highest-confidence",
-      autoDetectConflicts: options.autoDetectConflicts ?? true,
-      enableValidation: options.enableValidation ?? true,
-      minConfidenceThreshold: options.minConfidenceThreshold ?? 0.7,
-      enableMerging: options.enableMerging ?? true,
-      maxMergeAttempts: options.maxMergeAttempts ?? 3
-    };
-    this.validator = this.createValidator();
-  }
-  /**
-   * Aggregate results from multiple tasks
-   *
-   * @param tasks - Tasks with outputs to aggregate
-   * @param context - Aggregation context
-   * @returns Aggregation result
-   */
-  async aggregate(tasks, context) {
-    const aggregationContext = {
-      tasks,
-      strategy: context?.strategy ?? this.options.defaultStrategy,
-      expectedSchema: context?.expectedSchema,
-      metadata: context?.metadata
-    };
-    const tasksWithOutputs = tasks.filter((t) => t.output !== void 0);
-    if (tasksWithOutputs.length === 0) {
-      return this.createEmptyResult(tasks);
-    }
-    const validationErrors = [];
-    if (this.options.enableValidation) {
-      for (const task of tasksWithOutputs) {
-        const validation = this.validator.validate(task.output, aggregationContext.expectedSchema);
-        if (!validation.valid) {
-          validationErrors.push(
-            ...validation.errors.map((err) => ({
-              taskId: task.id,
-              field: err.field,
-              message: err.message
-            }))
-          );
-        }
-      }
-    }
-    const conflicts = [];
-    if (this.options.autoDetectConflicts) {
-      conflicts.push(...this.detectConflicts(tasksWithOutputs));
-    }
-    const resolvedConflicts = [];
-    const unresolvedConflicts = [];
-    for (const conflict of conflicts) {
-      const resolution = await this.resolveConflict(conflict);
-      if (resolution.resolved) {
-        resolvedConflicts.push(resolution);
-      } else {
-        unresolvedConflicts.push(conflict);
-      }
-    }
-    const aggregatedOutput = await this.aggregateOutputs(
-      tasksWithOutputs,
-      aggregationContext,
-      resolvedConflicts
-    );
-    const successfulTasks = tasksWithOutputs.filter((t) => t.status === "completed");
-    const failedTasks = tasks.filter((t) => t.status === "failed");
-    const averageConfidence = this.calculateAverageConfidence(tasksWithOutputs);
-    const warnings = [];
-    if (averageConfidence < this.options.minConfidenceThreshold) {
-      warnings.push(`Average confidence ${averageConfidence.toFixed(2)} is below threshold ${this.options.minConfidenceThreshold}`);
-    }
-    if (unresolvedConflicts.length > 0) {
-      warnings.push(`${unresolvedConflicts.length} conflicts remain unresolved`);
-    }
-    return {
-      success: unresolvedConflicts.length === 0 && validationErrors.length === 0,
-      output: aggregatedOutput,
-      conflicts,
-      resolvedConflicts,
-      unresolvedConflicts,
-      validationErrors,
-      warnings,
-      metadata: {
-        totalTasks: tasks.length,
-        successfulTasks: successfulTasks.length,
-        failedTasks: failedTasks.length,
-        averageConfidence,
-        aggregationTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }
-  /**
-   * Detect conflicts between task outputs
-   *
-   * @param tasks - Tasks to check for conflicts
-   * @returns Detected conflicts
-   */
-  detectConflicts(tasks) {
-    const conflicts = [];
-    const tasksByType = this.groupTasksByType(tasks);
-    for (const [_type, typeTasks] of tasksByType) {
-      if (typeTasks.length < 2)
-        continue;
-      const dataConflicts = this.detectDataConflicts(typeTasks);
-      conflicts.push(...dataConflicts);
-      const fileConflicts = this.detectFileConflicts(typeTasks);
-      conflicts.push(...fileConflicts);
-      const decisionConflicts = this.detectDecisionConflicts(typeTasks);
-      conflicts.push(...decisionConflicts);
-    }
-    return conflicts;
-  }
-  /**
-   * Detect data conflicts between tasks
-   *
-   * @param tasks - Tasks to check
-   * @returns Data conflicts
-   */
-  detectDataConflicts(tasks) {
-    const conflicts = [];
-    const dataFields = this.extractDataFields(tasks);
-    for (const field of dataFields) {
-      const values = tasks.map((t) => ({ taskId: t.id, value: this.getFieldValue(t.output, field) })).filter((v) => v.value !== void 0);
-      if (values.length < 2)
-        continue;
-      const uniqueValues = new Set(values.map((v) => JSON.stringify(v.value)));
-      if (uniqueValues.size > 1) {
-        conflicts.push({
-          conflictingTasks: values.map((v) => v.taskId),
-          results: tasks.map((t) => t.output),
-          strategy: this.options.defaultStrategy,
-          conflictType: "data",
-          description: `Conflicting values for field "${field}"`,
-          metadata: {
-            field,
-            values: values.map((v) => v.value)
-          }
-        });
-      }
-    }
-    return conflicts;
-  }
-  /**
-   * Detect file conflicts between tasks
-   *
-   * @param tasks - Tasks to check
-   * @returns File conflicts
-   */
-  detectFileConflicts(tasks) {
-    const conflicts = [];
-    const filesByPath = /* @__PURE__ */ new Map();
-    for (const task of tasks) {
-      if (!task.output?.files)
-        continue;
-      for (const file of task.output.files) {
-        if (!filesByPath.has(file)) {
-          filesByPath.set(file, []);
-        }
-        filesByPath.get(file).push({ taskId: task.id, file });
-      }
-    }
-    for (const [path, files] of filesByPath) {
-      if (files.length > 1) {
-        conflicts.push({
-          conflictingTasks: files.map((f) => f.taskId),
-          results: tasks.filter((t) => files.some((f) => f.taskId === t.id)).map((t) => t.output),
-          strategy: this.options.defaultStrategy,
-          conflictType: "file",
-          description: `Multiple tasks produced file "${path}"`,
-          metadata: {
-            filePath: path,
-            taskCount: files.length
-          }
-        });
-      }
-    }
-    return conflicts;
-  }
-  /**
-   * Detect decision conflicts between tasks
-   *
-   * @param tasks - Tasks to check
-   * @returns Decision conflicts
-   */
-  detectDecisionConflicts(tasks) {
-    const conflicts = [];
-    const decisions = tasks.map((t) => ({
-      taskId: t.id,
-      decision: t.output?.metadata?.decision
-    })).filter((d) => d.decision !== void 0);
-    if (decisions.length < 2)
-      return conflicts;
-    const uniqueDecisions = new Set(decisions.map((d) => d.decision));
-    if (uniqueDecisions.size > 1) {
-      conflicts.push({
-        conflictingTasks: decisions.map((d) => d.taskId),
-        results: tasks.map((t) => t.output),
-        strategy: this.options.defaultStrategy,
-        conflictType: "decision",
-        description: "Tasks made conflicting decisions",
-        metadata: {
-          decisions: decisions.map((d) => d.decision)
-        }
-      });
-    }
-    return conflicts;
-  }
-  /**
-   * Resolve a conflict using the specified strategy
-   *
-   * @param conflict - Conflict to resolve
-   * @returns Resolution result
-   */
-  async resolveConflict(conflict) {
-    switch (conflict.strategy) {
-      case "first-wins":
-        return this.resolveFirstWins(conflict);
-      case "last-wins":
-        return this.resolveLastWins(conflict);
-      case "vote":
-        return this.resolveByVote(conflict);
-      case "merge":
-        return this.resolveByMerge(conflict);
-      case "highest-confidence":
-        return this.resolveByConfidence(conflict);
-      case "manual":
-        return this.resolveManually(conflict);
-      default:
-        return {
-          resolved: false,
-          method: "unknown",
-          confidence: 0,
-          explanation: `Unknown resolution strategy: ${conflict.strategy}`
-        };
-    }
-  }
-  /**
-   * Resolve conflict using first-wins strategy
-   *
-   * @param conflict - Conflict to resolve
-   * @returns Resolution result
-   */
-  resolveFirstWins(conflict) {
-    return {
-      resolved: true,
-      result: conflict.results[0],
-      method: "first-wins",
-      confidence: 0.5,
-      explanation: "Used first completed result",
-      discarded: conflict.results.slice(1)
-    };
-  }
-  /**
-   * Resolve conflict using last-wins strategy
-   *
-   * @param conflict - Conflict to resolve
-   * @returns Resolution result
-   */
-  resolveLastWins(conflict) {
-    const lastResult = conflict.results[conflict.results.length - 1];
-    return {
-      resolved: true,
-      result: lastResult,
-      method: "last-wins",
-      confidence: 0.5,
-      explanation: "Used last completed result",
-      discarded: conflict.results.slice(0, -1)
-    };
-  }
-  /**
-   * Resolve conflict using voting strategy
-   *
-   * @param conflict - Conflict to resolve
-   * @returns Resolution result
-   */
-  resolveByVote(conflict) {
-    const resultCounts = /* @__PURE__ */ new Map();
-    for (const result of conflict.results) {
-      const key = JSON.stringify(result.data);
-      const existing = resultCounts.get(key);
-      if (existing) {
-        existing.count++;
-      } else {
-        resultCounts.set(key, { count: 1, result });
-      }
-    }
-    let maxCount = 0;
-    let winningResult;
-    for (const [_, { count, result }] of resultCounts) {
-      if (count > maxCount) {
-        maxCount = count;
-        winningResult = result;
-      }
-    }
-    const confidence = maxCount / conflict.results.length;
-    return {
-      resolved: winningResult !== void 0,
-      result: winningResult,
-      method: "vote",
-      confidence,
-      explanation: `Result won with ${maxCount}/${conflict.results.length} votes`,
-      discarded: conflict.results.filter((r) => r !== winningResult)
-    };
-  }
-  /**
-   * Resolve conflict by merging results
-   *
-   * @param conflict - Conflict to resolve
-   * @returns Resolution result
-   */
-  async resolveByMerge(conflict) {
-    if (!this.options.enableMerging) {
-      return {
-        resolved: false,
-        method: "merge",
-        confidence: 0,
-        explanation: "Merging is disabled"
-      };
-    }
-    try {
-      const mergedResult = await this.mergeResults(conflict.results, conflict.conflictType);
-      return {
-        resolved: true,
-        result: mergedResult,
-        method: "merge",
-        confidence: 0.8,
-        explanation: "Successfully merged conflicting results"
-      };
-    } catch (error) {
-      return {
-        resolved: false,
-        method: "merge",
-        confidence: 0,
-        explanation: `Merge failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      };
-    }
-  }
-  /**
-   * Resolve conflict using highest confidence strategy
-   *
-   * @param conflict - Conflict to resolve
-   * @returns Resolution result
-   */
-  resolveByConfidence(conflict) {
-    let maxConfidence = 0;
-    let bestResult;
-    for (const result of conflict.results) {
-      const confidence = result.confidence ?? 0;
-      if (confidence > maxConfidence) {
-        maxConfidence = confidence;
-        bestResult = result;
-      }
-    }
-    return {
-      resolved: bestResult !== void 0,
-      result: bestResult,
-      method: "highest-confidence",
-      confidence: maxConfidence,
-      explanation: `Selected result with confidence ${maxConfidence.toFixed(2)}`,
-      discarded: conflict.results.filter((r) => r !== bestResult)
-    };
-  }
-  /**
-   * Resolve conflict manually (placeholder for user intervention)
-   *
-   * @param _conflict - Conflict to resolve
-   * @returns Resolution result
-   */
-  resolveManually(_conflict) {
-    return {
-      resolved: false,
-      method: "manual",
-      confidence: 0,
-      explanation: "Manual resolution required"
-    };
-  }
-  /**
-   * Merge multiple results into a single result
-   *
-   * @param results - Results to merge
-   * @returns Merged result
-   */
-  async mergeResults(results, _conflictType) {
-    const mergedData = {};
-    const mergedFiles = [];
-    const mergedArtifacts = [];
-    const mergedLogs = [];
-    for (const result of results) {
-      for (const [key, value] of Object.entries(result.data)) {
-        if (!(key in mergedData)) {
-          mergedData[key] = value;
-        } else if (Array.isArray(mergedData[key]) && Array.isArray(value)) {
-          mergedData[key] = [...mergedData[key], ...value];
-        } else if (typeof mergedData[key] === "object" && typeof value === "object") {
-          mergedData[key] = { ...mergedData[key], ...value };
-        }
-      }
-      if (result.files) {
-        for (const file of result.files) {
-          if (!mergedFiles.includes(file)) {
-            mergedFiles.push(file);
-          }
-        }
-      }
-      if (result.artifacts) {
-        mergedArtifacts.push(...result.artifacts);
-      }
-      if (result.logs) {
-        mergedLogs.push(...result.logs);
-      }
-    }
-    const confidences = results.map((r) => r.confidence ?? 0).filter((c) => c > 0);
-    const avgConfidence = confidences.length > 0 ? confidences.reduce((sum, c) => sum + c, 0) / confidences.length : void 0;
-    return {
-      data: mergedData,
-      files: mergedFiles.length > 0 ? mergedFiles : void 0,
-      artifacts: mergedArtifacts.length > 0 ? mergedArtifacts : void 0,
-      logs: mergedLogs.length > 0 ? mergedLogs : void 0,
-      confidence: avgConfidence,
-      metadata: {
-        merged: true,
-        sourceCount: results.length,
-        mergeTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }
-  /**
-   * Aggregate outputs from multiple tasks
-   *
-   * @param tasks - Tasks with outputs
-   * @param context - Aggregation context
-   * @param resolvedConflicts - Resolved conflicts
-   * @returns Aggregated output
-   */
-  async aggregateOutputs(tasks, context, resolvedConflicts) {
-    const aggregated = {
-      data: {},
-      files: [],
-      artifacts: [],
-      logs: []
-    };
-    for (const resolution of resolvedConflicts) {
-      if (resolution.result) {
-        this.mergeIntoAggregated(aggregated, resolution.result);
-      }
-    }
-    for (const task of tasks) {
-      if (!task.output)
-        continue;
-      const taskOutput = task.output;
-      const wasInConflict = resolvedConflicts.some(
-        (r) => r.discarded?.includes(taskOutput)
-      );
-      if (!wasInConflict) {
-        this.mergeIntoAggregated(aggregated, taskOutput);
-      }
-    }
-    const confidences = tasks.map((t) => t.output?.confidence ?? 0).filter((c) => c > 0);
-    aggregated.confidence = confidences.length > 0 ? confidences.reduce((sum, c) => sum + c, 0) / confidences.length : void 0;
-    aggregated.metadata = {
-      ...aggregated.metadata,
-      aggregated: true,
-      taskCount: tasks.length,
-      aggregationStrategy: context.strategy,
-      aggregationTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    return aggregated;
-  }
-  /**
-   * Merge an output into the aggregated result
-   *
-   * @param aggregated - Aggregated output
-   * @param output - Output to merge
-   */
-  mergeIntoAggregated(aggregated, output) {
-    Object.assign(aggregated.data, output.data);
-    if (output.files) {
-      aggregated.files = [...aggregated.files ?? [], ...output.files];
-    }
-    if (output.artifacts) {
-      aggregated.artifacts = [...aggregated.artifacts ?? [], ...output.artifacts];
-    }
-    if (output.logs) {
-      aggregated.logs = [...aggregated.logs ?? [], ...output.logs];
-    }
-  }
-  /**
-   * Create empty aggregation result
-   *
-   * @param tasks - Tasks
-   * @returns Empty result
-   */
-  createEmptyResult(tasks) {
-    return {
-      success: false,
-      conflicts: [],
-      resolvedConflicts: [],
-      unresolvedConflicts: [],
-      validationErrors: [],
-      warnings: ["No task outputs to aggregate"],
-      metadata: {
-        totalTasks: tasks.length,
-        successfulTasks: 0,
-        failedTasks: tasks.filter((t) => t.status === "failed").length,
-        averageConfidence: 0,
-        aggregationTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }
-  /**
-   * Group tasks by type
-   *
-   * @param tasks - Tasks to group
-   * @returns Tasks grouped by type
-   */
-  groupTasksByType(tasks) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const task of tasks) {
-      if (!groups.has(task.type)) {
-        groups.set(task.type, []);
-      }
-      groups.get(task.type).push(task);
-    }
-    return groups;
-  }
-  /**
-   * Extract data fields from tasks
-   *
-   * @param tasks - Tasks to analyze
-   * @returns Data field names
-   */
-  extractDataFields(tasks) {
-    const fields = /* @__PURE__ */ new Set();
-    for (const task of tasks) {
-      if (!task.output)
-        continue;
-      for (const key of Object.keys(task.output.data)) {
-        fields.add(key);
-      }
-    }
-    return Array.from(fields);
-  }
-  /**
-   * Get field value from output
-   *
-   * @param output - Task output
-   * @param field - Field name
-   * @returns Field value
-   */
-  getFieldValue(output, field) {
-    return output.data[field];
-  }
-  /**
-   * Calculate average confidence from tasks
-   *
-   * @param tasks - Tasks with outputs
-   * @returns Average confidence
-   */
-  calculateAverageConfidence(tasks) {
-    const confidences = tasks.map((t) => t.output?.confidence ?? 0).filter((c) => c > 0);
-    if (confidences.length === 0)
-      return 0;
-    return confidences.reduce((sum, c) => sum + c, 0) / confidences.length;
-  }
-  /**
-   * Create result validator
-   *
-   * @returns Result validator
-   */
-  createValidator() {
-    return {
-      validate: (output, schema) => {
-        const errors = [];
-        const warnings = [];
-        if (!output.data || Object.keys(output.data).length === 0) {
-          errors.push({
-            field: "data",
-            message: "Output data is empty",
-            code: "EMPTY_DATA"
-          });
-        }
-        if (schema) {
-          for (const [field, _type] of Object.entries(schema)) {
-            if (!(field in output.data)) {
-              errors.push({
-                field,
-                message: `Required field "${field}" is missing`,
-                code: "MISSING_FIELD"
-              });
-            }
-          }
-        }
-        if (output.confidence !== void 0 && (output.confidence < 0 || output.confidence > 1)) {
-          warnings.push({
-            field: "confidence",
-            message: "Confidence score should be between 0 and 1",
-            code: "INVALID_CONFIDENCE"
-          });
-        }
-        return {
-          valid: errors.length === 0,
-          errors,
-          warnings
-        };
-      }
-    };
-  }
-}
-
-function toAgentCapabilities$1(names) {
-  return names.map((name) => ({
-    id: name,
-    name,
-    model: "sonnet",
-    specialties: [name],
-    strength: 0.8,
-    costFactor: 1
-  }));
-}
-function fromAgentCapabilities$1(capabilities) {
-  return capabilities.map((cap) => cap.id);
-}
-class TaskDecomposer {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      strategy: options.strategy ?? "hierarchical",
-      maxDepth: options.maxDepth ?? 5,
-      maxParallelTasks: options.maxParallelTasks ?? 10,
-      minTaskGranularity: options.minTaskGranularity ?? 1e3,
-      autoDetectDependencies: options.autoDetectDependencies ?? true,
-      enableOptimization: options.enableOptimization ?? true
-    };
-  }
-  /**
-   * Decompose a complex task into subtasks
-   *
-   * @param task - The task to decompose
-   * @param strategy - Optional strategy override
-   * @returns Decomposition result with subtasks and dependencies
-   */
-  async decompose(task, strategy) {
-    const decompositionStrategy = strategy ?? this.options.strategy;
-    const complexity = this.analyzeComplexity(task);
-    const effectiveStrategy = this.selectStrategy(task, complexity, decompositionStrategy);
-    let subtasks;
-    let dependencies;
-    switch (effectiveStrategy) {
-      case "sequential":
-        ({ subtasks, dependencies } = await this.decomposeSequential(task));
-        break;
-      case "parallel":
-        ({ subtasks, dependencies } = await this.decomposeParallel(task));
-        break;
-      case "hierarchical":
-        ({ subtasks, dependencies } = await this.decomposeHierarchical(task));
-        break;
-      case "pipeline":
-        ({ subtasks, dependencies } = await this.decomposePipeline(task));
-        break;
-      case "map-reduce":
-        ({ subtasks, dependencies } = await this.decomposeMapReduce(task));
-        break;
-      default:
-        throw new Error(`Unknown decomposition strategy: ${effectiveStrategy}`);
-    }
-    if (this.options.autoDetectDependencies) {
-      dependencies = this.detectDependencies(subtasks, dependencies);
-    }
-    const executionGraph = this.buildExecutionGraph(subtasks, dependencies);
-    if (this.options.enableOptimization) {
-      this.optimizeExecutionGraph(executionGraph, subtasks);
-    }
-    const estimatedDuration = this.calculateEstimatedDuration(subtasks, executionGraph);
-    return {
-      originalTask: task,
-      subtasks,
-      dependencies,
-      strategy: effectiveStrategy,
-      executionGraph,
-      estimatedDuration,
-      metadata: {
-        complexity,
-        decompositionTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        subtaskCount: subtasks.length,
-        dependencyCount: dependencies.length
-      }
-    };
-  }
-  /**
-   * Analyze task complexity
-   *
-   * @param task - Task to analyze
-   * @returns Complexity score (0-1)
-   */
-  analyzeComplexity(task) {
-    let complexity = 0;
-    complexity += Math.min(task.requiredCapabilities.length / 10, 0.3);
-    complexity += Math.min(task.description.length / 1e3, 0.2);
-    complexity += Math.min(Object.keys(task.input.parameters).length / 20, 0.2);
-    complexity += Math.min((task.input.constraints?.length ?? 0) / 10, 0.15);
-    if (task.estimatedDuration) {
-      complexity += Math.min(task.estimatedDuration / 3e5, 0.15);
-    }
-    return Math.min(complexity, 1);
-  }
-  /**
-   * Select appropriate decomposition strategy
-   *
-   * @param task - Task to decompose
-   * @param complexity - Task complexity score
-   * @param preferredStrategy - Preferred strategy
-   * @returns Selected strategy
-   */
-  selectStrategy(task, complexity, preferredStrategy) {
-    if (complexity < 0.3) {
-      return "sequential";
-    }
-    if (task.type.includes("data") || task.type.includes("process")) {
-      return task.input.files && task.input.files.length > 1 ? "map-reduce" : "pipeline";
-    }
-    if (task.type.includes("analysis") || task.type.includes("review")) {
-      return "parallel";
-    }
-    return preferredStrategy;
-  }
-  /**
-   * Decompose task sequentially
-   *
-   * @param task - Task to decompose
-   * @returns Subtasks and dependencies
-   */
-  async decomposeSequential(task) {
-    const subtasks = [];
-    const dependencies = [];
-    const steps = this.identifySequentialSteps(task);
-    for (let i = 0; i < steps.length; i++) {
-      const step = steps[i];
-      const subtask = this.createSubtask(task, step, i);
-      subtasks.push(subtask);
-      if (i > 0) {
-        dependencies.push({
-          taskId: subtasks[i - 1].id,
-          type: "sequential",
-          required: true
-        });
-      }
-    }
-    return { subtasks, dependencies };
-  }
-  /**
-   * Decompose task into parallel subtasks
-   *
-   * @param task - Task to decompose
-   * @returns Subtasks and dependencies
-   */
-  async decomposeParallel(task) {
-    const subtasks = [];
-    const dependencies = [];
-    const parallelSteps = this.identifyParallelSteps(task);
-    for (let i = 0; i < parallelSteps.length; i++) {
-      const step = parallelSteps[i];
-      const subtask = this.createSubtask(task, step, i);
-      subtasks.push(subtask);
-    }
-    return { subtasks, dependencies };
-  }
-  /**
-   * Decompose task hierarchically
-   *
-   * @param task - Task to decompose
-   * @returns Subtasks and dependencies
-   */
-  async decomposeHierarchical(task, depth = 0) {
-    const subtasks = [];
-    const dependencies = [];
-    if (depth >= this.options.maxDepth) {
-      return { subtasks: [task], dependencies: [] };
-    }
-    const phases = this.identifyPhases(task);
-    for (let i = 0; i < phases.length; i++) {
-      const phase = phases[i];
-      const phaseTask = this.createSubtask(task, phase, i);
-      const phaseComplexity = this.analyzeComplexity(phaseTask);
-      if (phaseComplexity > 0.5 && depth < this.options.maxDepth - 1) {
-        const { subtasks: phaseSubtasks, dependencies: phaseDeps } = await this.decomposeHierarchical(phaseTask, depth + 1);
-        subtasks.push(...phaseSubtasks);
-        dependencies.push(...phaseDeps);
-      } else {
-        subtasks.push(phaseTask);
-      }
-      if (i > 0 && subtasks.length > 1) {
-        dependencies.push({
-          taskId: subtasks[subtasks.length - 2].id,
-          type: "sequential",
-          required: true
-        });
-      }
-    }
-    return { subtasks, dependencies };
-  }
-  /**
-   * Decompose task as a pipeline
-   *
-   * @param task - Task to decompose
-   * @returns Subtasks and dependencies
-   */
-  async decomposePipeline(task) {
-    const subtasks = [];
-    const dependencies = [];
-    const stages = this.identifyPipelineStages(task);
-    for (let i = 0; i < stages.length; i++) {
-      const stage = stages[i];
-      const subtask = this.createSubtask(task, stage, i);
-      subtasks.push(subtask);
-      if (i > 0) {
-        dependencies.push({
-          taskId: subtasks[i - 1].id,
-          type: "data",
-          required: true,
-          dataMapping: {
-            output: "input"
-          }
-        });
-      }
-    }
-    return { subtasks, dependencies };
-  }
-  /**
-   * Decompose task using map-reduce pattern
-   *
-   * @param task - Task to decompose
-   * @returns Subtasks and dependencies
-   */
-  async decomposeMapReduce(task) {
-    const subtasks = [];
-    const dependencies = [];
-    const mapTasks = this.createMapTasks(task);
-    subtasks.push(...mapTasks);
-    const reduceTask = this.createReduceTask(task, mapTasks.length);
-    subtasks.push(reduceTask);
-    for (const mapTask of mapTasks) {
-      dependencies.push({
-        taskId: mapTask.id,
-        type: "data",
-        required: true,
-        dataMapping: {
-          output: "input"
-        }
-      });
-    }
-    return { subtasks, dependencies };
-  }
-  /**
-   * Identify sequential steps in a task
-   *
-   * @param task - Task to analyze
-   * @returns Sequential steps
-   */
-  identifySequentialSteps(task) {
-    const steps = [];
-    steps.push({
-      name: `${task.name} - Preparation`,
-      description: `Prepare for ${task.description}`,
-      capabilities: fromAgentCapabilities$1(task.requiredCapabilities)
-    });
-    steps.push({
-      name: `${task.name} - Execution`,
-      description: `Execute ${task.description}`,
-      capabilities: fromAgentCapabilities$1(task.requiredCapabilities)
-    });
-    steps.push({
-      name: `${task.name} - Validation`,
-      description: `Validate results of ${task.description}`,
-      capabilities: ["code-analysis"]
-    });
-    return steps;
-  }
-  /**
-   * Identify parallel steps in a task
-   *
-   * @param task - Task to analyze
-   * @returns Parallel steps
-   */
-  identifyParallelSteps(task) {
-    const steps = [];
-    if (task.input.files && task.input.files.length > 1) {
-      for (const file of task.input.files) {
-        steps.push({
-          name: `${task.name} - ${file}`,
-          description: `${task.description} for ${file}`,
-          capabilities: fromAgentCapabilities$1(task.requiredCapabilities)
-        });
-      }
-    } else {
-      const capabilityGroups = this.groupCapabilities(fromAgentCapabilities$1(task.requiredCapabilities));
-      for (const [group, capabilities] of capabilityGroups) {
-        steps.push({
-          name: `${task.name} - ${group}`,
-          description: `${task.description} (${group})`,
-          capabilities
-        });
-      }
-    }
-    return steps;
-  }
-  /**
-   * Identify high-level phases in a task
-   *
-   * @param task - Task to analyze
-   * @returns Task phases
-   */
-  identifyPhases(task) {
-    const phases = [];
-    phases.push({
-      name: `${task.name} - Planning`,
-      description: `Plan approach for ${task.description}`,
-      capabilities: ["architecture-design"]
-    });
-    phases.push({
-      name: `${task.name} - Implementation`,
-      description: `Implement ${task.description}`,
-      capabilities: fromAgentCapabilities$1(task.requiredCapabilities)
-    });
-    phases.push({
-      name: `${task.name} - Testing`,
-      description: `Test ${task.description}`,
-      capabilities: ["test-generation", "code-analysis"]
-    });
-    return phases;
-  }
-  /**
-   * Identify pipeline stages in a task
-   *
-   * @param task - Task to analyze
-   * @returns Pipeline stages
-   */
-  identifyPipelineStages(task) {
-    const stages = [];
-    stages.push({
-      name: `${task.name} - Input Processing`,
-      description: `Process input for ${task.description}`,
-      capabilities: fromAgentCapabilities$1(task.requiredCapabilities)
-    });
-    stages.push({
-      name: `${task.name} - Transformation`,
-      description: `Transform data for ${task.description}`,
-      capabilities: fromAgentCapabilities$1(task.requiredCapabilities)
-    });
-    stages.push({
-      name: `${task.name} - Output Generation`,
-      description: `Generate output for ${task.description}`,
-      capabilities: fromAgentCapabilities$1(task.requiredCapabilities)
-    });
-    return stages;
-  }
-  /**
-   * Create map tasks for map-reduce pattern
-   *
-   * @param task - Original task
-   * @returns Map tasks
-   */
-  createMapTasks(task) {
-    const mapTasks = [];
-    const items = task.input.files ?? [task.input.parameters];
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i];
-      mapTasks.push(this.createSubtask(task, {
-        name: `${task.name} - Map ${i + 1}`,
-        description: `Process ${typeof item === "string" ? item : `item ${i + 1}`}`,
-        capabilities: fromAgentCapabilities$1(task.requiredCapabilities)
-      }, i));
-    }
-    return mapTasks;
-  }
-  /**
-   * Create reduce task for map-reduce pattern
-   *
-   * @param task - Original task
-   * @param mapTaskCount - Number of map tasks
-   * @returns Reduce task
-   */
-  createReduceTask(task, mapTaskCount) {
-    return this.createSubtask(task, {
-      name: `${task.name} - Reduce`,
-      description: `Aggregate results from ${mapTaskCount} map tasks`,
-      capabilities: ["code-analysis"]
-    }, mapTaskCount);
-  }
-  /**
-   * Create a subtask from a task and step definition
-   *
-   * @param parentTask - Parent task
-   * @param step - Step definition object
-   * @param step.name - Step name
-   * @param step.description - Step description
-   * @param step.capabilities - Required agent capabilities
-   * @param index - Step index
-   * @returns Created subtask
-   */
-  createSubtask(parentTask, step, index) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return {
-      id: nanoid(),
-      name: step.name,
-      description: step.description,
-      type: parentTask.type,
-      priority: parentTask.priority,
-      status: "pending",
-      requiredCapabilities: toAgentCapabilities$1(step.capabilities),
-      input: {
-        parameters: parentTask.input.parameters,
-        files: parentTask.input.files,
-        context: parentTask.input.context,
-        instructions: parentTask.input.instructions,
-        constraints: parentTask.input.constraints
-      },
-      dependencies: [],
-      estimatedDuration: parentTask.estimatedDuration ? Math.floor(parentTask.estimatedDuration / 3) : void 0,
-      maxRetries: parentTask.maxRetries,
-      retryCount: 0,
-      timeout: parentTask.timeout,
-      metadata: {
-        ...parentTask.metadata,
-        tags: [...parentTask.metadata.tags, "subtask"],
-        custom: {
-          ...parentTask.metadata.custom,
-          parentTaskId: parentTask.id,
-          subtaskIndex: index
-        }
-      },
-      createdAt: now,
-      progress: 0,
-      parentId: parentTask.id
-    };
-  }
-  /**
-   * Group capabilities by category
-   *
-   * @param capabilities - Capabilities to group
-   * @returns Grouped capabilities
-   */
-  groupCapabilities(capabilities) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const capability of capabilities) {
-      const category = capability.split("-")[0];
-      if (!groups.has(category)) {
-        groups.set(category, []);
-      }
-      groups.get(category).push(capability);
-    }
-    return groups;
-  }
-  /**
-   * Detect additional dependencies between tasks
-   *
-   * @param subtasks - Subtasks to analyze
-   * @param existingDeps - Existing dependencies
-   * @returns Updated dependencies
-   */
-  detectDependencies(subtasks, existingDeps) {
-    const dependencies = [...existingDeps];
-    for (let i = 0; i < subtasks.length; i++) {
-      for (let j = i + 1; j < subtasks.length; j++) {
-        const task1 = subtasks[i];
-        const task2 = subtasks[j];
-        if (this.hasDataDependency(task1, task2)) {
-          const exists = dependencies.some(
-            (dep) => dep.taskId === task1.id && subtasks[j].id === task2.id
-          );
-          if (!exists) {
-            dependencies.push({
-              taskId: task1.id,
-              type: "data",
-              required: false
-            });
-          }
-        }
-      }
-    }
-    return dependencies;
-  }
-  /**
-   * Check if one task has a data dependency on another
-   *
-   * @param producer - Potential producer task
-   * @param consumer - Potential consumer task
-   * @returns Whether dependency exists
-   */
-  hasDataDependency(producer, consumer) {
-    const producerKeywords = producer.name.toLowerCase().split(/\s+/);
-    const consumerDesc = consumer.description.toLowerCase();
-    return producerKeywords.some((keyword) => consumerDesc.includes(keyword));
-  }
-  /**
-   * Build execution graph from tasks and dependencies
-   *
-   * @param subtasks - Subtasks
-   * @param dependencies - Task dependencies
-   * @returns Execution graph
-   */
-  buildExecutionGraph(subtasks, dependencies) {
-    const nodes = [];
-    const edges = [];
-    for (const task of subtasks) {
-      const incomingEdges = dependencies.filter((dep) => {
-        const dependentTask = subtasks.find(
-          (t) => t.dependencies.some((d) => d.taskId === dep.taskId)
-        );
-        return dependentTask?.id === task.id;
-      }).map((dep) => dep.taskId);
-      const outgoingEdges = dependencies.filter((dep) => dep.taskId === task.id).map((dep) => {
-        const dependentTask = subtasks.find(
-          (t) => t.dependencies.includes(dep)
-        );
-        return dependentTask?.id ?? "";
-      }).filter((id) => id !== "");
-      nodes.push({
-        taskId: task.id,
-        level: 0,
-        // Will be calculated later
-        isLeaf: outgoingEdges.length === 0,
-        isRoot: incomingEdges.length === 0,
-        incomingEdges,
-        outgoingEdges
-      });
-    }
-    for (const dep of dependencies) {
-      const dependentTask = subtasks.find(
-        (t) => t.dependencies.includes(dep)
-      );
-      if (dependentTask) {
-        edges.push({
-          id: nanoid(),
-          from: dep.taskId,
-          to: dependentTask.id,
-          type: dep.type,
-          weight: dep.required ? 1 : 0.5
-        });
-      }
-    }
-    this.calculateNodeLevels(nodes, edges);
-    const stages = this.buildExecutionStages(nodes, subtasks);
-    return { nodes, edges, stages };
-  }
-  /**
-   * Calculate node levels in the graph
-   *
-   * @param nodes - Graph nodes
-   * @param edges - Graph edges
-   */
-  calculateNodeLevels(nodes, edges) {
-    const visited = /* @__PURE__ */ new Set();
-    const levels = /* @__PURE__ */ new Map();
-    for (const node of nodes) {
-      if (node.isRoot) {
-        levels.set(node.taskId, 0);
-      }
-    }
-    const queue = nodes.filter((n) => n.isRoot).map((n) => n.taskId);
-    while (queue.length > 0) {
-      const taskId = queue.shift();
-      if (visited.has(taskId))
-        continue;
-      visited.add(taskId);
-      const currentLevel = levels.get(taskId) ?? 0;
-      const outgoingEdges = edges.filter((e) => e.from === taskId);
-      for (const edge of outgoingEdges) {
-        const newLevel = currentLevel + 1;
-        const existingLevel = levels.get(edge.to) ?? -1;
-        if (newLevel > existingLevel) {
-          levels.set(edge.to, newLevel);
-        }
-        queue.push(edge.to);
-      }
-    }
-    for (const node of nodes) {
-      node.level = levels.get(node.taskId) ?? 0;
-    }
-  }
-  /**
-   * Build execution stages from graph nodes
-   *
-   * @param nodes - Graph nodes
-   * @param subtasks - Subtasks
-   * @returns Execution stages
-   */
-  buildExecutionStages(nodes, subtasks) {
-    const stages = [];
-    const maxLevel = Math.max(...nodes.map((n) => n.level));
-    for (let level = 0; level <= maxLevel; level++) {
-      const stageTasks = nodes.filter((n) => n.level === level).map((n) => n.taskId);
-      const estimatedDuration = Math.max(
-        ...stageTasks.map((taskId) => {
-          const task = subtasks.find((t) => t.id === taskId);
-          return task?.estimatedDuration ?? 0;
-        })
-      );
-      stages.push({
-        stage: level,
-        tasks: stageTasks,
-        estimatedDuration
-      });
-    }
-    return stages;
-  }
-  /**
-   * Optimize execution graph for better performance
-   *
-   * @param graph - Execution graph
-   * @param subtasks - Subtasks
-   */
-  optimizeExecutionGraph(graph, subtasks) {
-    this.mergeSmallTasks(graph, subtasks);
-    this.reorderTasksInStages(graph, subtasks);
-    this.identifyCriticalPath(graph, subtasks);
-  }
-  /**
-   * Merge small sequential tasks
-   *
-   * @param graph - Execution graph
-   * @param subtasks - Subtasks
-   */
-  mergeSmallTasks(graph, subtasks) {
-    for (const stage of graph.stages) {
-      if (stage.tasks.length === 1) {
-        const task = subtasks.find((t) => t.id === stage.tasks[0]);
-        if (task && (task.estimatedDuration ?? 0) < this.options.minTaskGranularity) {
-          task.metadata.custom = {
-            ...task.metadata.custom,
-            mergeable: true
-          };
-        }
-      }
-    }
-  }
-  /**
-   * Reorder tasks within stages for load balancing
-   *
-   * @param graph - Execution graph
-   * @param subtasks - Subtasks
-   */
-  reorderTasksInStages(graph, subtasks) {
-    for (const stage of graph.stages) {
-      stage.tasks.sort((a, b) => {
-        const taskA = subtasks.find((t) => t.id === a);
-        const taskB = subtasks.find((t) => t.id === b);
-        const durationA = taskA?.estimatedDuration ?? 0;
-        const durationB = taskB?.estimatedDuration ?? 0;
-        return durationB - durationA;
-      });
-    }
-  }
-  /**
-   * Identify critical path in the execution graph
-   *
-   * @param graph - Execution graph
-   * @param subtasks - Subtasks
-   */
-  identifyCriticalPath(graph, subtasks) {
-    const earliestStart = /* @__PURE__ */ new Map();
-    for (const stage of graph.stages) {
-      for (const taskId of stage.tasks) {
-        const task = subtasks.find((t) => t.id === taskId);
-        const node = graph.nodes.find((n) => n.taskId === taskId);
-        if (!node || !task)
-          continue;
-        let maxPredecessorFinish = 0;
-        for (const predId of node.incomingEdges) {
-          const predTask = subtasks.find((t) => t.id === predId);
-          const predStart = earliestStart.get(predId) ?? 0;
-          const predDuration = predTask?.estimatedDuration ?? 0;
-          maxPredecessorFinish = Math.max(maxPredecessorFinish, predStart + predDuration);
-        }
-        earliestStart.set(taskId, maxPredecessorFinish);
-      }
-    }
-    for (const [taskId, _] of earliestStart) {
-      const task = subtasks.find((t) => t.id === taskId);
-      if (task) {
-        task.metadata.custom = {
-          ...task.metadata.custom,
-          onCriticalPath: true
-        };
-      }
-    }
-  }
-  /**
-   * Calculate estimated total duration
-   *
-   * @param _subtasks - Subtasks (unused but kept for API consistency)
-   * @param graph - Execution graph
-   * @returns Estimated duration in milliseconds
-   */
-  calculateEstimatedDuration(_subtasks, graph) {
-    return graph.stages.reduce((total, stage) => {
-      return total + stage.estimatedDuration;
-    }, 0);
-  }
-}
-
-function fromAgentCapabilities(capabilities) {
-  return capabilities.map((cap) => cap.id);
-}
-function toAgentCapabilities(capabilities) {
-  return capabilities.map((id) => ({
-    id,
-    name: id,
-    model: "sonnet",
-    specialties: [id],
-    strength: 0.8,
-    costFactor: 1
-  }));
-}
-class BrainOrchestrator extends EventEmitter {
-  config;
-  taskDecomposer;
-  resultAggregator;
-  state;
-  availableAgents;
-  forkManager;
-  dispatcher;
-  constructor(config = {}) {
-    super();
-    this.config = {
-      maxConcurrentTasks: config.maxConcurrentTasks ?? 10,
-      maxConcurrentAgents: config.maxConcurrentAgents ?? 5,
-      defaultTaskTimeout: config.defaultTaskTimeout ?? 3e5,
-      // 5 minutes
-      defaultRetryCount: config.defaultRetryCount ?? 3,
-      autoRetry: config.autoRetry ?? true,
-      conflictResolutionStrategy: config.conflictResolutionStrategy ?? "highest-confidence",
-      enableParallelExecution: config.enableParallelExecution ?? true,
-      enableCaching: config.enableCaching ?? false,
-      cacheTtl: config.cacheTtl ?? 36e5,
-      // 1 hour
-      verboseLogging: config.verboseLogging ?? false,
-      custom: config.custom ?? {},
-      // v3.8 options
-      forkContextOptions: config.forkContextOptions ?? {},
-      dispatcherOptions: config.dispatcherOptions ?? {},
-      enableForkContext: config.enableForkContext ?? true,
-      enableDispatcher: config.enableDispatcher ?? true
-    };
-    this.taskDecomposer = new TaskDecomposer({
-      strategy: "hierarchical",
-      maxDepth: 5,
-      maxParallelTasks: this.config.maxConcurrentTasks,
-      enableOptimization: true
-    });
-    this.resultAggregator = new ResultAggregator({
-      defaultStrategy: this.config.conflictResolutionStrategy,
-      autoDetectConflicts: true,
-      enableValidation: true,
-      enableMerging: true
-    });
-    this.state = {
-      activeTasks: /* @__PURE__ */ new Map(),
-      activeAgents: /* @__PURE__ */ new Map(),
-      taskQueue: [],
-      completedTasks: /* @__PURE__ */ new Map(),
-      failedTasks: /* @__PURE__ */ new Map(),
-      status: "idle",
-      totalTasksProcessed: 0,
-      metrics: this.createEmptyMetrics()
-    };
-    this.availableAgents = /* @__PURE__ */ new Map();
-    this.forkManager = new AgentForkManager(this.config.forkContextOptions);
-    this.setupForkManagerEvents();
-    this.dispatcher = new AgentDispatcher(this.config.dispatcherOptions);
-  }
-  /**
-   * Register an agent for use by the orchestrator
-   *
-   * @param role - Agent role
-   * @param agent - Agent definition
-   */
-  registerAgent(role, agent) {
-    this.availableAgents.set(role, agent);
-    this.log(`Registered agent: ${role}`);
-  }
-  /**
-   * Unregister an agent
-   *
-   * @param role - Agent role
-   */
-  unregisterAgent(role) {
-    this.availableAgents.delete(role);
-    this.log(`Unregistered agent: ${role}`);
-  }
-  /**
-   * Execute a complex task through orchestration
-   *
-   * @param task - Root task to execute
-   * @param strategy - Optional decomposition strategy
-   * @returns Orchestration result
-   */
-  async execute(task, strategy) {
-    const sessionId = `orchestration-${nanoid()}`;
-    executionTracer.startSession(sessionId);
-    executionTracer.logEvent("agent-start", {
-      task: task.name,
-      strategy: strategy || "auto"
-    });
-    taskPersistence.saveSession(sessionId, {
-      rootTask: task.name,
-      strategy: strategy || "auto"
-    });
-    taskPersistence.saveTask(task, sessionId);
-    const context = await contextLoader.load({
-      projectRoot: process.cwd(),
-      task,
-      layers: ["project", "domain", "task"],
-      tokenBudget: 4e3
-      // ~L1 depth, keeps orchestration context lean
-    });
-    task.metadata = task.metadata || { tags: [] };
-    if (!task.metadata.custom) {
-      task.metadata.custom = {};
-    }
-    task.metadata.custom.context = contextLoader.formatForLLM(context);
-    const intel = SessionIntelligence.getInstance();
-    intel.recordMessage("user", task.name);
-    try {
-      this.state.status = "planning";
-      intel.updatePhase("exploring");
-      this.log(`Starting orchestration for task: ${task.name}`);
-      executionTracer.logDecision("orchestrator", `Planning task: ${task.name}`);
-      const plan = await this.createPlan(task, strategy);
-      this.emit("plan:created", plan);
-      this.state.status = "executing";
-      intel.updatePhase("executing");
-      this.state.currentPlan = plan;
-      this.state.startTime = (/* @__PURE__ */ new Date()).toISOString();
-      this.emit("plan:started", plan.id);
-      const result = await this.executePlan(plan);
-      this.state.status = "idle";
-      intel.updatePhase("reviewing");
-      this.emit("plan:completed", result);
-      executionTracer.logAgentEnd("orchestrator", { success: true });
-      executionTracer.endSession(sessionId);
-      taskPersistence.updateTaskStatus(task.id, "completed", result);
-      return result;
-    } catch (error) {
-      this.state.status = "error";
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit("error", err);
-      executionTracer.logError(err, "orchestrator");
-      executionTracer.endSession(sessionId);
-      taskPersistence.updateTaskStatus(task.id, "failed", void 0, err);
-      return this.createFailedResult(task, err);
-    }
-  }
-  /**
-   * Create an orchestration plan from a task
-   *
-   * @param task - Root task
-   * @param strategy - Decomposition strategy
-   * @returns Orchestration plan
-   */
-  async createPlan(task, strategy) {
-    this.log(`Creating orchestration plan for: ${task.name}`);
-    const decomposition = await this.taskDecomposer.decompose(task, strategy);
-    const requiredAgents = this.analyzeRequiredAgents(decomposition.subtasks);
-    const executionGraph = decomposition.executionGraph;
-    const estimatedDuration = decomposition.estimatedDuration;
-    const plan = {
-      id: nanoid(),
-      name: `Plan: ${task.name}`,
-      description: `Orchestration plan for ${task.name}`,
-      rootTask: task,
-      tasks: decomposition.subtasks,
-      executionGraph,
-      requiredAgents,
-      decompositionStrategy: decomposition.strategy,
-      estimatedDuration,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      metadata: {
-        originalTaskId: task.id,
-        decompositionMetadata: decomposition.metadata
-      }
-    };
-    return plan;
-  }
-  /**
-   * Execute an orchestration plan
-   *
-   * @param plan - Orchestration plan to execute
-   * @returns Orchestration result
-   */
-  async executePlan(plan) {
-    const startTime = Date.now();
-    const completed = [];
-    const failed = [];
-    const cancelled = [];
-    const results = {};
-    const errors = [];
-    const warnings = [];
-    this.log(`Executing plan: ${plan.id}`);
-    for (const task of plan.tasks) {
-      this.state.taskQueue.push(task);
-      this.emit("task:created", task);
-    }
-    for (const stage of plan.executionGraph.stages) {
-      const stageTasks = plan.tasks.filter((t) => stage.tasks.includes(t.id));
-      const stagePromises = stageTasks.map(async (task) => {
-        this.emit("task:started", task);
-        task.status = "running";
-        task.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        try {
-          const agent = this.selectAgentForTask(task);
-          if (!agent) {
-            throw new Error(`No available agent for task: ${task.name}`);
-          }
-          task.assignedAgentId = agent.id;
-          this.emit("agent:assigned", agent, task);
-          await this.executeTask(agent, task);
-          task.status = "completed";
-          task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-          task.actualDuration = Date.now() - new Date(task.startedAt).getTime();
-          task.progress = 100;
-          completed.push(task.id);
-          this.emit("task:completed", task);
-          this.updateAgentMetrics(agent, task, true);
-          if (task.output) {
-            results[task.id] = task.output;
-          }
-          return { taskId: task.id, success: true };
-        } catch (error) {
-          const err = error instanceof Error ? error : new Error(String(error));
-          task.status = "failed";
-          task.error = {
-            code: "TASK_EXECUTION_FAILED",
-            message: err.message,
-            stack: err.stack,
-            recoverable: this.config.autoRetry && task.retryCount < task.maxRetries
-          };
-          task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-          failed.push(task.id);
-          this.emit("task:failed", task, task.error);
-          if (task.error) {
-            errors.push(task.error);
-          }
-          if (this.config.autoRetry && task.retryCount < task.maxRetries && task.error?.recoverable) {
-            task.retryCount++;
-            task.status = "pending";
-            warnings.push(`Retrying task ${task.name} (attempt ${task.retryCount}/${task.maxRetries})`);
-            return { taskId: task.id, success: false, retry: true };
-          }
-          return { taskId: task.id, success: false };
-        }
-      });
-      await Promise.all(stagePromises);
-      if (this.hasCriticalFailures(stageTasks)) {
-        this.log("Critical failure detected, cancelling remaining tasks");
-        for (const remainingTask of plan.tasks.filter((t) => t.status === "pending")) {
-          remainingTask.status = "cancelled";
-          cancelled.push(remainingTask.id);
-          this.emit("task:cancelled", remainingTask);
-        }
-        break;
-      }
-    }
-    const duration = Date.now() - startTime;
-    const metrics = this.calculateMetrics(plan, completed, failed, cancelled, duration);
-    const status = this.determineStatus(completed, failed, cancelled, plan.tasks.length);
-    const aggregationResult = await this.resultAggregator.aggregate(
-      plan.tasks.filter((t) => t.output !== void 0)
-    );
-    const finalResults = {};
-    for (const task of plan.tasks) {
-      if (task.output) {
-        finalResults[task.id] = task.output;
-      }
-    }
-    if (aggregationResult.output) {
-      finalResults._aggregated = aggregationResult.output;
-    }
-    return {
-      planId: plan.id,
-      success: status === "completed",
-      status,
-      completedTasks: completed,
-      failedTasks: failed,
-      cancelledTasks: cancelled,
-      results: finalResults,
-      metrics,
-      errors,
-      warnings,
-      startedAt: new Date(startTime).toISOString(),
-      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      duration
-    };
-  }
-  /**
-   * Select an agent for a task
-   *
-   * @param task - Task to execute
-   * @returns Selected agent instance or undefined
-   */
-  selectAgentForTask(task) {
-    const candidates = [];
-    const agentEntries = Array.from(this.availableAgents.entries());
-    for (const [role, agent] of agentEntries) {
-      const requiredCaps = fromAgentCapabilities(task.requiredCapabilities);
-      const hasCapabilities = requiredCaps.every(
-        (cap) => agent.definition.capabilities.includes(cap)
-      );
-      if (!hasCapabilities)
-        continue;
-      let instance = Array.from(this.state.activeAgents.values()).find(
-        (a) => a.role === role && a.status === "idle"
-      );
-      if (!instance && this.state.activeAgents.size < this.config.maxConcurrentAgents) {
-        instance = this.createAgentInstance(role, agent);
-      }
-      if (instance && instance.status === "idle") {
-        candidates.push(instance);
-      }
-    }
-    if (candidates.length === 0) {
-      return void 0;
-    }
-    const criteria = {
-      requiredCapabilities: task.requiredCapabilities,
-      strategy: "best-fit"
-    };
-    const selected = this.selectBestAgent(candidates, criteria);
-    return selected;
-  }
-  /**
-   * Execute a task on an agent
-   *
-   * @param agent - Agent instance
-   * @param task - Task to execute
-   */
-  async executeTask(agent, task) {
-    agent.status = "busy";
-    agent.currentTask = task;
-    agent.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.state.activeTasks.set(task.id, task);
-    await this.sleep(100);
-    task.output = {
-      data: {
-        message: `Task ${task.name} completed by ${agent.role}`,
-        agentId: agent.id
-      },
-      confidence: 0.9
-    };
-    agent.status = "idle";
-    agent.currentTask = void 0;
-    this.state.activeTasks.delete(task.id);
-  }
-  /**
-   * Select best agent from candidates
-   *
-   * @param candidates - Candidate agents
-   * @param criteria - Selection criteria
-   * @returns Selected agent
-   */
-  selectBestAgent(candidates, criteria) {
-    switch (criteria.strategy) {
-      case "best-fit":
-        return candidates.reduce(
-          (best, current) => current.metrics.successRate > best.metrics.successRate ? current : best
-        );
-      case "least-loaded":
-        return candidates.reduce(
-          (best, current) => current.taskHistory.length < best.taskHistory.length ? current : best
-        );
-      case "fastest":
-        return candidates.reduce(
-          (best, current) => current.metrics.avgTaskDuration < best.metrics.avgTaskDuration ? current : best
-        );
-      case "round-robin":
-      case "random":
-      default:
-        return candidates[Math.floor(Math.random() * candidates.length)];
-    }
-  }
-  /**
-   * Create an agent instance
-   *
-   * @param role - Agent role
-   * @param agent - Agent definition
-   * @returns Agent instance
-   */
-  createAgentInstance(role, agent) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const instance = {
-      id: nanoid(),
-      role,
-      agent,
-      status: "idle",
-      taskHistory: [],
-      capabilities: toAgentCapabilities(agent.definition.capabilities),
-      metrics: {
-        tasksExecuted: 0,
-        tasksSucceeded: 0,
-        tasksFailed: 0,
-        avgTaskDuration: 0,
-        successRate: 0,
-        totalExecutionTime: 0,
-        avgConfidence: 0,
-        lastUpdated: now
-      },
-      createdAt: now,
-      config: {
-        maxConcurrentTasks: 1,
-        taskTimeout: this.config.defaultTaskTimeout,
-        verboseLogging: this.config.verboseLogging
-      }
-    };
-    this.state.activeAgents.set(instance.id, instance);
-    this.emit("agent:created", instance);
-    return instance;
-  }
-  /**
-   * Update agent metrics after task execution
-   *
-   * @param agent - Agent instance
-   * @param task - Executed task
-   * @param success - Whether task succeeded
-   */
-  updateAgentMetrics(agent, task, success) {
-    const metrics = agent.metrics;
-    metrics.tasksExecuted++;
-    if (success) {
-      metrics.tasksSucceeded++;
-    } else {
-      metrics.tasksFailed++;
-    }
-    metrics.successRate = metrics.tasksSucceeded / metrics.tasksExecuted;
-    if (task.actualDuration) {
-      metrics.totalExecutionTime += task.actualDuration;
-      metrics.avgTaskDuration = metrics.totalExecutionTime / metrics.tasksExecuted;
-    }
-    if (task.output?.confidence) {
-      const totalConfidence = metrics.avgConfidence * (metrics.tasksExecuted - 1) + task.output.confidence;
-      metrics.avgConfidence = totalConfidence / metrics.tasksExecuted;
-    }
-    metrics.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    agent.taskHistory.push({
-      taskId: task.id,
-      taskName: task.name,
-      status: task.status,
-      startedAt: task.startedAt,
-      completedAt: task.completedAt,
-      duration: task.actualDuration,
-      success,
-      error: task.error?.message
-    });
-  }
-  /**
-   * Analyze required agents for tasks
-   *
-   * @param tasks - Tasks to analyze
-   * @returns Agent requirements
-   */
-  analyzeRequiredAgents(tasks) {
-    const capabilityGroups = /* @__PURE__ */ new Map();
-    for (const task of tasks) {
-      const key = task.requiredCapabilities.sort().join(",");
-      if (!capabilityGroups.has(key)) {
-        capabilityGroups.set(key, task.requiredCapabilities);
-      }
-    }
-    return Array.from(capabilityGroups.values()).map((capabilities) => ({
-      capabilities,
-      minInstances: 1,
-      maxInstances: this.config.maxConcurrentAgents
-    }));
-  }
-  /**
-   * Check if there are critical failures
-   *
-   * @param tasks - Tasks to check
-   * @returns Whether there are critical failures
-   */
-  hasCriticalFailures(tasks) {
-    return tasks.some((t) => t.status === "failed" && t.priority === "critical");
-  }
-  /**
-   * Calculate orchestration metrics
-   *
-   * @param plan - Orchestration plan
-   * @param completed - Completed task IDs
-   * @param failed - Failed task IDs
-   * @param cancelled - Cancelled task IDs
-   * @param duration - Total duration
-   * @returns Metrics
-   */
-  calculateMetrics(plan, completed, failed, cancelled, duration) {
-    const totalTasks = plan.tasks.length;
-    const tasksCompleted = completed.length;
-    const tasksFailed = failed.length;
-    const tasksCancelled = cancelled.length;
-    const completedTasks = plan.tasks.filter((t) => completed.includes(t.id));
-    const avgTaskDuration = completedTasks.length > 0 ? completedTasks.reduce((sum, t) => sum + (t.actualDuration ?? 0), 0) / completedTasks.length : 0;
-    const parallelEfficiency = plan.estimatedDuration > 0 ? Math.min(plan.estimatedDuration / duration, 1) : 0;
-    const agentUtilization = this.state.activeAgents.size > 0 ? this.state.activeTasks.size / this.state.activeAgents.size : 0;
-    return {
-      totalTasks,
-      tasksCompleted,
-      tasksFailed,
-      tasksCancelled,
-      successRate: totalTasks > 0 ? tasksCompleted / totalTasks : 0,
-      avgTaskDuration,
-      totalExecutionTime: duration,
-      parallelEfficiency,
-      agentUtilization
-    };
-  }
-  /**
-   * Determine overall orchestration status
-   *
-   * @param completed - Completed task count
-   * @param failed - Failed task count
-   * @param cancelled - Cancelled task count
-   * @param total - Total task count
-   * @returns Status
-   */
-  determineStatus(completed, failed, cancelled, total) {
-    if (completed.length === total) {
-      return "completed";
-    }
-    if (failed.length === total) {
-      return "failed";
-    }
-    if (cancelled.length === total) {
-      return "cancelled";
-    }
-    return "partial";
-  }
-  /**
-   * Create empty metrics
-   *
-   * @returns Empty metrics
-   */
-  createEmptyMetrics() {
-    return {
-      totalTasks: 0,
-      tasksCompleted: 0,
-      tasksFailed: 0,
-      tasksCancelled: 0,
-      successRate: 0,
-      avgTaskDuration: 0,
-      totalExecutionTime: 0,
-      parallelEfficiency: 0,
-      agentUtilization: 0
-    };
-  }
-  /**
-   * Create failed orchestration result
-   *
-   * @param task - Root task
-   * @param error - Error that occurred
-   * @returns Failed result
-   */
-  createFailedResult(task, error) {
-    return {
-      planId: "failed",
-      success: false,
-      status: "failed",
-      completedTasks: [],
-      failedTasks: [task.id],
-      cancelledTasks: [],
-      results: {},
-      metrics: this.createEmptyMetrics(),
-      errors: [{
-        code: "ORCHESTRATION_FAILED",
-        message: error.message,
-        stack: error.stack,
-        recoverable: false
-      }],
-      warnings: [],
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      duration: 0
-    };
-  }
-  /**
-   * Get current orchestrator state
-   *
-   * @returns Current state
-   */
-  getState() {
-    return { ...this.state };
-  }
-  /**
-   * Pause orchestration
-   */
-  pause() {
-    if (this.state.status === "executing") {
-      this.state.status = "paused";
-      this.log("Orchestration paused");
-    }
-  }
-  /**
-   * Resume orchestration
-   */
-  resume() {
-    if (this.state.status === "paused") {
-      this.state.status = "executing";
-      this.log("Orchestration resumed");
-    }
-  }
-  /**
-   * Cancel orchestration
-   */
-  cancel() {
-    this.state.status = "idle";
-    const activeTaskValues = Array.from(this.state.activeTasks.values());
-    for (const task of activeTaskValues) {
-      task.status = "cancelled";
-      this.emit("task:cancelled", task);
-    }
-    this.state.activeTasks.clear();
-    this.log("Orchestration cancelled");
-  }
-  /**
-   * Terminate all agents
-   */
-  terminateAllAgents() {
-    const activeAgentValues = Array.from(this.state.activeAgents.values());
-    for (const agent of activeAgentValues) {
-      agent.status = "terminated";
-      this.emit("agent:terminated", agent);
-    }
-    this.state.activeAgents.clear();
-    this.log("All agents terminated");
-  }
-  /**
-   * Log message if verbose logging is enabled
-   *
-   * @param message - Message to log
-   */
-  log(message) {
-    if (this.config.verboseLogging) {
-      console.log(`[BrainOrchestrator] ${message}`);
-    }
-  }
-  /**
-   * Sleep for specified duration
-   *
-   * @param ms - Duration in milliseconds
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  // ========================================================================
-  // FORK CONTEXT METHODS (v3.8)
-  // ========================================================================
-  /**
-   * Execute a task in a fork context
-   *
-   * Creates an isolated sub-agent context for executing a skill-based task.
-   *
-   * @param skill - Skill file with fork configuration
-   * @param task - Task to execute
-   * @param executeFn - Execution function
-   * @returns Fork context result
-   */
-  async executeInForkContext(skill, task, executeFn) {
-    if (!this.config.enableForkContext) {
-      throw new Error("Fork context execution is disabled");
-    }
-    this.log(`Executing task in fork context: ${task.name} (skill: ${skill.metadata.name})`);
-    const fork = this.forkManager.createFork(skill);
-    this.emit("fork:created", fork.id, skill);
-    const result = await this.forkManager.executeFork(fork.id, task, executeFn);
-    if (result.success) {
-      this.emit("fork:completed", fork.id, result);
-    } else {
-      this.emit("fork:failed", fork.id, result.error || "Unknown error");
-    }
-    return result;
-  }
-  /**
-   * Execute multiple tasks in parallel fork contexts
-   *
-   * @param execution - Parallel execution configuration
-   * @param executeFn - Execution function
-   * @returns Parallel execution result
-   */
-  async executeParallelForks(execution, executeFn) {
-    this.log(`Executing ${execution.tasks.length} parallel forks`);
-    this.emit("parallel:started", execution.id);
-    try {
-      const result = await this.dispatcher.dispatchParallel(execution, async (config) => {
-        const forkConfig = {
-          id: nanoid(),
-          sessionId: config.sessionId || nanoid(),
-          skill: {
-            metadata: {
-              name: config.agentType,
-              description: "",
-              version: "1.0.0",
-              category: "custom",
-              triggers: [],
-              use_when: []
-            },
-            content: "",
-            filePath: ""
-          },
-          agentType: config.agentType,
-          agentRole: config.agentRole,
-          mode: config.mode,
-          workingDirectory: config.workingDirectory,
-          env: config.env,
-          allowedTools: config.allowedTools,
-          disallowedTools: config.disallowedTools,
-          timeout: config.timeout
-        };
-        return executeFn(forkConfig);
-      });
-      this.emit("parallel:completed", execution.id, result);
-      return result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.emit("parallel:failed", execution.id, errorMessage);
-      return {
-        id: execution.id,
-        success: false,
-        results: [],
-        durationMs: 0,
-        successfulCount: 0,
-        failedCount: execution.tasks.length
-      };
-    }
-  }
-  /**
-   * Execute a task with agent dispatching
-   *
-   * Routes the task to the appropriate agent based on skill configuration.
-   *
-   * @param skill - Skill file with agent configuration
-   * @param task - Task to execute
-   * @param executeFn - Execution function
-   * @returns Dispatch result
-   */
-  async executeWithAgentDispatch(skill, task, executeFn) {
-    if (!this.config.enableDispatcher) {
-      throw new Error("Agent dispatcher is disabled");
-    }
-    this.log(`Dispatching task: ${task.name} to agent: ${skill.metadata.agent || "default"}`);
-    const dispatchResult = await this.dispatcher.dispatch(task, skill, async (config) => {
-      const forkConfig = {
-        id: nanoid(),
-        sessionId: config.sessionId || nanoid(),
-        skill,
-        agentType: config.agentType,
-        agentRole: config.agentRole,
-        mode: config.mode,
-        workingDirectory: config.workingDirectory,
-        env: config.env,
-        allowedTools: config.allowedTools,
-        disallowedTools: config.disallowedTools,
-        timeout: config.timeout
-      };
-      return executeFn(forkConfig);
-    });
-    if (!dispatchResult.success) {
-      throw new Error(dispatchResult.error || "Agent dispatch failed");
-    }
-    return dispatchResult.output;
-  }
-  /**
-   * Cancel a running fork context
-   *
-   * @param forkId - Fork context ID
-   */
-  cancelFork(forkId) {
-    this.forkManager.cancel(forkId);
-    this.emit("fork:cancelled", forkId);
-    this.log(`Cancelled fork: ${forkId}`);
-  }
-  /**
-   * Get fork context state
-   *
-   * @param forkId - Fork context ID
-   * @returns Fork state or null
-   */
-  getForkState(forkId) {
-    return this.forkManager.getFork(forkId);
-  }
-  /**
-   * Get all active fork contexts
-   *
-   * @returns Array of active fork states
-   */
-  getActiveForks() {
-    return this.forkManager.listActive();
-  }
-  /**
-   * Get fork context statistics
-   *
-   * @returns Fork statistics
-   */
-  getForkStats() {
-    return this.forkManager.getStats();
-  }
-  /**
-   * Get dispatcher statistics
-   *
-   * @returns Dispatcher statistics
-   */
-  getDispatcherStats() {
-    return this.dispatcher.getStats();
-  }
-  /**
-   * Setup fork manager event handlers
-   */
-  setupForkManagerEvents() {
-    this.forkManager.on("created", (fork) => {
-      this.log(`Fork context created: ${fork.id}`);
-    });
-    this.forkManager.on("started", (fork) => {
-      this.log(`Fork context started: ${fork.id}`);
-      this.emit("fork:started", fork.id);
-    });
-    this.forkManager.on("completed", (fork, result) => {
-      this.log(`Fork context completed: ${fork.id} (${result.durationMs}ms)`);
-    });
-    this.forkManager.on("failed", (fork, error) => {
-      this.log(`Fork context failed: ${fork.id} - ${error}`);
-    });
-    this.forkManager.on("timeout", (fork) => {
-      this.log(`Fork context timed out: ${fork.id}`);
-      this.emit("fork:failed", fork.id, "Timeout");
-    });
-    this.forkManager.on("cancelled", (fork) => {
-      this.log(`Fork context cancelled: ${fork.id}`);
-    });
-  }
-}
-
-const WORKFLOW_PRESETS = [
-  {
-    id: "analyze",
-    name: "Code Analysis",
-    description: "Analyze codebase structure, dependencies, and quality",
-    taskTemplate: (input) => ({
-      id: nanoid(),
-      name: "Analyze Codebase",
-      description: input || "Analyze the codebase for structure, dependencies, and quality issues",
-      type: "analysis",
-      priority: "normal",
-      status: "pending",
-      requiredCapabilities: [
-        {
-          id: "code-analysis",
-          name: "Code Analysis",
-          model: "sonnet",
-          specialties: ["static-analysis", "dependency-analysis"],
-          strength: 0.9,
-          costFactor: 1
-        }
-      ],
-      input: {
-        parameters: { task: input },
-        instructions: input
-      },
-      dependencies: [],
-      maxRetries: 3,
-      retryCount: 0,
-      metadata: {
-        tags: ["analysis", "code-quality"]
-      },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      progress: 0
-    })
-  },
-  {
-    id: "fix",
-    name: "Bug Fix",
-    description: "Identify and fix bugs in the codebase",
-    taskTemplate: (input) => ({
-      id: nanoid(),
-      name: "Fix Bugs",
-      description: input || "Identify and fix bugs in the codebase",
-      type: "bug-fix",
-      priority: "high",
-      status: "pending",
-      requiredCapabilities: [
-        {
-          id: "debugging",
-          name: "Debugging",
-          model: "sonnet",
-          specialties: ["bug-detection", "code-repair"],
-          strength: 0.85,
-          costFactor: 1.2
-        }
-      ],
-      input: {
-        parameters: { task: input },
-        instructions: input
-      },
-      dependencies: [],
-      maxRetries: 3,
-      retryCount: 0,
-      metadata: {
-        tags: ["bug-fix", "debugging"]
-      },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      progress: 0
-    })
-  },
-  {
-    id: "test",
-    name: "Test Generation",
-    description: "Generate comprehensive test suites",
-    taskTemplate: (input) => ({
-      id: nanoid(),
-      name: "Generate Tests",
-      description: input || "Generate comprehensive test suites for the codebase",
-      type: "testing",
-      priority: "normal",
-      status: "pending",
-      requiredCapabilities: [
-        {
-          id: "test-generation",
-          name: "Test Generation",
-          model: "sonnet",
-          specialties: ["unit-testing", "integration-testing"],
-          strength: 0.8,
-          costFactor: 1
-        }
-      ],
-      input: {
-        parameters: { task: input },
-        instructions: input
-      },
-      dependencies: [],
-      maxRetries: 3,
-      retryCount: 0,
-      metadata: {
-        tags: ["testing", "quality-assurance"]
-      },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      progress: 0
-    })
-  },
-  {
-    id: "optimize",
-    name: "Code Optimization",
-    description: "Optimize code for performance and efficiency",
-    taskTemplate: (input) => ({
-      id: nanoid(),
-      name: "Optimize Code",
-      description: input || "Optimize code for performance and efficiency",
-      type: "optimization",
-      priority: "normal",
-      status: "pending",
-      requiredCapabilities: [
-        {
-          id: "optimization",
-          name: "Code Optimization",
-          model: "sonnet",
-          specialties: ["performance-tuning", "refactoring"],
-          strength: 0.85,
-          costFactor: 1.1
-        }
-      ],
-      input: {
-        parameters: { task: input },
-        instructions: input
-      },
-      dependencies: [],
-      maxRetries: 3,
-      retryCount: 0,
-      metadata: {
-        tags: ["optimization", "performance"]
-      },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      progress: 0
-    })
-  }
-];
-async function handleAgentsCommand(args, options = {}) {
-  const subcommand = args[0];
-  switch (subcommand) {
-    case "run":
-      await runAgentTeam(options);
-      break;
-    case "status":
-      await showStatus(options);
-      break;
-    case "list":
-      await listWorkflows(options);
-      break;
-    case "cancel":
-      await cancelConvoy(args[1]);
-      break;
-    default:
-      showHelp();
-  }
-}
-async function runAgentTeam(options) {
-  if (!options.task) {
-    console.log(a.red("Error: Please specify a task with --task"));
-    console.log(a.dim('Example: agents run --task "Analyze the codebase"'));
-    return;
-  }
-  const workflow = options.workflow ? WORKFLOW_PRESETS.find((w) => w.id === options.workflow) : WORKFLOW_PRESETS[0];
-  if (options.workflow && !workflow) {
-    console.log(a.red(`Error: Unknown workflow: ${options.workflow}`));
-    console.log(a.dim('Run "agents list" to see available workflows'));
-    return;
-  }
-  console.log(a.cyan("\n\u{1F916} Starting Agent Team\n"));
-  console.log(a.bold("Task:"), options.task);
-  if (workflow) {
-    console.log(a.bold("Workflow:"), workflow.name);
-  }
-  console.log("");
-  const task = workflow.taskTemplate(options.task);
-  const convoyManager = getGlobalConvoyManager();
-  await convoyManager.initialize();
-  const convoy = await convoyManager.create(`Agent Team: ${task.name}`, {
-    description: task.description,
-    createdBy: "cli",
-    notifyOnComplete: true,
-    notifyOnFailure: true,
-    tags: ["agent-team", workflow?.id || "custom"]
-  });
-  await convoyManager.addTask(convoy.id, task.name, {
-    description: task.description
-  });
-  await convoyManager.start(convoy.id);
-  const orchestrator = new BrainOrchestrator({
-    maxConcurrentTasks: 10,
-    maxConcurrentAgents: 5,
-    verboseLogging: options.verbose || false,
-    enableParallelExecution: true
-  });
-  const spinner = ora("Initializing agent team...").start();
-  orchestrator.on("plan:created", (plan) => {
-    spinner.text = `Created plan with ${plan.tasks.length} tasks`;
-  });
-  orchestrator.on("task:started", (task2) => {
-    spinner.text = `Executing: ${task2.name}`;
-  });
-  orchestrator.on("task:completed", (task2) => {
-    spinner.succeed(`Completed: ${task2.name}`);
-    spinner.start();
-  });
-  orchestrator.on("task:failed", (task2, error) => {
-    spinner.fail(`Failed: ${task2.name} - ${error.message}`);
-    spinner.start();
-  });
-  try {
-    const result = await orchestrator.execute(task);
-    spinner.stop();
-    const convoyTask = convoy.tasks[0];
-    if (result.success) {
-      await convoyManager.completeTask(convoy.id, convoyTask.id, result);
-    } else {
-      await convoyManager.failTask(
-        convoy.id,
-        convoyTask.id,
-        result.errors[0]?.message || "Unknown error"
-      );
-    }
-    console.log("");
-    if (result.success) {
-      console.log(a.green("\u2705 Agent team completed successfully!"));
-    } else {
-      console.log(a.red("\u274C Agent team failed"));
-    }
-    console.log("");
-    console.log(a.bold("Results:"));
-    console.log(a.dim("\u2500".repeat(60)));
-    if (options.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      console.log(a.dim(`Status: ${result.status}`));
-      console.log(a.dim(`Tasks Completed: ${result.completedTasks.length}`));
-      console.log(a.dim(`Tasks Failed: ${result.failedTasks.length}`));
-      console.log(a.dim(`Duration: ${result.duration}ms`));
-      console.log(a.dim(`Success Rate: ${(result.metrics.successRate * 100).toFixed(1)}%`));
-      if (result.errors.length > 0) {
-        console.log("");
-        console.log(a.bold("Errors:"));
-        for (const error of result.errors) {
-          console.log(a.red(`  \u2022 ${error.message}`));
-        }
-      }
-      if (result.warnings.length > 0) {
-        console.log("");
-        console.log(a.bold("Warnings:"));
-        for (const warning of result.warnings) {
-          console.log(a.yellow(`  \u2022 ${warning}`));
-        }
-      }
-    }
-    console.log(a.dim("\u2500".repeat(60)));
-    console.log("");
-    console.log(a.dim(`Convoy ID: ${convoy.id}`));
-    console.log(a.dim('Run "agents status" to see all convoys'));
-  } catch (error) {
-    spinner.fail("Agent team execution failed");
-    console.log(a.red(`
-\u274C Error: ${error instanceof Error ? error.message : error}`));
-    const convoyTask = convoy.tasks[0];
-    await convoyManager.failTask(
-      convoy.id,
-      convoyTask.id,
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-}
-async function showStatus(options) {
-  const convoyManager = getGlobalConvoyManager();
-  await convoyManager.initialize();
-  const activeConvoys = convoyManager.getActive();
-  const allConvoys = convoyManager.list();
-  if (options.json) {
-    console.log(JSON.stringify({ active: activeConvoys, all: allConvoys }, null, 2));
-    return;
-  }
-  console.log(a.cyan("\n\u{1F680} Agent Teams Status\n"));
-  if (activeConvoys.length === 0) {
-    console.log(a.dim("No active convoys"));
-  } else {
-    console.log(a.bold("Active Convoys:"));
-    console.log("");
-    for (const convoy of activeConvoys) {
-      console.log(`  ${a.bold(convoy.name)} ${a.dim(`(${convoy.id})`)}`);
-      console.log(a.dim(`    Status: ${convoy.status}`));
-      console.log(a.dim(`    Progress: ${convoy.progress}%`));
-      console.log(a.dim(`    Tasks: ${convoy.completedTasks}/${convoy.totalTasks}`));
-      console.log("");
-    }
-  }
-  const recentConvoys = allConvoys.slice(0, 5);
-  if (recentConvoys.length > 0) {
-    console.log(a.bold("Recent Convoys:"));
-    console.log("");
-    for (const convoy of recentConvoys) {
-      const statusIcon = convoy.status === "completed" ? "\u2705" : convoy.status === "failed" ? "\u274C" : "\u23F8\uFE0F";
-      console.log(`  ${statusIcon} ${a.bold(convoy.name)} ${a.dim(`(${convoy.id})`)}`);
-      console.log(a.dim(`    Status: ${convoy.status}`));
-      console.log(a.dim(`    Progress: ${convoy.progress}%`));
-      console.log(a.dim(`    Created: ${new Date(convoy.createdAt).toLocaleString()}`));
-      console.log("");
-    }
-  }
-  console.log(a.dim(`Total convoys: ${allConvoys.length}`));
-}
-async function listWorkflows(options) {
-  if (options.json) {
-    console.log(JSON.stringify(WORKFLOW_PRESETS, null, 2));
-    return;
-  }
-  console.log(a.cyan("\n\u{1F4CB} Available Workflow Presets\n"));
-  for (const workflow of WORKFLOW_PRESETS) {
-    console.log(`  ${a.bold(workflow.name)} ${a.dim(`(${workflow.id})`)}`);
-    console.log(a.dim(`    ${workflow.description}`));
-    console.log("");
-  }
-  console.log(a.dim("Usage:"));
-  console.log(a.dim('  agents run --task "Your task" --workflow <id>'));
-  console.log("");
-  console.log(a.dim("Example:"));
-  console.log(a.dim('  agents run --task "Find performance bottlenecks" --workflow optimize'));
-}
-async function cancelConvoy(convoyId, _options) {
-  if (!convoyId) {
-    console.log(a.red("Error: Please specify a convoy ID"));
-    console.log(a.dim("Example: agents cancel cv-abc123"));
-    return;
-  }
-  const convoyManager = getGlobalConvoyManager();
-  await convoyManager.initialize();
-  const convoy = convoyManager.get(convoyId);
-  if (!convoy) {
-    console.log(a.red(`Error: Convoy not found: ${convoyId}`));
-    return;
-  }
-  await convoyManager.cancel(convoyId);
-  console.log(a.green(`\u2705 Cancelled convoy: ${convoy.name}`));
-}
-function showHelp() {
-  console.log(`
-${a.bold(a.cyan("\u{1F916} Agent Teams Command"))}
-
-${a.bold("Usage:")}
-  agents <command> [options]
-
-${a.bold("Commands:")}
-  ${a.green("run")}              Execute a task with agent teams
-  ${a.green("status")}           Show active convoys and status
-  ${a.green("list")}             List available workflow presets
-  ${a.green("cancel")} <id>      Cancel a running convoy
-
-${a.bold("Options:")}
-  --task <task>       Task description (required for run)
-  --workflow <id>     Workflow preset (analyze, fix, test, optimize)
-  --verbose, -v       Enable verbose logging
-  --json              Output as JSON
-
-${a.bold("Examples:")}
-  ${a.dim("# Run code analysis")}
-  agents run --task "Analyze the codebase for issues"
-
-  ${a.dim("# Run with specific workflow")}
-  agents run --task "Fix memory leaks" --workflow fix
-
-  ${a.dim("# Show status")}
-  agents status
-
-  ${a.dim("# List workflows")}
-  agents list
-
-  ${a.dim("# Cancel convoy")}
-  agents cancel cv-abc123
-
-${a.bold("Workflow Presets:")}
-  ${a.green("analyze")}    - Code analysis and quality checks
-  ${a.green("fix")}        - Bug detection and fixing
-  ${a.green("test")}       - Test generation and coverage
-  ${a.green("optimize")}   - Performance optimization
-`);
-}
-
-export { handleAgentsCommand as default, handleAgentsCommand };