@defai.digital/automatosx 12.4.1 → 12.5.1

package/dist/index.js

@@ -9431,7 +9431,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.4.1"
+  "version": "12.5.1"
 };
 
 // src/core/config/schemas.ts
@@ -14272,9 +14272,9 @@ async function initializeGitRepository(projectDir) {
       logger.info("Git repository already exists, skipping initialization");
       return true;
     }
-    const { spawn: spawn11 } = await import('child_process');
+    const { spawn: spawn12 } = await import('child_process');
     await new Promise((resolve13, reject) => {
-      const child = spawn11("git", ["init"], {
+      const child = spawn12("git", ["init"], {
         cwd: projectDir,
         stdio: "pipe",
         shell: false
@@ -14342,8 +14342,8 @@ async function updateGitignore(projectDir) {
   try {
     const exists = await checkExists2(gitignorePath);
     if (exists) {
-      const { readFile: readFile22 } = await import('fs/promises');
-      const content = await readFile22(gitignorePath, "utf-8");
+      const { readFile: readFile24 } = await import('fs/promises');
+      const content = await readFile24(gitignorePath, "utf-8");
       if (content.includes("# AutomatosX")) {
         return;
       }
@@ -16506,12 +16506,12 @@ var listCommand = {
 };
 async function listAgents(pathResolver, format) {
   const agentsDir = pathResolver.getAgentsDirectory();
-  const { existsSync: existsSync28 } = await import('fs');
+  const { existsSync: existsSync29 } = await import('fs');
   const projectDir = await detectProjectRoot();
   const examplesDir = join(projectDir, "examples", "agents");
   try {
     const agentFiles = [];
-    if (existsSync28(agentsDir)) {
+    if (existsSync29(agentsDir)) {
       const files = await readdir(agentsDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -16523,7 +16523,7 @@ async function listAgents(pathResolver, format) {
         }
       }
     }
-    if (existsSync28(examplesDir)) {
+    if (existsSync29(examplesDir)) {
       const files = await readdir(examplesDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -16549,12 +16549,12 @@ async function listAgents(pathResolver, format) {
       return;
     }
     const { load: load6 } = await import('js-yaml');
-    const { readFile: readFile22 } = await import('fs/promises');
+    const { readFile: readFile24 } = await import('fs/promises');
     agentFiles.sort((a, b) => a.file.localeCompare(b.file));
     const agents = [];
     for (const { file, path: agentPath, source } of agentFiles) {
       try {
-        const content = await readFile22(agentPath, "utf-8");
+        const content = await readFile24(agentPath, "utf-8");
         const agent = load6(content);
         const name = agent.displayName || agent.name || file.replace(/\.(yaml|yml)$/, "");
         const description = agent.description || "No description";
@@ -16607,12 +16607,12 @@ async function listAbilities(pathResolver, format) {
       }
       return;
     }
-    const { readFile: readFile22 } = await import('fs/promises');
+    const { readFile: readFile24 } = await import('fs/promises');
     const abilities = [];
     for (const file of abilityFiles.sort()) {
       const abilityPath = join(abilitiesDir, file);
       try {
-        const content = await readFile22(abilityPath, "utf-8");
+        const content = await readFile24(abilityPath, "utf-8");
         const lines = content.split("\n");
         const titleLine = lines.find((l) => l.startsWith("# "));
         const descLine = lines.find((l) => l.startsWith("## Description"));
@@ -20487,9 +20487,9 @@ var MemoryManager = class _MemoryManager {
       throw new MemoryError("Memory manager not initialized", "DATABASE_ERROR");
     }
     try {
-      const { mkdir: mkdir12 } = await import('fs/promises');
+      const { mkdir: mkdir13 } = await import('fs/promises');
       const destDir = dirname4(destPath);
-      await mkdir12(destDir, { recursive: true });
+      await mkdir13(destDir, { recursive: true });
       await this.db.backup(destPath);
       logger.info("Database backup created", { destPath: normalizePath(destPath) });
     } catch (error) {
@@ -20524,8 +20524,8 @@ var MemoryManager = class _MemoryManager {
         tempDb.prepare("SELECT COUNT(*) FROM memory_entries").get();
         tempDb.close();
       } catch (verifyError) {
-        const { unlink: unlink6 } = await import('fs/promises');
-        await unlink6(tempPath).catch(() => {
+        const { unlink: unlink7 } = await import('fs/promises');
+        await unlink7(tempPath).catch(() => {
         });
         throw new MemoryError(
           `Backup file verification failed: ${verifyError.message}`,
@@ -20645,9 +20645,9 @@ var MemoryManager = class _MemoryManager {
         },
         entries
       };
-      const { writeFile: writeFile15 } = await import('fs/promises');
+      const { writeFile: writeFile16 } = await import('fs/promises');
       const json = pretty ? JSON.stringify(exportData, null, 2) : JSON.stringify(exportData);
-      await writeFile15(filePath, json, "utf-8");
+      await writeFile16(filePath, json, "utf-8");
       const sizeBytes = Buffer.byteLength(json, "utf-8");
       logger.info("Memory exported to JSON", {
         filePath: normalizePath(filePath),
@@ -20696,8 +20696,8 @@ var MemoryManager = class _MemoryManager {
           { filePath }
         );
       }
-      const { readFile: readFile22 } = await import('fs/promises');
-      const content = await readFile22(filePath, "utf-8");
+      const { readFile: readFile24 } = await import('fs/promises');
+      const content = await readFile24(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)) {
@@ -26006,6 +26006,232 @@ ${context.task}`;
   }
 };
 
+// src/agents/agent-selector.ts
+init_esm_shims();
+init_logger();
+function scoreAgent(task, profile) {
+  let score = 0;
+  const taskLower = task.toLowerCase();
+  if (profile.selectionMetadata?.primaryIntents) {
+    for (const intent of profile.selectionMetadata.primaryIntents) {
+      const intentKeywords = intent.toLowerCase().split(/\s+/);
+      const matchedKeywords = intentKeywords.filter(
+        (keyword) => taskLower.includes(keyword) && keyword.length > 3
+      );
+      if (matchedKeywords.length >= 2) {
+        score += 10;
+      } else if (matchedKeywords.length === 1) {
+        score += 5;
+      }
+    }
+  }
+  if (profile.selectionMetadata?.secondarySignals) {
+    for (const signal of profile.selectionMetadata.secondarySignals) {
+      if (taskLower.includes(signal.toLowerCase())) {
+        score += 5;
+      }
+    }
+  }
+  if (profile.selectionMetadata?.negativeIntents) {
+    for (const negative of profile.selectionMetadata.negativeIntents) {
+      const keywords = negative.split("(")[0]?.toLowerCase() || "";
+      const negativeKeywords = keywords.split(/\s+/).filter((k) => k.length > 3);
+      const matchedNegative = negativeKeywords.filter(
+        (keyword) => taskLower.includes(keyword)
+      );
+      if (matchedNegative.length >= 2) {
+        score -= 20;
+      }
+    }
+  }
+  if (profile.selectionMetadata?.redirectWhen) {
+    for (const rule of profile.selectionMetadata.redirectWhen) {
+      try {
+        const regex = new RegExp(rule.phrase, "i");
+        if (regex.test(task)) {
+          score -= 15;
+        }
+      } catch (error) {
+        logger.debug("Invalid regex pattern in redirectWhen rule", {
+          pattern: rule.phrase,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  if (profile.abilitySelection?.taskBased) {
+    for (const keyword of Object.keys(profile.abilitySelection.taskBased)) {
+      if (taskLower.includes(keyword.toLowerCase())) {
+        score += 3;
+      }
+    }
+  }
+  return Math.max(0, score);
+}
+function buildRationale(task, profile) {
+  const rationale = [];
+  const taskLower = task.toLowerCase();
+  if (profile.selectionMetadata?.primaryIntents) {
+    const matchedIntents = profile.selectionMetadata.primaryIntents.filter((intent) => {
+      const keywords = intent.toLowerCase().split(/\s+/);
+      return keywords.some((k) => taskLower.includes(k) && k.length > 3);
+    });
+    if (matchedIntents.length > 0) {
+      rationale.push(`Matches: ${matchedIntents.slice(0, 2).join(", ")}`);
+    }
+  }
+  if (profile.selectionMetadata?.secondarySignals) {
+    const matchedSignals = profile.selectionMetadata.secondarySignals.filter(
+      (signal) => taskLower.includes(signal.toLowerCase())
+    );
+    if (matchedSignals.length > 0) {
+      rationale.push(`Keywords: ${matchedSignals.slice(0, 3).join(", ")}`);
+    }
+  }
+  if (profile.abilitySelection?.taskBased) {
+    const matchedAbilities = Object.keys(profile.abilitySelection.taskBased).filter(
+      (keyword) => taskLower.includes(keyword.toLowerCase())
+    );
+    if (matchedAbilities.length > 0) {
+      rationale.push(`Abilities: ${matchedAbilities.slice(0, 2).join(", ")}`);
+    }
+  }
+  if (rationale.length === 0) {
+    rationale.push("General capability match");
+  }
+  return rationale;
+}
+function getConfidence(score) {
+  if (score >= 30) return "high";
+  if (score >= 15) return "medium";
+  return "low";
+}
+var MIN_SELECTION_SCORE = 5;
+var FALLBACK_AGENT = "standard";
+var AgentSelector = class {
+  profileLoader;
+  constructor(profileLoader) {
+    this.profileLoader = profileLoader;
+  }
+  /**
+   * Select the best agent for a task
+   *
+   * @param task - Task description
+   * @returns Selection result with agent, score, confidence, and rationale
+   */
+  async selectAgent(task) {
+    logger.debug("[AgentSelector] Selecting agent for task", {
+      taskPreview: task.substring(0, 100)
+    });
+    const agentNames = await this.profileLoader.listProfiles();
+    if (agentNames.length === 0) {
+      logger.warn("[AgentSelector] No agents found, using fallback");
+      return this.createFallbackResult(task);
+    }
+    const profileResults = await Promise.all(
+      agentNames.map(async (name) => {
+        try {
+          const profile = await this.profileLoader.loadProfile(name);
+          return { name, profile, score: scoreAgent(task, profile) };
+        } catch (error) {
+          logger.debug(`[AgentSelector] Failed to load profile: ${name}`, { error });
+          return null;
+        }
+      })
+    );
+    const scoredAgents = profileResults.filter(
+      (result) => result !== null
+    );
+    if (scoredAgents.length === 0) {
+      logger.warn("[AgentSelector] Failed to load any profiles, using fallback");
+      return this.createFallbackResult(task);
+    }
+    scoredAgents.sort((a, b) => b.score - a.score);
+    const best = scoredAgents[0];
+    const alternatives = scoredAgents.slice(1, 4).map((a) => ({
+      agent: a.name,
+      score: a.score
+    }));
+    if (best.score < MIN_SELECTION_SCORE) {
+      logger.info("[AgentSelector] Best score below threshold, using fallback", {
+        bestAgent: best.name,
+        bestScore: best.score,
+        threshold: MIN_SELECTION_SCORE
+      });
+      const standardAgent = scoredAgents.find((a) => a.name === FALLBACK_AGENT);
+      if (standardAgent) {
+        return {
+          agent: standardAgent.name,
+          displayName: standardAgent.profile.displayName || standardAgent.name,
+          role: standardAgent.profile.role,
+          score: standardAgent.score,
+          confidence: "low",
+          rationale: ["No strong match found, using general-purpose agent"],
+          alternatives: scoredAgents.filter((a) => a.name !== FALLBACK_AGENT).slice(0, 3).map((a) => ({ agent: a.name, score: a.score })),
+          usedFallback: true
+        };
+      }
+      return {
+        agent: best.name,
+        displayName: best.profile.displayName || best.name,
+        role: best.profile.role,
+        score: best.score,
+        confidence: "low",
+        rationale: ["Low confidence match - consider specifying agent explicitly"],
+        alternatives,
+        usedFallback: false
+      };
+    }
+    const rationale = buildRationale(task, best.profile);
+    const confidence = getConfidence(best.score);
+    logger.info("[AgentSelector] Agent selected", {
+      agent: best.name,
+      score: best.score,
+      confidence,
+      rationale
+    });
+    return {
+      agent: best.name,
+      displayName: best.profile.displayName || best.name,
+      role: best.profile.role,
+      score: best.score,
+      confidence,
+      rationale,
+      alternatives,
+      usedFallback: false
+    };
+  }
+  /**
+   * Create a fallback result when no agents are available
+   */
+  async createFallbackResult(_task) {
+    try {
+      const profile = await this.profileLoader.loadProfile(FALLBACK_AGENT);
+      return {
+        agent: FALLBACK_AGENT,
+        displayName: profile.displayName || FALLBACK_AGENT,
+        role: profile.role,
+        score: 0,
+        confidence: "low",
+        rationale: ["No agents available, using fallback"],
+        alternatives: [],
+        usedFallback: true
+      };
+    } catch {
+      return {
+        agent: FALLBACK_AGENT,
+        displayName: "Standard",
+        role: "General-purpose agent",
+        score: 0,
+        confidence: "low",
+        rationale: ["No agents available"],
+        alternatives: [],
+        usedFallback: true
+      };
+    }
+  }
+};
+
 // src/mcp/tools/run-agent.ts
 init_logger();
 
@@ -26305,22 +26531,41 @@ async function buildAgentContext(agentName, task, deps, callerProvider, bestProv
 }
 function createRunAgentHandler(deps) {
   return async (input, context) => {
-    const { agent, task, provider, no_memory, mode = "auto" } = input;
+    const { task, provider, no_memory, mode = "auto" } = input;
+    let { agent } = input;
     if (context?.signal?.aborted) {
       throw new Error("Request was cancelled");
     }
-    validateAgentName(agent);
     validateStringParameter(task, "task", {
       required: true,
       minLength: 1,
       maxLength: 1e4
     });
+    let autoSelected = false;
+    if (!agent && deps.profileLoader) {
+      const selector = new AgentSelector(deps.profileLoader);
+      const selection = await selector.selectAgent(task);
+      agent = selection.agent;
+      autoSelected = true;
+      logger.info("[MCP] run_agent auto-selected agent", {
+        task: task.substring(0, 100),
+        selectedAgent: agent,
+        confidence: selection.confidence,
+        score: selection.score,
+        rationale: selection.rationale
+      });
+    }
+    if (!agent) {
+      throw new Error("Agent name is required when profileLoader is not available");
+    }
+    validateAgentName(agent);
     const actualProvider = mapMcpProviderToActual(provider);
     const session = deps.getSession?.() || null;
     const callerProvider = session?.normalizedProvider || "unknown";
     const callerActual = mapNormalizedCallerToActual(callerProvider);
     logger.info("[MCP] run_agent called (Smart Routing v10.5.0)", {
       agent,
+      autoSelected,
       task: task.substring(0, 100),
       mcpProvider: provider,
       actualProvider,
@@ -27133,20 +27378,35 @@ init_logger();
 function createGetAgentContextHandler(deps) {
   return async (input) => {
     const {
-      agent,
       task,
       includeMemory = true,
       maxMemoryResults = 5
     } = input;
+    let { agent } = input;
     const startTime = Date.now();
-    validateAgentName(agent);
     validateStringParameter(task, "task", {
       required: true,
       minLength: 1,
       maxLength: 1e4
     });
+    let autoSelected = false;
+    if (!agent) {
+      const selector = new AgentSelector(deps.profileLoader);
+      const selection = await selector.selectAgent(task);
+      agent = selection.agent;
+      autoSelected = true;
+      logger.info("[MCP] get_agent_context auto-selected agent", {
+        task: task.substring(0, 100),
+        selectedAgent: agent,
+        confidence: selection.confidence,
+        score: selection.score,
+        rationale: selection.rationale
+      });
+    }
+    validateAgentName(agent);
     logger.info("[MCP] get_agent_context called", {
       agent,
+      autoSelected,
       task: task.substring(0, 100),
       includeMemory,
       maxMemoryResults
@@ -31697,17 +31957,24 @@ var McpServer = class _McpServer {
     return [
       {
         name: "run_agent",
-        description: "Execute an AutomatosX agent with a specific task. Uses Smart Routing: returns context for same-provider calls, spawns cross-provider execution.",
+        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.
+
+Examples:
+- With agent: run_agent({ agent: "backend", task: "implement API" })
+- Auto-select: run_agent({ task: "fix bugs in the codebase" }) \u2192 selects "quality" agent`,
         inputSchema: {
           type: "object",
           properties: {
-            agent: { type: "string", description: "The name of the agent to run (e.g., backend, Paris, Bob)" },
+            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" }
           },
-          required: ["agent", "task"]
+          required: ["task"]
         }
       },
       {
@@ -31819,16 +32086,18 @@ Use this tool first to understand what AutomatosX offers.`,
       // 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 context without executing. Returns profile, relevant memory, and enhanced prompt for AI assistant to execute directly.
+
+v12.5.1: Agent auto-selection - if agent is omitted, system automatically selects the best agent based on task keywords.`,
         inputSchema: {
           type: "object",
           properties: {
-            agent: { type: "string", description: "The name of the agent (e.g., backend, Paris, Bob)" },
+            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" },
             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 }
           },
-          required: ["agent", "task"]
+          required: ["task"]
         }
       },
       // v11.3.5: Task Engine tools
@@ -31837,6 +32106,8 @@ Use this tool first to understand what AutomatosX offers.`,
       getTaskResultSchema,
       listTasksSchema,
       deleteTaskSchema
+      // v12.4.0: Bugfix tools intentionally NOT exposed via MCP
+      // Access via: run_agent({ agent: "quality", task: "scan for bugs" })
     ];
   }
   /**
@@ -35187,232 +35458,6 @@ var memoryCommand = {
 // src/cli/commands/run.ts
 init_esm_shims();
 
-// src/agents/agent-selector.ts
-init_esm_shims();
-init_logger();
-function scoreAgent(task, profile) {
-  let score = 0;
-  const taskLower = task.toLowerCase();
-  if (profile.selectionMetadata?.primaryIntents) {
-    for (const intent of profile.selectionMetadata.primaryIntents) {
-      const intentKeywords = intent.toLowerCase().split(/\s+/);
-      const matchedKeywords = intentKeywords.filter(
-        (keyword) => taskLower.includes(keyword) && keyword.length > 3
-      );
-      if (matchedKeywords.length >= 2) {
-        score += 10;
-      } else if (matchedKeywords.length === 1) {
-        score += 5;
-      }
-    }
-  }
-  if (profile.selectionMetadata?.secondarySignals) {
-    for (const signal of profile.selectionMetadata.secondarySignals) {
-      if (taskLower.includes(signal.toLowerCase())) {
-        score += 5;
-      }
-    }
-  }
-  if (profile.selectionMetadata?.negativeIntents) {
-    for (const negative of profile.selectionMetadata.negativeIntents) {
-      const keywords = negative.split("(")[0]?.toLowerCase() || "";
-      const negativeKeywords = keywords.split(/\s+/).filter((k) => k.length > 3);
-      const matchedNegative = negativeKeywords.filter(
-        (keyword) => taskLower.includes(keyword)
-      );
-      if (matchedNegative.length >= 2) {
-        score -= 20;
-      }
-    }
-  }
-  if (profile.selectionMetadata?.redirectWhen) {
-    for (const rule of profile.selectionMetadata.redirectWhen) {
-      try {
-        const regex = new RegExp(rule.phrase, "i");
-        if (regex.test(task)) {
-          score -= 15;
-        }
-      } catch (error) {
-        logger.debug("Invalid regex pattern in redirectWhen rule", {
-          pattern: rule.phrase,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-  }
-  if (profile.abilitySelection?.taskBased) {
-    for (const keyword of Object.keys(profile.abilitySelection.taskBased)) {
-      if (taskLower.includes(keyword.toLowerCase())) {
-        score += 3;
-      }
-    }
-  }
-  return Math.max(0, score);
-}
-function buildRationale(task, profile) {
-  const rationale = [];
-  const taskLower = task.toLowerCase();
-  if (profile.selectionMetadata?.primaryIntents) {
-    const matchedIntents = profile.selectionMetadata.primaryIntents.filter((intent) => {
-      const keywords = intent.toLowerCase().split(/\s+/);
-      return keywords.some((k) => taskLower.includes(k) && k.length > 3);
-    });
-    if (matchedIntents.length > 0) {
-      rationale.push(`Matches: ${matchedIntents.slice(0, 2).join(", ")}`);
-    }
-  }
-  if (profile.selectionMetadata?.secondarySignals) {
-    const matchedSignals = profile.selectionMetadata.secondarySignals.filter(
-      (signal) => taskLower.includes(signal.toLowerCase())
-    );
-    if (matchedSignals.length > 0) {
-      rationale.push(`Keywords: ${matchedSignals.slice(0, 3).join(", ")}`);
-    }
-  }
-  if (profile.abilitySelection?.taskBased) {
-    const matchedAbilities = Object.keys(profile.abilitySelection.taskBased).filter(
-      (keyword) => taskLower.includes(keyword.toLowerCase())
-    );
-    if (matchedAbilities.length > 0) {
-      rationale.push(`Abilities: ${matchedAbilities.slice(0, 2).join(", ")}`);
-    }
-  }
-  if (rationale.length === 0) {
-    rationale.push("General capability match");
-  }
-  return rationale;
-}
-function getConfidence(score) {
-  if (score >= 30) return "high";
-  if (score >= 15) return "medium";
-  return "low";
-}
-var MIN_SELECTION_SCORE = 5;
-var FALLBACK_AGENT = "standard";
-var AgentSelector = class {
-  profileLoader;
-  constructor(profileLoader) {
-    this.profileLoader = profileLoader;
-  }
-  /**
-   * Select the best agent for a task
-   *
-   * @param task - Task description
-   * @returns Selection result with agent, score, confidence, and rationale
-   */
-  async selectAgent(task) {
-    logger.debug("[AgentSelector] Selecting agent for task", {
-      taskPreview: task.substring(0, 100)
-    });
-    const agentNames = await this.profileLoader.listProfiles();
-    if (agentNames.length === 0) {
-      logger.warn("[AgentSelector] No agents found, using fallback");
-      return this.createFallbackResult(task);
-    }
-    const profileResults = await Promise.all(
-      agentNames.map(async (name) => {
-        try {
-          const profile = await this.profileLoader.loadProfile(name);
-          return { name, profile, score: scoreAgent(task, profile) };
-        } catch (error) {
-          logger.debug(`[AgentSelector] Failed to load profile: ${name}`, { error });
-          return null;
-        }
-      })
-    );
-    const scoredAgents = profileResults.filter(
-      (result) => result !== null
-    );
-    if (scoredAgents.length === 0) {
-      logger.warn("[AgentSelector] Failed to load any profiles, using fallback");
-      return this.createFallbackResult(task);
-    }
-    scoredAgents.sort((a, b) => b.score - a.score);
-    const best = scoredAgents[0];
-    const alternatives = scoredAgents.slice(1, 4).map((a) => ({
-      agent: a.name,
-      score: a.score
-    }));
-    if (best.score < MIN_SELECTION_SCORE) {
-      logger.info("[AgentSelector] Best score below threshold, using fallback", {
-        bestAgent: best.name,
-        bestScore: best.score,
-        threshold: MIN_SELECTION_SCORE
-      });
-      const standardAgent = scoredAgents.find((a) => a.name === FALLBACK_AGENT);
-      if (standardAgent) {
-        return {
-          agent: standardAgent.name,
-          displayName: standardAgent.profile.displayName || standardAgent.name,
-          role: standardAgent.profile.role,
-          score: standardAgent.score,
-          confidence: "low",
-          rationale: ["No strong match found, using general-purpose agent"],
-          alternatives: scoredAgents.filter((a) => a.name !== FALLBACK_AGENT).slice(0, 3).map((a) => ({ agent: a.name, score: a.score })),
-          usedFallback: true
-        };
-      }
-      return {
-        agent: best.name,
-        displayName: best.profile.displayName || best.name,
-        role: best.profile.role,
-        score: best.score,
-        confidence: "low",
-        rationale: ["Low confidence match - consider specifying agent explicitly"],
-        alternatives,
-        usedFallback: false
-      };
-    }
-    const rationale = buildRationale(task, best.profile);
-    const confidence = getConfidence(best.score);
-    logger.info("[AgentSelector] Agent selected", {
-      agent: best.name,
-      score: best.score,
-      confidence,
-      rationale
-    });
-    return {
-      agent: best.name,
-      displayName: best.profile.displayName || best.name,
-      role: best.profile.role,
-      score: best.score,
-      confidence,
-      rationale,
-      alternatives,
-      usedFallback: false
-    };
-  }
-  /**
-   * Create a fallback result when no agents are available
-   */
-  async createFallbackResult(_task) {
-    try {
-      const profile = await this.profileLoader.loadProfile(FALLBACK_AGENT);
-      return {
-        agent: FALLBACK_AGENT,
-        displayName: profile.displayName || FALLBACK_AGENT,
-        role: profile.role,
-        score: 0,
-        confidence: "low",
-        rationale: ["No agents available, using fallback"],
-        alternatives: [],
-        usedFallback: true
-      };
-    } catch {
-      return {
-        agent: FALLBACK_AGENT,
-        displayName: "Standard",
-        role: "General-purpose agent",
-        score: 0,
-        confidence: "low",
-        rationale: ["No agents available"],
-        alternatives: [],
-        usedFallback: true
-      };
-    }
-  }
-};
-
 // src/core/stage-execution-controller.ts
 init_esm_shims();
 
@@ -42317,8 +42362,8 @@ async function getProjectInfo(projectDir) {
     return {};
   }
   try {
-    const { readFile: readFile22 } = await import('fs/promises');
-    const content = await readFile22(packageJsonPath, "utf-8");
+    const { readFile: readFile24 } = await import('fs/promises');
+    const content = await readFile24(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     return {
       name: pkg.name,
@@ -42431,13 +42476,13 @@ async function getCurrentVersion() {
     const result = JSON.parse(stdout);
     return result.dependencies["@defai.digital/automatosx"]?.version || "unknown";
   } catch (error) {
-    const { readFile: readFile22 } = await import('fs/promises');
-    const { dirname: dirname16, join: join52 } = await import('path');
+    const { readFile: readFile24 } = await import('fs/promises');
+    const { dirname: dirname17, join: join54 } = await import('path');
     const { fileURLToPath: fileURLToPath5 } = await import('url');
     const __filename3 = fileURLToPath5(import.meta.url);
-    const __dirname4 = dirname16(__filename3);
-    const pkgPath = join52(__dirname4, "../../../package.json");
-    const content = await readFile22(pkgPath, "utf-8");
+    const __dirname4 = dirname17(__filename3);
+    const pkgPath = join54(__dirname4, "../../../package.json");
+    const content = await readFile24(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version;
   }
@@ -49488,10 +49533,10 @@ async function handleReset() {
 `));
 }
 async function handleTrace(workspacePath, argv) {
-  const { existsSync: existsSync28, readFileSync: readFileSync10, watchFile } = await import('fs');
-  const { join: join52 } = await import('path');
-  const traceFile = join52(workspacePath, ".automatosx/logs/router.trace.jsonl");
-  if (!existsSync28(traceFile)) {
+  const { existsSync: existsSync29, readFileSync: readFileSync10, watchFile } = await import('fs');
+  const { join: join54 } = await import('path');
+  const traceFile = join54(workspacePath, ".automatosx/logs/router.trace.jsonl");
+  if (!existsSync29(traceFile)) {
     console.log(chalk5.yellow("\n\u26A0\uFE0F  No trace log found\n"));
     console.log(chalk5.gray(`Expected location: ${traceFile}
 `));
@@ -50225,8 +50270,8 @@ async function runCodexDiagnostics(verbose) {
   const configPath = join(workingDir, "ax.config.json");
   if (existsSync(configPath)) {
     try {
-      const { readFile: readFile22 } = await import('fs/promises');
-      const configContent = await readFile22(configPath, "utf-8");
+      const { readFile: readFile24 } = await import('fs/promises');
+      const configContent = await readFile24(configPath, "utf-8");
       const config = JSON.parse(configContent);
       providerConfigured = config?.providers?.openai?.enabled === true;
     } catch {
@@ -50910,8 +50955,8 @@ async function runMcpDiagnostics(verbose) {
   let serverStarts = false;
   if (cliAvailable) {
     try {
-      const { spawn: spawn11 } = await import('child_process');
-      const proc = spawn11("automatosx", ["mcp", "server"], { stdio: ["pipe", "pipe", "pipe"] });
+      const { spawn: spawn12 } = await import('child_process');
+      const proc = spawn12("automatosx", ["mcp", "server"], { stdio: ["pipe", "pipe", "pipe"] });
       const initResult = await new Promise((resolve13) => {
         let output = "";
         proc.stderr?.on("data", (data) => {
@@ -55574,6 +55619,1641 @@ var reviewCommand = {
   }
 };
 
+// src/cli/commands/bugfix.ts
+init_esm_shims();
+
+// src/core/bugfix/index.ts
+init_esm_shims();
+
+// src/core/bugfix/types.ts
+init_esm_shims();
+
+// src/core/bugfix/bug-detector.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_DETECTION_RULES = [
+  // Timer leak: setInterval without .unref()
+  {
+    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: 5,
+    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
+  {
+    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: 100,
+    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"]
+  }
+];
+var BugDetector = class {
+  rules;
+  config;
+  constructor(config, customRules) {
+    this.config = config;
+    this.rules = customRules || DEFAULT_DETECTION_RULES;
+    if (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
+    });
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+        }
+      }
+      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 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.warn("Rule application failed", {
+        ruleId: rule.id,
+        file: filePath,
+        error: error.message
+      });
+    }
+    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 yaml5 = await import('js-yaml');
+      const parsed = yaml5.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: 60,
+    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/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_OPTIONS4 = {
+  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_OPTIONS4, ...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((resolve13) => {
+      const parts = command.split(" ");
+      const cmd = parts[0];
+      const args = parts.slice(1);
+      const errors = [];
+      let stderr = "";
+      if (!cmd) {
+        resolve13({ success: false, errors: ["Empty command"] });
+        return;
+      }
+      logger.debug(`Running ${name}`, { command });
+      const proc = spawn(cmd, args, {
+        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) {
+          resolve13({ success: true, errors: [] });
+        } else {
+          const errorLines = stderr.split("\n").filter((line) => line.includes("error") || line.includes("Error") || line.includes("FAIL")).slice(0, 10);
+          resolve13({
+            success: false,
+            errors: errorLines.length > 0 ? errorLines : [`${name} failed with exit code ${code}`]
+          });
+        }
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timeoutId);
+        resolve13({
+          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
+init_esm_shims();
+init_logger();
+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/cli/commands/bugfix.ts
+init_logger();
+init_path_resolver();
+function formatSeverity(severity) {
+  switch (severity) {
+    case "critical":
+      return chalk5.bgRed.white(" CRITICAL ");
+    case "high":
+      return chalk5.red("[HIGH]");
+    case "medium":
+      return chalk5.yellow("[MED]");
+    case "low":
+      return chalk5.gray("[LOW]");
+    default: {
+      const s = severity;
+      return `[${s.toUpperCase()}]`;
+    }
+  }
+}
+function formatBugType(type) {
+  const typeNames = {
+    timer_leak: "Timer leak",
+    missing_destroy: "Missing destroy()",
+    promise_timeout_leak: "Promise timeout leak",
+    event_leak: "Event listener leak",
+    resource_leak: "Resource leak",
+    race_condition: "Race condition",
+    memory_leak: "Memory leak",
+    uncaught_promise: "Uncaught promise",
+    deprecated_api: "Deprecated API",
+    security_issue: "Security issue",
+    type_error: "Type error",
+    test_failure: "Test failure",
+    custom: "Custom"
+  };
+  return typeNames[type] || type;
+}
+var bugfixCommand = {
+  command: "bugfix",
+  describe: "Find and fix bugs in the codebase",
+  builder: {
+    auto: {
+      type: "boolean",
+      default: false,
+      describe: "Run autonomously without prompts"
+    },
+    scope: {
+      type: "string",
+      describe: "Limit scan to directory (e.g., src/core/)"
+    },
+    severity: {
+      type: "string",
+      choices: ["low", "medium", "high", "critical"],
+      default: "medium",
+      describe: "Minimum severity to fix"
+    },
+    "max-iterations": {
+      type: "number",
+      default: 10,
+      describe: "Maximum bugs to fix per session"
+    },
+    "dry-run": {
+      type: "boolean",
+      default: false,
+      describe: "Preview fixes without applying"
+    },
+    verbose: {
+      type: "boolean",
+      default: false,
+      describe: "Verbose output"
+    },
+    quiet: {
+      type: "boolean",
+      default: false,
+      describe: "Minimal output"
+    },
+    types: {
+      type: "array",
+      describe: "Bug types to scan for",
+      choices: [
+        "timer_leak",
+        "missing_destroy",
+        "promise_timeout_leak",
+        "event_leak",
+        "resource_leak"
+      ]
+    }
+  },
+  handler: async (argv) => {
+    const spinner = ora8();
+    const findings = [];
+    const fixedBugs = [];
+    const failedBugs = [];
+    const skippedBugs = [];
+    const rootDir = await detectProjectRoot() || process.cwd();
+    const config = {
+      maxBugs: argv.maxIterations || 10,
+      severityThreshold: argv.severity || "medium",
+      scope: argv.scope,
+      dryRun: argv.dryRun || false,
+      verbose: argv.verbose || false,
+      bugTypes: argv.types || ["timer_leak", "missing_destroy", "promise_timeout_leak"]
+    };
+    if (!argv.quiet) {
+      console.log(chalk5.cyan("\n\u{1F527} AutomatosX Bug Fixer\n"));
+      if (argv.dryRun) {
+        console.log(chalk5.yellow("  \u26A0\uFE0F  Dry run mode - no changes will be made\n"));
+      }
+      if (argv.scope) {
+        console.log(chalk5.gray(`  Scope: ${argv.scope}`));
+      }
+      console.log(chalk5.gray(`  Severity threshold: ${argv.severity}`));
+      console.log(chalk5.gray(`  Max bugs: ${argv.maxIterations}`));
+      console.log();
+    }
+    try {
+      const controller = new BugfixController({
+        config,
+        rootDir,
+        onProgress: (message, data) => {
+          if (argv.quiet) return;
+          if (message.startsWith("Scanning")) {
+            spinner.start(message);
+          } else if (message.includes("Found")) {
+            spinner.succeed(message);
+          } else if (message.startsWith("Fixing")) {
+            spinner.start(message);
+          } else if (message.includes("verified") || message.includes("Verified")) {
+            spinner.succeed(message);
+          } else if (message.includes("failed") || message.includes("Failed")) {
+            spinner.fail(message);
+          } else if (message.includes("Skipped")) {
+            spinner.info(message);
+          } else if (argv.verbose) {
+            spinner.info(message);
+          }
+        },
+        onBugFound: (finding) => {
+          findings.push(finding);
+        },
+        onFixApplied: (finding, attempt) => {
+          if (attempt.status === "verified") {
+            fixedBugs.push(finding);
+          } else if (attempt.status === "failed") {
+            failedBugs.push(finding);
+          } else if (attempt.status === "skipped") {
+            skippedBugs.push(finding);
+          }
+        },
+        onVerification: (finding, success) => {
+          if (!argv.quiet && argv.verbose) {
+            const icon = success ? "\u2713" : "\u2717";
+            console.log(chalk5.gray(`   ${icon} Verification: ${success ? "passed" : "failed"}`));
+          }
+        }
+      });
+      const result = await controller.execute();
+      if (!argv.quiet) {
+        spinner.stop();
+        console.log("\n" + chalk5.cyan("\u2501".repeat(50)));
+        console.log(chalk5.cyan.bold("  Results"));
+        console.log(chalk5.cyan("\u2501".repeat(50)) + "\n");
+        if (findings.length > 0) {
+          console.log(chalk5.bold("\u{1F4CB} Bugs found:\n"));
+          for (const finding of findings.slice(0, 20)) {
+            const severity = formatSeverity(finding.severity);
+            const type = formatBugType(finding.type);
+            console.log(`   ${severity} ${type} in ${chalk5.cyan(finding.file)}:${finding.lineStart}`);
+          }
+          if (findings.length > 20) {
+            console.log(chalk5.gray(`   ... and ${findings.length - 20} more`));
+          }
+          console.log();
+        }
+        if (fixedBugs.length > 0) {
+          console.log(chalk5.green.bold(`\u2705 Fixed: ${fixedBugs.length} bug(s)
+`));
+          for (const bug of fixedBugs.slice(0, 10)) {
+            console.log(chalk5.green(`   \u2713 ${formatBugType(bug.type)} in ${bug.file}:${bug.lineStart}`));
+          }
+          if (fixedBugs.length > 10) {
+            console.log(chalk5.gray(`   ... and ${fixedBugs.length - 10} more`));
+          }
+          console.log();
+        }
+        if (failedBugs.length > 0) {
+          console.log(chalk5.red.bold(`\u274C Failed: ${failedBugs.length} bug(s)
+`));
+          for (const bug of failedBugs.slice(0, 5)) {
+            console.log(chalk5.red(`   \u2717 ${formatBugType(bug.type)} in ${bug.file}:${bug.lineStart}`));
+          }
+          console.log();
+        }
+        if (skippedBugs.length > 0) {
+          console.log(chalk5.yellow.bold(`\u26A0\uFE0F  Skipped (manual review needed): ${skippedBugs.length} bug(s)
+`));
+          for (const bug of skippedBugs.slice(0, 5)) {
+            console.log(chalk5.yellow(`   \u2192 ${formatBugType(bug.type)} in ${bug.file}:${bug.lineStart}`));
+          }
+          console.log();
+        }
+        console.log(chalk5.cyan("\u2501".repeat(50)));
+        console.log(chalk5.bold("  Summary"));
+        console.log(chalk5.cyan("\u2501".repeat(50)));
+        console.log();
+        console.log(`   Bugs found:    ${result.stats.bugsFound}`);
+        console.log(`   Bugs fixed:    ${chalk5.green(result.stats.bugsFixed.toString())}`);
+        console.log(`   Bugs failed:   ${result.stats.bugsFailed > 0 ? chalk5.red(result.stats.bugsFailed.toString()) : "0"}`);
+        console.log(`   Bugs skipped:  ${result.stats.bugsSkipped}`);
+        console.log(`   Success rate:  ${(result.stats.successRate * 100).toFixed(1)}%`);
+        console.log(`   Duration:      ${(result.stats.totalDurationMs / 1e3).toFixed(1)}s`);
+        console.log(`   Stop reason:   ${result.stats.stopReason}`);
+        console.log();
+        if (argv.dryRun) {
+          console.log(chalk5.yellow("  \u2139\uFE0F  This was a dry run. Run without --dry-run to apply fixes.\n"));
+        }
+      } else {
+        console.log(JSON.stringify({
+          found: result.stats.bugsFound,
+          fixed: result.stats.bugsFixed,
+          failed: result.stats.bugsFailed,
+          skipped: result.stats.bugsSkipped,
+          successRate: result.stats.successRate,
+          durationMs: result.stats.totalDurationMs
+        }));
+      }
+      if (result.stats.bugsFailed > 0) {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      spinner.fail(chalk5.red(`Error: ${error.message}`));
+      logger.error("Bugfix command failed", { error: error.message });
+      process.exitCode = 1;
+    }
+  }
+};
+
 // src/cli/index.ts
 installExitHandlers();
 var VERSION2 = getVersion();
@@ -55596,7 +57276,7 @@ globalTracker.mark("cli_start");
       type: "string",
       description: "Path to custom config file",
       global: true
-    }).command(setupCommand).command(initCommand).command(configureCommand).command(agentCommand).command(listCommand).command(runCommand).command(resumeCommand).command(runsCommand).command(sessionCommand).command(workspaceCommand).command(cacheCommand).command(configCommand).command(statusCommand4).command(doctorCommand2).command(cleanupCommand2).command(analyticsCommand).command(memoryCommand).command(mcpCommand).command(geminiCommand).command(providerLimitsCommand).command(providersCommand).command(flagsCommand).command(specCommand).command(genCommand).command(updateCommand).command(uninstallCommand).command(modeCommand).command(debugInstructionsCommand).command(planCommand).command(iterateCommand).command(reviewCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
+    }).command(setupCommand).command(initCommand).command(configureCommand).command(agentCommand).command(listCommand).command(runCommand).command(resumeCommand).command(runsCommand).command(sessionCommand).command(workspaceCommand).command(cacheCommand).command(configCommand).command(statusCommand4).command(doctorCommand2).command(cleanupCommand2).command(analyticsCommand).command(memoryCommand).command(mcpCommand).command(geminiCommand).command(providerLimitsCommand).command(providersCommand).command(flagsCommand).command(specCommand).command(genCommand).command(updateCommand).command(uninstallCommand).command(modeCommand).command(debugInstructionsCommand).command(planCommand).command(iterateCommand).command(reviewCommand).command(bugfixCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
     globalTracker.mark("yargs_parse_end");
     globalTracker.measure("yargs_parsing", "yargs_parse_start", "yargs_parse_end");
     globalTracker.mark("options_setup_start");