@defai.digital/automatosx 12.5.4 → 12.5.5

package/dist/mcp/index.js

@@ -8390,12 +8390,11 @@ function calculateMaxConcurrentAgents(staticLimit) {
 init_esm_shims();
 var PRECOMPILED_CONFIG = {
   "providers": {
-    "gemini-cli": {
+    "claude-code": {
       "enabled": true,
-      "priority": 1,
+      "priority": 3,
       "timeout": 27e5,
-      "command": "gemini",
-      "description": "#1 Frontend/Design, multimodal, free tier, WebDev Arena leader",
+      "command": "claude",
       "healthCheck": {
         "enabled": true,
         "interval": 3e5,
@@ -8417,16 +8416,15 @@ var PRECOMPILED_CONFIG = {
       },
       "limitTracking": {
         "enabled": true,
-        "window": "daily",
+        "window": "weekly",
         "resetHourUtc": 0
       }
     },
-    "openai": {
+    "gemini-cli": {
       "enabled": true,
-      "priority": 3,
+      "priority": 2,
       "timeout": 27e5,
-      "command": "codex",
-      "description": "Best reasoning (o3), strategy, 75% accuracy, 192k context",
+      "command": "gemini",
       "healthCheck": {
         "enabled": true,
         "interval": 3e5,
@@ -8452,12 +8450,11 @@ var PRECOMPILED_CONFIG = {
         "resetHourUtc": 0
       }
     },
-    "claude-code": {
+    "openai": {
       "enabled": true,
-      "priority": 2,
+      "priority": 1,
       "timeout": 27e5,
-      "command": "claude",
-      "description": "#1 Coding model, agentic workflows, security, 0% edit error rate",
+      "command": "codex",
       "healthCheck": {
         "enabled": true,
         "interval": 3e5,
@@ -8477,50 +8474,6 @@ var PRECOMPILED_CONFIG = {
         "forceKillDelay": 1e3,
         "cacheEnabled": true
       },
-      "limitTracking": {
-        "enabled": true,
-        "window": "weekly",
-        "resetHourUtc": 0
-      }
-    },
-    "glm": {
-      "enabled": true,
-      "priority": 4,
-      "timeout": 27e5,
-      "type": "sdk",
-      "description": "Near Claude coding (48.6%), low cost $3/mo, 200k context, agentic",
-      "healthCheck": {
-        "enabled": true,
-        "interval": 3e5,
-        "timeout": 5e3
-      },
-      "circuitBreaker": {
-        "enabled": true,
-        "failureThreshold": 3,
-        "recoveryTimeout": 6e4
-      },
-      "limitTracking": {
-        "enabled": true,
-        "window": "daily",
-        "resetHourUtc": 0
-      }
-    },
-    "grok": {
-      "enabled": true,
-      "priority": 5,
-      "timeout": 27e5,
-      "type": "sdk",
-      "description": "Fastest (67ms), reasoning (93% AIME), 1M context, DeepSearch",
-      "healthCheck": {
-        "enabled": true,
-        "interval": 3e5,
-        "timeout": 5e3
-      },
-      "circuitBreaker": {
-        "enabled": true,
-        "failureThreshold": 3,
-        "recoveryTimeout": 6e4
-      },
       "limitTracking": {
         "enabled": true,
         "window": "daily",
@@ -8737,7 +8690,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.5.4"
+  "version": "12.5.5"
 };
 
 // src/core/config/schemas.ts
@@ -10403,6 +10356,12 @@ var ProviderLimitManager = class _ProviderLimitManager extends DisposableEventEm
       }
     });
   }
+  /**
+   * Clean up resources and remove all event listeners.
+   */
+  async destroy() {
+    this.removeAllListeners();
+  }
 };
 async function getProviderLimitManager(stateDirectory) {
   if (!stateDirectory) {
@@ -11098,6 +11057,12 @@ var ProviderMetricsTracker = class extends DisposableEventEmitter {
     const records = this.metrics.get(provider);
     return records ? [...records] : null;
   }
+  /**
+   * Clean up resources and remove all event listeners.
+   */
+  async destroy() {
+    this.removeAllListeners();
+  }
 };
 var globalMetricsTracker = null;
 function getProviderMetricsTracker() {
@@ -11381,6 +11346,12 @@ var RoutingStrategyManager = class extends DisposableEventEmitter {
   exportHistory() {
     return [...this.decisionHistory];
   }
+  /**
+   * Clean up resources and remove all event listeners.
+   */
+  async destroy() {
+    this.removeAllListeners();
+  }
 };
 var globalRoutingStrategy = null;
 function getRoutingStrategyManager(config) {
@@ -13996,9 +13967,9 @@ var MemoryManager = class _MemoryManager {
       throw new MemoryError("Memory manager not initialized", "DATABASE_ERROR");
     }
     try {
-      const { mkdir: mkdir4 } = await import('fs/promises');
+      const { mkdir: mkdir5 } = await import('fs/promises');
       const destDir = dirname3(destPath);
-      await mkdir4(destDir, { recursive: true });
+      await mkdir5(destDir, { recursive: true });
       await this.db.backup(destPath);
       logger.info("Database backup created", { destPath: normalizePath(destPath) });
     } catch (error) {
@@ -14033,8 +14004,8 @@ var MemoryManager = class _MemoryManager {
         tempDb.prepare("SELECT COUNT(*) FROM memory_entries").get();
         tempDb.close();
       } catch (verifyError) {
-        const { unlink: unlink3 } = await import('fs/promises');
-        await unlink3(tempPath).catch(() => {
+        const { unlink: unlink4 } = await import('fs/promises');
+        await unlink4(tempPath).catch(() => {
         });
         throw new MemoryError(
           `Backup file verification failed: ${verifyError.message}`,
@@ -14154,9 +14125,9 @@ var MemoryManager = class _MemoryManager {
         },
         entries
       };
-      const { writeFile: writeFile6 } = await import('fs/promises');
+      const { writeFile: writeFile7 } = await import('fs/promises');
       const json = pretty ? JSON.stringify(exportData, null, 2) : JSON.stringify(exportData);
-      await writeFile6(filePath, json, "utf-8");
+      await writeFile7(filePath, json, "utf-8");
       const sizeBytes = Buffer.byteLength(json, "utf-8");
       logger.info("Memory exported to JSON", {
         filePath: normalizePath(filePath),
@@ -14205,8 +14176,8 @@ var MemoryManager = class _MemoryManager {
           { filePath }
         );
       }
-      const { readFile: readFile11 } = await import('fs/promises');
-      const content = await readFile11(filePath, "utf-8");
+      const { readFile: readFile13 } = await import('fs/promises');
+      const content = await readFile13(filePath, "utf-8");
       const importData = JSON.parse(content);
       const SUPPORTED_VERSIONS = ["1.0", "4.0.0", "4.11.0"];
       if (!importData.version || !SUPPORTED_VERSIONS.includes(importData.version)) {
@@ -18423,12 +18394,7 @@ var WarningEmitter = class extends EventEmitter {
     this.emit("timeout-warning", event);
   }
   /**
-   * Destroy warning emitter
-   *
-   * CRITICAL FIX (v5.6.18): Remove all event listeners to prevent memory leak.
-   * Must be called when WarningEmitter instance is no longer needed.
-   *
-   * @since 5.6.18
+   * Clean up resources and remove all event listeners.
    */
   destroy() {
     this.removeAllListeners("timeout-warning");
@@ -22789,149 +22755,1796 @@ Task: ${task}`;
   };
 }
 
-// src/mcp/tools/get-capabilities.ts
+// src/mcp/tools/bugfix-scan.ts
 init_esm_shims();
 init_logger();
-function categorizeTools(name) {
-  if (name.startsWith("memory_") || name === "search_memory") return "memory";
-  if (name.startsWith("session_")) return "session";
-  if (name.startsWith("create_task") || name.startsWith("run_task") || name.startsWith("get_task") || name.startsWith("list_task") || name.startsWith("delete_task")) return "task";
-  if (name === "get_capabilities" || name === "list_agents" || name === "get_status" || name === "get_agent_context") return "discovery";
-  if (name.includes("context")) return "context";
-  return "execution";
-}
-function getExecutionMode(providerName, _providerConfig) {
-  if (providerName === "glm" || providerName === "grok") {
-    return "sdk";
+
+// src/core/bugfix/bug-detector.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_DETECTION_RULES = [
+  // Timer leak: setInterval without .unref()
+  // v12.5.5: Increased withinLines from 5 to 50 to handle multi-line callbacks
+  // where .unref() is called after the closing brace (some callbacks are 35+ lines)
+  // NOTE: This is a workaround - proper fix would use AST-based detection
+  {
+    id: "timer-leak-interval",
+    type: "timer_leak",
+    name: "setInterval without unref",
+    description: "setInterval() without .unref() blocks process exit",
+    pattern: "setInterval\\s*\\(",
+    negativePattern: "\\.unref\\s*\\(\\)",
+    withinLines: 50,
+    confidence: 0.9,
+    severity: "high",
+    autoFixable: true,
+    fixTemplate: "add_unref",
+    fileExtensions: [".ts", ".js", ".mts", ".mjs"]
+  },
+  // Timer leak: setTimeout in promise without cleanup
+  {
+    id: "timer-leak-timeout-promise",
+    type: "promise_timeout_leak",
+    name: "setTimeout in Promise without cleanup",
+    description: "setTimeout in Promise should be cleared in finally block",
+    pattern: "new\\s+Promise[^}]*setTimeout\\s*\\(",
+    negativePattern: "finally|clearTimeout",
+    withinLines: 20,
+    confidence: 0.7,
+    severity: "medium",
+    autoFixable: false,
+    // Complex, needs manual review
+    fileExtensions: [".ts", ".js", ".mts", ".mjs"]
+  },
+  // Missing destroy: EventEmitter without destroy method
+  // v12.5.5: Increased withinLines from 100 to 800 to scan entire class
+  // Classes can be large - need to check the whole class for destroy() method
+  {
+    id: "missing-destroy-eventemitter",
+    type: "missing_destroy",
+    name: "EventEmitter without destroy",
+    description: "Classes extending EventEmitter should have destroy() method",
+    pattern: "class\\s+\\w+\\s+extends\\s+(?:EventEmitter|DisposableEventEmitter)",
+    negativePattern: "destroy\\s*\\(\\s*\\)",
+    withinLines: 800,
+    confidence: 0.85,
+    severity: "high",
+    autoFixable: true,
+    fixTemplate: "add_destroy_method",
+    fileExtensions: [".ts", ".js", ".mts", ".mjs"]
+  },
+  // Event leak: .on() without corresponding cleanup
+  {
+    id: "event-leak-on",
+    type: "event_leak",
+    name: "Event listener without cleanup",
+    description: ".on() or .addListener() without corresponding .off() or .removeListener()",
+    pattern: "\\.(on|addListener)\\s*\\(['\"`]\\w+['\"`]",
+    negativePattern: "\\.(off|removeListener|removeAllListeners)\\s*\\(",
+    withinLines: 50,
+    confidence: 0.6,
+    // Lower confidence - may have false positives
+    severity: "medium",
+    autoFixable: false,
+    fileExtensions: [".ts", ".js", ".mts", ".mjs"]
+  },
+  // Uncaught promise: Promise without catch
+  {
+    id: "uncaught-promise",
+    type: "uncaught_promise",
+    name: "Promise without error handling",
+    description: "Promise should have .catch() or be awaited in try/catch",
+    pattern: "new\\s+Promise\\s*\\([^)]+\\)",
+    negativePattern: "\\.catch\\s*\\(|try\\s*\\{",
+    withinLines: 10,
+    confidence: 0.5,
+    // Low confidence - many false positives
+    severity: "low",
+    autoFixable: false,
+    fileExtensions: [".ts", ".js", ".mts", ".mjs"]
   }
-  if (providerName === "claude-code" || providerName === "gemini-cli") {
-    return "cli";
+];
+var BugDetector = class {
+  rules;
+  config;
+  constructor(config, customRules) {
+    this.config = config;
+    this.rules = customRules || DEFAULT_DETECTION_RULES;
+    if (config.bugTypes && config.bugTypes.length > 0) {
+      this.rules = this.rules.filter(
+        (rule) => config.bugTypes.includes(rule.type)
+      );
+    }
+    logger.debug("BugDetector initialized", {
+      ruleCount: this.rules.length,
+      bugTypes: config.bugTypes,
+      scope: config.scope
+    });
   }
-  if (providerName === "openai") {
-    return "hybrid";
+  /**
+   * Scan codebase for bugs
+   *
+   * @param rootDir - Root directory to scan
+   * @returns Array of bug findings
+   */
+  async scan(rootDir) {
+    const startTime = Date.now();
+    const findings = [];
+    logger.info("Starting bug scan", {
+      rootDir,
+      scope: this.config.scope,
+      ruleCount: this.rules.length
+    });
+    const scanDir = this.config.scope ? join(rootDir, this.config.scope) : rootDir;
+    const files = await this.getFilesToScan(scanDir, rootDir);
+    logger.debug("Files to scan", { count: files.length });
+    for (const file of files) {
+      try {
+        const fileFindings = await this.scanFile(file, rootDir);
+        findings.push(...fileFindings);
+      } catch (error) {
+        logger.warn("Error scanning file", {
+          file,
+          error: error.message
+        });
+      }
+    }
+    const filteredFindings = this.filterBySeverity(findings);
+    filteredFindings.sort((a, b) => {
+      const severityOrder = {
+        critical: 4,
+        high: 3,
+        medium: 2,
+        low: 1
+      };
+      const severityDiff = severityOrder[b.severity] - severityOrder[a.severity];
+      if (severityDiff !== 0) return severityDiff;
+      return b.confidence - a.confidence;
+    });
+    const duration = Date.now() - startTime;
+    logger.info("Bug scan complete", {
+      totalFindings: filteredFindings.length,
+      filesScanned: files.length,
+      durationMs: duration
+    });
+    return filteredFindings;
   }
-  return "cli";
-}
-function getProviderType(providerName) {
-  if (providerName === "glm" || providerName === "grok") return "sdk";
-  if (providerName === "openai") return "hybrid";
-  return "cli";
-}
-function createGetCapabilitiesHandler(deps) {
-  return async () => {
-    logger.info("[MCP] get_capabilities called");
-    try {
-      const projectDir = process.cwd();
-      const config = await loadConfig(projectDir);
-      const version = getVersion();
-      const providers = [];
-      const providerConfigs = config.providers || {};
-      for (const [name, providerConfig] of Object.entries(providerConfigs)) {
-        const cfg = providerConfig;
-        const enabled = cfg.enabled === true;
-        let available = false;
-        try {
-          const availableProviders = await deps.router.getAvailableProviders();
-          available = availableProviders.some((p) => p.name === name);
-        } catch {
-          available = enabled;
+  /**
+   * Scan a single file for bugs
+   */
+  async scanFile(filePath, rootDir) {
+    const findings = [];
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const relativePath = relative(rootDir, filePath);
+    for (const rule of this.rules) {
+      if (rule.fileExtensions && rule.fileExtensions.length > 0) {
+        const ext = extname$1(filePath);
+        if (!rule.fileExtensions.includes(ext)) {
+          continue;
         }
-        providers.push({
-          name,
-          enabled,
-          available,
-          type: getProviderType(name),
-          executionMode: getExecutionMode(name, cfg),
-          priority: cfg.priority || 0,
-          model: cfg.model
-        });
       }
-      providers.sort((a, b) => b.priority - a.priority);
-      const agentNames = await deps.profileLoader.listProfiles();
-      const agentResults = await Promise.all(
-        agentNames.map(async (agentName) => {
-          try {
-            const profile = await deps.profileLoader.loadProfile(agentName);
-            return {
-              name: profile.name,
-              displayName: profile.displayName,
-              role: profile.role,
-              description: profile.systemPrompt?.substring(0, 200),
-              team: profile.team,
-              abilities: profile.abilities || []
-            };
-          } catch (error) {
-            logger.warn(`Failed to load profile for ${agentName}`, { error });
-            return null;
+      const ruleFindings = this.applyRule(rule, content, lines, relativePath);
+      findings.push(...ruleFindings);
+    }
+    return findings;
+  }
+  /**
+   * Apply a detection rule to file content
+   */
+  applyRule(rule, content, lines, filePath) {
+    const findings = [];
+    if (!rule.pattern) {
+      return findings;
+    }
+    try {
+      const regex = new RegExp(rule.pattern, "g");
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        const beforeMatch = content.substring(0, match.index);
+        const lineNumber = beforeMatch.split("\n").length;
+        if (rule.negativePattern) {
+          const withinLines = rule.withinLines || 5;
+          const startLine = Math.max(0, lineNumber - 1);
+          const endLine = Math.min(lines.length, lineNumber + withinLines);
+          const contextLines = lines.slice(startLine, endLine).join("\n");
+          const negativeRegex = new RegExp(rule.negativePattern);
+          if (negativeRegex.test(contextLines)) {
+            continue;
           }
-        })
-      );
-      const agents = agentResults.filter((a) => a !== null);
-      const tools = deps.toolSchemas.map((schema) => ({
-        name: schema.name,
-        description: schema.description,
-        category: categorizeTools(schema.name)
-      }));
-      const [memoryStats, activeSessions] = await Promise.all([
-        deps.memoryManager.getStats(),
-        deps.sessionManager.getActiveSessions()
-      ]);
-      const result = {
-        version,
-        providers,
-        agents,
-        tools,
-        memory: {
-          enabled: true,
-          entryCount: memoryStats.totalEntries,
-          maxEntries: config.memory?.maxEntries || 1e4
-        },
-        sessions: {
-          enabled: true,
-          activeCount: activeSessions.length,
-          maxSessions: config.orchestration?.session?.maxSessions || 100
-        },
-        features: {
-          smartRouting: true,
-          // Always enabled in v13.0.0
-          memorySearch: true,
-          multiAgentSessions: true,
-          streamingNotifications: false
-          // Configured via MCP server options
         }
-      };
-      logger.info("[MCP] get_capabilities completed", {
-        version,
-        providersCount: providers.length,
-        agentsCount: agents.length,
-        toolsCount: tools.length
-      });
-      return result;
+        const contextStart = Math.max(0, lineNumber - 3);
+        const contextEnd = Math.min(lines.length, lineNumber + 3);
+        const context = lines.slice(contextStart, contextEnd).join("\n");
+        const finding = {
+          id: randomUUID(),
+          file: filePath,
+          lineStart: lineNumber,
+          lineEnd: lineNumber + (rule.withinLines ? Math.min(rule.withinLines, 5) : 1),
+          type: rule.type,
+          severity: rule.severity,
+          message: rule.description,
+          context,
+          fixStrategy: rule.autoFixable ? rule.fixTemplate : void 0,
+          confidence: rule.confidence,
+          detectionMethod: "regex",
+          metadata: {
+            ruleId: rule.id,
+            ruleName: rule.name,
+            matchedText: match[0].substring(0, 100)
+          },
+          detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        findings.push(finding);
+        logger.debug("Bug detected", {
+          file: filePath,
+          line: lineNumber,
+          type: rule.type,
+          rule: rule.id
+        });
+      }
     } catch (error) {
-      logger.error("[MCP] get_capabilities failed", { error });
-      throw new Error(`Capabilities check failed: ${error.message}`);
+      logger.warn("Rule application failed", {
+        ruleId: rule.id,
+        file: filePath,
+        error: error.message
+      });
     }
-  };
-}
-
-// src/mcp/tools/task/index.ts
-init_esm_shims();
-
-// src/mcp/tools/task/create-task.ts
-init_esm_shims();
-
-// src/core/task-engine/index.ts
-init_esm_shims();
-
-// src/core/task-engine/types.ts
-init_esm_shims();
-var TaskEngineError = class _TaskEngineError extends Error {
-  constructor(message, code, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "TaskEngineError";
-    Error.captureStackTrace?.(this, _TaskEngineError);
+    return findings;
+  }
+  /**
+   * Get all files to scan
+   */
+  async getFilesToScan(scanDir, rootDir) {
+    const files = [];
+    const scanDirectory = async (dir) => {
+      try {
+        const entries = await readdir(dir);
+        for (const entry of entries) {
+          const fullPath = join(dir, entry);
+          const relativePath = relative(rootDir, fullPath);
+          if (this.isExcluded(relativePath)) {
+            continue;
+          }
+          const stats = await stat(fullPath);
+          if (stats.isDirectory()) {
+            await scanDirectory(fullPath);
+          } else if (stats.isFile()) {
+            const ext = extname$1(fullPath);
+            if ([".ts", ".js", ".mts", ".mjs", ".tsx", ".jsx"].includes(ext)) {
+              files.push(fullPath);
+            }
+          }
+        }
+      } catch (error) {
+        logger.warn("Error reading directory", {
+          dir,
+          error: error.message
+        });
+      }
+    };
+    await scanDirectory(scanDir);
+    return files;
+  }
+  /**
+   * Check if a path should be excluded
+   */
+  isExcluded(relativePath) {
+    const defaultExclusions = [
+      "node_modules",
+      "dist",
+      "build",
+      ".git",
+      "coverage",
+      ".nyc_output",
+      "*.test.ts",
+      "*.spec.ts",
+      "__tests__",
+      "__mocks__"
+    ];
+    const exclusions = [...defaultExclusions, ...this.config.excludePatterns || []];
+    for (const pattern of exclusions) {
+      if (pattern.includes("*")) {
+        const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*");
+        const regex = new RegExp(regexPattern);
+        if (regex.test(relativePath)) {
+          return true;
+        }
+      } else {
+        if (relativePath.includes(pattern)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Filter findings by severity threshold
+   */
+  filterBySeverity(findings) {
+    const severityOrder = {
+      low: 1,
+      medium: 2,
+      high: 3,
+      critical: 4
+    };
+    const threshold = severityOrder[this.config.severityThreshold];
+    return findings.filter(
+      (finding) => severityOrder[finding.severity] >= threshold
+    );
+  }
+  /**
+   * Get detection rules
+   */
+  getRules() {
+    return [...this.rules];
+  }
+  /**
+   * Add a custom detection rule
+   */
+  addRule(rule) {
+    this.rules.push(rule);
+    logger.debug("Detection rule added", { ruleId: rule.id });
+  }
+  /**
+   * Load rules from YAML file
+   */
+  async loadRulesFromFile(filePath) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const yaml2 = await import('js-yaml');
+      const parsed = yaml2.load(content);
+      if (parsed.rules && Array.isArray(parsed.rules)) {
+        for (const rule of parsed.rules) {
+          this.addRule(rule);
+        }
+        logger.info("Detection rules loaded from file", {
+          filePath,
+          ruleCount: parsed.rules.length
+        });
+      }
+    } catch (error) {
+      logger.warn("Failed to load detection rules", {
+        filePath,
+        error: error.message
+      });
+    }
+  }
+};
+function createDefaultBugfixConfig(overrides) {
+  return {
+    maxBugs: 10,
+    maxDurationMinutes: 45,
+    maxTokens: 5e5,
+    maxRetriesPerBug: 3,
+    minConfidence: 0.7,
+    bugTypes: ["timer_leak", "missing_destroy", "promise_timeout_leak"],
+    severityThreshold: "medium",
+    excludePatterns: [],
+    dryRun: false,
+    requireTests: true,
+    requireTypecheck: true,
+    generateTests: false,
+    verbose: false,
+    ...overrides
+  };
+}
+
+// src/mcp/tools/bugfix-scan.ts
+function createBugfixScanHandler() {
+  return async (input) => {
+    const startTime = Date.now();
+    logger.info("[MCP] bugfix_scan called", { path: input.path, types: input.types });
+    const progressToken = sendMcpProgressBegin("Bug Scan", "Scanning codebase...");
+    try {
+      const rootDir = input.path || process.cwd();
+      const limit = input.limit || 50;
+      const configOverrides = {};
+      if (input.types) configOverrides.bugTypes = input.types;
+      if (input.excludePatterns) configOverrides.excludePatterns = input.excludePatterns;
+      const config = createDefaultBugfixConfig(configOverrides);
+      sendMcpProgress("Initializing bug detector...", progressToken);
+      const detector = new BugDetector(config);
+      let findings = await detector.scan(rootDir);
+      sendMcpProgress(`Found ${findings.length} potential bugs`, progressToken);
+      if (input.minSeverity) {
+        const severityOrder = ["low", "medium", "high", "critical"];
+        const minIndex = severityOrder.indexOf(input.minSeverity);
+        findings = findings.filter((f) => severityOrder.indexOf(f.severity) >= minIndex);
+      }
+      const bySeverity = {
+        low: 0,
+        medium: 0,
+        high: 0,
+        critical: 0
+      };
+      const byType = {};
+      for (const finding of findings) {
+        bySeverity[finding.severity]++;
+        byType[finding.type] = (byType[finding.type] || 0) + 1;
+      }
+      const limitedFindings = findings.slice(0, limit).map((f) => ({
+        id: f.id,
+        file: f.file,
+        line: f.lineStart,
+        type: f.type,
+        severity: f.severity,
+        message: f.message,
+        confidence: f.confidence,
+        hasAutoFix: !!f.fixStrategy
+      }));
+      const result = {
+        total: findings.length,
+        bySeverity,
+        byType,
+        findings: limitedFindings,
+        durationMs: Date.now() - startTime
+      };
+      logger.info("[MCP] bugfix_scan completed", {
+        total: result.total,
+        durationMs: result.durationMs
+      });
+      sendMcpProgressEnd(progressToken, `Completed: ${result.total} bugs found`);
+      return result;
+    } catch (error) {
+      logger.error("[MCP] bugfix_scan failed", { error });
+      sendMcpProgressEnd(progressToken, `Error: ${error.message}`);
+      throw new Error(`Bug scan failed: ${error.message}`);
+    }
+  };
+}
+var bugfixScanSchema = {
+  name: "bugfix_scan",
+  description: `Scan codebase for bugs without applying fixes.
+
+**Time**: Usually 10-60 seconds. You can stop anytime.
+**Progress**: Streamed notifications show scanning status.
+
+Detects: Timer leaks, missing destroy(), promise leaks, resource issues.
+Returns: Severity-sorted findings with auto-fix availability.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Directory to scan (default: current directory)"
+      },
+      types: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: ["timer_leak", "missing_destroy", "promise_timeout_leak", "event_leak", "resource_leak", "race_condition", "memory_leak", "uncaught_promise", "deprecated_api", "security_issue", "type_error", "test_failure", "custom"]
+        },
+        description: "Bug types to scan for (default: all)"
+      },
+      minSeverity: {
+        type: "string",
+        enum: ["low", "medium", "high", "critical"],
+        description: "Minimum severity to report (default: low)"
+      },
+      includePatterns: {
+        type: "array",
+        items: { type: "string" },
+        description: 'File patterns to include (default: ["**/*.ts", "**/*.js"])'
+      },
+      excludePatterns: {
+        type: "array",
+        items: { type: "string" },
+        description: 'File patterns to exclude (default: ["node_modules", "dist"])'
+      },
+      limit: {
+        type: "integer",
+        minimum: 1,
+        maximum: 100,
+        description: "Maximum number of bugs to return (default: 50)"
+      }
+    }
+  }
+};
+
+// src/mcp/tools/bugfix-run.ts
+init_esm_shims();
+init_logger();
+
+// src/core/bugfix/bugfix-controller.ts
+init_esm_shims();
+init_logger();
+
+// src/core/bugfix/bug-fixer.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_FIX_TEMPLATES = [
+  {
+    id: "add_unref",
+    name: "Add .unref() to interval",
+    description: "Add .unref() call after setInterval to prevent blocking process exit",
+    bugType: "timer_leak",
+    template: `
+// Replace setInterval with createSafeInterval for automatic cleanup
+import { createSafeInterval } from '@/shared/utils';
+
+// Or add .unref() manually:
+// const interval = setInterval(callback, ms);
+// if (interval.unref) interval.unref();
+`,
+    imports: ['createSafeInterval from "@/shared/utils"'],
+    confidence: 0.9
+  },
+  {
+    id: "add_destroy_method",
+    name: "Add destroy() method",
+    description: "Add destroy() method that calls removeAllListeners()",
+    bugType: "missing_destroy",
+    template: `
+  /**
+   * Clean up resources and remove all event listeners.
+   */
+  destroy(): void {
+    this.removeAllListeners();
+  }
+`,
+    confidence: 0.85
+  },
+  {
+    id: "use_disposable_eventemitter",
+    name: "Extend DisposableEventEmitter",
+    description: "Replace EventEmitter with DisposableEventEmitter for automatic cleanup",
+    bugType: "missing_destroy",
+    template: `
+// Change: extends EventEmitter
+// To: extends DisposableEventEmitter
+
+import { DisposableEventEmitter } from '@/shared/utils';
+
+// Then implement onDestroy() hook:
+protected onDestroy(): void {
+  // Custom cleanup logic
+}
+`,
+    imports: ['DisposableEventEmitter from "@/shared/utils"'],
+    confidence: 0.9
+  },
+  {
+    id: "wrap_with_timeout",
+    name: "Wrap with withTimeout",
+    description: "Use withTimeout() utility for automatic cleanup",
+    bugType: "promise_timeout_leak",
+    template: `
+import { withTimeout } from '@/shared/utils';
+
+// Replace manual timeout handling with:
+const result = await withTimeout(promise, timeoutMs, {
+  message: 'Operation timed out'
+});
+`,
+    imports: ['withTimeout from "@/shared/utils"'],
+    confidence: 0.85
+  }
+];
+var BugFixer = class {
+  templates;
+  backupDir;
+  backups;
+  // filePath -> backupPath
+  constructor(backupDir) {
+    this.templates = /* @__PURE__ */ new Map();
+    this.backupDir = backupDir || join(process.cwd(), ".automatosx", "backups");
+    this.backups = /* @__PURE__ */ new Map();
+    for (const template of DEFAULT_FIX_TEMPLATES) {
+      this.templates.set(template.id, template);
+    }
+    logger.debug("BugFixer initialized", {
+      templateCount: this.templates.size,
+      backupDir: this.backupDir
+    });
+  }
+  /**
+   * Apply a fix for a bug finding
+   *
+   * @param finding - Bug finding to fix
+   * @param rootDir - Root directory of the project
+   * @param dryRun - If true, don't actually modify files
+   * @returns Fix attempt result
+   */
+  async applyFix(finding, rootDir, dryRun = false) {
+    const startTime = Date.now();
+    const attemptId = randomUUID();
+    const filePath = join(rootDir, finding.file);
+    logger.info("Applying fix", {
+      bugId: finding.id,
+      file: finding.file,
+      type: finding.type,
+      dryRun
+    });
+    try {
+      const originalContent = await readFile(filePath, "utf-8");
+      const lines = originalContent.split("\n");
+      const strategy = this.determineStrategy(finding);
+      if (!strategy) {
+        return this.createAttempt(attemptId, finding.id, 1, "manual_review", "", "skipped", startTime, "No automatic fix available");
+      }
+      const { fixedContent, diff } = await this.generateFix(finding, originalContent, lines, strategy);
+      if (!fixedContent || fixedContent === originalContent) {
+        return this.createAttempt(attemptId, finding.id, 1, strategy, "", "skipped", startTime, "No changes needed");
+      }
+      if (dryRun) {
+        logger.info("Dry run - fix not applied", {
+          bugId: finding.id,
+          strategy,
+          diffLength: diff.length
+        });
+        return this.createAttempt(attemptId, finding.id, 1, strategy, diff, "applied", startTime);
+      }
+      await this.createBackup(filePath);
+      await writeFile(filePath, fixedContent, "utf-8");
+      logger.info("Fix applied", {
+        bugId: finding.id,
+        file: finding.file,
+        strategy
+      });
+      return this.createAttempt(attemptId, finding.id, 1, strategy, diff, "applied", startTime);
+    } catch (error) {
+      logger.error("Fix application failed", {
+        bugId: finding.id,
+        file: finding.file,
+        error: error.message
+      });
+      return this.createAttempt(attemptId, finding.id, 1, "unknown", "", "failed", startTime, error.message);
+    }
+  }
+  /**
+   * Rollback a fix
+   *
+   * @param filePath - File to rollback
+   * @returns True if rollback successful
+   */
+  async rollback(filePath) {
+    const backupPath = this.backups.get(filePath);
+    if (!backupPath || !existsSync(backupPath)) {
+      logger.warn("No backup found for rollback", { filePath });
+      return false;
+    }
+    try {
+      await copyFile(backupPath, filePath);
+      await unlink(backupPath);
+      this.backups.delete(filePath);
+      logger.info("Fix rolled back", { filePath });
+      return true;
+    } catch (error) {
+      logger.error("Rollback failed", {
+        filePath,
+        error: error.message
+      });
+      return false;
+    }
+  }
+  /**
+   * Rollback all fixes in this session
+   */
+  async rollbackAll() {
+    let rolledBack = 0;
+    for (const filePath of this.backups.keys()) {
+      if (await this.rollback(filePath)) {
+        rolledBack++;
+      }
+    }
+    logger.info("All fixes rolled back", { count: rolledBack });
+    return rolledBack;
+  }
+  /**
+   * Clean up backups (call after successful verification)
+   */
+  async cleanupBackups() {
+    for (const [filePath, backupPath] of this.backups.entries()) {
+      try {
+        if (existsSync(backupPath)) {
+          await unlink(backupPath);
+        }
+        this.backups.delete(filePath);
+      } catch (error) {
+        logger.warn("Failed to cleanup backup", {
+          filePath,
+          backupPath,
+          error: error.message
+        });
+      }
+    }
+    logger.debug("Backups cleaned up");
+  }
+  /**
+   * Determine fix strategy for a finding
+   */
+  determineStrategy(finding) {
+    if (finding.fixStrategy) {
+      return finding.fixStrategy;
+    }
+    for (const template of this.templates.values()) {
+      if (template.bugType === finding.type) {
+        return template.id;
+      }
+    }
+    const autoFixableTypes = ["timer_leak", "missing_destroy"];
+    if (autoFixableTypes.includes(finding.type)) {
+      return `auto_fix_${finding.type}`;
+    }
+    return null;
+  }
+  /**
+   * Generate fix for a finding
+   */
+  async generateFix(finding, originalContent, lines, strategy) {
+    let fixedContent = originalContent;
+    let diff = "";
+    switch (strategy) {
+      case "add_unref":
+        ({ fixedContent, diff } = this.applyAddUnrefFix(finding, originalContent, lines));
+        break;
+      case "add_destroy_method":
+        ({ fixedContent, diff } = this.applyAddDestroyMethodFix(finding, originalContent, lines));
+        break;
+      case "use_disposable_eventemitter":
+        ({ fixedContent, diff } = this.applyUseDisposableEventEmitterFix(finding, originalContent, lines));
+        break;
+      case "auto_fix_timer_leak":
+        ({ fixedContent, diff } = this.applyAddUnrefFix(finding, originalContent, lines));
+        break;
+      case "auto_fix_missing_destroy":
+        ({ fixedContent, diff } = this.applyAddDestroyMethodFix(finding, originalContent, lines));
+        break;
+      default:
+        logger.warn("Unknown fix strategy", { strategy });
+    }
+    return { fixedContent, diff };
+  }
+  /**
+   * Apply add .unref() fix
+   */
+  applyAddUnrefFix(finding, originalContent, lines) {
+    const lineIndex = finding.lineStart - 1;
+    const line = lines[lineIndex];
+    if (!line) {
+      return { fixedContent: originalContent, diff: "" };
+    }
+    const setIntervalPattern = /(\w+)\s*=\s*setInterval\s*\([^)]+\)\s*;?/;
+    const match = line.match(setIntervalPattern);
+    if (match) {
+      const varName = match[1];
+      const nextLines = lines.slice(lineIndex + 1, lineIndex + 5).join("\n");
+      if (nextLines.includes(`${varName}.unref`) || nextLines.includes(`${varName}?.unref`)) {
+        return { fixedContent: originalContent, diff: "" };
+      }
+      const indent = line.match(/^(\s*)/)?.[1] || "";
+      const unrefLine = `${indent}if (${varName}.unref) ${varName}.unref();`;
+      const newLines = [...lines];
+      newLines.splice(lineIndex + 1, 0, unrefLine);
+      const fixedContent = newLines.join("\n");
+      const diff = `@@ -${finding.lineStart},1 +${finding.lineStart},2 @@
+ ${line}
++${unrefLine}`;
+      return { fixedContent, diff };
+    }
+    const directSetIntervalPattern = /setInterval\s*\(/;
+    if (directSetIntervalPattern.test(line)) {
+      line.match(/^(\s*)/)?.[1] || "";
+      const newLine = line.replace(
+        /(setInterval\s*\([^)]+\))/,
+        "const _interval = $1; if (_interval.unref) _interval.unref()"
+      );
+      const newLines = [...lines];
+      newLines[lineIndex] = newLine;
+      const fixedContent = newLines.join("\n");
+      const diff = `@@ -${finding.lineStart},1 +${finding.lineStart},1 @@
+-${line}
++${newLine}`;
+      return { fixedContent, diff };
+    }
+    return { fixedContent: originalContent, diff: "" };
+  }
+  /**
+   * Apply add destroy() method fix
+   */
+  applyAddDestroyMethodFix(finding, originalContent, lines) {
+    const classPattern = /class\s+(\w+)\s+extends\s+(?:EventEmitter|DisposableEventEmitter)/;
+    let classStartLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const currentLine = lines[i];
+      if (!currentLine) continue;
+      const match = currentLine.match(classPattern);
+      if (match && match[1]) {
+        classStartLine = i;
+        match[1];
+        break;
+      }
+    }
+    if (classStartLine === -1) {
+      return { fixedContent: originalContent, diff: "" };
+    }
+    let braceCount = 0;
+    let classEndLine = -1;
+    for (let i = classStartLine; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line) continue;
+      braceCount += (line.match(/{/g) || []).length;
+      braceCount -= (line.match(/}/g) || []).length;
+      if (braceCount === 0 && i > classStartLine) {
+        classEndLine = i;
+        break;
+      }
+    }
+    if (classEndLine === -1) {
+      return { fixedContent: originalContent, diff: "" };
+    }
+    let indent = "  ";
+    for (let i = classStartLine + 1; i < classEndLine; i++) {
+      const indentLine = lines[i];
+      if (!indentLine) continue;
+      const indentMatch = indentLine.match(/^(\s+)\S/);
+      if (indentMatch && indentMatch[1]) {
+        indent = indentMatch[1];
+        break;
+      }
+    }
+    const destroyMethod = [
+      "",
+      `${indent}/**`,
+      `${indent} * Clean up resources and remove all event listeners.`,
+      `${indent} */`,
+      `${indent}destroy(): void {`,
+      `${indent}  this.removeAllListeners();`,
+      `${indent}}`
+    ].join("\n");
+    const newLines = [...lines];
+    newLines.splice(classEndLine, 0, destroyMethod);
+    const fixedContent = newLines.join("\n");
+    const diff = `@@ -${classEndLine + 1},1 +${classEndLine + 1},8 @@
++${destroyMethod}
+ ${lines[classEndLine]}`;
+    return { fixedContent, diff };
+  }
+  /**
+   * Apply use DisposableEventEmitter fix
+   */
+  applyUseDisposableEventEmitterFix(finding, originalContent, lines) {
+    let fixedContent = originalContent.replace(
+      /extends\s+EventEmitter\b/g,
+      "extends DisposableEventEmitter"
+    );
+    if (!originalContent.includes("DisposableEventEmitter")) {
+      const importPattern = /^import\s+.*from\s+['"][^'"]+['"];?\s*$/m;
+      const lastImportMatch = originalContent.match(new RegExp(importPattern.source + "(?!.*" + importPattern.source + ")", "s"));
+      if (lastImportMatch) {
+        const importStatement = `import { DisposableEventEmitter } from '@/shared/utils';`;
+        const insertPos = lastImportMatch.index + lastImportMatch[0].length;
+        fixedContent = fixedContent.slice(0, insertPos) + "\n" + importStatement + fixedContent.slice(insertPos);
+      }
+    }
+    const diff = '--- EventEmitter\n+++ DisposableEventEmitter\n+ import { DisposableEventEmitter } from "@/shared/utils";';
+    return { fixedContent, diff };
+  }
+  /**
+   * Create backup of a file
+   */
+  async createBackup(filePath) {
+    if (!existsSync(this.backupDir)) {
+      await mkdir(this.backupDir, { recursive: true });
+    }
+    const backupName = `${basename(filePath)}.${Date.now()}.bak`;
+    const backupPath = join(this.backupDir, backupName);
+    await copyFile(filePath, backupPath);
+    this.backups.set(filePath, backupPath);
+    logger.debug("Backup created", { filePath, backupPath });
+    return backupPath;
+  }
+  /**
+   * Create a fix attempt result
+   */
+  createAttempt(id, bugId, attemptNumber, strategy, diff, status, startTime, error) {
+    return {
+      id,
+      bugId,
+      attemptNumber,
+      strategy,
+      diff,
+      status,
+      error,
+      attemptedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - startTime
+    };
+  }
+  /**
+   * Add a custom fix template
+   */
+  addTemplate(template) {
+    this.templates.set(template.id, template);
+    logger.debug("Fix template added", { templateId: template.id });
+  }
+  /**
+   * Get all fix templates
+   */
+  getTemplates() {
+    return Array.from(this.templates.values());
+  }
+};
+
+// src/core/bugfix/verification-gate.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_OPTIONS3 = {
+  typecheck: true,
+  tests: true,
+  checkNewErrors: true,
+  checkCoverage: false,
+  timeout: 12e4,
+  // 2 minutes
+  testCommand: "npm test",
+  typecheckCommand: "npm run typecheck",
+  cwd: process.cwd()
+};
+var VerificationGate = class {
+  options;
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS3, ...options };
+    logger.debug("VerificationGate initialized", {
+      typecheck: this.options.typecheck,
+      tests: this.options.tests,
+      timeout: this.options.timeout
+    });
+  }
+  /**
+   * Verify a fix passes all gates
+   *
+   * @param finding - Bug finding that was fixed
+   * @param affectedFiles - Files affected by the fix
+   * @returns Verification result
+   */
+  async verify(finding, affectedFiles) {
+    const startTime = Date.now();
+    logger.info("Starting verification", {
+      bugId: finding.id,
+      file: finding.file,
+      affectedFiles
+    });
+    const result = {
+      success: true,
+      typecheckPassed: true,
+      testsPassed: true,
+      noNewErrors: true,
+      affectedTests: [],
+      failedTests: [],
+      newErrors: [],
+      durationMs: 0
+    };
+    try {
+      if (this.options.typecheck) {
+        logger.debug("Running typecheck gate");
+        const typecheckResult = await this.runTypecheck();
+        result.typecheckPassed = typecheckResult.success;
+        if (!typecheckResult.success) {
+          result.success = false;
+          result.newErrors = typecheckResult.errors;
+          logger.warn("Typecheck failed", {
+            bugId: finding.id,
+            errors: typecheckResult.errors.slice(0, 5)
+          });
+        } else {
+          logger.debug("Typecheck passed");
+        }
+      }
+      if (this.options.tests && result.typecheckPassed) {
+        logger.debug("Running test gate");
+        const testResult = await this.runTests(affectedFiles);
+        result.testsPassed = testResult.success;
+        result.affectedTests = testResult.affectedTests;
+        result.failedTests = testResult.failedTests;
+        if (!testResult.success) {
+          result.success = false;
+          logger.warn("Tests failed", {
+            bugId: finding.id,
+            failed: testResult.failedTests.slice(0, 5)
+          });
+        } else {
+          logger.debug("Tests passed", { count: testResult.affectedTests.length });
+        }
+      }
+      if (this.options.checkNewErrors && result.typecheckPassed && result.testsPassed) {
+        result.noNewErrors = true;
+      }
+      if (this.options.checkCoverage && result.success) {
+        result.coverageMaintained = true;
+      }
+    } catch (error) {
+      result.success = false;
+      result.newErrors = [error.message];
+      logger.error("Verification error", {
+        bugId: finding.id,
+        error: error.message
+      });
+    }
+    result.durationMs = Date.now() - startTime;
+    logger.info("Verification complete", {
+      bugId: finding.id,
+      success: result.success,
+      typecheckPassed: result.typecheckPassed,
+      testsPassed: result.testsPassed,
+      durationMs: result.durationMs
+    });
+    return result;
+  }
+  /**
+   * Run TypeScript typecheck
+   */
+  async runTypecheck() {
+    return this.runCommand(this.options.typecheckCommand, "typecheck");
+  }
+  /**
+   * Run tests for affected files
+   */
+  async runTests(affectedFiles) {
+    const result = await this.runCommand(this.options.testCommand, "test");
+    return {
+      success: result.success,
+      affectedTests: affectedFiles.map((f) => `${f} tests`),
+      failedTests: result.success ? [] : result.errors
+    };
+  }
+  /**
+   * Run a shell command
+   */
+  async runCommand(command, name) {
+    return new Promise((resolve5) => {
+      const parts = command.split(" ");
+      const cmd = parts[0];
+      const args2 = parts.slice(1);
+      const errors = [];
+      let stderr = "";
+      if (!cmd) {
+        resolve5({ success: false, errors: ["Empty command"] });
+        return;
+      }
+      logger.debug(`Running ${name}`, { command });
+      const proc = spawn(cmd, args2, {
+        cwd: this.options.cwd,
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const timeoutId = setTimeout(() => {
+        proc.kill("SIGTERM");
+        errors.push(`${name} timed out after ${this.options.timeout}ms`);
+      }, this.options.timeout);
+      if (timeoutId.unref) {
+        timeoutId.unref();
+      }
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timeoutId);
+        if (code === 0) {
+          resolve5({ success: true, errors: [] });
+        } else {
+          const errorLines = stderr.split("\n").filter((line) => line.includes("error") || line.includes("Error") || line.includes("FAIL")).slice(0, 10);
+          resolve5({
+            success: false,
+            errors: errorLines.length > 0 ? errorLines : [`${name} failed with exit code ${code}`]
+          });
+        }
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timeoutId);
+        resolve5({
+          success: false,
+          errors: [err.message]
+        });
+      });
+    });
+  }
+  /**
+   * Quick verification (typecheck only)
+   */
+  async quickVerify(finding) {
+    const result = await this.runTypecheck();
+    return result.success;
+  }
+  /**
+   * Full verification (all gates)
+   */
+  async fullVerify(finding, affectedFiles) {
+    return this.verify(finding, affectedFiles);
+  }
+};
+
+// src/core/bugfix/bugfix-controller.ts
+var BugfixController = class {
+  config;
+  rootDir;
+  state = "IDLE";
+  sessionId;
+  startTime = 0;
+  totalTokens = 0;
+  // Components
+  detector;
+  fixer;
+  verifier;
+  // Session data
+  findings = [];
+  attempts = [];
+  currentBugIndex = 0;
+  retryCount = /* @__PURE__ */ new Map();
+  // Callbacks
+  onProgress;
+  onBugFound;
+  onFixApplied;
+  onVerification;
+  constructor(options = {}) {
+    this.config = createDefaultBugfixConfig(options.config);
+    this.rootDir = options.rootDir || process.cwd();
+    this.sessionId = randomUUID();
+    this.detector = new BugDetector(this.config);
+    this.fixer = new BugFixer();
+    this.verifier = new VerificationGate({
+      typecheck: this.config.requireTypecheck,
+      tests: this.config.requireTests,
+      cwd: this.rootDir
+    });
+    this.onProgress = options.onProgress;
+    this.onBugFound = options.onBugFound;
+    this.onFixApplied = options.onFixApplied;
+    this.onVerification = options.onVerification;
+    logger.debug("BugfixController initialized", {
+      sessionId: this.sessionId,
+      rootDir: this.rootDir,
+      config: this.config
+    });
+  }
+  /**
+   * Execute autonomous bugfix workflow
+   *
+   * @returns Bugfix session result
+   */
+  async execute() {
+    this.startTime = Date.now();
+    this.state = "SCANNING";
+    logger.info("Starting bugfix session", {
+      sessionId: this.sessionId,
+      rootDir: this.rootDir,
+      maxBugs: this.config.maxBugs,
+      dryRun: this.config.dryRun
+    });
+    this.emitProgress("Starting bug scan...");
+    try {
+      while (this.shouldContinue()) {
+        const currentState = this.state;
+        if (currentState === "IDLE") {
+          this.state = "SCANNING";
+        } else if (currentState === "SCANNING") {
+          await this.handleScanning();
+        } else if (currentState === "ANALYZING") {
+          await this.handleAnalyzing();
+        } else if (currentState === "PLANNING") {
+          await this.handlePlanning();
+        } else if (currentState === "FIXING") {
+          await this.handleFixing();
+        } else if (currentState === "VERIFYING") {
+          await this.handleVerifying();
+        } else if (currentState === "LEARNING") {
+          await this.handleLearning();
+        } else if (currentState === "ITERATING") {
+          await this.handleIterating();
+        } else if (currentState === "COMPLETE" || currentState === "FAILED") {
+          break;
+        }
+      }
+      return this.buildResult();
+    } catch (error) {
+      this.state = "FAILED";
+      logger.error("Bugfix session failed", {
+        sessionId: this.sessionId,
+        error: error.message,
+        state: this.state
+      });
+      return this.buildResult(error.message);
+    }
+  }
+  /**
+   * Check if execution should continue
+   */
+  shouldContinue() {
+    if (this.state === "COMPLETE" || this.state === "FAILED") {
+      return false;
+    }
+    const elapsedMinutes = (Date.now() - this.startTime) / 1e3 / 60;
+    if (elapsedMinutes >= this.config.maxDurationMinutes) {
+      logger.warn("Time limit exceeded", {
+        elapsed: elapsedMinutes,
+        limit: this.config.maxDurationMinutes
+      });
+      this.state = "COMPLETE";
+      return false;
+    }
+    if (this.totalTokens >= this.config.maxTokens) {
+      logger.warn("Token limit exceeded", {
+        tokens: this.totalTokens,
+        limit: this.config.maxTokens
+      });
+      this.state = "COMPLETE";
+      return false;
+    }
+    const fixedCount = this.attempts.filter((a) => a.status === "verified").length;
+    if (fixedCount >= this.config.maxBugs) {
+      logger.info("Max bugs fixed", {
+        fixed: fixedCount,
+        limit: this.config.maxBugs
+      });
+      this.state = "COMPLETE";
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Handle SCANNING state
+   */
+  async handleScanning() {
+    this.emitProgress("Scanning for bugs...");
+    this.findings = await this.detector.scan(this.rootDir);
+    if (this.findings.length === 0) {
+      this.emitProgress("No bugs found!");
+      this.state = "COMPLETE";
+      return;
+    }
+    this.emitProgress(`Found ${this.findings.length} bugs`);
+    for (const finding of this.findings) {
+      this.onBugFound?.(finding);
+    }
+    this.state = "ANALYZING";
+  }
+  /**
+   * Handle ANALYZING state
+   */
+  async handleAnalyzing() {
+    this.emitProgress("Analyzing bugs...");
+    this.findings = this.findings.filter((f) => f.confidence >= this.config.minConfidence);
+    if (this.findings.length === 0) {
+      this.emitProgress("No bugs above confidence threshold");
+      this.state = "COMPLETE";
+      return;
+    }
+    this.emitProgress(`${this.findings.length} bugs to fix`);
+    this.currentBugIndex = 0;
+    this.state = "PLANNING";
+  }
+  /**
+   * Handle PLANNING state
+   */
+  async handlePlanning() {
+    const finding = this.findings[this.currentBugIndex];
+    if (!finding) {
+      this.state = "COMPLETE";
+      return;
+    }
+    this.emitProgress(`Planning fix for bug ${this.currentBugIndex + 1}/${this.findings.length}`, {
+      file: finding.file,
+      type: finding.type,
+      severity: finding.severity
+    });
+    if (!finding.fixStrategy) {
+      logger.info("Bug requires manual review", {
+        bugId: finding.id,
+        type: finding.type
+      });
+      const skippedAttempt = {
+        id: randomUUID(),
+        bugId: finding.id,
+        attemptNumber: 1,
+        strategy: "manual_review",
+        diff: "",
+        status: "skipped",
+        error: "No automatic fix available",
+        attemptedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: 0
+      };
+      this.attempts.push(skippedAttempt);
+      this.currentBugIndex++;
+      if (this.currentBugIndex >= this.findings.length) {
+        this.state = "COMPLETE";
+      }
+      return;
+    }
+    this.state = "FIXING";
+  }
+  /**
+   * Handle FIXING state
+   */
+  async handleFixing() {
+    const finding = this.findings[this.currentBugIndex];
+    if (!finding) {
+      this.state = "COMPLETE";
+      return;
+    }
+    this.emitProgress(`Fixing: ${finding.file}:${finding.lineStart}`, {
+      type: finding.type,
+      strategy: finding.fixStrategy
+    });
+    const attempt = await this.fixer.applyFix(finding, this.rootDir, this.config.dryRun);
+    this.attempts.push(attempt);
+    this.onFixApplied?.(finding, attempt);
+    if (attempt.status === "applied") {
+      this.state = "VERIFYING";
+    } else if (attempt.status === "skipped") {
+      this.emitProgress(`Skipped: ${attempt.error || "No changes needed"}`);
+      this.currentBugIndex++;
+      this.state = this.currentBugIndex >= this.findings.length ? "COMPLETE" : "PLANNING";
+    } else {
+      this.state = "ITERATING";
+    }
+  }
+  /**
+   * Handle VERIFYING state
+   */
+  async handleVerifying() {
+    const finding = this.findings[this.currentBugIndex];
+    const lastAttempt = this.attempts[this.attempts.length - 1];
+    if (!finding || !lastAttempt) {
+      this.state = "COMPLETE";
+      return;
+    }
+    this.emitProgress(`Verifying fix for ${finding.file}...`);
+    if (!this.config.dryRun) {
+      const result = await this.verifier.verify(finding, [finding.file]);
+      lastAttempt.verificationResult = result;
+      this.onVerification?.(finding, result.success);
+      if (result.success) {
+        lastAttempt.status = "verified";
+        this.emitProgress("Fix verified!", {
+          typecheck: result.typecheckPassed,
+          tests: result.testsPassed
+        });
+        this.state = "LEARNING";
+      } else {
+        lastAttempt.status = "failed";
+        lastAttempt.error = result.newErrors.join("; ") || "Verification failed";
+        this.emitProgress("Verification failed, rolling back...", {
+          errors: result.newErrors
+        });
+        await this.fixer.rollback(finding.file);
+        this.state = "ITERATING";
+      }
+    } else {
+      lastAttempt.status = "verified";
+      this.emitProgress("Dry run - skipping verification");
+      this.state = "LEARNING";
+    }
+  }
+  /**
+   * Handle LEARNING state
+   */
+  async handleLearning() {
+    const finding = this.findings[this.currentBugIndex];
+    if (!finding) {
+      this.state = "COMPLETE";
+      return;
+    }
+    this.emitProgress("Storing pattern to knowledge base...");
+    logger.info("Pattern learned", {
+      bugId: finding.id,
+      type: finding.type,
+      file: finding.file
+    });
+    this.currentBugIndex++;
+    if (this.currentBugIndex >= this.findings.length) {
+      this.state = "COMPLETE";
+    } else {
+      this.state = "PLANNING";
+    }
+  }
+  /**
+   * Handle ITERATING state (retry logic)
+   */
+  async handleIterating() {
+    const finding = this.findings[this.currentBugIndex];
+    if (!finding) {
+      this.state = "COMPLETE";
+      return;
+    }
+    const currentRetries = this.retryCount.get(finding.id) || 0;
+    if (currentRetries >= this.config.maxRetriesPerBug) {
+      this.emitProgress(`Max retries reached for ${finding.file}`, {
+        retries: currentRetries
+      });
+      this.currentBugIndex++;
+      if (this.currentBugIndex >= this.findings.length) {
+        this.state = "COMPLETE";
+      } else {
+        this.state = "PLANNING";
+      }
+      return;
+    }
+    this.retryCount.set(finding.id, currentRetries + 1);
+    this.emitProgress(`Retrying fix (attempt ${currentRetries + 2})...`);
+    this.state = "FIXING";
+  }
+  /**
+   * Build final result
+   */
+  buildResult(error) {
+    const stats = this.calculateStats();
+    return {
+      sessionId: this.sessionId,
+      startedAt: new Date(this.startTime).toISOString(),
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      config: this.config,
+      findings: this.findings,
+      attempts: this.attempts,
+      stats,
+      finalState: this.state,
+      error
+    };
+  }
+  /**
+   * Calculate session statistics
+   */
+  calculateStats() {
+    const verified = this.attempts.filter((a) => a.status === "verified").length;
+    const failed = this.attempts.filter((a) => a.status === "failed").length;
+    const skipped = this.attempts.filter((a) => a.status === "skipped").length;
+    const bugsByType = {
+      timer_leak: 0,
+      missing_destroy: 0,
+      promise_timeout_leak: 0,
+      event_leak: 0,
+      resource_leak: 0,
+      race_condition: 0,
+      memory_leak: 0,
+      uncaught_promise: 0,
+      deprecated_api: 0,
+      security_issue: 0,
+      type_error: 0,
+      test_failure: 0,
+      custom: 0
+    };
+    for (const finding of this.findings) {
+      bugsByType[finding.type] = (bugsByType[finding.type] || 0) + 1;
+    }
+    const bugsBySeverity = {
+      low: 0,
+      medium: 0,
+      high: 0,
+      critical: 0
+    };
+    for (const finding of this.findings) {
+      bugsBySeverity[finding.severity] = (bugsBySeverity[finding.severity] || 0) + 1;
+    }
+    let stopReason = "complete";
+    const elapsedMinutes = (Date.now() - this.startTime) / 1e3 / 60;
+    if (this.state === "FAILED") {
+      stopReason = "error";
+    } else if (verified >= this.config.maxBugs) {
+      stopReason = "max_bugs";
+    } else if (elapsedMinutes >= this.config.maxDurationMinutes) {
+      stopReason = "max_time";
+    } else if (this.totalTokens >= this.config.maxTokens) {
+      stopReason = "max_tokens";
+    }
+    return {
+      bugsFound: this.findings.length,
+      bugsFixed: verified,
+      bugsFailed: failed,
+      bugsSkipped: skipped,
+      totalAttempts: this.attempts.length,
+      successRate: this.attempts.length > 0 ? verified / this.attempts.length : 0,
+      totalDurationMs: Date.now() - this.startTime,
+      totalTokens: this.totalTokens,
+      patternsLearned: verified,
+      // Each verified fix is a learned pattern
+      regressions: 0,
+      // Should always be 0 with verification
+      stopReason,
+      bugsByType,
+      bugsBySeverity
+    };
+  }
+  /**
+   * Emit progress update
+   */
+  emitProgress(message, data) {
+    logger.info(message, { sessionId: this.sessionId, ...data });
+    this.onProgress?.(message, data);
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get current statistics
+   */
+  getStats() {
+    return this.calculateStats();
+  }
+  /**
+   * Stop execution
+   */
+  async stop() {
+    logger.info("Stopping bugfix session", { sessionId: this.sessionId });
+    this.state = "COMPLETE";
+    await this.fixer.cleanupBackups();
+  }
+};
+
+// src/mcp/tools/bugfix-run.ts
+function createBugfixRunHandler() {
+  return async (input) => {
+    logger.info("[MCP] bugfix_run called", {
+      path: input.path,
+      maxBugs: input.maxBugs,
+      dryRun: input.dryRun
+    });
+    const progressToken = sendMcpProgressBegin("Bugfix", "Starting bug scan...");
+    try {
+      const controller = new BugfixController({
+        rootDir: input.path || process.cwd(),
+        config: {
+          bugTypes: input.types,
+          maxBugs: input.maxBugs || 10,
+          dryRun: input.dryRun || false,
+          excludePatterns: input.excludePatterns,
+          requireTypecheck: input.requireTypecheck ?? true,
+          requireTests: input.requireTests ?? false
+        },
+        // v12.5.5: Stream brief progress updates to MCP client
+        onProgress: (message) => {
+          sendMcpProgress(message, progressToken);
+        },
+        onBugFound: (finding) => {
+          sendMcpProgress(`Found: ${finding.type} in ${finding.file}`, progressToken);
+        },
+        onFixApplied: (finding, attempt) => {
+          const status = attempt.status === "applied" ? "\u2713" : "\u25CB";
+          sendMcpProgress(`${status} Fix applied: ${finding.file}:${finding.lineStart}`, progressToken);
+        }
+      });
+      const result = await controller.execute();
+      const fixed = result.attempts.filter((a) => a.status === "verified").map((a) => {
+        const finding = result.findings.find((f) => f.id === a.bugId);
+        return {
+          file: finding?.file || "unknown",
+          line: finding?.lineStart || 0,
+          type: finding?.type || "custom",
+          message: finding?.message || "Fixed"
+        };
+      });
+      const output = {
+        sessionId: result.sessionId,
+        bugsFound: result.stats.bugsFound,
+        bugsFixed: result.stats.bugsFixed,
+        bugsFailed: result.stats.bugsFailed,
+        bugsSkipped: result.stats.bugsSkipped,
+        successRate: result.stats.successRate,
+        durationMs: result.stats.totalDurationMs,
+        finalState: result.finalState,
+        bySeverity: result.stats.bugsBySeverity,
+        fixed,
+        error: result.error
+      };
+      logger.info("[MCP] bugfix_run completed", {
+        sessionId: output.sessionId,
+        bugsFixed: output.bugsFixed,
+        durationMs: output.durationMs
+      });
+      sendMcpProgressEnd(progressToken, `Completed: ${output.bugsFixed} bugs fixed`);
+      return output;
+    } catch (error) {
+      logger.error("[MCP] bugfix_run failed", { error });
+      sendMcpProgressEnd(progressToken, `Error: ${error.message}`);
+      throw new Error(`Bugfix run failed: ${error.message}`);
+    }
+  };
+}
+var bugfixRunSchema = {
+  name: "bugfix_run",
+  description: `Run autonomous bug-fixing workflow.
+
+**Time limit**: Max 45 minutes. You can stop anytime.
+**Progress**: Streamed notifications show what's happening.
+
+Workflow:
+1. Scans codebase for bugs
+2. Prioritizes by severity
+3. Applies fixes with backups
+4. Verifies via typecheck/tests
+5. Rolls back failed fixes
+
+Safety: Backups created, dry-run available, stops at limits.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Directory to scan (default: current directory)"
+      },
+      types: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: ["timer_leak", "missing_destroy", "promise_timeout_leak", "event_leak", "resource_leak", "race_condition", "memory_leak", "uncaught_promise", "deprecated_api", "security_issue", "type_error", "test_failure", "custom"]
+        },
+        description: "Bug types to fix (default: all)"
+      },
+      maxBugs: {
+        type: "integer",
+        minimum: 1,
+        maximum: 100,
+        description: "Maximum bugs to fix (default: 10)"
+      },
+      dryRun: {
+        type: "boolean",
+        description: "Preview fixes without applying (default: false)"
+      },
+      includePatterns: {
+        type: "array",
+        items: { type: "string" },
+        description: "File patterns to include"
+      },
+      excludePatterns: {
+        type: "array",
+        items: { type: "string" },
+        description: "File patterns to exclude"
+      },
+      requireTypecheck: {
+        type: "boolean",
+        description: "Require typecheck after each fix (default: true)"
+      },
+      requireTests: {
+        type: "boolean",
+        description: "Require tests to pass after fixes (default: false)"
+      }
+    }
+  }
+};
+
+// src/mcp/tools/get-capabilities.ts
+init_esm_shims();
+init_logger();
+function categorizeTools(name) {
+  if (name.startsWith("memory_") || name === "search_memory") return "memory";
+  if (name.startsWith("session_")) return "session";
+  if (name.startsWith("create_task") || name.startsWith("run_task") || name.startsWith("get_task") || name.startsWith("list_task") || name.startsWith("delete_task")) return "task";
+  if (name === "get_capabilities" || name === "list_agents" || name === "get_status" || name === "get_agent_context") return "discovery";
+  if (name.includes("context")) return "context";
+  return "execution";
+}
+function getExecutionMode(providerName, _providerConfig) {
+  if (providerName === "glm" || providerName === "grok") {
+    return "sdk";
+  }
+  if (providerName === "claude-code" || providerName === "gemini-cli") {
+    return "cli";
+  }
+  if (providerName === "openai") {
+    return "hybrid";
+  }
+  return "cli";
+}
+function getProviderType(providerName) {
+  if (providerName === "glm" || providerName === "grok") return "sdk";
+  if (providerName === "openai") return "hybrid";
+  return "cli";
+}
+function createGetCapabilitiesHandler(deps) {
+  return async () => {
+    logger.info("[MCP] get_capabilities called");
+    try {
+      const projectDir = process.cwd();
+      const config = await loadConfig(projectDir);
+      const version = getVersion();
+      const providers = [];
+      const providerConfigs = config.providers || {};
+      for (const [name, providerConfig] of Object.entries(providerConfigs)) {
+        const cfg = providerConfig;
+        const enabled = cfg.enabled === true;
+        let available = false;
+        try {
+          const availableProviders = await deps.router.getAvailableProviders();
+          available = availableProviders.some((p) => p.name === name);
+        } catch {
+          available = enabled;
+        }
+        providers.push({
+          name,
+          enabled,
+          available,
+          type: getProviderType(name),
+          executionMode: getExecutionMode(name, cfg),
+          priority: cfg.priority || 0,
+          model: cfg.model
+        });
+      }
+      providers.sort((a, b) => b.priority - a.priority);
+      const agentNames = await deps.profileLoader.listProfiles();
+      const agentResults = await Promise.all(
+        agentNames.map(async (agentName) => {
+          try {
+            const profile = await deps.profileLoader.loadProfile(agentName);
+            return {
+              name: profile.name,
+              displayName: profile.displayName,
+              role: profile.role,
+              description: profile.systemPrompt?.substring(0, 200),
+              team: profile.team,
+              abilities: profile.abilities || []
+            };
+          } catch (error) {
+            logger.warn(`Failed to load profile for ${agentName}`, { error });
+            return null;
+          }
+        })
+      );
+      const agents = agentResults.filter((a) => a !== null);
+      const tools = deps.toolSchemas.map((schema) => ({
+        name: schema.name,
+        description: schema.description,
+        category: categorizeTools(schema.name)
+      }));
+      const [memoryStats, activeSessions] = await Promise.all([
+        deps.memoryManager.getStats(),
+        deps.sessionManager.getActiveSessions()
+      ]);
+      const result = {
+        version,
+        providers,
+        agents,
+        tools,
+        memory: {
+          enabled: true,
+          entryCount: memoryStats.totalEntries,
+          maxEntries: config.memory?.maxEntries || 1e4
+        },
+        sessions: {
+          enabled: true,
+          activeCount: activeSessions.length,
+          maxSessions: config.orchestration?.session?.maxSessions || 100
+        },
+        features: {
+          smartRouting: true,
+          // Always enabled in v13.0.0
+          memorySearch: true,
+          multiAgentSessions: true,
+          streamingNotifications: false
+          // Configured via MCP server options
+        }
+      };
+      logger.info("[MCP] get_capabilities completed", {
+        version,
+        providersCount: providers.length,
+        agentsCount: agents.length,
+        toolsCount: tools.length
+      });
+      return result;
+    } catch (error) {
+      logger.error("[MCP] get_capabilities failed", { error });
+      throw new Error(`Capabilities check failed: ${error.message}`);
+    }
+  };
+}
+
+// src/mcp/tools/task/index.ts
+init_esm_shims();
+
+// src/mcp/tools/task/create-task.ts
+init_esm_shims();
+
+// src/core/task-engine/index.ts
+init_esm_shims();
+
+// src/core/task-engine/types.ts
+init_esm_shims();
+var TaskEngineError = class _TaskEngineError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "TaskEngineError";
+    Error.captureStackTrace?.(this, _TaskEngineError);
   }
 };
 var LoopPreventionError = class extends TaskEngineError {
@@ -24639,6 +26252,12 @@ var TaskEngine = class extends EventEmitter {
       signal?.addEventListener("abort", abortHandler, { once: true });
     });
   }
+  /**
+   * Clean up resources and remove all event listeners.
+   */
+  destroy() {
+    this.removeAllListeners();
+  }
 };
 var defaultTaskEngine = null;
 function getTaskEngine(config) {
@@ -24743,14 +26362,33 @@ function mapNormalizedProviderToOriginClient(provider) {
 }
 var createTaskSchema = {
   name: "create_task",
-  description: "Create a new task with payload for deferred execution. Returns task_id for later execution via run_task.",
+  description: `Create a new task with payload for deferred execution. Returns task_id for later execution via run_task.
+
+**When to use**: For tasks that benefit from decoupled creation and execution:
+- Queue work for later processing
+- Create multiple tasks in batch, then execute selectively
+- Store task definitions for retries on failure
+
+**Task types** optimize routing:
+- web_search: Internet searches, fact-checking (uses Gemini for free tier)
+- code_review: Code analysis, style checks (uses Claude for accuracy)
+- code_generation: Write new code (uses best available coding model)
+- analysis: Data analysis, summarization (general purpose)
+- custom: User-defined tasks
+
+**Workflow**:
+1. create_task({ type: "code_review", payload: { files: ["src/api.ts"] } })
+2. ... later ...
+3. run_task({ task_id: "abc-123" })
+
+**Returns**: task_id, estimated_engine, expires_at, compression info`,
   inputSchema: {
     type: "object",
     properties: {
       type: {
         type: "string",
         enum: ["web_search", "code_review", "code_generation", "analysis", "custom"],
-        description: "Task type for routing optimization"
+        description: "Task type: web_search, code_review, code_generation, analysis, or custom"
       },
       payload: {
         type: "object",
@@ -24842,7 +26480,23 @@ function createRunTaskHandler(deps) {
 }
 var runTaskSchema = {
   name: "run_task",
-  description: "Execute a previously created task and return results. Blocks until completion or timeout.",
+  description: `Execute a previously created task and return results. Blocks until completion or timeout.
+
+**When to use**: Execute a task created with create_task.
+
+**Features**:
+- Caching: Identical tasks return cached results (use skip_cache to bypass)
+- Engine override: Force execution on specific provider
+- Timeout control: Adjust for long-running tasks
+
+**Returns**:
+- status: "completed" or "failed"
+- result: Task output (null if failed)
+- engine: Which AI provider executed the task
+- metrics: Duration, token counts
+- cache_hit: Whether result came from cache
+
+**Example**: run_task({ task_id: "abc-123", timeout_ms: 60000 })`,
   inputSchema: {
     type: "object",
     properties: {
@@ -24860,7 +26514,7 @@ var runTaskSchema = {
         minimum: 1e3,
         maximum: 3e5,
         default: 3e4,
-        description: "Custom timeout in milliseconds"
+        description: "Custom timeout in milliseconds (default: 30000)"
       },
       skip_cache: {
         type: "boolean",
@@ -24922,7 +26576,18 @@ function createGetTaskResultHandler() {
 }
 var getTaskResultSchema = {
   name: "get_task_result",
-  description: "Retrieve the result of a task. Does not execute - use run_task for execution.",
+  description: `Retrieve the result of a task. Does not execute - use run_task for execution.
+
+**When to use**: Check status or get results of a previously created/executed task.
+
+**Returns**:
+- status: pending, running, completed, failed, or expired
+- result: Output data (null if not completed)
+- engine: Which provider executed the task
+- created_at, completed_at, expires_at: Timestamps
+- error: Details if failed
+
+**Example**: get_task_result({ task_id: "abc-123", include_payload: true })`,
   inputSchema: {
     type: "object",
     properties: {
@@ -24997,7 +26662,24 @@ function createListTasksHandler() {
 }
 var listTasksSchema = {
   name: "list_tasks",
-  description: "List tasks with optional filtering. Supports pagination.",
+  description: `List tasks with optional filtering. Supports pagination.
+
+**When to use**: Browse task queue, find tasks to execute, or monitor task status.
+
+**Filters**:
+- status: pending, running, completed, failed, expired
+- type: web_search, code_review, code_generation, analysis, custom
+- engine: gemini, claude, codex, glm, grok
+
+**Returns**: Array of task summaries with pagination info:
+- tasks: [{task_id, type, status, engine, priority, created_at, expires_at, has_result}]
+- total: Total matching tasks
+- has_more: Whether more pages exist
+
+**Examples**:
+- list_tasks({}) - List all tasks
+- list_tasks({ status: "pending" }) - Find pending tasks
+- list_tasks({ type: "code_review", limit: 50 }) - List code reviews`,
   inputSchema: {
     type: "object",
     properties: {
@@ -25086,7 +26768,20 @@ function createDeleteTaskHandler() {
 }
 var deleteTaskSchema = {
   name: "delete_task",
-  description: "Delete a task and its associated data. Cannot delete running tasks unless force=true.",
+  description: `Delete a task and its associated data. Cannot delete running tasks unless force=true.
+
+**When to use**: Clean up completed tasks, remove failed tasks, or cancel pending tasks.
+
+**Safety**: Running tasks are protected - use force=true to delete anyway.
+
+**Returns**:
+- deleted: Whether deletion succeeded
+- previous_status: Status before deletion
+- message: Human-readable result
+
+**Examples**:
+- delete_task({ task_id: "abc-123" }) - Delete completed task
+- delete_task({ task_id: "abc-123", force: true }) - Force delete running task`,
   inputSchema: {
     type: "object",
     properties: {
@@ -25476,6 +27171,12 @@ var McpClient = class _McpClient extends EventEmitter {
       this.process = null;
     }
   }
+  /**
+   * Clean up resources and remove all event listeners.
+   */
+  destroy() {
+    this.removeAllListeners();
+  }
 };
 var MCP_DEFAULTS = {
   timeout: 6e4,
@@ -25910,6 +27611,12 @@ var McpClientPool = class extends EventEmitter {
     this.emit(type, event);
     this.emit("event", event);
   }
+  /**
+   * Clean up resources and remove all event listeners.
+   */
+  destroy() {
+    this.removeAllListeners();
+  }
 };
 var globalPool = null;
 function getGlobalPool(config) {
@@ -26626,6 +28333,9 @@ var McpServer = class _McpServer {
    * Get static tool schemas (no initialization required)
    * Returns tool schemas that can be provided during MCP handshake
    * before services are initialized.
+   *
+   * v12.5.5: Enhanced descriptions with examples, return formats, and use cases
+   * to improve AI client understanding and tool selection.
    */
   static getStaticToolSchemas() {
     return [
@@ -26633,37 +28343,110 @@ var McpServer = class _McpServer {
         name: "run_agent",
         description: `Execute an AutomatosX agent with a specific task.
 
-v12.5.1: Agent auto-selection - if agent is omitted, system automatically selects the best agent based on task keywords.
-Uses Smart Routing: returns context for same-provider calls, spawns cross-provider execution.
+**When to use**: Delegate specialized tasks to expert agents. Each agent has domain expertise:
+- "backend": API development, database design, server-side logic
+- "frontend": UI/UX, React components, styling, accessibility
+- "quality": Testing, debugging, bug detection, code review
+- "security": Security audits, vulnerability scanning, auth systems
+- "architecture": System design, tech stack decisions, scalability
+- "devops": CI/CD, Docker, deployment, infrastructure
+
+**Auto-selection**: If agent is omitted, system analyzes task keywords and selects the best agent.
 
-Examples:
-- With agent: run_agent({ agent: "backend", task: "implement API" })
-- Auto-select: run_agent({ task: "fix bugs in the codebase" }) \u2192 selects "quality" agent`,
+**Returns**: JSON with execution result, output from the agent, and metadata.
+
+**Examples**:
+- run_agent({ agent: "backend", task: "Create a REST API endpoint for user authentication with JWT" })
+- run_agent({ agent: "quality", task: "Review the auth module for security issues" })
+- run_agent({ task: "Fix the memory leak in the connection pool" }) \u2192 auto-selects "quality"
+- run_agent({ task: "Design a microservices architecture for the payment system" }) \u2192 auto-selects "architecture"`,
         inputSchema: {
           type: "object",
           properties: {
-            agent: { type: "string", description: "Optional: Agent name (e.g., backend, quality). If omitted, best agent is auto-selected based on task." },
-            task: { type: "string", description: "The task for the agent to perform" },
-            provider: { type: "string", description: "Optional: Override the AI provider", enum: ["claude", "gemini", "openai"] },
-            no_memory: { type: "boolean", description: "Optional: Skip memory injection", default: false },
-            mode: { type: "string", description: "Optional: Execution mode - auto (default), context (always return context), execute (always spawn)", enum: ["auto", "context", "execute"], default: "auto" }
+            agent: { type: "string", description: "Agent name: backend, frontend, quality, security, architecture, devops. If omitted, auto-selected based on task." },
+            task: { type: "string", description: "Detailed task description. Be specific about requirements and expected outcomes." },
+            provider: { type: "string", description: "AI provider override: claude (best coding), gemini (free tier), openai (balanced)", enum: ["claude", "gemini", "openai"] },
+            no_memory: { type: "boolean", description: "Skip injecting relevant past context into agent prompt", default: false },
+            mode: { type: "string", description: "auto: smart routing, context: return prompt without executing, execute: always spawn process", enum: ["auto", "context", "execute"], default: "auto" }
           },
           required: ["task"]
         }
       },
       {
         name: "list_agents",
-        description: "List all available AutomatosX agents",
+        description: `List all available AutomatosX agents with their profiles.
+
+**When to use**: Discover available agents before delegating tasks, or to understand agent capabilities.
+
+**Returns**: Array of agent profiles, each containing:
+- name: Agent identifier (e.g., "backend", "quality")
+- displayName: Human-readable name (e.g., "Queenie")
+- role: Job title (e.g., "QA Engineer", "Backend Developer")
+- description: What the agent specializes in
+- abilities: List of capabilities (e.g., ["testing", "debugging"])
+- provider: Preferred AI provider
+- team: Team membership (e.g., "core", "platform")
+
+**Example response**:
+[
+  { "name": "backend", "displayName": "Benny", "role": "Backend Developer", "abilities": ["api-design", "database"] },
+  { "name": "quality", "displayName": "Queenie", "role": "QA Engineer", "abilities": ["testing", "debugging"] }
+]`,
         inputSchema: { type: "object", properties: {} }
       },
       {
         name: "search_memory",
-        description: "Search AutomatosX memory for relevant information",
-        inputSchema: { type: "object", properties: { query: { type: "string", description: "Search query" }, limit: { type: "number", description: "Maximum number of results", default: 10 } }, required: ["query"] }
+        description: `Search AutomatosX persistent memory using full-text search.
+
+**What memory contains**: Past task executions, code snippets, architectural decisions, debugging sessions, and context from previous conversations. Memory persists across sessions.
+
+**When to use**:
+- Find previous work on a similar task
+- Retrieve past decisions or implementations
+- Check if a bug was fixed before
+- Get context before starting new work
+
+**Search tips**:
+- Use specific keywords: "authentication JWT" rather than "auth"
+- Include file names: "router.ts error handling"
+- Search by agent: Results include which agent created the entry
+
+**Returns**: Array of memory entries with content, timestamp, agent, and relevance score.
+
+**Examples**:
+- search_memory({ query: "database migration", limit: 5 })
+- search_memory({ query: "authentication security audit" })
+- search_memory({ query: "React component performance optimization" })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search terms. Use specific keywords for better results." },
+            limit: { type: "number", description: "Max results to return (default: 10, max: 100)", default: 10 }
+          },
+          required: ["query"]
+        }
       },
       {
         name: "get_status",
-        description: "Get AutomatosX system status and configuration",
+        description: `Get AutomatosX system status and health information.
+
+**When to use**: Check system health, verify configuration, or diagnose issues.
+
+**Returns**:
+- version: AutomatosX version
+- providers: List of configured AI providers and their availability
+- memory: Stats (entry count, database size, last access)
+- sessions: Active session count and recent activity
+- router: Current routing configuration and provider health
+- uptime: Server uptime and initialization state
+
+**Example response**:
+{
+  "version": "12.5.4",
+  "providers": { "claude": "available", "gemini": "available", "openai": "unavailable" },
+  "memory": { "entries": 1523, "sizeMB": 12.5 },
+  "sessions": { "active": 2, "total": 45 }
+}`,
         inputSchema: { type: "object", properties: {} }
       },
       // v13.0.0: Enhanced Service Discovery
@@ -26684,92 +28467,419 @@ Use this tool first to understand what AutomatosX offers.`,
       },
       {
         name: "session_create",
-        description: "Create a new multi-agent session",
-        inputSchema: { type: "object", properties: { name: { type: "string", description: "Session name/task description" }, agent: { type: "string", description: "Initiating agent name" } }, required: ["name", "agent"] }
+        description: `Create a new multi-agent collaborative session.
+
+**What sessions are for**: Sessions track complex tasks that involve multiple agents working together. They provide:
+- Task state persistence across agent invocations
+- History of which agents contributed what
+- Ability to resume interrupted work
+- Coordination between agents (e.g., backend implements, quality reviews)
+
+**When to use**:
+- Multi-step tasks requiring multiple agents
+- Long-running work that may span multiple conversations
+- Collaborative workflows (design \u2192 implement \u2192 review \u2192 deploy)
+
+**Returns**: Session object with unique ID, state, timestamps, and task list.
+
+**Example workflow**:
+1. session_create({ name: "Implement auth system", agent: "architecture" })
+2. run_agent({ agent: "backend", task: "Implement JWT auth" })
+3. run_agent({ agent: "quality", task: "Review auth implementation" })
+4. session_complete({ id: "session-uuid" })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: 'Descriptive session name (e.g., "Implement user authentication")' },
+            agent: { type: "string", description: 'Initial agent to assign (e.g., "backend", "architecture")' }
+          },
+          required: ["name", "agent"]
+        }
       },
       {
         name: "session_list",
-        description: "List all active sessions",
+        description: `List all active and recent sessions.
+
+**When to use**: Find existing sessions to resume, check what work is in progress, or audit past work.
+
+**Returns**: Array of session summaries with:
+- id: Unique session identifier
+- name: Session description
+- state: "active", "completed", or "failed"
+- createdAt: Session start time
+- updatedAt: Last activity time
+- agents: List of agents that participated
+
+**Example response**:
+[
+  { "id": "abc-123", "name": "Auth system", "state": "active", "agents": ["backend", "quality"] },
+  { "id": "def-456", "name": "API refactor", "state": "completed", "agents": ["architecture", "backend"] }
+]`,
         inputSchema: { type: "object", properties: {} }
       },
       {
         name: "session_status",
-        description: "Get detailed status of a specific session",
-        inputSchema: { type: "object", properties: { id: { type: "string", description: "Session ID" } }, required: ["id"] }
+        description: `Get detailed status of a specific session including task history.
+
+**When to use**: Check progress of a session, see what agents have done, or decide next steps.
+
+**Returns**: Full session details with:
+- id, name, state, timestamps
+- tasks: Array of all tasks executed with results
+- currentAgent: Which agent is active (if any)
+- metadata: Additional context stored with session
+
+**Example**: session_status({ id: "abc-123" })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Session ID from session_create or session_list" }
+          },
+          required: ["id"]
+        }
       },
       {
         name: "session_complete",
-        description: "Mark a session as completed",
-        inputSchema: { type: "object", properties: { id: { type: "string", description: "Session ID" } }, required: ["id"] }
+        description: `Mark a session as successfully completed.
+
+**When to use**: After all tasks in a session are done and verified.
+
+**What it does**:
+- Updates session state to "completed"
+- Records completion timestamp
+- Persists session to history for future reference
+- Releases any held resources
+
+**Example**: session_complete({ id: "abc-123" })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Session ID to mark as completed" }
+          },
+          required: ["id"]
+        }
       },
       {
         name: "session_fail",
-        description: "Mark a session as failed with an error reason",
-        inputSchema: { type: "object", properties: { id: { type: "string", description: "Session ID" }, reason: { type: "string", description: "Failure reason" } }, required: ["id", "reason"] }
+        description: `Mark a session as failed with an error reason.
+
+**When to use**: When a session cannot be completed due to errors, blockers, or abandonment.
+
+**What it does**:
+- Updates session state to "failed"
+- Records failure reason for debugging
+- Preserves partial work for potential recovery
+
+**Example**: session_fail({ id: "abc-123", reason: "API rate limit exceeded, cannot complete integration" })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Session ID to mark as failed" },
+            reason: { type: "string", description: "Detailed explanation of why the session failed" }
+          },
+          required: ["id", "reason"]
+        }
       },
       {
         name: "memory_add",
-        description: "Add a new memory entry to the system",
-        inputSchema: { type: "object", properties: { content: { type: "string", description: "Memory content" }, metadata: { type: "object", description: "Optional metadata (agent, timestamp, etc.)", properties: { agent: { type: "string" }, timestamp: { type: "string" } } } }, required: ["content"] }
+        description: `Add a new entry to AutomatosX persistent memory.
+
+**When to use**:
+- Save important decisions or implementations for future reference
+- Store code snippets that worked well
+- Record architectural decisions and their rationale
+- Preserve debugging insights
+
+**Memory is searchable**: Entries are indexed for full-text search via search_memory.
+
+**Best practices**:
+- Include context: what problem was solved, what approach was used
+- Tag with relevant keywords for easier retrieval
+- Include agent name if storing agent output
+
+**Example**: memory_add({ content: "Implemented rate limiting using token bucket algorithm. Config: 100 req/min burst, 10 req/s sustained.", metadata: { agent: "backend", tags: ["rate-limiting", "performance"] } })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string", description: "Content to store. Be descriptive for better searchability." },
+            metadata: {
+              type: "object",
+              description: "Optional metadata for categorization and filtering",
+              properties: {
+                agent: { type: "string", description: "Agent that created this entry" },
+                timestamp: { type: "string", description: "Custom timestamp (ISO format)" },
+                tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" }
+              }
+            }
+          },
+          required: ["content"]
+        }
       },
       {
         name: "memory_list",
-        description: "List memory entries with optional filtering",
-        inputSchema: { type: "object", properties: { agent: { type: "string", description: "Filter by agent name" }, limit: { type: "number", description: "Maximum number of entries", default: 50 } } }
+        description: `List memory entries with optional filtering.
+
+**When to use**: Browse memory contents, audit what's stored, or filter by agent.
+
+**Returns**: Array of memory entries sorted by recency, with:
+- id: Unique identifier (use for memory_delete)
+- content: Stored text
+- agent: Source agent (if specified)
+- createdAt: When entry was added
+- metadata: Additional tags/info
+
+**Example**: memory_list({ agent: "backend", limit: 20 })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            agent: { type: "string", description: "Filter to entries from specific agent" },
+            limit: { type: "number", description: "Max entries to return (default: 50)", default: 50 }
+          }
+        }
       },
       {
         name: "memory_delete",
-        description: "Delete a specific memory entry by ID",
-        inputSchema: { type: "object", properties: { id: { type: "number", description: "Memory entry ID" } }, required: ["id"] }
+        description: `Delete a specific memory entry by ID.
+
+**When to use**: Remove outdated, incorrect, or sensitive information from memory.
+
+**Note**: Deletion is permanent. Use memory_list to find the ID first.
+
+**Example**: memory_delete({ id: 42 })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "number", description: "Memory entry ID from memory_list" }
+          },
+          required: ["id"]
+        }
       },
       {
         name: "memory_export",
-        description: "Export all memory entries to a JSON file",
-        inputSchema: { type: "object", properties: { path: { type: "string", description: "Export file path" } }, required: ["path"] }
+        description: `Export all memory entries to a JSON file.
+
+**When to use**:
+- Backup memory before major changes
+- Transfer memory to another system
+- Archive project knowledge
+- Audit stored information
+
+**Returns**: Confirmation with entry count and file path.
+
+**Example**: memory_export({ path: "./backup/memory-2024-01-15.json" })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "File path for export (JSON format)" }
+          },
+          required: ["path"]
+        }
       },
       {
         name: "memory_import",
-        description: "Import memory entries from a JSON file",
-        inputSchema: { type: "object", properties: { path: { type: "string", description: "Import file path" } }, required: ["path"] }
+        description: `Import memory entries from a JSON file.
+
+**When to use**:
+- Restore from backup
+- Load memory from another project
+- Seed new project with existing knowledge
+
+**Format**: JSON array of memory entries (same format as memory_export).
+
+**Note**: Imported entries are merged with existing memory.
+
+**Example**: memory_import({ path: "./backup/memory-2024-01-15.json" })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "File path to import from (JSON format)" }
+          },
+          required: ["path"]
+        }
       },
       {
         name: "memory_stats",
-        description: "Get detailed memory statistics",
+        description: `Get detailed memory statistics and health information.
+
+**When to use**: Check memory usage, diagnose performance issues, or monitor growth.
+
+**Returns**:
+- totalEntries: Number of memory entries
+- totalSizeBytes: Database size
+- entriesByAgent: Breakdown by agent
+- oldestEntry: Timestamp of oldest entry
+- newestEntry: Timestamp of newest entry
+- averageEntrySize: Bytes per entry
+
+**Example response**:
+{
+  "totalEntries": 1523,
+  "totalSizeBytes": 1245678,
+  "entriesByAgent": { "backend": 456, "quality": 312, "architecture": 89 }
+}`,
         inputSchema: { type: "object", properties: {} }
       },
       {
         name: "memory_clear",
-        description: "Clear all memory entries from the database",
+        description: `Clear ALL memory entries from the database.
+
+**WARNING**: This permanently deletes all stored memory. Use with caution.
+
+**When to use**:
+- Starting fresh on a new project
+- Removing sensitive data
+- Resetting after major changes
+
+**Recommendation**: Use memory_export first to create a backup.
+
+**Returns**: Confirmation with count of deleted entries.`,
         inputSchema: { type: "object", properties: {} }
       },
       {
         name: "get_conversation_context",
-        description: "Retrieve conversation context from the shared context store",
-        inputSchema: { type: "object", properties: { id: { type: "string", description: "Optional: Context ID to retrieve" }, source: { type: "string", description: "Optional: Filter by source (e.g., gemini-cli)" }, limit: { type: "number", description: "Optional: Max results (default: 10)", default: 10 } } }
+        description: `Retrieve conversation context from the shared cross-assistant context store.
+
+**What this is for**: AutomatosX allows different AI assistants (Claude, Gemini, etc.) to share context. This enables workflows where one assistant's work informs another's.
+
+**When to use**:
+- Resume work started by another assistant
+- Get context from a different AI provider's session
+- Check what information was shared across assistants
+
+**Returns**: Array of context entries with:
+- id: Context entry identifier
+- source: Which assistant created it (e.g., "gemini-cli", "claude-code")
+- content: The shared context/information
+- metadata: Topic, participants, tags
+- createdAt: When context was stored
+
+**Example**: get_conversation_context({ source: "gemini-cli", limit: 5 })`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Specific context ID to retrieve" },
+            source: { type: "string", description: 'Filter by source assistant (e.g., "gemini-cli", "claude-code")' },
+            limit: { type: "number", description: "Max entries to return (default: 10)", default: 10 }
+          }
+        }
       },
       {
         name: "inject_conversation_context",
-        description: "Inject conversation context into the shared context store",
-        inputSchema: { type: "object", properties: { source: { type: "string", description: "Source assistant (e.g., gemini-cli, claude-code)" }, content: { type: "string", description: "Context content" }, metadata: { type: "object", description: "Optional metadata", properties: { topic: { type: "string" }, participants: { type: "array", items: { type: "string" } }, tags: { type: "array", items: { type: "string" } } } } }, required: ["source", "content"] }
+        description: `Share conversation context with other AI assistants via the context store.
+
+**What this is for**: Enables cross-assistant collaboration by sharing context between different AI providers.
+
+**When to use**:
+- Hand off work to another AI assistant
+- Share discoveries or decisions across assistants
+- Create checkpoints in multi-assistant workflows
+
+**Best practices**:
+- Include enough context for the other assistant to continue
+- Use descriptive topics and tags
+- List relevant participants (agents involved)
+
+**Example**: inject_conversation_context({
+  source: "claude-code",
+  content: "Completed auth module implementation. JWT tokens work, need security review.",
+  metadata: { topic: "authentication", tags: ["security", "backend"], participants: ["backend", "security"] }
+})`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            source: { type: "string", description: 'Your assistant identifier (e.g., "claude-code", "gemini-cli")' },
+            content: { type: "string", description: "Context to share - be descriptive for handoffs" },
+            metadata: {
+              type: "object",
+              description: "Optional categorization",
+              properties: {
+                topic: { type: "string", description: 'Main topic (e.g., "authentication")' },
+                participants: { type: "array", items: { type: "string" }, description: "Agents involved" },
+                tags: { type: "array", items: { type: "string" }, description: "Searchable tags" }
+              }
+            }
+          },
+          required: ["source", "content"]
+        }
       },
       {
         name: "implement_and_document",
-        description: "Implement code and generate documentation atomically to prevent documentation drift",
-        inputSchema: { type: "object", properties: { task: { type: "string", description: "Task description" }, agent: { type: "string", description: "Optional: Agent to use (default: backend)" }, documentation: { type: "object", description: "Documentation options", properties: { format: { type: "string", enum: ["markdown", "jsdoc"], description: "Doc format (default: markdown)" }, outputPath: { type: "string", description: "Optional: Custom doc output path" }, updateChangelog: { type: "boolean", description: "Update CHANGELOG.md (default: true)", default: true } } }, provider: { type: "string", enum: ["claude", "gemini", "openai"], description: "Optional: AI provider override" } }, required: ["task"] }
+        description: `Implement code AND generate documentation in one atomic operation.
+
+**Why this exists**: Prevents "documentation drift" where code changes but docs don't. Both are generated together from the same understanding.
+
+**When to use**:
+- New feature implementations that need docs
+- API changes that require documentation updates
+- Any code change that should be documented
+
+**What it does**:
+1. Runs agent to implement the task
+2. Generates documentation from the implementation
+3. Optionally updates CHANGELOG.md
+4. Returns both code and docs together
+
+**Example**: implement_and_document({
+  task: "Add rate limiting middleware with configurable limits",
+  agent: "backend",
+  documentation: { format: "markdown", updateChangelog: true }
+})`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            task: { type: "string", description: "Implementation task - be specific about requirements" },
+            agent: { type: "string", description: "Agent to use (default: backend)" },
+            documentation: {
+              type: "object",
+              description: "Documentation generation options",
+              properties: {
+                format: { type: "string", enum: ["markdown", "jsdoc"], description: "Doc format (default: markdown)" },
+                outputPath: { type: "string", description: "Custom output path for docs" },
+                updateChangelog: { type: "boolean", description: "Update CHANGELOG.md (default: true)", default: true }
+              }
+            },
+            provider: { type: "string", enum: ["claude", "gemini", "openai"], description: "AI provider override" }
+          },
+          required: ["task"]
+        }
       },
       // v10.5.0: Smart Routing - Explicit context retrieval
       {
         name: "get_agent_context",
-        description: `Get agent context without executing. Returns profile, relevant memory, and enhanced prompt for AI assistant to execute directly.
+        description: `Get agent profile and context WITHOUT executing. Returns everything needed for YOU to execute the task directly.
+
+**When to use**:
+- You want to understand an agent's expertise before deciding to delegate
+- You prefer to execute the task yourself with agent guidance
+- You need the agent's system prompt and relevant memory
+
+**What it returns**:
+- profile: Full agent profile (role, abilities, system prompt)
+- memory: Relevant past context from search_memory
+- enhancedPrompt: Ready-to-use prompt incorporating agent expertise
+
+**Auto-selection**: If agent is omitted, system analyzes task and selects the best-matching agent.
+
+**Example**: get_agent_context({
+  task: "Implement caching layer for database queries",
+  includeMemory: true,
+  maxMemoryResults: 5
+})
 
-v12.5.1: Agent auto-selection - if agent is omitted, system automatically selects the best agent based on task keywords.`,
+**Returns example**:
+{
+  "selectedAgent": "backend",
+  "profile": { "role": "Backend Developer", "abilities": [...], "systemPrompt": "..." },
+  "memory": [{ "content": "Previous caching implementation used Redis...", ... }],
+  "enhancedPrompt": "You are a Backend Developer. Your task: Implement caching..."
+}`,
         inputSchema: {
           type: "object",
           properties: {
-            agent: { type: "string", description: "Optional: Agent name (e.g., backend, quality). If omitted, best agent is auto-selected based on task." },
-            task: { type: "string", description: "The task description for context building" },
+            agent: { type: "string", description: "Agent name, or omit for auto-selection based on task" },
+            task: { type: "string", description: "Task description - used for auto-selection and memory search" },
             includeMemory: { type: "boolean", description: "Include relevant memory entries (default: true)", default: true },
-            maxMemoryResults: { type: "number", description: "Maximum memory entries to return (default: 5)", default: 5 }
+            maxMemoryResults: { type: "number", description: "Max memory entries to include (default: 5)", default: 5 }
           },
           required: ["task"]
         }
@@ -26779,9 +28889,10 @@ v12.5.1: Agent auto-selection - if agent is omitted, system automatically select
       runTaskSchema,
       getTaskResultSchema,
       listTasksSchema,
-      deleteTaskSchema
-      // v12.4.0: Bugfix tools intentionally NOT exposed via MCP
-      // Access via: run_agent({ agent: "quality", task: "scan for bugs" })
+      deleteTaskSchema,
+      // v12.5.5: Bugfix tools now exposed directly via MCP
+      bugfixScanSchema,
+      bugfixRunSchema
     ];
   }
   /**
@@ -26998,6 +29109,8 @@ v12.5.1: Agent auto-selection - if agent is omitted, system automatically select
     register("get_task_result", createGetTaskResultHandler());
     register("list_tasks", createListTasksHandler());
     register("delete_task", createDeleteTaskHandler());
+    register("bugfix_scan", createBugfixScanHandler());
+    register("bugfix_run", createBugfixRunHandler());
     logger.info("[MCP Server] Registered tools", {
       count: this.tools.size,
       tools: Array.from(this.tools.keys())