ccjk 14.2.2 → 15.0.0

package/dist/chunks/cli-hook.mjs

@@ -1,4096 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { DEFAULT_CODE_TOOL_TYPE, isCodeToolType, getCodeToolNativeSlashCommands } from './constants.mjs';
-import { readZcfConfig } from './ccjk-config.mjs';
-import { a as getGlobalStateManager, g as getGlobalConvoyManager, c as contextLoader, S as SessionIntelligence } from './session-manager.mjs';
-import { l as logger } from '../shared/ccjk.8oaxX4iR.mjs';
-import { Buffer } from 'node:buffer';
-import { randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
-import { d as dirname, j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
-import process__default from 'node:process';
-import 'node:os';
-import './index2.mjs';
-import 'node:url';
-import '../shared/ccjk.BBtCGd_g.mjs';
-import './index3.mjs';
-import './fs-operations.mjs';
-import 'node:fs/promises';
-import './json-config.mjs';
-import '../shared/ccjk.RyizuzOI.mjs';
-import '../shared/ccjk.BAGoDD49.mjs';
-import './main.mjs';
-import 'module';
-import 'node:child_process';
-import 'node:path';
-import 'node:stream';
-import 'node:readline';
-import 'tinyglobby';
-import '../shared/ccjk.DlTXS9rP.mjs';
-import './index5.mjs';
-import '../shared/ccjk.wLJHO0Af.mjs';
-
-class HookRegistry {
-  hooks = /* @__PURE__ */ new Map();
-  /**
-   * Register a hook for an event
-   */
-  register(event, hook) {
-    const hooks = this.hooks.get(event) || [];
-    hooks.push(hook);
-    hooks.sort((a, b) => (b.priority || 0) - (a.priority || 0));
-    this.hooks.set(event, hooks);
-    logger.debug(`Registered hook "${hook.name}" for event "${event}"`);
-  }
-  /**
-   * Unregister a hook
-   */
-  unregister(event, hookName) {
-    const hooks = this.hooks.get(event);
-    if (!hooks)
-      return;
-    const filtered = hooks.filter((h) => h.name !== hookName);
-    this.hooks.set(event, filtered);
-    logger.debug(`Unregistered hook "${hookName}" for event "${event}"`);
-  }
-  /**
-   * Execute all hooks for an event
-   * Returns false if any hook returns continue: false
-   */
-  async execute(context) {
-    const hooks = this.hooks.get(context.event) || [];
-    const enabledHooks = hooks.filter((h) => h.enabled !== false);
-    if (enabledHooks.length === 0) {
-      return { continue: true };
-    }
-    let currentContext = context;
-    let aggregatedData = {};
-    for (const hook of enabledHooks) {
-      try {
-        const result = await hook.fn(currentContext);
-        if (result.data) {
-          aggregatedData = { ...aggregatedData, ...result.data };
-        }
-        if (!result.continue) {
-          return {
-            continue: false,
-            data: aggregatedData,
-            error: result.error
-          };
-        }
-        currentContext = {
-          ...currentContext,
-          data: { ...currentContext.data, ...aggregatedData }
-        };
-      } catch (error) {
-        logger.error(`Hook "${hook.name}" failed:`, error);
-      }
-    }
-    return {
-      continue: true,
-      data: aggregatedData
-    };
-  }
-  /**
-   * Get all registered hooks for an event
-   */
-  getHooks(event) {
-    return this.hooks.get(event) || [];
-  }
-  /**
-   * Clear all hooks
-   */
-  clear() {
-    this.hooks.clear();
-  }
-}
-const hookRegistry = new HookRegistry();
-
-async function emitCommandHookEvent(event, data, sessionId) {
-  try {
-    const context = {
-      event,
-      sessionId,
-      data,
-      timestamp: Date.now(),
-      metadata: {
-        source: "brain-router"
-      }
-    };
-    await hookRegistry.execute(context);
-  } catch (error) {
-    logger.debug(`Command hook bridge skipped for "${event}": ${String(error)}`);
-  }
-}
-
-const DEFAULT_CONFIG = {
-  enablePersistence: false,
-  maxHistorySize: 1e3,
-  messageRetentionTime: 24 * 60 * 60 * 1e3,
-  // 24 hours
-  enableLogging: true,
-  logLevel: "info",
-  enableValidation: true,
-  maxMessageSize: 1024 * 1024,
-  // 1MB
-  enableDeadLetterQueue: true
-};
-class FileMessageStorage {
-  filePath;
-  constructor(filePath) {
-    this.filePath = filePath;
-    this.ensureDirectory();
-  }
-  ensureDirectory() {
-    const dir = dirname(this.filePath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-  }
-  async save(message) {
-    try {
-      const messages = await this.load();
-      messages.push(message);
-      writeFileSync(this.filePath, JSON.stringify(messages, null, 2), "utf-8");
-    } catch (error) {
-      console.error("Failed to save message:", error);
-      throw error;
-    }
-  }
-  async load(filter) {
-    try {
-      if (!existsSync(this.filePath)) {
-        return [];
-      }
-      const content = readFileSync(this.filePath, "utf-8");
-      const messages = JSON.parse(content);
-      if (filter) {
-        return messages.filter(filter);
-      }
-      return messages;
-    } catch (error) {
-      console.error("Failed to load messages:", error);
-      return [];
-    }
-  }
-  async delete(messageId) {
-    try {
-      const messages = await this.load();
-      const filtered = messages.filter((msg) => msg.id !== messageId);
-      writeFileSync(this.filePath, JSON.stringify(filtered, null, 2), "utf-8");
-    } catch (error) {
-      console.error("Failed to delete message:", error);
-      throw error;
-    }
-  }
-  async clear() {
-    try {
-      writeFileSync(this.filePath, JSON.stringify([], null, 2), "utf-8");
-    } catch (error) {
-      console.error("Failed to clear messages:", error);
-      throw error;
-    }
-  }
-  async getStats() {
-    try {
-      if (!existsSync(this.filePath)) {
-        return { count: 0, size: 0 };
-      }
-      const messages = await this.load();
-      const content = readFileSync(this.filePath, "utf-8");
-      return {
-        count: messages.length,
-        size: Buffer.byteLength(content, "utf-8")
-      };
-    } catch (error) {
-      console.error("Failed to get storage stats:", error);
-      return { count: 0, size: 0 };
-    }
-  }
-}
-class MessageBus {
-  config;
-  subscriptions;
-  messageHistory;
-  deadLetterQueue;
-  storage;
-  stats;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.subscriptions = /* @__PURE__ */ new Map();
-    this.messageHistory = [];
-    this.deadLetterQueue = [];
-    if (this.config.enablePersistence && this.config.persistencePath) {
-      this.storage = new FileMessageStorage(this.config.persistencePath);
-      this.loadPersistedMessages();
-    }
-    this.stats = {
-      totalMessages: 0,
-      messagesByType: {},
-      messagesByStatus: {},
-      activeSubscriptions: 0,
-      historySize: 0,
-      deadLetterQueueSize: 0,
-      avgProcessingTime: 0
-    };
-    this.startCleanupInterval();
-  }
-  /**
-   * Publish a message to the bus
-   */
-  async publish(type, from, to, subject, payload, options = {}) {
-    const message = {
-      id: randomUUID(),
-      type,
-      from,
-      to,
-      subject,
-      payload,
-      priority: options.priority || "normal",
-      status: "pending",
-      timestamp: Date.now(),
-      correlationId: options.correlationId,
-      replyTo: options.replyTo,
-      metadata: options.metadata
-    };
-    if (this.config.enableValidation) {
-      this.validateMessage(message);
-    }
-    this.logMessage("publish", message);
-    this.updateStats(message);
-    this.addToHistory(message);
-    if (this.storage) {
-      await this.storage.save(message);
-    }
-    await this.routeMessage(message);
-    return message.id;
-  }
-  /**
-   * Subscribe to messages
-   */
-  subscribe(subscriber, handler, options = {}) {
-    const subscription = {
-      id: randomUUID(),
-      subscriber,
-      options,
-      handler,
-      createdAt: Date.now(),
-      unsubscribe: () => this.unsubscribe(subscription.id)
-    };
-    this.subscriptions.set(subscription.id, subscription);
-    this.stats.activeSubscriptions = this.subscriptions.size;
-    this.log("info", `Agent ${subscriber} subscribed with ID ${subscription.id}`);
-    return subscription;
-  }
-  /**
-   * Unsubscribe from messages
-   */
-  unsubscribe(subscriptionId) {
-    const subscription = this.subscriptions.get(subscriptionId);
-    if (subscription) {
-      this.subscriptions.delete(subscriptionId);
-      this.stats.activeSubscriptions = this.subscriptions.size;
-      this.log("info", `Subscription ${subscriptionId} removed`);
-    }
-  }
-  /**
-   * Get message by ID
-   */
-  getMessage(messageId) {
-    return this.messageHistory.find((msg) => msg.id === messageId);
-  }
-  /**
-   * Get messages by filter
-   */
-  getMessages(filter) {
-    return this.messageHistory.filter(filter);
-  }
-  /**
-   * Update message status
-   */
-  async updateMessageStatus(messageId, status, error) {
-    const message = this.getMessage(messageId);
-    if (message) {
-      message.status = status;
-      if (error) {
-        message.error = error;
-      }
-      if (status === "failed" && this.config.enableDeadLetterQueue) {
-        this.deadLetterQueue.push(message);
-        this.stats.deadLetterQueueSize = this.deadLetterQueue.length;
-      }
-      this.stats.messagesByStatus[status] = (this.stats.messagesByStatus[status] || 0) + 1;
-      if (this.storage) {
-        await this.storage.save(message);
-      }
-      this.log("debug", `Message ${messageId} status updated to ${status}`);
-    }
-  }
-  /**
-   * Get message bus statistics
-   */
-  getStats() {
-    return { ...this.stats };
-  }
-  /**
-   * Clear message history
-   */
-  async clearHistory() {
-    this.messageHistory = [];
-    this.stats.historySize = 0;
-    if (this.storage) {
-      await this.storage.clear();
-    }
-    this.log("info", "Message history cleared");
-  }
-  /**
-   * Clear dead letter queue
-   */
-  clearDeadLetterQueue() {
-    this.deadLetterQueue = [];
-    this.stats.deadLetterQueueSize = 0;
-    this.log("info", "Dead letter queue cleared");
-  }
-  /**
-   * Get dead letter queue messages
-   */
-  getDeadLetterQueue() {
-    return [...this.deadLetterQueue];
-  }
-  /**
-   * Shutdown message bus
-   */
-  async shutdown() {
-    this.log("info", "Shutting down message bus");
-    this.subscriptions.clear();
-    this.stats.activeSubscriptions = 0;
-    if (this.storage && this.messageHistory.length > 0) {
-      for (const message of this.messageHistory) {
-        await this.storage.save(message);
-      }
-    }
-    this.log("info", "Message bus shutdown complete");
-  }
-  /**
-   * Route message to subscribers
-   */
-  async routeMessage(message) {
-    const startTime = Date.now();
-    const matchingSubscriptions = this.findMatchingSubscriptions(message);
-    this.log("debug", `Routing message ${message.id} to ${matchingSubscriptions.length} subscribers`);
-    for (const subscription of matchingSubscriptions) {
-      try {
-        message.status = "processing";
-        if (subscription.options.async) {
-          await subscription.handler(message);
-        } else {
-          subscription.handler(message);
-        }
-        message.status = "completed";
-      } catch (error) {
-        this.log("error", `Error handling message ${message.id} in subscription ${subscription.id}:`, error);
-        await this.updateMessageStatus(message.id, "failed", {
-          code: "HANDLER_ERROR",
-          message: error instanceof Error ? error.message : String(error),
-          stack: error instanceof Error ? error.stack : void 0
-        });
-      }
-    }
-    const processingTime = Date.now() - startTime;
-    this.stats.avgProcessingTime = (this.stats.avgProcessingTime + processingTime) / 2;
-  }
-  /**
-   * Find subscriptions matching the message
-   */
-  findMatchingSubscriptions(message) {
-    const matching = [];
-    const subscriptions = Array.from(this.subscriptions.values());
-    for (const subscription of subscriptions) {
-      const isAddressed = message.to === "all" || message.to === subscription.subscriber || Array.isArray(message.to) && message.to.includes(subscription.subscriber);
-      if (!isAddressed) {
-        continue;
-      }
-      if (!this.matchesSubscriptionFilters(message, subscription.options)) {
-        continue;
-      }
-      matching.push(subscription);
-    }
-    return matching;
-  }
-  /**
-   * Check if message matches subscription filters
-   */
-  matchesSubscriptionFilters(message, options) {
-    if (options.type) {
-      const types = Array.isArray(options.type) ? options.type : [options.type];
-      if (!types.includes(message.type)) {
-        return false;
-      }
-    }
-    if (options.from) {
-      const senders = Array.isArray(options.from) ? options.from : [options.from];
-      if (!senders.includes(message.from)) {
-        return false;
-      }
-    }
-    if (options.priority) {
-      const priorities = Array.isArray(options.priority) ? options.priority : [options.priority];
-      if (!priorities.includes(message.priority)) {
-        return false;
-      }
-    }
-    if (options.filter && !options.filter(message)) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Validate message
-   */
-  validateMessage(message) {
-    if (!message.id) {
-      throw new Error("Message ID is required");
-    }
-    if (!message.type) {
-      throw new Error("Message type is required");
-    }
-    if (!message.from) {
-      throw new Error("Message sender is required");
-    }
-    if (!message.to) {
-      throw new Error("Message recipient is required");
-    }
-    if (!message.subject) {
-      throw new Error("Message subject is required");
-    }
-    if (this.config.maxMessageSize) {
-      const messageSize = Buffer.byteLength(JSON.stringify(message), "utf-8");
-      if (messageSize > this.config.maxMessageSize) {
-        throw new Error(`Message size ${messageSize} exceeds maximum ${this.config.maxMessageSize}`);
-      }
-    }
-  }
-  /**
-   * Add message to history
-   */
-  addToHistory(message) {
-    this.messageHistory.push(message);
-    this.stats.historySize = this.messageHistory.length;
-    const maxHistorySize = this.config.maxHistorySize ?? 1e3;
-    if (this.messageHistory.length > maxHistorySize) {
-      this.messageHistory.shift();
-      this.stats.historySize = this.messageHistory.length;
-    }
-  }
-  /**
-   * Update statistics
-   */
-  updateStats(message) {
-    this.stats.totalMessages++;
-    this.stats.messagesByType[message.type] = (this.stats.messagesByType[message.type] || 0) + 1;
-    this.stats.messagesByStatus[message.status] = (this.stats.messagesByStatus[message.status] || 0) + 1;
-  }
-  /**
-   * Load persisted messages
-   */
-  async loadPersistedMessages() {
-    if (!this.storage) {
-      return;
-    }
-    try {
-      const messages = await this.storage.load();
-      this.messageHistory = messages;
-      this.stats.historySize = messages.length;
-      this.log("info", `Loaded ${messages.length} persisted messages`);
-    } catch (error) {
-      this.log("error", "Failed to load persisted messages:", error);
-    }
-  }
-  /**
-   * Start cleanup interval for old messages
-   */
-  startCleanupInterval() {
-    setInterval(() => {
-      const now = Date.now();
-      const retentionTime = this.config.messageRetentionTime ?? 864e5;
-      this.messageHistory = this.messageHistory.filter(
-        (msg) => now - msg.timestamp < retentionTime
-      );
-      this.stats.historySize = this.messageHistory.length;
-      this.deadLetterQueue = this.deadLetterQueue.filter(
-        (msg) => now - msg.timestamp < retentionTime
-      );
-      this.stats.deadLetterQueueSize = this.deadLetterQueue.length;
-      this.log("debug", "Cleanup completed");
-    }, 60 * 60 * 1e3);
-  }
-  /**
-   * Log message
-   */
-  logMessage(action, message) {
-    if (!this.config.enableLogging) {
-      return;
-    }
-    const logLevel = this.config.logLevel;
-    const shouldLog = logLevel === "debug" || logLevel === "info" && ["publish", "subscribe"].includes(action) || logLevel === "warn" && message.priority === "high" || logLevel === "error" && message.status === "failed";
-    if (shouldLog) {
-      this.log("debug", `[${action}] ${message.type} from ${message.from} to ${message.to}: ${message.subject}`);
-    }
-  }
-  /**
-   * Internal logging
-   */
-  log(level, message, ...args) {
-    if (!this.config.enableLogging) {
-      return;
-    }
-    const levels = ["debug", "info", "warn", "error"];
-    const configLevel = levels.indexOf(this.config.logLevel ?? "info");
-    const messageLevel = levels.indexOf(level);
-    if (messageLevel >= configLevel) {
-      console[level](`[MessageBus] ${message}`, ...args);
-    }
-  }
-}
-let globalMessageBus = null;
-function getMessageBus(config) {
-  if (!globalMessageBus) {
-    globalMessageBus = new MessageBus(config);
-  }
-  return globalMessageBus;
-}
-
-class SkillRegistry extends EventEmitter {
-  skills;
-  filePathIndex;
-  triggerIndex;
-  messageBus = getMessageBus();
-  constructor() {
-    super();
-    this.skills = /* @__PURE__ */ new Map();
-    this.filePathIndex = /* @__PURE__ */ new Map();
-    this.triggerIndex = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Register a skill
-   *
-   * @param skill - Parsed skill file
-   * @param source - Skill source type
-   * @returns Registered entry
-   */
-  register(skill, source = "user") {
-    const id = skill.metadata.name;
-    const existing = this.skills.get(id);
-    const dependencies = this.extractDependencies(skill.metadata);
-    const entry = {
-      id,
-      metadata: skill.metadata,
-      content: skill.content,
-      filePath: skill.filePath,
-      enabled: existing?.enabled ?? true,
-      source,
-      registeredAt: existing?.registeredAt ?? Date.now(),
-      modifiedAt: skill.modifiedAt?.getTime() ?? Date.now(),
-      estimatedTokens: this.estimateTokens(skill),
-      dependencies,
-      dependents: existing?.dependents || /* @__PURE__ */ new Set()
-    };
-    this.skills.set(id, entry);
-    this.filePathIndex.set(skill.filePath, id);
-    this.updateTriggerIndex(id, entry.metadata.triggers);
-    this.updateDependencyGraph(id, dependencies);
-    if (existing) {
-      this.emit("skill:updated", existing, entry);
-      this.publishMessage("skill:updated", { oldSkill: existing, newSkill: entry });
-    } else {
-      this.emit("skill:registered", entry);
-      this.publishMessage("skill:registered", entry);
-    }
-    return entry;
-  }
-  /**
-   * Unregister a skill by ID
-   *
-   * @param id - Skill ID
-   * @returns True if skill was unregistered
-   */
-  unregister(id) {
-    const entry = this.skills.get(id);
-    if (!entry)
-      return false;
-    if (entry.dependents.size > 0) {
-      const dependentList = Array.from(entry.dependents).join(", ");
-      throw new Error(`Cannot unregister skill "${id}": depended upon by: ${dependentList}`);
-    }
-    this.skills.delete(id);
-    this.filePathIndex.delete(entry.filePath);
-    for (const trigger of entry.metadata.triggers) {
-      const skills = this.triggerIndex.get(trigger);
-      if (skills) {
-        skills.delete(id);
-        if (skills.size === 0)
-          this.triggerIndex.delete(trigger);
-      }
-    }
-    for (const dep of entry.dependencies) {
-      const depEntry = this.skills.get(dep);
-      if (depEntry)
-        depEntry.dependents.delete(id);
-    }
-    this.emit("skill:unregistered", entry);
-    this.publishMessage("skill:unregistered", entry);
-    return true;
-  }
-  /**
-   * Unregister a skill by file path
-   *
-   * @param filePath - File path
-   * @returns True if skill was unregistered
-   */
-  unregisterByPath(filePath) {
-    const id = this.filePathIndex.get(filePath);
-    return id ? this.unregister(id) : false;
-  }
-  /**
-   * Get a skill by ID
-   *
-   * @param id - Skill ID
-   * @returns Skill entry or undefined
-   */
-  getById(id) {
-    return this.skills.get(id);
-  }
-  /**
-   * Get a skill by file path
-   *
-   * @param filePath - File path
-   * @returns Skill entry or undefined
-   */
-  getByPath(filePath) {
-    const id = this.filePathIndex.get(filePath);
-    return id ? this.skills.get(id) : void 0;
-  }
-  /**
-   * Get skills by trigger
-   *
-   * @param trigger - Trigger string (e.g., '/commit')
-   * @returns Array of matching skills
-   */
-  getByTrigger(trigger) {
-    const ids = this.triggerIndex.get(trigger);
-    if (!ids)
-      return [];
-    return Array.from(ids).map((id) => this.skills.get(id)).filter((e) => e !== void 0 && e.enabled);
-  }
-  /**
-   * Lookup skills with filters
-   *
-   * @param options - Lookup options
-   * @returns Array of matching skills
-   */
-  lookup(options = {}) {
-    let results = Array.from(this.skills.values());
-    if (options.enabled !== void 0) {
-      results = results.filter((e) => e.enabled === options.enabled);
-    }
-    if (options.category) {
-      results = results.filter((e) => e.metadata.category === options.category);
-    }
-    if (options.source) {
-      results = results.filter((e) => e.source === options.source);
-    }
-    if (options.userInvocable !== void 0) {
-      results = results.filter(
-        (e) => (e.metadata.user_invocable ?? true) === options.userInvocable
-      );
-    }
-    if (options.autoActivate !== void 0) {
-      results = results.filter(
-        (e) => (e.metadata.auto_activate ?? false) === options.autoActivate
-      );
-    }
-    if (options.agent) {
-      results = results.filter(
-        (e) => e.metadata.agent === options.agent || e.metadata.agents?.includes(options.agent)
-      );
-    }
-    if (options.search) {
-      const query = options.search.toLowerCase();
-      results = results.filter(
-        (e) => e.id.toLowerCase().includes(query) || e.metadata.description.toLowerCase().includes(query) || e.metadata.tags?.some((t) => t.toLowerCase().includes(query))
-      );
-    }
-    if (options.sortBy) {
-      const dir = options.sortDir === "desc" ? -1 : 1;
-      results.sort((a, b) => {
-        switch (options.sortBy) {
-          case "name":
-            return a.id.localeCompare(b.id) * dir;
-          case "priority":
-            return ((a.metadata.priority ?? 5) - (b.metadata.priority ?? 5)) * dir;
-          case "registeredAt":
-            return (a.registeredAt - b.registeredAt) * dir;
-          case "modifiedAt":
-            return (a.modifiedAt - b.modifiedAt) * dir;
-          default:
-            return 0;
-        }
-      });
-    }
-    if (options.limit) {
-      results = results.slice(0, options.limit);
-    }
-    return results;
-  }
-  /**
-   * Enable a skill
-   *
-   * @param id - Skill ID
-   * @returns True if enabled
-   */
-  enable(id) {
-    const entry = this.skills.get(id);
-    if (!entry || entry.enabled)
-      return false;
-    entry.enabled = true;
-    this.emit("skill:enabled", entry);
-    this.publishMessage("skill:enabled", entry);
-    return true;
-  }
-  /**
-   * Disable a skill
-   *
-   * @param id - Skill ID
-   * @returns True if disabled
-   */
-  disable(id) {
-    const entry = this.skills.get(id);
-    if (!entry || !entry.enabled)
-      return false;
-    entry.enabled = false;
-    this.emit("skill:disabled", entry);
-    this.publishMessage("skill:disabled", entry);
-    return true;
-  }
-  /**
-   * Toggle skill enabled state
-   *
-   * @param id - Skill ID
-   * @returns New enabled state
-   */
-  toggle(id) {
-    const entry = this.skills.get(id);
-    if (!entry)
-      return false;
-    entry.enabled = !entry.enabled;
-    const event = entry.enabled ? "skill:enabled" : "skill:disabled";
-    this.emit(event, entry);
-    this.publishMessage(event, entry);
-    return entry.enabled;
-  }
-  /**
-   * Check if a skill exists
-   *
-   * @param id - Skill ID
-   * @returns True if skill exists
-   */
-  has(id) {
-    return this.skills.has(id);
-  }
-  /**
-   * Check if a skill is enabled
-   *
-   * @param id - Skill ID
-   * @returns True if enabled, false if disabled or not found
-   */
-  isEnabled(id) {
-    return this.skills.get(id)?.enabled ?? false;
-  }
-  /**
-   * Get all skill IDs
-   *
-   * @returns Array of skill IDs
-   */
-  getIds() {
-    return Array.from(this.skills.keys());
-  }
-  /**
-   * Get all entries
-   *
-   * @returns Array of all entries
-   */
-  getAll() {
-    return Array.from(this.skills.values());
-  }
-  /**
-   * Get enabled entries
-   *
-   * @returns Array of enabled entries
-   */
-  getEnabled() {
-    return this.lookup({ enabled: true });
-  }
-  /**
-   * Get registry statistics
-   *
-   * @returns Registry statistics
-   */
-  getStats() {
-    const all = this.getAll();
-    const enabled = this.getEnabled();
-    const byCategory = {
-      dev: 0,
-      git: 0,
-      review: 0,
-      testing: 0,
-      docs: 0,
-      devops: 0,
-      planning: 0,
-      debugging: 0,
-      custom: 0
-    };
-    const bySource = { builtin: 0, user: 0, marketplace: 0 };
-    let totalTokens = 0;
-    let lastRegistered = 0;
-    let lastModified = 0;
-    for (const entry of all) {
-      byCategory[entry.metadata.category]++;
-      bySource[entry.source]++;
-      totalTokens += entry.estimatedTokens;
-      if (entry.registeredAt > lastRegistered)
-        lastRegistered = entry.registeredAt;
-      if (entry.modifiedAt > lastModified)
-        lastModified = entry.modifiedAt;
-    }
-    return {
-      totalSkills: all.length,
-      enabledSkills: enabled.length,
-      disabledSkills: all.length - enabled.length,
-      byCategory,
-      bySource,
-      totalTokens,
-      lastRegistered: lastRegistered > 0 ? this.getById(this.getEntriesSortedBy("registeredAt")[0]?.id || "")?.id : void 0,
-      lastModified: lastModified > 0 ? this.getById(this.getEntriesSortedBy("modifiedAt")[0]?.id || "")?.id : void 0
-    };
-  }
-  /**
-   * Get dependent skills
-   *
-   * @param id - Skill ID
-   * @returns Array of dependent skill IDs
-   */
-  getDependents(id) {
-    return Array.from(this.skills.get(id)?.dependents || []);
-  }
-  /**
-   * Get skill dependencies
-   *
-   * @param id - Skill ID
-   * @returns Array of dependency IDs
-   */
-  getDependencies(id) {
-    return this.skills.get(id)?.dependencies || [];
-  }
-  /**
-   * Check for missing dependencies
-   *
-   * @param id - Skill ID
-   * @returns Array of missing dependency IDs
-   */
-  getMissingDependencies(id) {
-    const deps = this.getDependencies(id);
-    return deps.filter((dep) => !this.has(dep));
-  }
-  /**
-   * Validate all dependencies
-   *
-   * @returns Map of skill ID to missing dependencies
-   */
-  validateDependencies() {
-    const missing = /* @__PURE__ */ new Map();
-    Array.from(this.skills.entries()).forEach(([id, entry]) => {
-      const missingDeps = entry.dependencies.filter((dep) => !this.has(dep));
-      if (missingDeps.length > 0) {
-        missing.set(id, missingDeps);
-      }
-    });
-    return missing;
-  }
-  /**
-   * Clear all skills from registry
-   */
-  clear() {
-    this.skills.clear();
-    this.filePathIndex.clear();
-    this.triggerIndex.clear();
-    this.emit("registry:cleared");
-    this.publishMessage("registry:cleared", {});
-  }
-  /**
-   * Get the size of the registry
-   *
-   * @returns Number of registered skills
-   */
-  size() {
-    return this.skills.size;
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  /**
-   * Extract dependencies from skill metadata
-   */
-  extractDependencies(metadata) {
-    const deps = [];
-    if (metadata.agents) {
-      deps.push(...metadata.agents);
-    }
-    if (metadata.related_skills) {
-      deps.push(...metadata.related_skills);
-    }
-    return deps;
-  }
-  /**
-   * Update trigger index
-   */
-  updateTriggerIndex(id, triggers) {
-    Array.from(this.triggerIndex.entries()).forEach(([trigger, skillIds]) => {
-      skillIds.delete(id);
-      if (skillIds.size === 0)
-        this.triggerIndex.delete(trigger);
-    });
-    for (const trigger of triggers) {
-      if (!this.triggerIndex.has(trigger)) {
-        this.triggerIndex.set(trigger, /* @__PURE__ */ new Set());
-      }
-      this.triggerIndex.get(trigger).add(id);
-    }
-  }
-  /**
-   * Update dependency graph
-   */
-  updateDependencyGraph(id, dependencies) {
-    Array.from(this.skills.entries()).forEach(([_depId, entry]) => {
-      if (entry.dependencies.includes(id)) {
-        entry.dependents.delete(id);
-      }
-    });
-    for (const dep of dependencies) {
-      const depEntry = this.skills.get(dep);
-      if (depEntry) {
-        depEntry.dependents.add(id);
-      }
-    }
-  }
-  /**
-   * Estimate token count for a skill
-   */
-  estimateTokens(skill) {
-    const contentTokens = Math.ceil(skill.content.length / 4);
-    const metadataTokens = Math.ceil(JSON.stringify(skill.metadata).length / 4);
-    return contentTokens + metadataTokens;
-  }
-  /**
-   * Get entries sorted by a field
-   */
-  getEntriesSortedBy(field) {
-    return Array.from(this.skills.values()).sort((a, b) => b[field] - a[field]);
-  }
-  /**
-   * Publish message to event bus
-   */
-  publishMessage(type, payload) {
-    this.messageBus.publish(
-      type,
-      "coordinator",
-      "all",
-      `Skill registry event: ${type}`,
-      payload,
-      { priority: "normal" }
-    ).catch(console.error);
-  }
-}
-let registryInstance = null;
-function getSkillRegistry() {
-  if (!registryInstance) {
-    registryInstance = new SkillRegistry();
-  }
-  return registryInstance;
-}
-
-class ProgressTracker extends EventEmitter {
-  config;
-  convoyManager;
-  trackedConvoys = /* @__PURE__ */ new Map();
-  taskStartTimes = /* @__PURE__ */ new Map();
-  taskDurations = /* @__PURE__ */ new Map();
-  constructor(convoyManager, config = {}) {
-    super();
-    this.convoyManager = convoyManager;
-    this.config = {
-      updateInterval: config.updateInterval ?? 1e3,
-      consoleOutput: config.consoleOutput ?? false,
-      progressBarWidth: config.progressBarWidth ?? 40
-    };
-    this.setupEventListeners();
-  }
-  /**
-   * Start tracking a convoy
-   */
-  track(convoyId) {
-    if (this.trackedConvoys.has(convoyId)) {
-      return;
-    }
-    const interval = setInterval(() => {
-      this.emitProgress(convoyId);
-    }, this.config.updateInterval);
-    this.trackedConvoys.set(convoyId, interval);
-    this.taskDurations.set(convoyId, []);
-    this.emitProgress(convoyId);
-  }
-  /**
-   * Stop tracking a convoy
-   */
-  untrack(convoyId) {
-    const interval = this.trackedConvoys.get(convoyId);
-    if (interval) {
-      clearInterval(interval);
-      this.trackedConvoys.delete(convoyId);
-    }
-    this.taskDurations.delete(convoyId);
-  }
-  /**
-   * Get current progress for a convoy
-   */
-  getProgress(convoyId) {
-    const convoy = this.convoyManager.get(convoyId);
-    if (!convoy)
-      return null;
-    return this.buildProgressUpdate(convoy);
-  }
-  /**
-   * Get progress bar string
-   */
-  getProgressBar(convoyId) {
-    const convoy = this.convoyManager.get(convoyId);
-    if (!convoy)
-      return "";
-    return this.buildProgressBar(convoy.progress);
-  }
-  /**
-   * Get formatted progress string
-   */
-  getFormattedProgress(convoyId) {
-    const update = this.getProgress(convoyId);
-    if (!update)
-      return "Convoy not found";
-    const lines = [
-      `${update.convoyName} [${update.convoyId}]`,
-      this.buildProgressBar(update.progress),
-      `Status: ${this.formatStatus(update.status)}`,
-      `Progress: ${update.progress}% (${update.completedTasks}/${update.totalTasks})`
-    ];
-    if (update.inProgressTasks > 0) {
-      lines.push(`In Progress: ${update.inProgressTasks}`);
-    }
-    if (update.failedTasks > 0) {
-      lines.push(`Failed: ${update.failedTasks}`);
-    }
-    if (update.currentTasks.length > 0) {
-      lines.push("\nCurrent Tasks:");
-      for (const task of update.currentTasks) {
-        lines.push(`  - ${task.title} (${task.assignedTo ?? "unassigned"})`);
-      }
-    }
-    if (update.estimatedCompletion) {
-      lines.push(`
-ETA: ${this.formatTime(update.estimatedCompletion.getTime() - Date.now())}`);
-    }
-    lines.push(`Elapsed: ${this.formatTime(update.elapsedTime)}`);
-    return lines.join("\n");
-  }
-  /**
-   * Stop all tracking
-   */
-  stopAll() {
-    const convoyIds = Array.from(this.trackedConvoys.keys());
-    for (const convoyId of convoyIds) {
-      this.untrack(convoyId);
-    }
-  }
-  /**
-   * Destroy tracker
-   */
-  destroy() {
-    this.stopAll();
-    this.removeAllListeners();
-  }
-  // ========================================================================
-  // Private Methods
-  // ========================================================================
-  setupEventListeners() {
-    this.convoyManager.on("task:started", (convoy, task) => {
-      this.taskStartTimes.set(task.id, Date.now());
-    });
-    this.convoyManager.on("task:completed", (convoy, task) => {
-      const startTime = this.taskStartTimes.get(task.id);
-      if (startTime) {
-        const duration = Date.now() - startTime;
-        const durations = this.taskDurations.get(convoy.id) ?? [];
-        durations.push(duration);
-        this.taskDurations.set(convoy.id, durations);
-        this.taskStartTimes.delete(task.id);
-      }
-    });
-    this.convoyManager.on("convoy:completed", (convoy) => {
-      this.untrack(convoy.id);
-    });
-    this.convoyManager.on("convoy:failed", (convoy) => {
-      this.untrack(convoy.id);
-    });
-    this.convoyManager.on("convoy:cancelled", (convoy) => {
-      this.untrack(convoy.id);
-    });
-  }
-  emitProgress(convoyId) {
-    const update = this.getProgress(convoyId);
-    if (update) {
-      this.emit("progress", update);
-      if (this.config.consoleOutput) {
-        console.log(this.getFormattedProgress(convoyId));
-      }
-    }
-  }
-  buildProgressUpdate(convoy) {
-    const inProgressTasks = convoy.tasks.filter((t) => t.status === "in_progress").length;
-    const pendingTasks = convoy.tasks.filter((t) => t.status === "pending").length;
-    const currentTasks = convoy.tasks.filter((t) => t.status === "in_progress");
-    const durations = this.taskDurations.get(convoy.id) ?? [];
-    const averageTaskTime = durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0;
-    const elapsedTime = convoy.startedAt ? Date.now() - new Date(convoy.startedAt).getTime() : 0;
-    let estimatedCompletion;
-    if (averageTaskTime > 0 && pendingTasks > 0) {
-      const remainingTime = (pendingTasks + inProgressTasks) * averageTaskTime;
-      estimatedCompletion = new Date(Date.now() + remainingTime);
-    }
-    return {
-      convoyId: convoy.id,
-      convoyName: convoy.name,
-      progress: convoy.progress,
-      status: convoy.status,
-      totalTasks: convoy.totalTasks,
-      completedTasks: convoy.completedTasks,
-      failedTasks: convoy.failedTasks,
-      inProgressTasks,
-      pendingTasks,
-      currentTasks,
-      estimatedCompletion,
-      elapsedTime,
-      averageTaskTime
-    };
-  }
-  buildProgressBar(progress) {
-    const width = this.config.progressBarWidth;
-    const filled = Math.round(progress / 100 * width);
-    const empty = width - filled;
-    const filledChar = "\u2588";
-    const emptyChar = "\u2591";
-    return `[${filledChar.repeat(filled)}${emptyChar.repeat(empty)}] ${progress}%`;
-  }
-  formatStatus(status) {
-    const statusMap = {
-      pending: "\u23F3 Pending",
-      in_progress: "\u{1F504} In Progress",
-      completed: "\u2705 Completed",
-      failed: "\u274C Failed",
-      cancelled: "\u{1F6AB} Cancelled",
-      paused: "\u23F8\uFE0F Paused"
-    };
-    return statusMap[status] ?? status;
-  }
-  formatTime(ms) {
-    if (ms < 0)
-      return "0s";
-    const seconds = Math.floor(ms / 1e3);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    if (hours > 0) {
-      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-    }
-    if (minutes > 0) {
-      return `${minutes}m ${seconds % 60}s`;
-    }
-    return `${seconds}s`;
-  }
-}
-
-class PersistentMailboxManager extends EventEmitter {
-  stateManager;
-  mailboxes = /* @__PURE__ */ new Map();
-  expirationCheckInterval = null;
-  initialized = false;
-  constructor(stateManager) {
-    super();
-    this.stateManager = stateManager ?? getGlobalStateManager();
-    this.expirationCheckInterval = setInterval(() => {
-      this.checkExpiredMessages();
-    }, 6e4);
-  }
-  /**
-   * Initialize mailbox manager
-   */
-  async initialize() {
-    if (this.initialized)
-      return;
-    await this.stateManager.initialize();
-    for (const agentId of this.stateManager.getAgentIds()) {
-      await this.loadMailbox(agentId);
-    }
-    this.initialized = true;
-  }
-  /**
-   * Create mailbox for agent
-   */
-  async createMailbox(agentId) {
-    await this.ensureInitialized();
-    if (this.mailboxes.has(agentId)) {
-      return this.mailboxes.get(agentId);
-    }
-    const mailbox = {
-      agentId,
-      inbox: [],
-      outbox: [],
-      archive: [],
-      updatedAt: Date.now()
-    };
-    this.mailboxes.set(agentId, mailbox);
-    await this.persistMailbox(agentId);
-    this.emit("mailbox:created", agentId);
-    return mailbox;
-  }
-  /**
-   * Get mailbox for agent
-   */
-  async getMailbox(agentId) {
-    await this.ensureInitialized();
-    if (!this.mailboxes.has(agentId)) {
-      return this.createMailbox(agentId);
-    }
-    return this.mailboxes.get(agentId);
-  }
-  /**
-   * Send message to agent
-   */
-  async send(from, to, subject, body, options = {}) {
-    await this.ensureInitialized();
-    const message = {
-      id: nanoid(),
-      from,
-      to,
-      subject,
-      body,
-      priority: options.priority ?? "normal",
-      timestamp: Date.now(),
-      read: false,
-      archived: false,
-      correlationId: options.correlationId,
-      replyTo: options.replyTo,
-      expiresAt: options.expiresIn ? Date.now() + options.expiresIn : void 0,
-      metadata: options.metadata
-    };
-    const senderMailbox = await this.getMailbox(from);
-    senderMailbox.outbox.push(message);
-    senderMailbox.updatedAt = Date.now();
-    await this.persistMailbox(from);
-    const recipientMailbox = await this.getMailbox(to);
-    recipientMailbox.inbox.push(message);
-    recipientMailbox.updatedAt = Date.now();
-    await this.persistMailbox(to);
-    this.emit("message:sent", message);
-    this.emit("message:received", message);
-    return message;
-  }
-  /**
-   * Reply to a message
-   */
-  async reply(originalMessage, from, body, options = {}) {
-    return this.send(
-      from,
-      originalMessage.replyTo ?? originalMessage.from,
-      `Re: ${originalMessage.subject}`,
-      body,
-      {
-        ...options,
-        correlationId: originalMessage.id
-      }
-    );
-  }
-  /**
-   * Broadcast message to multiple agents
-   */
-  async broadcast(from, toAgents, subject, body, options = {}) {
-    const messages = [];
-    for (const to of toAgents) {
-      const message = await this.send(from, to, subject, body, options);
-      messages.push(message);
-    }
-    return messages;
-  }
-  /**
-   * Check inbox for unread messages
-   */
-  async checkInbox(agentId) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    return mailbox.inbox.filter((m) => !m.read && !m.archived);
-  }
-  /**
-   * Get unread message count
-   */
-  async getUnreadCount(agentId) {
-    const unread = await this.checkInbox(agentId);
-    return unread.length;
-  }
-  /**
-   * Get messages by priority
-   */
-  async getByPriority(agentId, priority) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    return mailbox.inbox.filter((m) => m.priority === priority && !m.archived);
-  }
-  /**
-   * Get messages by correlation ID
-   */
-  async getByCorrelationId(agentId, correlationId) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    return [
-      ...mailbox.inbox.filter((m) => m.correlationId === correlationId),
-      ...mailbox.outbox.filter((m) => m.correlationId === correlationId)
-    ];
-  }
-  /**
-   * Mark message as read
-   */
-  async markAsRead(agentId, messageId) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    const message = mailbox.inbox.find((m) => m.id === messageId);
-    if (message && !message.read) {
-      message.read = true;
-      mailbox.updatedAt = Date.now();
-      await this.persistMailbox(agentId);
-      this.emit("message:read", messageId, agentId);
-    }
-  }
-  /**
-   * Mark all messages as read
-   */
-  async markAllAsRead(agentId) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    let count = 0;
-    for (const message of mailbox.inbox) {
-      if (!message.read) {
-        message.read = true;
-        count++;
-        this.emit("message:read", message.id, agentId);
-      }
-    }
-    if (count > 0) {
-      mailbox.updatedAt = Date.now();
-      await this.persistMailbox(agentId);
-    }
-    return count;
-  }
-  /**
-   * Archive message
-   */
-  async archive(agentId, messageId) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    const inboxIndex = mailbox.inbox.findIndex((m) => m.id === messageId);
-    if (inboxIndex !== -1) {
-      const [message] = mailbox.inbox.splice(inboxIndex, 1);
-      message.archived = true;
-      mailbox.archive.push(message);
-      mailbox.updatedAt = Date.now();
-      await this.persistMailbox(agentId);
-      this.emit("message:archived", messageId, agentId);
-      return;
-    }
-    const outboxIndex = mailbox.outbox.findIndex((m) => m.id === messageId);
-    if (outboxIndex !== -1) {
-      const [message] = mailbox.outbox.splice(outboxIndex, 1);
-      message.archived = true;
-      mailbox.archive.push(message);
-      mailbox.updatedAt = Date.now();
-      await this.persistMailbox(agentId);
-      this.emit("message:archived", messageId, agentId);
-    }
-  }
-  /**
-   * Delete message permanently
-   */
-  async delete(agentId, messageId) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    let deleted = false;
-    for (const arr of [mailbox.inbox, mailbox.outbox, mailbox.archive]) {
-      const index = arr.findIndex((m) => m.id === messageId);
-      if (index !== -1) {
-        arr.splice(index, 1);
-        deleted = true;
-        break;
-      }
-    }
-    if (deleted) {
-      mailbox.updatedAt = Date.now();
-      await this.persistMailbox(agentId);
-    }
-    return deleted;
-  }
-  /**
-   * Search messages
-   */
-  async search(agentId, query) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    const allMessages = [...mailbox.inbox, ...mailbox.outbox, ...mailbox.archive];
-    return allMessages.filter((m) => {
-      if (query.subject && !m.subject.toLowerCase().includes(query.subject.toLowerCase())) {
-        return false;
-      }
-      if (query.from && m.from !== query.from) {
-        return false;
-      }
-      if (query.to && m.to !== query.to) {
-        return false;
-      }
-      if (query.read !== void 0 && m.read !== query.read) {
-        return false;
-      }
-      if (query.priority && m.priority !== query.priority) {
-        return false;
-      }
-      if (query.after && m.timestamp < query.after) {
-        return false;
-      }
-      if (query.before && m.timestamp > query.before) {
-        return false;
-      }
-      return true;
-    });
-  }
-  /**
-   * Get mailbox statistics
-   */
-  async getStats(agentId) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    const unread = mailbox.inbox.filter((m) => !m.read);
-    return {
-      inboxCount: mailbox.inbox.length,
-      outboxCount: mailbox.outbox.length,
-      archiveCount: mailbox.archive.length,
-      unreadCount: unread.length,
-      oldestUnread: unread.length > 0 ? Math.min(...unread.map((m) => m.timestamp)) : null
-    };
-  }
-  /**
-   * Cleanup old archived messages
-   */
-  async cleanupArchive(agentId, olderThanMs) {
-    await this.ensureInitialized();
-    const mailbox = await this.getMailbox(agentId);
-    const cutoff = Date.now() - olderThanMs;
-    const originalLength = mailbox.archive.length;
-    mailbox.archive = mailbox.archive.filter((m) => m.timestamp > cutoff);
-    const removed = originalLength - mailbox.archive.length;
-    if (removed > 0) {
-      mailbox.updatedAt = Date.now();
-      await this.persistMailbox(agentId);
-    }
-    return removed;
-  }
-  /**
-   * Destroy mailbox manager
-   */
-  destroy() {
-    if (this.expirationCheckInterval) {
-      clearInterval(this.expirationCheckInterval);
-    }
-  }
-  // ========================================================================
-  // Private Methods
-  // ========================================================================
-  async ensureInitialized() {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-  }
-  async loadMailbox(agentId) {
-    const agentPath = this.stateManager.getAgentPath(agentId);
-    if (!agentPath)
-      return;
-    const mailboxFile = join(agentPath, "mailbox.json");
-    if (!existsSync(mailboxFile))
-      return;
-    try {
-      const data = JSON.parse(readFileSync(mailboxFile, "utf-8"));
-      this.mailboxes.set(agentId, {
-        agentId,
-        inbox: data.inbox ?? [],
-        outbox: data.outbox ?? [],
-        archive: data.archive ?? [],
-        updatedAt: data.updatedAt ?? Date.now()
-      });
-    } catch {
-    }
-  }
-  async persistMailbox(agentId) {
-    const mailbox = this.mailboxes.get(agentId);
-    if (!mailbox)
-      return;
-    await this.stateManager.createAgentWorktree(agentId);
-    const agentPath = this.stateManager.getAgentPath(agentId);
-    if (!agentPath)
-      return;
-    const mailboxFile = join(agentPath, "mailbox.json");
-    writeFileSync(mailboxFile, JSON.stringify(mailbox, null, 2));
-  }
-  async checkExpiredMessages() {
-    const now = Date.now();
-    const entries = Array.from(this.mailboxes.entries());
-    for (const [agentId, mailbox] of entries) {
-      let changed = false;
-      for (const message of mailbox.inbox) {
-        if (message.expiresAt && message.expiresAt < now && !message.archived) {
-          message.archived = true;
-          mailbox.archive.push(message);
-          changed = true;
-          this.emit("message:expired", message.id);
-        }
-      }
-      mailbox.inbox = mailbox.inbox.filter((m) => !m.archived);
-      if (changed) {
-        mailbox.updatedAt = now;
-        await this.persistMailbox(agentId);
-      }
-    }
-  }
-}
-let globalMailboxManager = null;
-function getGlobalMailboxManager() {
-  if (!globalMailboxManager) {
-    globalMailboxManager = new PersistentMailboxManager();
-  }
-  return globalMailboxManager;
-}
-
-const persistentMailbox = {
-  __proto__: null,
-  PersistentMailboxManager: PersistentMailboxManager,
-  getGlobalMailboxManager: getGlobalMailboxManager
-};
-
-class MayorAgent extends EventEmitter {
-  id;
-  config;
-  convoyManager;
-  mailboxManager;
-  progressTrackers = /* @__PURE__ */ new Map();
-  activeConvoys = /* @__PURE__ */ new Set();
-  constructor(config = {}) {
-    super();
-    this.id = `mayor-${nanoid(6)}`;
-    this.config = {
-      autoCreateConvoy: config.autoCreateConvoy ?? true,
-      autoSpawnWorkers: config.autoSpawnWorkers ?? true,
-      monitorProgress: config.monitorProgress ?? true,
-      progressInterval: config.progressInterval ?? 5e3,
-      notifyHuman: config.notifyHuman ?? true,
-      maxConcurrentWorkers: config.maxConcurrentWorkers ?? 5
-    };
-    this.convoyManager = getGlobalConvoyManager();
-    this.mailboxManager = getGlobalMailboxManager();
-    this.setupEventListeners();
-  }
-  /**
-   * Process user request - main entry point
-   */
-  async processRequest(input) {
-    try {
-      const intent = await this.analyzeIntent(input);
-      this.emit("intent:analyzed", intent);
-      const plan = await this.createTaskPlan(intent);
-      this.emit("plan:created", plan);
-      let convoy = null;
-      if (this.config.autoCreateConvoy) {
-        convoy = await this.createConvoy(plan);
-        this.emit("convoy:created", convoy);
-      }
-      let workerCount = 0;
-      if (this.config.autoSpawnWorkers && convoy) {
-        workerCount = await this.spawnWorkers(convoy, plan);
-        this.emit("workers:spawned", workerCount);
-      }
-      if (this.config.monitorProgress && convoy) {
-        this.startMonitoring(convoy.id);
-      }
-      return {
-        id: nanoid(),
-        convoyId: convoy?.id ?? "",
-        plan,
-        workerCount,
-        message: this.buildResponseMessage(plan, convoy, workerCount),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit("error", err);
-      throw err;
-    }
-  }
-  /**
-   * Analyze user intent from natural language
-   */
-  async analyzeIntent(input) {
-    const lowerInput = input.toLowerCase();
-    let type = "other";
-    if (lowerInput.includes("add") || lowerInput.includes("implement") || lowerInput.includes("create")) {
-      type = "feature";
-    } else if (lowerInput.includes("fix") || lowerInput.includes("bug") || lowerInput.includes("error")) {
-      type = "bugfix";
-    } else if (lowerInput.includes("refactor") || lowerInput.includes("clean") || lowerInput.includes("improve")) {
-      type = "refactor";
-    } else if (lowerInput.includes("research") || lowerInput.includes("investigate")) {
-      type = "research";
-    } else if (lowerInput.includes("document") || lowerInput.includes("docs")) {
-      type = "documentation";
-    } else if (lowerInput.includes("test") || lowerInput.includes("spec")) {
-      type = "testing";
-    } else if (lowerInput.includes("deploy") || lowerInput.includes("release")) {
-      type = "deployment";
-    }
-    const entities = {
-      files: this.extractFiles(input),
-      functions: this.extractFunctions(input),
-      components: this.extractComponents(input),
-      technologies: this.extractTechnologies(input),
-      keywords: this.extractKeywords(input)
-    };
-    const complexity = this.estimateComplexity(input, entities);
-    const requiredRoles = this.determineRequiredRoles(type, entities);
-    return {
-      id: nanoid(),
-      originalInput: input,
-      type,
-      summary: this.generateSummary(input, type),
-      entities,
-      confidence: 0.8,
-      approach: this.suggestApproach(type, complexity),
-      complexity,
-      requiredRoles
-    };
-  }
-  /**
-   * Create task plan from intent
-   */
-  async createTaskPlan(intent) {
-    const tasks = [];
-    switch (intent.type) {
-      case "feature":
-        tasks.push(
-          { title: "Analyze requirements", description: `Understand: ${intent.summary}`, role: "researcher", dependsOn: [], estimatedEffort: "small" },
-          { title: "Design implementation", description: "Create design and identify files", role: "architect", dependsOn: ["task-0"], estimatedEffort: "medium" },
-          { title: "Implement feature", description: "Write the code", role: "coder", dependsOn: ["task-1"], estimatedEffort: "large" },
-          { title: "Write tests", description: "Create tests", role: "tester", dependsOn: ["task-2"], estimatedEffort: "medium" },
-          { title: "Review", description: "Code review", role: "reviewer", dependsOn: ["task-3"], estimatedEffort: "small" }
-        );
-        break;
-      case "bugfix":
-        tasks.push(
-          { title: "Reproduce issue", description: "Understand the bug", role: "researcher", dependsOn: [], estimatedEffort: "small" },
-          { title: "Find root cause", description: "Debug and find cause", role: "debugger", dependsOn: ["task-0"], estimatedEffort: "medium" },
-          { title: "Implement fix", description: "Write the fix", role: "coder", dependsOn: ["task-1"], estimatedEffort: "medium" },
-          { title: "Add regression test", description: "Prevent regression", role: "tester", dependsOn: ["task-2"], estimatedEffort: "small" }
-        );
-        break;
-      case "refactor":
-        tasks.push(
-          { title: "Analyze code", description: "Understand current implementation", role: "researcher", dependsOn: [], estimatedEffort: "medium" },
-          { title: "Plan refactoring", description: "Design approach", role: "architect", dependsOn: ["task-0"], estimatedEffort: "medium" },
-          { title: "Execute refactoring", description: "Perform refactoring", role: "coder", dependsOn: ["task-1"], estimatedEffort: "large" },
-          { title: "Verify tests", description: "Ensure tests pass", role: "tester", dependsOn: ["task-2"], estimatedEffort: "small" }
-        );
-        break;
-      default:
-        tasks.push(
-          { title: "Analyze request", description: `Understand: ${intent.summary}`, role: "researcher", dependsOn: [], estimatedEffort: "small" },
-          { title: "Execute task", description: "Perform the work", role: "coder", dependsOn: ["task-0"], estimatedEffort: "medium" }
-        );
-    }
-    return {
-      id: nanoid(),
-      name: intent.summary,
-      description: `Task plan for: ${intent.originalInput}`,
-      tasks,
-      totalEffort: this.calculateTotalEffort(tasks),
-      risks: this.identifyRisks(intent),
-      successCriteria: this.defineSuccessCriteria(intent)
-    };
-  }
-  /**
-   * Create convoy from task plan
-   */
-  async createConvoy(plan) {
-    const convoy = await this.convoyManager.create(plan.name, {
-      description: plan.description,
-      createdBy: this.id,
-      notifyOnComplete: this.config.notifyHuman,
-      notifyOnFailure: true,
-      notifyOnProgress: true,
-      metadata: { planId: plan.id, totalEffort: plan.totalEffort }
-    });
-    const taskIdMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < plan.tasks.length; i++) {
-      const planTask = plan.tasks[i];
-      const dependsOn = planTask.dependsOn.map((dep) => taskIdMap.get(dep)).filter((id) => id !== void 0);
-      const task = await this.convoyManager.addTask(convoy.id, planTask.title, {
-        description: planTask.description,
-        dependsOn,
-        metadata: { role: planTask.role, estimatedEffort: planTask.estimatedEffort }
-      });
-      taskIdMap.set(`task-${i}`, task.id);
-    }
-    this.activeConvoys.add(convoy.id);
-    return this.convoyManager.get(convoy.id);
-  }
-  /**
-   * Spawn worker agents for convoy
-   */
-  async spawnWorkers(convoy, plan) {
-    const uniqueRoles = new Set(plan.tasks.map((t) => t.role));
-    const workerCount = Math.min(uniqueRoles.size, this.config.maxConcurrentWorkers);
-    await this.convoyManager.start(convoy.id);
-    return workerCount;
-  }
-  /**
-   * Start monitoring convoy progress
-   */
-  startMonitoring(convoyId) {
-    if (this.progressTrackers.has(convoyId))
-      return;
-    const tracker = new ProgressTracker(this.convoyManager, {
-      updateInterval: this.config.progressInterval
-    });
-    tracker.on("progress", (update) => {
-      this.emit("progress:update", update);
-    });
-    tracker.track(convoyId);
-    this.progressTrackers.set(convoyId, tracker);
-  }
-  /**
-   * Stop monitoring convoy
-   */
-  stopMonitoring(convoyId) {
-    const tracker = this.progressTrackers.get(convoyId);
-    if (tracker) {
-      tracker.destroy();
-      this.progressTrackers.delete(convoyId);
-    }
-  }
-  /**
-   * Get convoy status
-   */
-  getConvoyStatus(convoyId) {
-    return this.convoyManager.getSummary(convoyId);
-  }
-  /**
-   * Get all active convoys
-   */
-  getActiveConvoys() {
-    return Array.from(this.activeConvoys).map((id) => this.convoyManager.get(id)).filter((c) => c !== void 0);
-  }
-  /**
-   * Destroy mayor agent
-   */
-  destroy() {
-    const trackers = Array.from(this.progressTrackers.values());
-    for (const tracker of trackers) {
-      tracker.destroy();
-    }
-    this.progressTrackers.clear();
-    this.activeConvoys.clear();
-    this.removeAllListeners();
-  }
-  // ========================================================================
-  // Private Methods
-  // ========================================================================
-  setupEventListeners() {
-    this.convoyManager.on("convoy:completed", (convoy) => {
-      if (this.activeConvoys.has(convoy.id)) {
-        this.activeConvoys.delete(convoy.id);
-        this.stopMonitoring(convoy.id);
-        this.emit("convoy:completed", convoy, this.convoyManager.getSummary(convoy.id));
-      }
-    });
-    this.convoyManager.on("convoy:failed", (convoy) => {
-      if (this.activeConvoys.has(convoy.id)) {
-        this.activeConvoys.delete(convoy.id);
-        this.stopMonitoring(convoy.id);
-        this.emit("convoy:failed", convoy, "Convoy failed");
-      }
-    });
-  }
-  extractFiles(input) {
-    const filePattern = /[\w-]+\.(ts|js|tsx|jsx|json|md|yaml|yml|toml)/gi;
-    return input.match(filePattern) ?? [];
-  }
-  extractFunctions(input) {
-    const funcPattern = /\b(\w+)\s*\(/g;
-    const matches = [];
-    let match;
-    while ((match = funcPattern.exec(input)) !== null) {
-      if (!["if", "for", "while", "switch", "catch"].includes(match[1])) {
-        matches.push(match[1]);
-      }
-    }
-    return matches;
-  }
-  extractComponents(input) {
-    const componentPattern = /\b([A-Z][a-zA-Z]+)\b/g;
-    return input.match(componentPattern) ?? [];
-  }
-  extractTechnologies(input) {
-    const techs = ["react", "vue", "angular", "node", "typescript", "javascript", "python", "rust", "go", "docker", "kubernetes", "aws", "gcp", "azure"];
-    const lowerInput = input.toLowerCase();
-    return techs.filter((tech) => lowerInput.includes(tech));
-  }
-  extractKeywords(input) {
-    const words = input.toLowerCase().split(/\s+/);
-    const stopWords = /* @__PURE__ */ new Set(["the", "a", "an", "is", "are", "was", "were", "be", "been", "being", "have", "has", "had", "do", "does", "did", "will", "would", "could", "should", "may", "might", "must", "shall", "can", "need", "dare", "ought", "used", "to", "of", "in", "for", "on", "with", "at", "by", "from", "as", "into", "through", "during", "before", "after", "above", "below", "between", "under", "again", "further", "then", "once", "here", "there", "when", "where", "why", "how", "all", "each", "few", "more", "most", "other", "some", "such", "no", "nor", "not", "only", "own", "same", "so", "than", "too", "very", "just", "and", "but", "if", "or", "because", "until", "while", "although", "though", "after", "before", "when", "whenever", "where", "wherever", "whether", "which", "who", "whom", "whose", "what", "whatever", "whichever", "whoever", "whomever", "this", "that", "these", "those", "i", "me", "my", "myself", "we", "our", "ours", "ourselves", "you", "your", "yours", "yourself", "yourselves", "he", "him", "his", "himself", "she", "her", "hers", "herself", "it", "its", "itself", "they", "them", "their", "theirs", "themselves"]);
-    return words.filter((w) => w.length > 2 && !stopWords.has(w));
-  }
-  estimateComplexity(input, entities) {
-    const fileCount = entities.files?.length ?? 0;
-    const componentCount = entities.components?.length ?? 0;
-    const wordCount = input.split(/\s+/).length;
-    if (wordCount < 10 && fileCount <= 1)
-      return "trivial";
-    if (wordCount < 20 && fileCount <= 2)
-      return "simple";
-    if (wordCount < 50 && fileCount <= 5)
-      return "moderate";
-    if (wordCount < 100 || componentCount > 3)
-      return "complex";
-    return "very_complex";
-  }
-  determineRequiredRoles(type, _entities) {
-    const roles = ["researcher"];
-    switch (type) {
-      case "feature":
-        roles.push("architect", "coder", "tester", "reviewer");
-        break;
-      case "bugfix":
-        roles.push("debugger", "coder", "tester");
-        break;
-      case "refactor":
-        roles.push("architect", "coder", "tester");
-        break;
-      case "testing":
-        roles.push("tester");
-        break;
-      case "documentation":
-        roles.push("writer");
-        break;
-      default:
-        roles.push("coder");
-    }
-    return roles;
-  }
-  generateSummary(input, type) {
-    const words = input.split(/\s+/).slice(0, 10).join(" ");
-    const typeLabel = type.charAt(0).toUpperCase() + type.slice(1);
-    return `${typeLabel}: ${words}${input.split(/\s+/).length > 10 ? "..." : ""}`;
-  }
-  suggestApproach(type, _complexity) {
-    const approaches = {
-      feature: "Design-first approach with incremental implementation",
-      bugfix: "Reproduce, isolate, fix, and verify",
-      refactor: "Ensure test coverage, then refactor incrementally",
-      research: "Gather information, analyze, and document findings",
-      documentation: "Review code, document API and usage patterns",
-      testing: "Identify test cases, implement, and verify coverage",
-      deployment: "Prepare, validate, deploy, and monitor",
-      other: "Analyze requirements and implement solution"
-    };
-    return approaches[type];
-  }
-  calculateTotalEffort(tasks) {
-    const effortMap = { minimal: 1, small: 2, medium: 4, large: 8 };
-    const total = tasks.reduce((sum, t) => sum + effortMap[t.estimatedEffort], 0);
-    if (total <= 4)
-      return "Small";
-    if (total <= 10)
-      return "Medium";
-    if (total <= 20)
-      return "Large";
-    return "Very Large";
-  }
-  identifyRisks(intent) {
-    const risks = [];
-    if (intent.complexity === "complex" || intent.complexity === "very_complex") {
-      risks.push("High complexity may require multiple iterations");
-    }
-    if (intent.type === "refactor") {
-      risks.push("Refactoring may introduce regressions");
-    }
-    if (intent.entities.files && intent.entities.files.length > 5) {
-      risks.push("Multiple files affected - careful coordination needed");
-    }
-    if (risks.length === 0) {
-      risks.push("No significant risks identified");
-    }
-    return risks;
-  }
-  defineSuccessCriteria(intent) {
-    const criteria = [];
-    switch (intent.type) {
-      case "feature":
-        criteria.push("Feature implemented as specified", "Tests pass", "Code reviewed");
-        break;
-      case "bugfix":
-        criteria.push("Bug no longer reproducible", "Regression test added", "No new issues introduced");
-        break;
-      case "refactor":
-        criteria.push("All existing tests pass", "Code quality improved", "No functional changes");
-        break;
-      default:
-        criteria.push("Task completed successfully", "Results documented");
-    }
-    return criteria;
-  }
-  buildResponseMessage(plan, convoy, workerCount) {
-    const lines = [
-      `Created plan: ${plan.name}`,
-      `Tasks: ${plan.tasks.length}`,
-      `Estimated effort: ${plan.totalEffort}`
-    ];
-    if (convoy) {
-      lines.push(`Convoy: ${convoy.id}`);
-    }
-    if (workerCount > 0) {
-      lines.push(`Workers: ${workerCount}`);
-    }
-    return lines.join("\n");
-  }
-}
-let globalMayorAgent = null;
-function getGlobalMayorAgent(config) {
-  if (!globalMayorAgent) {
-    globalMayorAgent = new MayorAgent(config);
-  }
-  return globalMayorAgent;
-}
-
-class MetricsCollector {
-  metrics = /* @__PURE__ */ new Map();
-  taskMetrics = /* @__PURE__ */ new Map();
-  performanceMetrics = /* @__PURE__ */ new Map();
-  maxRecords;
-  retentionPeriod;
-  constructor(options = {}) {
-    this.maxRecords = options.maxRecords ?? 1e3;
-    this.retentionPeriod = options.retentionPeriod ?? 36e5;
-  }
-  /**
-   * Record a metric value
-   */
-  recordMetric(agentId, metricName, value, metadata) {
-    if (!this.metrics.has(agentId)) {
-      this.metrics.set(agentId, /* @__PURE__ */ new Map());
-    }
-    const agentMetrics = this.metrics.get(agentId);
-    if (!agentMetrics.has(metricName)) {
-      agentMetrics.set(metricName, []);
-    }
-    const records = agentMetrics.get(metricName);
-    records.push({
-      timestamp: Date.now(),
-      value,
-      metadata
-    });
-    this.trimRecords(records);
-  }
-  /**
-   * Record CPU usage
-   */
-  recordCpuUsage(agentId, usage) {
-    this.recordMetric(agentId, "cpu_usage", usage);
-    this.updatePerformanceMetrics(agentId, { cpuUsage: usage });
-  }
-  /**
-   * Record memory usage
-   */
-  recordMemoryUsage(agentId, usage) {
-    this.recordMetric(agentId, "memory_usage", usage);
-    this.updatePerformanceMetrics(agentId, { memoryUsage: usage });
-  }
-  /**
-   * Record response time
-   */
-  recordResponseTime(agentId, responseTime) {
-    this.recordMetric(agentId, "response_time", responseTime);
-    this.updatePerformanceMetrics(agentId, { responseTime });
-  }
-  /**
-   * Record task completion
-   */
-  recordTaskCompletion(agentId, success, duration) {
-    if (!this.taskMetrics.has(agentId)) {
-      this.taskMetrics.set(agentId, {
-        totalTasks: 0,
-        completedTasks: 0,
-        failedTasks: 0,
-        avgDuration: 0,
-        successRate: 0
-      });
-    }
-    const metrics = this.taskMetrics.get(agentId);
-    metrics.totalTasks++;
-    if (success) {
-      metrics.completedTasks++;
-    } else {
-      metrics.failedTasks++;
-    }
-    metrics.avgDuration = (metrics.avgDuration * (metrics.totalTasks - 1) + duration) / metrics.totalTasks;
-    metrics.successRate = metrics.completedTasks / metrics.totalTasks;
-    this.recordMetric(agentId, "task_duration", duration, { success });
-  }
-  /**
-   * Record error
-   */
-  recordError(agentId, errorType, errorMessage) {
-    this.recordMetric(agentId, "error", 1, { errorType, errorMessage });
-    this.updatePerformanceMetrics(agentId, { errorCount: 1 });
-  }
-  /**
-   * Get agent metrics
-   */
-  getAgentMetrics(agentId) {
-    const taskMetrics = this.taskMetrics.get(agentId);
-    const cpuRecords = this.getMetricRecords(agentId, "cpu_usage");
-    const memoryRecords = this.getMetricRecords(agentId, "memory_usage");
-    const responseTimeRecords = this.getMetricRecords(agentId, "response_time");
-    const cpuUsage = cpuRecords.length > 0 ? cpuRecords[cpuRecords.length - 1].value : 0;
-    const memoryUsage = memoryRecords.length > 0 ? memoryRecords[memoryRecords.length - 1].value : 0;
-    this.calculateAverage(responseTimeRecords.map((r) => r.value));
-    taskMetrics ? taskMetrics.failedTasks / taskMetrics.totalTasks : 0;
-    return {
-      tasksExecuted: taskMetrics?.totalTasks ?? 0,
-      tasksSucceeded: taskMetrics?.completedTasks ?? 0,
-      tasksFailed: taskMetrics?.failedTasks ?? 0,
-      avgTaskDuration: taskMetrics?.avgDuration ?? 0,
-      successRate: taskMetrics?.successRate ?? 0,
-      totalExecutionTime: taskMetrics?.avgDuration ?? 0,
-      avgConfidence: 0.8,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      cpuUsage,
-      memoryUsage
-    };
-  }
-  /**
-   * Get metric snapshot
-   */
-  getMetricSnapshot(agentId, metricName, timeRange) {
-    const records = this.getMetricRecords(agentId, metricName, timeRange);
-    const values = records.map((r) => r.value);
-    if (values.length === 0) {
-      return {
-        metricName,
-        agentId,
-        timestamp: Date.now(),
-        current: 0,
-        min: 0,
-        max: 0,
-        avg: 0,
-        count: 0
-      };
-    }
-    return {
-      metricName,
-      agentId,
-      timestamp: Date.now(),
-      current: values[values.length - 1],
-      min: Math.min(...values),
-      max: Math.max(...values),
-      avg: this.calculateAverage(values),
-      count: values.length
-    };
-  }
-  /**
-   * Get aggregated metrics
-   */
-  getAggregatedMetrics(agentId, metricName, timeRange) {
-    const records = this.getMetricRecords(agentId, metricName, timeRange);
-    const values = records.map((r) => r.value).sort((a, b) => a - b);
-    if (values.length === 0) {
-      return {
-        min: 0,
-        max: 0,
-        avg: 0,
-        median: 0,
-        p95: 0,
-        p99: 0,
-        count: 0
-      };
-    }
-    return {
-      min: values[0],
-      max: values[values.length - 1],
-      avg: this.calculateAverage(values),
-      median: this.calculatePercentile(values, 50),
-      p95: this.calculatePercentile(values, 95),
-      p99: this.calculatePercentile(values, 99),
-      count: values.length
-    };
-  }
-  /**
-   * Get task metrics
-   */
-  getTaskMetrics(agentId) {
-    return this.taskMetrics.get(agentId);
-  }
-  /**
-   * Get performance metrics
-   */
-  getPerformanceMetrics(agentId) {
-    return this.performanceMetrics.get(agentId);
-  }
-  /**
-   * Get all agents with metrics
-   */
-  getAllAgents() {
-    return Array.from(this.metrics.keys());
-  }
-  /**
-   * Clear metrics for an agent
-   */
-  clearAgentMetrics(agentId) {
-    this.metrics.delete(agentId);
-    this.taskMetrics.delete(agentId);
-    this.performanceMetrics.delete(agentId);
-  }
-  /**
-   * Clear all metrics
-   */
-  clearAll() {
-    this.metrics.clear();
-    this.taskMetrics.clear();
-    this.performanceMetrics.clear();
-  }
-  /**
-   * Export metrics to JSON
-   */
-  exportMetrics(agentId) {
-    if (agentId) {
-      return {
-        agentId,
-        metrics: this.getAgentMetrics(agentId),
-        taskMetrics: this.getTaskMetrics(agentId),
-        performanceMetrics: this.getPerformanceMetrics(agentId),
-        timestamp: Date.now()
-      };
-    }
-    const allMetrics = {};
-    for (const id of this.getAllAgents()) {
-      allMetrics[id] = {
-        metrics: this.getAgentMetrics(id),
-        taskMetrics: this.getTaskMetrics(id),
-        performanceMetrics: this.getPerformanceMetrics(id)
-      };
-    }
-    return {
-      agents: allMetrics,
-      timestamp: Date.now()
-    };
-  }
-  /**
-   * Get metric records
-   */
-  getMetricRecords(agentId, metricName, timeRange) {
-    const agentMetrics = this.metrics.get(agentId);
-    if (!agentMetrics) {
-      return [];
-    }
-    const records = agentMetrics.get(metricName) ?? [];
-    if (timeRange) {
-      const cutoff = Date.now() - timeRange;
-      return records.filter((r) => r.timestamp >= cutoff);
-    }
-    return records;
-  }
-  /**
-   * Update performance metrics
-   */
-  updatePerformanceMetrics(agentId, update) {
-    if (!this.performanceMetrics.has(agentId)) {
-      this.performanceMetrics.set(agentId, {
-        cpuUsage: 0,
-        memoryUsage: 0,
-        responseTime: 0,
-        errorCount: 0,
-        requestCount: 0,
-        timestamp: Date.now()
-      });
-    }
-    const metrics = this.performanceMetrics.get(agentId);
-    if (update.cpuUsage !== void 0) {
-      metrics.cpuUsage = update.cpuUsage;
-    }
-    if (update.memoryUsage !== void 0) {
-      metrics.memoryUsage = update.memoryUsage;
-    }
-    if (update.responseTime !== void 0) {
-      metrics.requestCount++;
-      metrics.responseTime = (metrics.responseTime * (metrics.requestCount - 1) + update.responseTime) / metrics.requestCount;
-    }
-    if (update.errorCount !== void 0) {
-      metrics.errorCount += update.errorCount;
-    }
-    metrics.timestamp = Date.now();
-  }
-  /**
-   * Trim old records
-   */
-  trimRecords(records) {
-    const cutoff = Date.now() - this.retentionPeriod;
-    while (records.length > 0 && records[0].timestamp < cutoff) {
-      records.shift();
-    }
-    while (records.length > this.maxRecords) {
-      records.shift();
-    }
-  }
-  /**
-   * Calculate average
-   */
-  calculateAverage(values) {
-    if (values.length === 0) {
-      return 0;
-    }
-    return values.reduce((sum, val) => sum + val, 0) / values.length;
-  }
-  /**
-   * Calculate percentile
-   */
-  calculatePercentile(sortedValues, percentile) {
-    if (sortedValues.length === 0) {
-      return 0;
-    }
-    const index = Math.ceil(percentile / 100 * sortedValues.length) - 1;
-    return sortedValues[Math.max(0, index)];
-  }
-}
-let globalMetricsCollector;
-function getMetricsCollector(options) {
-  if (!globalMetricsCollector) {
-    globalMetricsCollector = new MetricsCollector(options);
-  }
-  return globalMetricsCollector;
-}
-
-const promptUserQuestion = async (question) => {
-  if (!process__default.stdin.isTTY || !process__default.stdout.isTTY) {
-    return null;
-  }
-  try {
-    const inquirer = (await import('./index6.mjs').then(function (n) { return n.c; })).default;
-    const choices = question.options.map((option) => ({
-      name: option.description ? `${option.label} \u2014 ${option.description}` : option.label,
-      value: option.value
-    }));
-    const defaultIndex = typeof question.defaultValue === "string" ? Math.max(0, choices.findIndex((choice) => choice.value === question.defaultValue)) : 0;
-    const { selected } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "selected",
-        message: question.prompt,
-        choices,
-        default: defaultIndex
-      }
-    ]);
-    return {
-      value: selected,
-      source: "option"
-    };
-  } catch {
-    return null;
-  }
-};
-
-const DEFAULT_PHASE_SUMMARY = {
-  calls: 0,
-  failures: 0,
-  successRate: 0,
-  avgDurationMs: 0
-};
-class ExecutionTelemetry {
-  constructor(maxEvents = 2e3) {
-    this.maxEvents = maxEvents;
-  }
-  events = [];
-  record(event) {
-    const entry = {
-      id: `te-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      timestamp: Date.now(),
-      ...event
-    };
-    this.events.push(entry);
-    if (this.events.length > this.maxEvents) {
-      this.events.shift();
-    }
-    return entry;
-  }
-  getRecent(limit = 50) {
-    if (limit <= 0) {
-      return [];
-    }
-    return this.events.slice(-limit);
-  }
-  summarize() {
-    const phaseStats = {
-      execution: { ...DEFAULT_PHASE_SUMMARY },
-      intent: { ...DEFAULT_PHASE_SUMMARY },
-      elicitation: { ...DEFAULT_PHASE_SUMMARY },
-      skill: { ...DEFAULT_PHASE_SUMMARY },
-      agent: { ...DEFAULT_PHASE_SUMMARY },
-      mcp: { ...DEFAULT_PHASE_SUMMARY },
-      route: { ...DEFAULT_PHASE_SUMMARY }
-    };
-    let totalSuccess = 0;
-    let durationCount = 0;
-    let durationTotal = 0;
-    for (const event of this.events) {
-      const summary = phaseStats[event.phase];
-      summary.calls++;
-      if (!event.success) {
-        summary.failures++;
-      } else {
-        totalSuccess++;
-      }
-      if (typeof event.durationMs === "number") {
-        durationTotal += event.durationMs;
-        durationCount++;
-        summary.avgDurationMs = (summary.avgDurationMs * (summary.calls - 1) + event.durationMs) / summary.calls;
-      }
-      summary.successRate = summary.calls === 0 ? 0 : (summary.calls - summary.failures) / summary.calls;
-    }
-    return {
-      totalEvents: this.events.length,
-      overallSuccessRate: this.events.length === 0 ? 0 : totalSuccess / this.events.length,
-      avgDurationMs: durationCount === 0 ? 0 : durationTotal / durationCount,
-      phaseStats
-    };
-  }
-  clear() {
-    this.events = [];
-  }
-}
-let globalExecutionTelemetry = null;
-function getGlobalExecutionTelemetry() {
-  if (!globalExecutionTelemetry) {
-    globalExecutionTelemetry = new ExecutionTelemetry();
-  }
-  return globalExecutionTelemetry;
-}
-
-class IntentRouter extends EventEmitter {
-  config;
-  // Keywords for intent detection
-  mayorKeywords = [
-    "implement",
-    "build",
-    "create",
-    "add",
-    "develop",
-    "integrate",
-    "system",
-    "architecture",
-    "multiple",
-    "complex",
-    "full",
-    "authentication",
-    "authorization",
-    "api",
-    "database",
-    "backend",
-    "frontend",
-    "ui",
-    "ux",
-    "design",
-    "workflow"
-  ];
-  planKeywords = [
-    "plan",
-    "design",
-    "architect",
-    "structure",
-    "organize",
-    "refactor",
-    "restructure",
-    "reorganize",
-    "improve",
-    "how to",
-    "approach",
-    "strategy",
-    "best way"
-  ];
-  featureKeywords = [
-    "add",
-    "create",
-    "implement",
-    "build",
-    "make",
-    "feature",
-    "function",
-    "component",
-    "module",
-    "button",
-    "form",
-    "page",
-    "endpoint",
-    "route"
-  ];
-  bugFixKeywords = [
-    "fix",
-    "bug",
-    "error",
-    "issue",
-    "problem",
-    "broken",
-    "not working",
-    "crash",
-    "fail",
-    "debug",
-    "resolve",
-    "solve"
-  ];
-  questionKeywords = [
-    "what",
-    "how",
-    "why",
-    "when",
-    "where",
-    "which",
-    "explain",
-    "tell me",
-    "show me",
-    "help",
-    "can you",
-    "could you",
-    "would you"
-  ];
-  constructor(config = {}) {
-    super();
-    this.config = {
-      mayorComplexityThreshold: config.mayorComplexityThreshold || "complex",
-      planComplexityThreshold: config.planComplexityThreshold || "moderate",
-      autoRoute: config.autoRoute !== void 0 ? config.autoRoute : true,
-      askConfirmation: config.askConfirmation !== void 0 ? config.askConfirmation : false,
-      verbose: config.verbose !== void 0 ? config.verbose : false
-    };
-  }
-  /**
-   * Analyze user input and determine intent
-   */
-  async analyze(input) {
-    const normalized = input.toLowerCase().trim();
-    const complexity = this.calculateComplexity(normalized);
-    const type = this.detectIntentType(normalized);
-    const keywords = this.extractKeywords(normalized);
-    const requiresPlanning = this.needsPlanning(normalized, complexity);
-    const requiresMultipleAgents = this.needsMultipleAgents(normalized, complexity);
-    const estimatedSteps = this.estimateSteps(normalized, complexity);
-    const confidence = this.calculateConfidence(type, complexity, keywords);
-    const suggestedRoute = this.determineSuggestedRoute(
-      type,
-      complexity,
-      requiresPlanning,
-      requiresMultipleAgents
-    );
-    const reasoning = this.generateReasoning(
-      type,
-      complexity,
-      suggestedRoute,
-      requiresPlanning,
-      requiresMultipleAgents,
-      estimatedSteps
-    );
-    const intent = {
-      type,
-      complexity,
-      confidence,
-      reasoning,
-      suggestedRoute,
-      keywords,
-      requiresPlanning,
-      requiresMultipleAgents,
-      estimatedSteps
-    };
-    this.emit("intent:analyzed", intent);
-    return intent;
-  }
-  /**
-   * Route user input to appropriate system
-   */
-  async route(input) {
-    const intent = await this.analyze(input);
-    let shouldExecute = this.config.autoRoute;
-    if (this.config.askConfirmation && intent.complexity === "very_complex") {
-      shouldExecute = false;
-    }
-    const message = this.generateRouteMessage(intent);
-    this.emit("route:determined", {
-      route: intent.suggestedRoute,
-      intent,
-      shouldExecute
-    });
-    return {
-      route: intent.suggestedRoute,
-      intent,
-      shouldExecute,
-      message
-    };
-  }
-  /**
-   * Calculate complexity level
-   */
-  calculateComplexity(input) {
-    let score = 0;
-    const words = input.split(/\s+/).length;
-    if (words > 50)
-      score += 3;
-    else if (words > 30)
-      score += 2;
-    else if (words > 15)
-      score += 1;
-    const components = ["frontend", "backend", "database", "api", "ui", "auth", "test"];
-    const mentionedComponents = components.filter((c) => input.includes(c)).length;
-    score += mentionedComponents;
-    const actions = ["create", "update", "delete", "implement", "integrate", "test", "deploy"];
-    const mentionedActions = actions.filter((a) => input.includes(a)).length;
-    score += mentionedActions;
-    const technicalTerms = [
-      "authentication",
-      "authorization",
-      "middleware",
-      "validation",
-      "encryption",
-      "jwt",
-      "oauth",
-      "websocket",
-      "graphql",
-      "rest",
-      "microservice",
-      "docker",
-      "kubernetes",
-      "ci/cd"
-    ];
-    const mentionedTerms = technicalTerms.filter((t) => input.includes(t)).length;
-    score += mentionedTerms * 2;
-    if (input.match(/\band\b/gi)?.length || 0 > 2)
-      score += 2;
-    if (score >= 10)
-      return "very_complex";
-    if (score >= 7)
-      return "complex";
-    if (score >= 4)
-      return "moderate";
-    if (score >= 2)
-      return "simple";
-    return "trivial";
-  }
-  /**
-   * Detect intent type from input
-   */
-  detectIntentType(input) {
-    if (this.matchesKeywords(input, this.questionKeywords)) {
-      return "question";
-    }
-    if (this.matchesKeywords(input, this.bugFixKeywords)) {
-      return "bug_fix";
-    }
-    if (this.matchesKeywords(input, this.planKeywords)) {
-      return "plan";
-    }
-    if (this.matchesKeywords(input, this.featureKeywords)) {
-      return "feature";
-    }
-    if (input.includes("refactor") || input.includes("improve") || input.includes("optimize")) {
-      return "refactor";
-    }
-    if (this.matchesKeywords(input, this.mayorKeywords)) {
-      return "mayor";
-    }
-    return "direct";
-  }
-  /**
-   * Check if input matches keywords
-   */
-  matchesKeywords(input, keywords) {
-    return keywords.some((keyword) => input.includes(keyword));
-  }
-  /**
-   * Extract relevant keywords
-   */
-  extractKeywords(input) {
-    const allKeywords = [
-      ...this.mayorKeywords,
-      ...this.planKeywords,
-      ...this.featureKeywords,
-      ...this.bugFixKeywords,
-      ...this.questionKeywords
-    ];
-    return allKeywords.filter((keyword) => input.includes(keyword));
-  }
-  /**
-   * Determine if planning is needed
-   */
-  needsPlanning(input, complexity) {
-    if (complexity === "very_complex")
-      return true;
-    if (this.matchesKeywords(input, this.planKeywords))
-      return true;
-    const architecturalKeywords = [
-      "architecture",
-      "structure",
-      "design",
-      "refactor",
-      "reorganize",
-      "restructure",
-      "system"
-    ];
-    if (this.matchesKeywords(input, architecturalKeywords))
-      return true;
-    if (complexity === "complex" || complexity === "moderate") {
-      const components = ["frontend", "backend", "database", "api"];
-      const mentionedComponents = components.filter((c) => input.includes(c)).length;
-      if (mentionedComponents >= 2)
-        return true;
-    }
-    return false;
-  }
-  /**
-   * Determine if multiple agents are needed
-   */
-  needsMultipleAgents(input, complexity) {
-    if (complexity === "very_complex")
-      return true;
-    if (complexity === "complex")
-      return true;
-    const components = ["frontend", "backend", "database", "api", "test", "deploy"];
-    const mentionedComponents = components.filter((c) => input.includes(c)).length;
-    if (mentionedComponents >= 2)
-      return true;
-    const actions = ["create", "update", "delete", "test", "deploy", "integrate"];
-    const mentionedActions = actions.filter((a) => input.includes(a)).length;
-    if (mentionedActions >= 3)
-      return true;
-    return false;
-  }
-  /**
-   * Estimate number of steps
-   */
-  estimateSteps(input, complexity) {
-    const baseSteps = {
-      trivial: 1,
-      simple: 2,
-      moderate: 4,
-      complex: 8,
-      very_complex: 15
-    };
-    let steps = baseSteps[complexity];
-    const components = ["frontend", "backend", "database", "api", "test", "deploy"];
-    const mentionedComponents = components.filter((c) => input.includes(c)).length;
-    steps += mentionedComponents * 2;
-    const actions = ["create", "update", "delete", "integrate", "test", "deploy"];
-    const mentionedActions = actions.filter((a) => input.includes(a)).length;
-    steps += mentionedActions;
-    return Math.min(steps, 30);
-  }
-  /**
-   * Calculate confidence score
-   */
-  calculateConfidence(type, complexity, keywords) {
-    let confidence = 0.5;
-    confidence += Math.min(keywords.length * 0.05, 0.3);
-    if (type !== "direct") {
-      confidence += 0.2;
-    }
-    return Math.min(confidence, 1);
-  }
-  /**
-   * Determine suggested route
-   */
-  determineSuggestedRoute(type, complexity, requiresPlanning, requiresMultipleAgents) {
-    if (type === "question") {
-      return "direct";
-    }
-    if (complexity === "very_complex" || requiresMultipleAgents) {
-      return "mayor";
-    }
-    if (complexity === "complex" && requiresPlanning) {
-      return "mayor";
-    }
-    if (type === "plan" || requiresPlanning) {
-      return "plan";
-    }
-    if (complexity === "moderate" && (type === "feature" || type === "bug_fix")) {
-      return "feature";
-    }
-    if (complexity === "simple" || complexity === "trivial") {
-      return "direct";
-    }
-    return "feature";
-  }
-  /**
-   * Generate reasoning explanation
-   */
-  generateReasoning(type, complexity, route, requiresPlanning, requiresMultipleAgents, estimatedSteps) {
-    const reasons = [];
-    reasons.push(`Complexity: ${complexity}`);
-    reasons.push(`Intent: ${type}`);
-    if (requiresPlanning) {
-      reasons.push("Requires architectural planning");
-    }
-    if (requiresMultipleAgents) {
-      reasons.push("Requires multiple specialized agents");
-    }
-    reasons.push(`Estimated ${estimatedSteps} steps`);
-    const routeReasons = {
-      mayor: "Using Mayor Agent for orchestration",
-      plan: "Using Plan Mode for architectural design",
-      feature: "Using Feature Mode for implementation",
-      direct: "Direct execution"
-    };
-    reasons.push(routeReasons[route]);
-    return reasons.join(" \u2022 ");
-  }
-  /**
-   * Generate user-friendly route message
-   */
-  generateRouteMessage(intent) {
-    const messages = {
-      mayor: `\u{1F9E0} Mayor Agent will orchestrate this ${intent.complexity} task with ${intent.estimatedSteps} steps`,
-      plan: `\u{1F4CB} Creating architectural plan for this ${intent.complexity} task`,
-      feature: `\u26A1 Implementing feature directly (${intent.complexity} complexity)`,
-      direct: `\u{1F680} Executing directly`
-    };
-    return messages[intent.suggestedRoute];
-  }
-}
-let globalRouter$1 = null;
-function getGlobalIntentRouter(config) {
-  if (!globalRouter$1) {
-    globalRouter$1 = new IntentRouter(config);
-  }
-  return globalRouter$1;
-}
-
-const MCP_TOOL_PROFILES = [
-  {
-    tool: "filesystem",
-    keywords: ["file", "directory", "folder", "workspace", "path", "read", "write"],
-    basePriority: 5,
-    intentBoost: {
-      feature: 2,
-      refactor: 2,
-      bug_fix: 2
-    }
-  },
-  {
-    tool: "github",
-    keywords: ["github", "repository", "repo", "pr", "pull request", "issue", "commit"],
-    basePriority: 4,
-    intentBoost: {
-      feature: 1,
-      bug_fix: 1
-    }
-  },
-  {
-    tool: "web-search",
-    keywords: ["search", "research", "web", "documentation", "docs", "latest", "reference"],
-    basePriority: 3,
-    intentBoost: {
-      question: 2,
-      plan: 1
-    }
-  },
-  {
-    tool: "context7",
-    keywords: ["library", "framework", "package", "sdk", "api docs", "best practice"],
-    basePriority: 4,
-    intentBoost: {
-      feature: 2,
-      plan: 2,
-      question: 1
-    }
-  },
-  {
-    tool: "ide",
-    keywords: ["diagnostic", "error", "lint", "typecheck", "compile", "warning"],
-    basePriority: 3,
-    intentBoost: {
-      bug_fix: 2,
-      refactor: 1
-    }
-  },
-  {
-    tool: "playwright",
-    keywords: ["browser", "webpage", "e2e", "ui test", "automation", "screenshot"],
-    basePriority: 2,
-    intentBoost: {
-      feature: 1,
-      bug_fix: 1
-    }
-  }
-];
-class AutoExecutor extends EventEmitter {
-  config;
-  metricsCollector = getMetricsCollector();
-  constructor(config = {}) {
-    super();
-    this.config = {
-      autoCreateSkills: config.autoCreateSkills !== void 0 ? config.autoCreateSkills : true,
-      autoCreateAgents: config.autoCreateAgents !== void 0 ? config.autoCreateAgents : true,
-      autoSelectMcp: config.autoSelectMcp !== void 0 ? config.autoSelectMcp : true,
-      enableElicitation: config.enableElicitation !== void 0 ? config.enableElicitation : true,
-      maxMcpTools: config.maxMcpTools !== void 0 ? Math.max(1, config.maxMcpTools) : 3,
-      askUserQuestion: config.askUserQuestion || promptUserQuestion,
-      intentRouter: config.intentRouter || getGlobalIntentRouter(),
-      telemetry: config.telemetry || getGlobalExecutionTelemetry(),
-      verbose: config.verbose !== void 0 ? config.verbose : false
-    };
-  }
-  /**
-   * Execute a user request after a router has selected this executor.
-   */
-  async execute(userInput) {
-    const executionId = `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const startedAt = Date.now();
-    this.emit("execution:started", { input: userInput });
-    this.emitCommandHook("command-start", {
-      executionId,
-      inputLength: userInput.length,
-      source: "auto-executor"
-    });
-    this.config.telemetry.record({
-      executionId,
-      phase: "execution",
-      action: "start",
-      success: true,
-      metadata: {
-        inputLength: userInput.length
-      }
-    });
-    try {
-      const routeStart = Date.now();
-      const routeResult = await this.config.intentRouter.route(userInput);
-      this.config.telemetry.record({
-        executionId,
-        phase: "intent",
-        action: "route",
-        success: true,
-        durationMs: Date.now() - routeStart,
-        metadata: {
-          initialRoute: routeResult.route,
-          confidence: routeResult.intent.confidence,
-          intentType: routeResult.intent.type,
-          complexity: routeResult.intent.complexity
-        }
-      });
-      this.emitCommandHook("command-telemetry", {
-        executionId,
-        phase: "intent",
-        action: "route",
-        route: routeResult.route,
-        confidence: routeResult.intent.confidence
-      });
-      const elicitationResult = await this.resolveRouteWithElicitation(
-        routeResult.route,
-        routeResult.intent,
-        executionId
-      );
-      const route = elicitationResult.route;
-      const intent = elicitationResult.intent;
-      this.log(`Intent analyzed: ${intent.type} (${intent.complexity})`);
-      this.log(`Suggested route: ${route}`);
-      const skillDetectStart = Date.now();
-      const skillReq = await this.detectSkillRequirement(userInput, intent);
-      this.config.telemetry.record({
-        executionId,
-        phase: "skill",
-        action: "detect",
-        success: true,
-        durationMs: Date.now() - skillDetectStart,
-        metadata: {
-          needed: skillReq.needed,
-          reason: skillReq.reason
-        }
-      });
-      const agentDetectStart = Date.now();
-      const agentReq = await this.detectAgentRequirement(userInput, intent);
-      this.config.telemetry.record({
-        executionId,
-        phase: "agent",
-        action: "detect",
-        success: true,
-        durationMs: Date.now() - agentDetectStart,
-        metadata: {
-          needed: agentReq.needed,
-          reason: agentReq.reason
-        }
-      });
-      const mcpDetectStart = Date.now();
-      const mcpReq = await this.detectMcpRequirement(userInput, intent);
-      this.config.telemetry.record({
-        executionId,
-        phase: "mcp",
-        action: "detect",
-        success: true,
-        durationMs: Date.now() - mcpDetectStart,
-        metadata: {
-          needed: mcpReq.needed,
-          selectedTools: mcpReq.tools,
-          candidates: mcpReq.candidates,
-          reason: mcpReq.reason
-        }
-      });
-      const agentsCreated = [];
-      const skillsCreated = [];
-      const mcpToolsUsed = [];
-      if (this.config.autoCreateSkills && skillReq.needed) {
-        this.log(`Auto-creating skill: ${skillReq.skillName}`);
-        const skillCreateStart = Date.now();
-        const skillId = await this.autoCreateSkill(skillReq);
-        skillsCreated.push(skillId);
-        this.config.telemetry.record({
-          executionId,
-          phase: "skill",
-          action: "create",
-          success: true,
-          durationMs: Date.now() - skillCreateStart,
-          metadata: {
-            skillId,
-            skillName: skillReq.skillName
-          }
-        });
-        this.emit("skill:created", { skillId, skillReq });
-      }
-      if (this.config.autoCreateAgents && agentReq.needed) {
-        this.log(`Auto-creating agent: ${agentReq.domain}`);
-        const agentCreateStart = Date.now();
-        const agentId = await this.autoCreateAgent(agentReq);
-        agentsCreated.push(agentId);
-        this.config.telemetry.record({
-          executionId,
-          phase: "agent",
-          action: "create",
-          success: true,
-          durationMs: Date.now() - agentCreateStart,
-          metadata: {
-            agentId,
-            agentType: agentReq.agentType,
-            domain: agentReq.domain
-          }
-        });
-        this.emit("agent:created", { agentId, agentReq });
-      }
-      if (this.config.autoSelectMcp && mcpReq.needed) {
-        this.log(`Auto-selecting MCP tools: ${mcpReq.tools.join(", ")}`);
-        mcpToolsUsed.push(...mcpReq.tools);
-        this.config.telemetry.record({
-          executionId,
-          phase: "mcp",
-          action: "select",
-          success: true,
-          metadata: {
-            tools: mcpReq.tools,
-            candidates: mcpReq.candidates
-          }
-        });
-        this.emit("mcp:selected", { tools: mcpReq.tools, mcpReq });
-      }
-      let result;
-      const routeExecutionStart = Date.now();
-      switch (route) {
-        case "mayor":
-          result = await this.executeMayor(userInput, intent, agentsCreated, skillsCreated, mcpToolsUsed);
-          break;
-        case "plan":
-          result = await this.executePlan(userInput, intent, agentsCreated, skillsCreated, mcpToolsUsed);
-          break;
-        case "feature":
-          result = await this.executeFeature(userInput, intent, agentsCreated, skillsCreated, mcpToolsUsed);
-          break;
-        case "direct":
-          result = await this.executeDirect(userInput, intent, agentsCreated, skillsCreated, mcpToolsUsed);
-          break;
-        default:
-          throw new Error(`Unknown route: ${route}`);
-      }
-      const routeDuration = Date.now() - routeExecutionStart;
-      this.config.telemetry.record({
-        executionId,
-        phase: "route",
-        action: route,
-        success: true,
-        durationMs: routeDuration,
-        metadata: {
-          intentType: intent.type,
-          complexity: intent.complexity
-        }
-      });
-      this.emitCommandHook("command-telemetry", {
-        executionId,
-        phase: "route",
-        action: route,
-        durationMs: routeDuration
-      });
-      const totalDuration = Date.now() - startedAt;
-      this.metricsCollector.recordResponseTime("auto-executor", totalDuration);
-      this.metricsCollector.recordTaskCompletion("auto-executor", true, totalDuration);
-      this.config.telemetry.record({
-        executionId,
-        phase: "execution",
-        action: "complete",
-        success: true,
-        durationMs: totalDuration,
-        metadata: {
-          route,
-          agentsCreated: agentsCreated.length,
-          skillsCreated: skillsCreated.length,
-          mcpToolsUsed: mcpToolsUsed.length
-        }
-      });
-      this.emitCommandHook("command-complete", {
-        executionId,
-        success: true,
-        route,
-        durationMs: totalDuration,
-        mcpToolsUsed: mcpToolsUsed.length
-      });
-      result.insights = this.buildExecutionInsights({
-        initialRoute: routeResult.route,
-        resolvedRoute: route,
-        elicitationAsked: elicitationResult.elicitationAsked,
-        userSelectedRoute: elicitationResult.userSelectedRoute,
-        mcpReq,
-        totalDurationMs: totalDuration,
-        executionId
-      });
-      this.emit("execution:completed", result);
-      return result;
-    } catch (error) {
-      const totalDuration = Date.now() - startedAt;
-      const errorMessage = this.getErrorMessage(error);
-      this.metricsCollector.recordResponseTime("auto-executor", totalDuration);
-      this.metricsCollector.recordTaskCompletion("auto-executor", false, totalDuration);
-      this.metricsCollector.recordError("auto-executor", "execution_error", errorMessage);
-      this.config.telemetry.record({
-        executionId,
-        phase: "execution",
-        action: "complete",
-        success: false,
-        durationMs: totalDuration,
-        metadata: {
-          error: errorMessage
-        }
-      });
-      this.emitCommandHook("command-complete", {
-        executionId,
-        success: false,
-        durationMs: totalDuration,
-        error: errorMessage
-      });
-      this.emit("execution:failed", { error, input: userInput });
-      throw error;
-    }
-  }
-  /**
-   * Resolve route with optional structured elicitation.
-   * This keeps model autonomy but lets users disambiguate complex intent.
-   */
-  async resolveRouteWithElicitation(suggestedRoute, intent, executionId) {
-    if (!this.config.enableElicitation || !this.shouldAskRouteQuestion(intent)) {
-      return {
-        route: suggestedRoute,
-        intent,
-        elicitationAsked: false,
-        userSelectedRoute: false
-      };
-    }
-    const question = this.buildRouteQuestion(suggestedRoute, intent);
-    const askStart = Date.now();
-    const answer = await this.config.askUserQuestion(question);
-    this.config.telemetry.record({
-      executionId,
-      phase: "elicitation",
-      action: "route-choice",
-      success: true,
-      durationMs: Date.now() - askStart,
-      metadata: {
-        asked: true,
-        suggestedRoute,
-        answered: Boolean(answer),
-        selected: answer?.value
-      }
-    });
-    if (!answer) {
-      return {
-        route: suggestedRoute,
-        intent,
-        elicitationAsked: true,
-        userSelectedRoute: false
-      };
-    }
-    return this.applyRouteAnswer(suggestedRoute, intent, answer);
-  }
-  shouldAskRouteQuestion(intent) {
-    if (intent.complexity === "trivial" || intent.complexity === "simple") {
-      return false;
-    }
-    const lowConfidence = intent.confidence < 0.65;
-    const multiRouteIndicators = intent.requiresPlanning && intent.requiresMultipleAgents;
-    return lowConfidence || multiRouteIndicators;
-  }
-  buildRouteQuestion(suggestedRoute, intent) {
-    const routeLabels = {
-      direct: "Direct execution",
-      feature: "Feature implementation",
-      plan: "Plan first",
-      mayor: "Multi-agent orchestration"
-    };
-    const options = [
-      {
-        value: suggestedRoute,
-        label: `Use recommended: ${routeLabels[suggestedRoute]}`,
-        description: `Best guess from intent analysis (confidence ${Math.round(intent.confidence * 100)}%)`
-      },
-      {
-        value: "plan",
-        label: routeLabels.plan,
-        description: "Start with architecture and implementation plan"
-      },
-      {
-        value: "feature",
-        label: routeLabels.feature,
-        description: "Implement directly with focused feature workflow"
-      },
-      {
-        value: "direct",
-        label: routeLabels.direct,
-        description: "Run quickly without extra orchestration"
-      },
-      {
-        value: "mayor",
-        label: routeLabels.mayor,
-        description: "Use specialized agents for decomposition and coordination"
-      }
-    ].filter((option, index, arr) => arr.findIndex((x) => x.value === option.value) === index);
-    return {
-      id: "execution-route-choice",
-      prompt: "How should I execute this request?",
-      options,
-      defaultValue: suggestedRoute
-    };
-  }
-  applyRouteAnswer(suggestedRoute, intent, answer) {
-    const selectedRoute = ["direct", "feature", "plan", "mayor"].includes(answer.value) ? answer.value : suggestedRoute;
-    if (selectedRoute === suggestedRoute) {
-      return {
-        route: suggestedRoute,
-        intent,
-        elicitationAsked: true,
-        userSelectedRoute: false
-      };
-    }
-    return {
-      route: selectedRoute,
-      intent: {
-        ...intent,
-        suggestedRoute: selectedRoute,
-        reasoning: `${intent.reasoning} \u2022 User selected route: ${selectedRoute}`
-      },
-      elicitationAsked: true,
-      userSelectedRoute: true
-    };
-  }
-  /**
-   * Detect if a new skill is needed
-   */
-  async detectSkillRequirement(input, intent) {
-    const normalized = input.toLowerCase();
-    const technologies = [
-      { name: "react", type: "code" },
-      { name: "vue", type: "code" },
-      { name: "angular", type: "code" },
-      { name: "docker", type: "deployment" },
-      { name: "kubernetes", type: "deployment" },
-      { name: "graphql", type: "integration" },
-      { name: "websocket", type: "integration" },
-      { name: "oauth", type: "integration" },
-      { name: "jwt", type: "integration" }
-    ];
-    for (const tech of technologies) {
-      if (normalized.includes(tech.name)) {
-        return {
-          needed: true,
-          skillName: `${tech.name}-specialist`,
-          skillType: tech.type,
-          reason: `Detected ${tech.name} technology requirement`
-        };
-      }
-    }
-    if (normalized.includes("authentication") || normalized.includes("auth")) {
-      return {
-        needed: true,
-        skillName: "authentication-specialist",
-        skillType: "integration",
-        reason: "Authentication system requires specialized skill"
-      };
-    }
-    if (normalized.includes("database") || normalized.includes("sql")) {
-      return {
-        needed: true,
-        skillName: "database-specialist",
-        skillType: "code",
-        reason: "Database operations require specialized skill"
-      };
-    }
-    if (normalized.includes("api") && normalized.includes("design")) {
-      return {
-        needed: true,
-        skillName: "api-architect",
-        skillType: "analysis",
-        reason: "API design requires architectural skill"
-      };
-    }
-    if (intent.complexity === "very_complex" || intent.complexity === "complex") {
-      return {
-        needed: true,
-        skillName: `custom-${intent.type}-specialist`,
-        skillType: "code",
-        reason: `Complex ${intent.type} task requires specialized skill`
-      };
-    }
-    return {
-      needed: false,
-      skillName: "",
-      skillType: "code",
-      reason: "No specialized skill needed"
-    };
-  }
-  /**
-   * Detect if a new agent is needed
-   */
-  async detectAgentRequirement(input, intent) {
-    const normalized = input.toLowerCase();
-    if (normalized.includes("architecture") || normalized.includes("design system")) {
-      return {
-        needed: true,
-        agentType: "architect",
-        domain: "System Architecture",
-        reason: "Architectural design requires architect agent"
-      };
-    }
-    if (normalized.includes("deploy") || normalized.includes("ci/cd") || normalized.includes("docker")) {
-      return {
-        needed: true,
-        agentType: "devops",
-        domain: "DevOps & Deployment",
-        reason: "Deployment tasks require DevOps agent"
-      };
-    }
-    const specializations = [
-      { keywords: ["security", "encryption", "auth"], domain: "Security" },
-      { keywords: ["performance", "optimize", "cache"], domain: "Performance" },
-      { keywords: ["test", "testing", "qa"], domain: "Testing" },
-      { keywords: ["ui", "ux", "design", "frontend"], domain: "Frontend" },
-      { keywords: ["api", "backend", "server"], domain: "Backend" },
-      { keywords: ["database", "sql", "query"], domain: "Database" }
-    ];
-    for (const spec of specializations) {
-      if (spec.keywords.some((kw) => normalized.includes(kw))) {
-        return {
-          needed: true,
-          agentType: "specialist",
-          domain: spec.domain,
-          reason: `${spec.domain} tasks require specialized agent`
-        };
-      }
-    }
-    if (intent.estimatedSteps > 5) {
-      return {
-        needed: true,
-        agentType: "engineer",
-        domain: "Implementation",
-        reason: "Multi-step implementation requires engineer agent"
-      };
-    }
-    return {
-      needed: false,
-      agentType: "engineer",
-      domain: "",
-      reason: "Existing agents can handle this task"
-    };
-  }
-  /**
-   * Detect which MCP tools are needed
-   */
-  async detectMcpRequirement(input, intent) {
-    const normalized = input.toLowerCase();
-    const scoredTools = MCP_TOOL_PROFILES.map((profile) => {
-      const matchedKeywords = profile.keywords.filter((keyword) => normalized.includes(keyword));
-      if (matchedKeywords.length === 0) {
-        return null;
-      }
-      const intentBoost = profile.intentBoost?.[intent.type] ?? 0;
-      const complexityBoost = intent.complexity === "complex" || intent.complexity === "very_complex" ? 1 : 0;
-      const score = profile.basePriority + matchedKeywords.length * 2 + intentBoost + complexityBoost;
-      return {
-        tool: profile.tool,
-        score
-      };
-    }).filter((item) => item !== null).sort((a, b) => b.score - a.score);
-    const candidates = scoredTools.map((item) => item.tool);
-    const tools = scoredTools.slice(0, this.config.maxMcpTools).map((item) => item.tool);
-    return {
-      needed: tools.length > 0,
-      tools,
-      candidates,
-      reason: tools.length > 0 ? candidates.length > tools.length ? `Selected top ${tools.length}/${candidates.length} MCP tools by capability score: ${tools.join(", ")}` : `Requires MCP tools: ${tools.join(", ")}` : "No MCP tools needed"
-    };
-  }
-  /**
-   * Auto-create a skill
-   */
-  async autoCreateSkill(req) {
-    const skillId = `skill-${req.skillName}-${Date.now()}`;
-    const skillDefinition = {
-      id: skillId,
-      name: req.skillName,
-      type: req.skillType,
-      description: `Auto-generated skill for ${req.reason}`,
-      capabilities: this.generateSkillCapabilities(req),
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      autoGenerated: true
-    };
-    const stateManager = getGlobalStateManager();
-    await stateManager.initialize();
-    await stateManager.createAgentWorktree(skillId);
-    await stateManager.saveState(skillId, {
-      agentId: skillId,
-      status: "active",
-      currentTask: "Ready",
-      memory: { skillDefinition }
-    });
-    this.log(`Skill created: ${skillId}`);
-    return skillId;
-  }
-  /**
-   * Generate skill capabilities based on requirement
-   */
-  generateSkillCapabilities(req) {
-    const capabilitiesMap = {
-      code: ["write_code", "review_code", "refactor_code", "debug_code"],
-      analysis: ["analyze_requirements", "design_architecture", "create_diagrams", "document_design"],
-      integration: ["integrate_apis", "configure_services", "test_integration", "handle_auth"],
-      deployment: ["deploy_application", "configure_infrastructure", "setup_ci_cd", "monitor_services"]
-    };
-    return capabilitiesMap[req.skillType] || ["general_task"];
-  }
-  /**
-   * Auto-create an agent
-   */
-  async autoCreateAgent(req) {
-    const agentId = `agent-${req.agentType}-${Date.now()}`;
-    const agentDefinition = {
-      id: agentId,
-      name: `${req.domain} ${req.agentType}`,
-      type: req.agentType,
-      domain: req.domain,
-      status: "active",
-      model: req.agentType === "architect" ? "opus" : "sonnet",
-      capabilities: this.generateAgentCapabilities(req),
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      autoGenerated: true
-    };
-    const stateManager = getGlobalStateManager();
-    await stateManager.initialize();
-    await stateManager.createAgentWorktree(agentId);
-    await stateManager.saveState(agentId, {
-      agentId,
-      status: "active",
-      currentTask: "Ready",
-      memory: { agentDefinition }
-    });
-    const mailboxManager = getGlobalMailboxManager();
-    await mailboxManager.initialize();
-    await mailboxManager.createMailbox(agentId);
-    this.log(`Agent created: ${agentId}`);
-    return agentId;
-  }
-  /**
-   * Generate agent capabilities based on requirement
-   */
-  generateAgentCapabilities(req) {
-    const capabilitiesMap = {
-      architect: ["design_architecture", "create_plans", "review_design", "make_decisions"],
-      specialist: ["deep_expertise", "solve_complex_problems", "optimize_solutions", "provide_guidance"],
-      engineer: ["implement_features", "write_code", "test_code", "fix_bugs"],
-      devops: ["deploy_applications", "manage_infrastructure", "setup_pipelines", "monitor_systems"]
-    };
-    return capabilitiesMap[req.agentType] || ["general_task"];
-  }
-  /**
-   * Execute via Mayor Agent
-   */
-  async executeMayor(input, intent, agentsCreated, skillsCreated, mcpToolsUsed) {
-    this.log("Executing via Mayor Agent");
-    const mayor = getGlobalMayorAgent({
-      autoCreateConvoy: true,
-      autoSpawnWorkers: true,
-      monitorProgress: true,
-      notifyHuman: true
-    });
-    const response = await mayor.processRequest(input);
-    return {
-      success: true,
-      route: "mayor",
-      intent,
-      convoyId: response.convoyId,
-      agentsCreated,
-      skillsCreated,
-      mcpToolsUsed,
-      message: response.message,
-      details: response
-    };
-  }
-  /**
-   * Execute via Plan Mode
-   */
-  async executePlan(input, intent, agentsCreated, skillsCreated, mcpToolsUsed) {
-    this.log("Executing via Plan Mode");
-    const convoyManager = getGlobalConvoyManager();
-    await convoyManager.initialize();
-    const convoy = await convoyManager.create(`Plan: ${input.substring(0, 50)}`, {
-      description: input,
-      createdBy: "auto-executor"
-    });
-    await convoyManager.addTask(convoy.id, "Analyze requirements");
-    await convoyManager.addTask(convoy.id, "Design architecture");
-    await convoyManager.addTask(convoy.id, "Create implementation plan");
-    await convoyManager.start(convoy.id);
-    return {
-      success: true,
-      route: "plan",
-      intent,
-      convoyId: convoy.id,
-      agentsCreated,
-      skillsCreated,
-      mcpToolsUsed,
-      message: `Planning convoy created: ${convoy.id}`,
-      details: { convoy }
-    };
-  }
-  /**
-   * Execute via Feature Mode
-   */
-  async executeFeature(input, intent, agentsCreated, skillsCreated, mcpToolsUsed) {
-    this.log("Executing via Feature Mode");
-    const convoyManager = getGlobalConvoyManager();
-    await convoyManager.initialize();
-    const convoy = await convoyManager.create(`Feature: ${input.substring(0, 50)}`, {
-      description: input,
-      createdBy: "auto-executor"
-    });
-    await convoyManager.addTask(convoy.id, "Implement feature");
-    await convoyManager.addTask(convoy.id, "Write tests");
-    await convoyManager.addTask(convoy.id, "Update documentation");
-    await convoyManager.start(convoy.id);
-    return {
-      success: true,
-      route: "feature",
-      intent,
-      convoyId: convoy.id,
-      agentsCreated,
-      skillsCreated,
-      mcpToolsUsed,
-      message: `Feature convoy created: ${convoy.id}`,
-      details: { convoy }
-    };
-  }
-  /**
-   * Execute directly
-   */
-  async executeDirect(input, intent, agentsCreated, skillsCreated, mcpToolsUsed) {
-    this.log("Executing directly");
-    return {
-      success: true,
-      route: "direct",
-      intent,
-      agentsCreated,
-      skillsCreated,
-      mcpToolsUsed,
-      message: `Direct execution: ${input}`,
-      details: { input }
-    };
-  }
-  buildExecutionInsights(options) {
-    return {
-      decisionProfile: options.userSelectedRoute ? "user_guided" : "automatic",
-      routeDecision: {
-        initial: options.initialRoute,
-        final: options.resolvedRoute,
-        elicitationAsked: options.elicitationAsked,
-        userSelectedRoute: options.userSelectedRoute
-      },
-      mcpSelection: {
-        selected: options.mcpReq.tools,
-        candidates: options.mcpReq.candidates,
-        truncated: options.mcpReq.candidates.length > options.mcpReq.tools.length,
-        reason: options.mcpReq.reason
-      },
-      telemetry: {
-        totalDurationMs: options.totalDurationMs,
-        eventCount: this.getExecutionTelemetryEventCount(options.executionId)
-      }
-    };
-  }
-  getExecutionTelemetryEventCount(executionId) {
-    return this.config.telemetry.getRecent(500).filter((event) => event.executionId === executionId).length;
-  }
-  /**
-   * Get aggregated execution telemetry.
-   */
-  getTelemetrySummary() {
-    return this.config.telemetry.summarize();
-  }
-  /**
-   * Get recent execution telemetry events.
-   */
-  getTelemetryEvents(limit = 50) {
-    return this.config.telemetry.getRecent(limit);
-  }
-  clearTelemetry() {
-    this.config.telemetry.clear();
-  }
-  getErrorMessage(error) {
-    if (error instanceof Error) {
-      return error.message;
-    }
-    return String(error);
-  }
-  /**
-   * Log message if verbose
-   */
-  log(message) {
-    if (this.config.verbose) {
-      console.log(`[AutoExecutor] ${message}`);
-    }
-  }
-  emitCommandHook(event, data) {
-    void emitCommandHookEvent(event, data);
-  }
-}
-let globalExecutor = null;
-function getGlobalAutoExecutor(config) {
-  if (!globalExecutor) {
-    globalExecutor = new AutoExecutor(config);
-  }
-  return globalExecutor;
-}
-
-class CliInterceptor extends EventEmitter {
-  config;
-  autoExecutor = getGlobalAutoExecutor({
-    autoCreateSkills: true,
-    autoCreateAgents: true,
-    autoSelectMcp: true,
-    verbose: false
-  });
-  getActiveCodeTool() {
-    const codeToolType = readZcfConfig()?.codeToolType;
-    return isCodeToolType(codeToolType) ? codeToolType : DEFAULT_CODE_TOOL_TYPE;
-  }
-  getSystemCommands() {
-    return getCodeToolNativeSlashCommands(this.getActiveCodeTool());
-  }
-  // Simple queries that don't need interception
-  simpleQueryPatterns = [
-    /^what is/i,
-    /^who is/i,
-    /^when was/i,
-    /^where is/i,
-    /^how do i/i,
-    /^can you explain/i,
-    /^tell me about/i
-  ];
-  constructor(config = {}) {
-    super();
-    this.config = {
-      enabled: config.enabled !== void 0 ? config.enabled : true,
-      autoExecute: config.autoExecute !== void 0 ? config.autoExecute : true,
-      showIntent: config.showIntent !== void 0 ? config.showIntent : true,
-      bypassKeywords: config.bypassKeywords || [],
-      ccjkOwnedSlashPrefixes: config.ccjkOwnedSlashPrefixes || ["/ccjk", "/ccjk:", "/plugin", "/plugins", "/skill"],
-      verbose: config.verbose !== void 0 ? config.verbose : false
-    };
-  }
-  /**
-   * Intercept user input when this component is explicitly integrated.
-   */
-  async intercept(userInput) {
-    if (!this.config.enabled) {
-      return {
-        intercepted: false,
-        reason: "Interceptor disabled"
-      };
-    }
-    this.emit("intercept:started", { input: userInput });
-    const bypassCheck = this.shouldBypass(userInput);
-    if (bypassCheck.bypass) {
-      await this.handleBypassedCommand(userInput, bypassCheck.reason);
-      this.emit("intercept:bypassed", { input: userInput, reason: bypassCheck.reason });
-      return {
-        intercepted: false,
-        reason: "Bypassed",
-        bypassed: true,
-        bypassReason: bypassCheck.reason
-      };
-    }
-    try {
-      this.log(`Intercepting: ${userInput.substring(0, 50)}...`);
-      if (this.config.showIntent) {
-        this.showIntentMessage(userInput);
-      }
-      const executionResult = await this.autoExecutor.execute(userInput);
-      this.emit("intercept:completed", { input: userInput, result: executionResult });
-      return {
-        intercepted: true,
-        reason: "Automatically routed and executed",
-        executionResult
-      };
-    } catch (error) {
-      this.emit("intercept:failed", { input: userInput, error });
-      throw error;
-    }
-  }
-  /**
-   * Check if input should bypass interception
-   */
-  shouldBypass(input) {
-    const normalized = input.trim().toLowerCase();
-    const systemCommands = this.getSystemCommands();
-    if (normalized.startsWith("/")) {
-      const isCcjkOwned = this.config.ccjkOwnedSlashPrefixes.some((prefix) => normalized.startsWith(prefix));
-      if (!isCcjkOwned && systemCommands.some((cmd) => normalized.startsWith(cmd))) {
-        return { bypass: true, reason: "Native slash command passthrough" };
-      }
-    }
-    if (systemCommands.some((cmd) => normalized.startsWith(cmd))) {
-      return { bypass: true, reason: "System command" };
-    }
-    if (this.config.bypassKeywords.some((kw) => normalized.includes(kw.toLowerCase()))) {
-      return { bypass: true, reason: "Custom bypass keyword" };
-    }
-    if (this.simpleQueryPatterns.some((pattern) => pattern.test(input))) {
-      return { bypass: true, reason: "Simple informational query" };
-    }
-    if (input.split(/\s+/).length <= 3) {
-      return { bypass: true, reason: "Too short - likely a simple question" };
-    }
-    return { bypass: false, reason: "" };
-  }
-  /**
-   * Show intent message to user
-   */
-  showIntentMessage(_input) {
-    console.log("\n\u{1F9E0} Brain router is handling this request...");
-    console.log("   It may use skills, agents, and MCP tools based on the active routing config.\n");
-  }
-  async handleBypassedCommand(input, reason) {
-    const normalized = input.trim().toLowerCase();
-    const command = this.extractCommandName(normalized);
-    if (normalized.startsWith("/clear")) {
-      this.autoExecutor.clearTelemetry();
-      contextLoader.clearCache();
-      getSkillRegistry().clear();
-      await emitCommandHookEvent("command-clear", {
-        command,
-        cleared: ["telemetry", "context-cache", "skill-registry"]
-      });
-    }
-    if (normalized.startsWith("/")) {
-      await emitCommandHookEvent("command-bypass", {
-        command,
-        reason
-      });
-    }
-  }
-  extractCommandName(input) {
-    if (!input.startsWith("/")) {
-      return "";
-    }
-    return input.split(/\s+/)[0];
-  }
-  /**
-   * Enable interceptor
-   */
-  enable() {
-    this.config.enabled = true;
-    this.emit("interceptor:enabled");
-  }
-  /**
-   * Disable interceptor
-   */
-  disable() {
-    this.config.enabled = false;
-    this.emit("interceptor:disabled");
-  }
-  /**
-   * Check if interceptor is enabled
-   */
-  isEnabled() {
-    return this.config.enabled;
-  }
-  /**
-   * Log message if verbose
-   */
-  log(message) {
-    if (this.config.verbose) {
-      console.log(`[CliInterceptor] ${message}`);
-    }
-  }
-}
-let globalInterceptor = null;
-function getGlobalCliInterceptor(config) {
-  if (!globalInterceptor) {
-    globalInterceptor = new CliInterceptor(config);
-  }
-  return globalInterceptor;
-}
-
-class BrainRouter extends EventEmitter {
-  interceptor = getGlobalCliInterceptor({
-    enabled: true,
-    autoExecute: true,
-    showIntent: true,
-    verbose: false
-  });
-  constructor() {
-    super();
-    this.interceptor.on("intercept:started", (data) => {
-      this.emit("router:started", data);
-    });
-    this.interceptor.on("intercept:completed", (data) => {
-      this.emit("router:completed", data);
-    });
-    this.interceptor.on("intercept:failed", (data) => {
-      this.emit("router:failed", data);
-    });
-    this.interceptor.on("intercept:bypassed", (data) => {
-      this.emit("router:bypassed", data);
-    });
-  }
-  /**
-   * Process user input - main entry point
-   *
-   * This is the ONLY function users/CLI need to call.
-   * Everything else is automatic.
-   */
-  async process(userInput) {
-    try {
-      const interceptionResult = await this.interceptor.intercept(userInput);
-      if (interceptionResult.bypassed) {
-        return {
-          handled: false,
-          passthrough: true,
-          message: `Passing through to Claude Code: ${interceptionResult.bypassReason}`
-        };
-      }
-      if (interceptionResult.intercepted && interceptionResult.executionResult) {
-        return {
-          handled: true,
-          result: interceptionResult.executionResult,
-          message: interceptionResult.executionResult.message
-        };
-      }
-      return {
-        handled: false,
-        passthrough: true,
-        message: "No interception needed"
-      };
-    } catch (error) {
-      this.emit("router:error", { error, input: userInput });
-      throw error;
-    }
-  }
-  /**
-   * Enable automatic routing
-   */
-  enable() {
-    this.interceptor.enable();
-    this.emit("router:enabled");
-  }
-  /**
-   * Disable automatic routing
-   */
-  disable() {
-    this.interceptor.disable();
-    this.emit("router:disabled");
-  }
-  /**
-   * Check if router is enabled
-   */
-  isEnabled() {
-    return this.interceptor.isEnabled();
-  }
-}
-let globalRouter = null;
-function getGlobalBrainRouter() {
-  if (!globalRouter) {
-    globalRouter = new BrainRouter();
-  }
-  return globalRouter;
-}
-async function processUserInput(userInput) {
-  const router = getGlobalBrainRouter();
-  return await router.process(userInput);
-}
-
-class BrainCliHook extends EventEmitter {
-  config;
-  initialized = false;
-  constructor(config = {}) {
-    super();
-    this.config = {
-      enabled: config.enabled !== void 0 ? config.enabled : true,
-      silent: config.silent !== void 0 ? config.silent : false,
-      fallbackToClaudeCode: config.fallbackToClaudeCode !== void 0 ? config.fallbackToClaudeCode : true
-    };
-  }
-  /**
-   * Initialize the hook
-   */
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-    const { getGlobalStateManager } = await import('./session-manager.mjs').then(function (n) { return n.b; });
-    const { getGlobalMailboxManager } = await Promise.resolve().then(function () { return persistentMailbox; });
-    const { getGlobalConvoyManager } = await import('./session-manager.mjs').then(function (n) { return n.d; });
-    const stateManager = getGlobalStateManager();
-    const mailboxManager = getGlobalMailboxManager();
-    const convoyManager = getGlobalConvoyManager();
-    await stateManager.initialize();
-    await mailboxManager.initialize();
-    await convoyManager.initialize();
-    this.initialized = true;
-    this.emit("hook:initialized");
-    if (!this.config.silent) {
-      console.log("\u{1F9E0} Brain system initialized - automatic routing enabled");
-    }
-  }
-  /**
-   * Process user input through the hook
-   */
-  async processInput(userInput) {
-    if (!this.config.enabled) {
-      return {
-        intercepted: false,
-        handled: false,
-        shouldContinue: true,
-        message: "Hook disabled"
-      };
-    }
-    if (!this.initialized) {
-      await this.initialize();
-    }
-    try {
-      SessionIntelligence.getInstance().recordMessage("user", userInput);
-      const result = await processUserInput(userInput);
-      if (result.handled && result.result) {
-        this.emit("hook:handled", { input: userInput, result: result.result });
-        if (!this.config.silent) {
-          this.displayResult(result.result);
-        }
-        return {
-          intercepted: true,
-          handled: true,
-          executionResult: result.result,
-          shouldContinue: false,
-          // Don't pass to Claude Code
-          message: result.message
-        };
-      }
-      if (result.passthrough) {
-        this.emit("hook:passthrough", { input: userInput, reason: result.message });
-        const additionalContext = this.config.silent ? void 0 : await this.buildAdditionalContext();
-        return {
-          intercepted: true,
-          handled: false,
-          shouldContinue: true,
-          // Pass to Claude Code
-          message: result.message,
-          additionalContext
-        };
-      }
-      return {
-        intercepted: false,
-        handled: false,
-        shouldContinue: this.config.fallbackToClaudeCode,
-        message: "No interception"
-      };
-    } catch (error) {
-      this.emit("hook:error", { error, input: userInput });
-      if (this.config.fallbackToClaudeCode) {
-        console.error("Brain system error, falling back to Claude Code:", error);
-        return {
-          intercepted: true,
-          handled: false,
-          shouldContinue: true,
-          message: "Error - falling back to Claude Code"
-        };
-      }
-      throw error;
-    }
-  }
-  /**
-   * Display execution result to user
-   */
-  displayResult(result) {
-    console.log(`
-${"=".repeat(60)}`);
-    console.log("\u{1F9E0} Brain System Result");
-    console.log("=".repeat(60));
-    console.log();
-    const routeEmoji = {
-      mayor: "\u{1F454}",
-      plan: "\u{1F4CB}",
-      feature: "\u26A1",
-      direct: "\u{1F680}"
-    };
-    console.log(`${routeEmoji[result.route]} Route: ${result.route.toUpperCase()}`);
-    console.log(`\u{1F4CA} Complexity: ${result.intent.complexity}`);
-    console.log(`\u{1F3AF} Intent: ${result.intent.type}`);
-    console.log();
-    if (result.agentsCreated.length > 0) {
-      console.log("\u{1F916} Agents Created:");
-      for (const agent of result.agentsCreated) {
-        console.log(`   \u2713 ${agent}`);
-      }
-      console.log();
-    }
-    if (result.skillsCreated.length > 0) {
-      console.log("\u{1F393} Skills Created:");
-      for (const skill of result.skillsCreated) {
-        console.log(`   \u2713 ${skill}`);
-      }
-      console.log();
-    }
-    if (result.mcpToolsUsed.length > 0) {
-      console.log("\u{1F527} MCP Tools Selected:");
-      for (const tool of result.mcpToolsUsed) {
-        console.log(`   \u2713 ${tool}`);
-      }
-      console.log();
-    }
-    if (result.insights) {
-      console.log("\u2728 Smart Upgrade Signals:");
-      console.log(`   Route decision: ${result.insights.routeDecision.initial} \u2192 ${result.insights.routeDecision.final}`);
-      if (result.insights.routeDecision.userSelectedRoute) {
-        console.log("   Mode: User-guided route disambiguation");
-      } else if (result.insights.routeDecision.elicitationAsked) {
-        console.log("   Mode: Asked for route preference (kept recommended)");
-      } else {
-        console.log("   Mode: Fully automatic route decision");
-      }
-      if (result.insights.mcpSelection.selected.length > 0) {
-        if (result.insights.mcpSelection.truncated) {
-          console.log(`   MCP ranking: selected ${result.insights.mcpSelection.selected.length} of ${result.insights.mcpSelection.candidates.length} candidates`);
-        }
-        console.log(`   MCP reason: ${result.insights.mcpSelection.reason}`);
-      } else {
-        console.log("   MCP reason: no external tools needed");
-      }
-      console.log(`   Telemetry: ${result.insights.telemetry.eventCount} events, ${result.insights.telemetry.totalDurationMs}ms`);
-      console.log();
-    }
-    if (result.convoyId) {
-      console.log(`\u{1F4E6} Convoy: ${result.convoyId}`);
-      console.log();
-    }
-    console.log("\u{1F4AC} Message:");
-    console.log(`   ${result.message}`);
-    console.log();
-    console.log("=".repeat(60));
-    console.log();
-  }
-  /**
-   * Build additional context string for PreToolUse hook injection.
-   * Provides brain insights (task state, session context) to the model
-   * without blocking tool execution. Claude Code 2.1+ feature.
-   */
-  async buildAdditionalContext() {
-    try {
-      const { loadContextAtDepth } = await import('./session-manager.mjs').then(function (n) { return n.e; });
-      const ctx = await loadContextAtDepth("L0");
-      if (ctx.totalTokens > 0) {
-        return `[Brain Context: ${ctx.layers.size} layers, ~${ctx.totalTokens} tokens, depth=${ctx.depth}]`;
-      }
-      return void 0;
-    } catch {
-      return void 0;
-    }
-  }
-  /**
-   * Enable the hook
-   */
-  enable() {
-    this.config.enabled = true;
-    this.emit("hook:enabled");
-  }
-  /**
-   * Disable the hook
-   */
-  disable() {
-    this.config.enabled = false;
-    this.emit("hook:disabled");
-  }
-  /**
-   * Check if hook is enabled
-   */
-  isEnabled() {
-    return this.config.enabled;
-  }
-}
-let globalHook = null;
-function getGlobalBrainHook(config) {
-  if (!globalHook) {
-    globalHook = new BrainCliHook(config);
-  }
-  return globalHook;
-}
-async function setupBrainHook(config) {
-  const hook = getGlobalBrainHook(config);
-  await hook.initialize();
-  return hook;
-}
-
-export { BrainCliHook, getGlobalBrainHook, setupBrainHook };