ccjk 12.0.7 → 12.0.8

package/dist/chunks/cli-hook.mjs

@@ -1,2285 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { a as getGlobalStateManager, g as getGlobalConvoyManager } from './convoy-manager.mjs';
-import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import 'node:os';
-import './main.mjs';
-import 'module';
-import 'node:child_process';
-import 'node:path';
-import 'node:process';
-import 'node:stream';
-import 'node:readline';
-import 'node:crypto';
-
-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 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;
-}
-
-class AutoExecutor extends EventEmitter {
-  config;
-  intentRouter = getGlobalIntentRouter();
-  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,
-      verbose: config.verbose !== void 0 ? config.verbose : false
-    };
-  }
-  /**
-   * Execute user request automatically
-   */
-  async execute(userInput) {
-    this.emit("execution:started", { input: userInput });
-    try {
-      const routeResult = await this.intentRouter.route(userInput);
-      const { route, intent } = routeResult;
-      this.log(`Intent analyzed: ${intent.type} (${intent.complexity})`);
-      this.log(`Suggested route: ${route}`);
-      const skillReq = await this.detectSkillRequirement(userInput, intent);
-      const agentReq = await this.detectAgentRequirement(userInput, intent);
-      const mcpReq = await this.detectMcpRequirement(userInput, intent);
-      const agentsCreated = [];
-      const skillsCreated = [];
-      const mcpToolsUsed = [];
-      if (this.config.autoCreateSkills && skillReq.needed) {
-        this.log(`Auto-creating skill: ${skillReq.skillName}`);
-        const skillId = await this.autoCreateSkill(skillReq);
-        skillsCreated.push(skillId);
-        this.emit("skill:created", { skillId, skillReq });
-      }
-      if (this.config.autoCreateAgents && agentReq.needed) {
-        this.log(`Auto-creating agent: ${agentReq.domain}`);
-        const agentId = await this.autoCreateAgent(agentReq);
-        agentsCreated.push(agentId);
-        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.emit("mcp:selected", { tools: mcpReq.tools, mcpReq });
-      }
-      let result;
-      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}`);
-      }
-      this.emit("execution:completed", result);
-      return result;
-    } catch (error) {
-      this.emit("execution:failed", { error, input: userInput });
-      throw error;
-    }
-  }
-  /**
-   * 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 tools = [];
-    if (normalized.includes("file") || normalized.includes("directory") || normalized.includes("folder")) {
-      tools.push("filesystem");
-    }
-    if (normalized.includes("github") || normalized.includes("repository") || normalized.includes("pr")) {
-      tools.push("github");
-    }
-    if (normalized.includes("search") || normalized.includes("documentation") || normalized.includes("docs")) {
-      tools.push("web-search");
-    }
-    if (normalized.includes("browser") || normalized.includes("webpage") || normalized.includes("ui test")) {
-      tools.push("playwright");
-    }
-    if (normalized.includes("library") || normalized.includes("framework") || normalized.includes("package")) {
-      tools.push("context7");
-    }
-    if (normalized.includes("diagnostic") || normalized.includes("error") || normalized.includes("lint")) {
-      tools.push("ide");
-    }
-    return {
-      needed: tools.length > 0,
-      tools,
-      reason: tools.length > 0 ? `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 }
-    };
-  }
-  /**
-   * Log message if verbose
-   */
-  log(message) {
-    if (this.config.verbose) {
-      console.log(`[AutoExecutor] ${message}`);
-    }
-  }
-}
-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
-  });
-  // Claude Code native commands that should bypass interception
-  // Reference: https://deepwiki.com/FlorianBruniaux/claude-code-ultimate-guide/16-command-reference
-  systemCommands = [
-    // Session Management
-    "/help",
-    "/clear",
-    "/exit",
-    "/quit",
-    "/resume",
-    // Context Management
-    "/compact",
-    "/context",
-    "/status",
-    // Mode Control
-    "/plan",
-    "/execute",
-    // History
-    "/rewind",
-    // Diagnostic
-    "/mcp",
-    "/doctor",
-    // Configuration
-    "/settings",
-    "/config",
-    "/version",
-    // Extension System
-    "/agents",
-    "/skills",
-    "/commands",
-    // Plugin/Marketplace - CCJK 接管，不在此列表
-    // '/plugin',
-    // '/plugins',
-    // Tasks
-    "/tasks",
-    // Memory
-    "/memory",
-    "/memories",
-    // Model
-    "/model",
-    // Cost
-    "/cost",
-    // Permissions
-    "/permissions",
-    // Hooks
-    "/hooks",
-    // Init
-    "/init",
-    // Login/Logout
-    "/login",
-    "/logout",
-    // Bug report
-    "/bug",
-    // Terminal
-    "/terminal",
-    // IDE
-    "/ide",
-    // Review
-    "/review",
-    // PR
-    "/pr",
-    // Vim mode
-    "/vim",
-    // Listen mode
-    "/listen",
-    // Add files
-    "/add",
-    // Install
-    "/install",
-    // Allowed tools
-    "/allowed-tools",
-    // Thinking
-    "/think",
-    "/thinking"
-  ];
-  // 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 || [],
-      verbose: config.verbose !== void 0 ? config.verbose : false
-    };
-  }
-  /**
-   * Intercept user input and route automatically
-   */
-  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) {
-      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();
-    if (this.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} Analyzing your request...");
-    console.log("   System will automatically handle: skills, agents, MCP tools\n");
-  }
-  /**
-   * 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('./convoy-manager.mjs').then(function (n) { return n.b; });
-    const { getGlobalMailboxManager } = await Promise.resolve().then(function () { return persistentMailbox; });
-    const { getGlobalConvoyManager } = await import('./convoy-manager.mjs').then(function (n) { return n.c; });
-    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 {
-      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.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('./context-loader.mjs');
-      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 };