@defai.digital/automatosx 12.7.0 → 12.8.2

package/dist/mcp/index.js

@@ -868,9 +868,9 @@ function createSafeTimeout(callback, delayMs, options = {}) {
   return cleanup;
 }
 async function sleep(ms, signal) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const timeoutId = setTimeout(() => {
-      resolve5();
+      resolve6();
     }, ms);
     if (timeoutId.unref) {
       timeoutId.unref();
@@ -1007,7 +1007,7 @@ var init_process_manager = __esm({
           if (child.killed || child.exitCode !== null) {
             continue;
           }
-          killPromises.push(new Promise((resolve5) => {
+          killPromises.push(new Promise((resolve6) => {
             let mainTimeoutId = null;
             let fallbackTimeoutId = null;
             let resolved = false;
@@ -1022,7 +1022,7 @@ var init_process_manager = __esm({
               }
               if (!resolved) {
                 resolved = true;
-                resolve5();
+                resolve6();
               }
             };
             child.once("exit", () => {
@@ -1047,8 +1047,8 @@ var init_process_manager = __esm({
         try {
           await Promise.race([
             Promise.all(killPromises),
-            new Promise((resolve5) => {
-              finalTimeoutId = setTimeout(resolve5, timeout);
+            new Promise((resolve6) => {
+              finalTimeoutId = setTimeout(resolve6, timeout);
             })
           ]);
         } finally {
@@ -2704,7 +2704,7 @@ var init_base_provider = __esm({
        * @returns Promise resolving to stdout and stderr
        */
       async executeWithSpawn(command, cliCommand) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const child = spawn(command, [], {
             shell: true,
             // Auto-detects: cmd.exe on Windows, /bin/sh on Unix
@@ -2795,7 +2795,7 @@ var init_base_provider = __esm({
               if (progressParser) {
                 progressParser.succeed(`${cliCommand} completed successfully`);
               }
-              resolve5({ stdout, stderr });
+              resolve6({ stdout, stderr });
             } else if (signal) {
               if (progressParser) {
                 progressParser.fail(`${cliCommand} killed by signal ${signal}`);
@@ -2855,7 +2855,7 @@ var init_base_provider = __esm({
        * @returns Promise resolving to stdout and stderr
        */
       async executeWithStdin(cliCommand, cliArgs, prompt) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           logger.debug(`Executing ${cliCommand} CLI with stdin`, {
             command: cliCommand,
             args: cliArgs,
@@ -2983,7 +2983,7 @@ var init_base_provider = __esm({
               if (progressParser) {
                 progressParser.succeed(`${cliCommand} completed successfully`);
               }
-              resolve5({ stdout, stderr });
+              resolve6({ stdout, stderr });
             } else if (signal) {
               if (progressParser) {
                 progressParser.fail(`${cliCommand} killed by signal ${signal}`);
@@ -3779,7 +3779,7 @@ var init_cli_wrapper = __esm({
        * Spawn codex process
        */
       async spawnProcess(args2, prompt, timeout) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           let stdout = "";
           let stderr = "";
           let hasTimedOut = false;
@@ -3836,7 +3836,7 @@ var init_cli_wrapper = __esm({
               return;
             }
             if (code === 0) {
-              resolve5({ stdout, stderr, exitCode: code });
+              resolve6({ stdout, stderr, exitCode: code });
             } else {
               reject(
                 new CodexError(
@@ -3869,7 +3869,7 @@ var init_cli_wrapper = __esm({
        * Spawn codex process with streaming support
        */
       async spawnProcessWithStreaming(args2, prompt, timeout, renderer) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           let stdout = "";
           let stderr = "";
           let hasTimedOut = false;
@@ -3949,7 +3949,7 @@ var init_cli_wrapper = __esm({
               if (renderer) {
                 renderer.succeed("Execution complete");
               }
-              resolve5({ stdout, stderr, exitCode: code });
+              resolve6({ stdout, stderr, exitCode: code });
             } else {
               if (renderer) {
                 renderer.fail(`Process exited with code ${code}`);
@@ -6086,7 +6086,7 @@ var init_cli_wrapper2 = __esm({
        * Spawn CLI process and get output
        */
       spawnCLI(args2, prompt) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const process2 = spawn(this.config.command, args2, {
             stdio: ["pipe", "pipe", "pipe"],
             timeout: this.config.timeout
@@ -6104,7 +6104,7 @@ var init_cli_wrapper2 = __esm({
           });
           process2.on("close", (code) => {
             if (code === 0) {
-              resolve5(stdout);
+              resolve6(stdout);
             } else {
               reject(new Error(
                 `CLI exited with code ${code}: ${stderr || "No error message"}`
@@ -7046,7 +7046,7 @@ var init_cli_wrapper3 = __esm({
        * Spawn CLI process and get output
        */
       spawnCLI(args2, prompt) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const process2 = spawn(this.config.command, args2, {
             stdio: ["pipe", "pipe", "pipe"],
             timeout: this.config.timeout
@@ -7064,7 +7064,7 @@ var init_cli_wrapper3 = __esm({
           });
           process2.on("close", (code) => {
             if (code === 0) {
-              resolve5(stdout);
+              resolve6(stdout);
             } else {
               reject(new Error(
                 `CLI exited with code ${code}: ${stderr || "No error message"}`
@@ -7951,7 +7951,7 @@ var init_cli_wrapper4 = __esm({
           return this.createMockResponse(request.prompt);
         }
         const startTime = Date.now();
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const args2 = [];
           if (this.config.vlmSwitchMode !== "once") {
             args2.push("--vlm-switch-mode", this.config.vlmSwitchMode);
@@ -8045,7 +8045,7 @@ ${request.prompt}`;
             }
             if ((code === 0 || code === null) && !signal) {
               const content = this.parseResponse(stdout);
-              resolve5({
+              resolve6({
                 content: content.trim(),
                 model: "qwen-code-cli",
                 tokensUsed: {
@@ -9713,7 +9713,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.7.0"
+  "version": "12.8.2"
 };
 
 // src/core/config/schemas.ts
@@ -12447,6 +12447,778 @@ var CircuitBreaker = class {
   }
 };
 
+// src/core/router/affinity-manager.ts
+init_esm_shims();
+init_logger();
+var RouterAffinityManager = class {
+  routingConfig;
+  agentAffinities;
+  constructor(routingConfig) {
+    this.routingConfig = routingConfig;
+    this.agentAffinities = routingConfig?.agentAffinities ?? {};
+    logger.debug("RouterAffinityManager initialized", {
+      hasConfig: !!routingConfig,
+      agentCount: Object.keys(this.agentAffinities).length,
+      autoConfigured: routingConfig?.autoConfigured
+    });
+  }
+  /**
+   * Update routing configuration at runtime
+   */
+  updateConfig(routingConfig) {
+    this.routingConfig = routingConfig;
+    this.agentAffinities = routingConfig.agentAffinities ?? {};
+    logger.debug("RouterAffinityManager config updated", {
+      agentCount: Object.keys(this.agentAffinities).length,
+      strategy: routingConfig.strategy
+    });
+  }
+  /**
+   * Get affinity configuration for a specific agent
+   *
+   * @param agentName - Name of the agent
+   * @returns AffinityLookupResult with primary provider and fallback chain
+   */
+  getAgentAffinity(agentName) {
+    const affinity = this.agentAffinities[agentName];
+    if (affinity) {
+      return {
+        hasAffinity: true,
+        primary: affinity.primary,
+        fallback: affinity.fallback,
+        source: "config"
+      };
+    }
+    return {
+      hasAffinity: false,
+      primary: null,
+      fallback: [],
+      source: "default"
+    };
+  }
+  /**
+   * Reorder providers based on agent affinity
+   *
+   * If an agent has configured affinities, reorders the available providers
+   * to prioritize the primary provider and fallback chain.
+   *
+   * @param options - Agent name and available providers
+   * @returns Reordered provider names, or original order if no affinity
+   */
+  reorderByAffinity(options) {
+    const { agentName, availableProviders } = options;
+    if (availableProviders.length <= 1) {
+      return availableProviders;
+    }
+    const affinity = this.getAgentAffinity(agentName);
+    if (!affinity.hasAffinity || !affinity.primary) {
+      logger.debug("No affinity configured, using default order", {
+        agentName,
+        source: affinity.source
+      });
+      return availableProviders;
+    }
+    const reordered = [];
+    const used = /* @__PURE__ */ new Set();
+    if (affinity.primary && availableProviders.includes(affinity.primary)) {
+      reordered.push(affinity.primary);
+      used.add(affinity.primary);
+    }
+    for (const fallback of affinity.fallback) {
+      if (availableProviders.includes(fallback) && !used.has(fallback)) {
+        reordered.push(fallback);
+        used.add(fallback);
+      }
+    }
+    for (const provider of availableProviders) {
+      if (!used.has(provider)) {
+        reordered.push(provider);
+        used.add(provider);
+      }
+    }
+    logger.debug("Providers reordered by affinity", {
+      agentName,
+      original: availableProviders,
+      reordered,
+      primary: affinity.primary,
+      fallbackChain: affinity.fallback
+    });
+    return reordered;
+  }
+  /**
+   * Check if affinity-based routing is enabled
+   */
+  isEnabled() {
+    return !!this.routingConfig?.autoConfigured && Object.keys(this.agentAffinities).length > 0;
+  }
+  /**
+   * Get all configured agent affinities
+   */
+  getAllAffinities() {
+    return { ...this.agentAffinities };
+  }
+  /**
+   * Get affinity statistics for observability
+   */
+  getStats() {
+    return {
+      enabled: this.isEnabled(),
+      agentCount: Object.keys(this.agentAffinities).length,
+      strategy: this.routingConfig?.strategy,
+      lastConfiguredAt: this.routingConfig?.lastConfiguredAt
+    };
+  }
+};
+
+// src/core/router/ability-manager.ts
+init_esm_shims();
+init_logger();
+var ABILITY_TYPES = [
+  "code-generation",
+  "code-review",
+  "security-audit",
+  "documentation",
+  "data-analysis",
+  "architecture",
+  "testing",
+  "devops",
+  "research",
+  "creative"
+];
+var DEFAULT_ABILITY_ROUTING = {
+  "code-generation": ["claude-code", "codex", "qwen", "gemini-cli"],
+  "code-review": ["gemini-cli", "claude-code", "grok", "codex"],
+  "security-audit": ["claude-code", "grok", "codex"],
+  "documentation": ["gemini-cli", "claude-code", "grok"],
+  "data-analysis": ["gemini-cli", "claude-code", "grok", "qwen"],
+  "architecture": ["claude-code", "gemini-cli", "grok"],
+  "testing": ["gemini-cli", "claude-code", "codex"],
+  "devops": ["codex", "claude-code", "gemini-cli"],
+  "research": ["grok", "gemini-cli", "claude-code"],
+  "creative": ["grok", "gemini-cli", "claude-code"]
+};
+var RouterAbilityManager = class {
+  routingConfig;
+  abilityRouting;
+  constructor(routingConfig) {
+    this.routingConfig = routingConfig;
+    this.abilityRouting = routingConfig?.abilityRouting ?? {};
+    logger.debug("RouterAbilityManager initialized", {
+      hasConfig: !!routingConfig,
+      abilityCount: Object.keys(this.abilityRouting).length,
+      autoConfigured: routingConfig?.autoConfigured
+    });
+  }
+  /**
+   * Update routing configuration at runtime
+   */
+  updateConfig(routingConfig) {
+    this.routingConfig = routingConfig;
+    this.abilityRouting = routingConfig.abilityRouting ?? {};
+    logger.debug("RouterAbilityManager config updated", {
+      abilityCount: Object.keys(this.abilityRouting).length,
+      strategy: routingConfig.strategy
+    });
+  }
+  /**
+   * Get routing configuration for a specific ability type
+   *
+   * @param abilityType - Type of ability (e.g., 'code-generation')
+   * @returns AbilityLookupResult with preferred providers
+   */
+  getAbilityRouting(abilityType) {
+    const routing = this.abilityRouting[abilityType];
+    if (routing) {
+      return {
+        hasRouting: true,
+        preferredProviders: routing.preferredProviders,
+        source: "config"
+      };
+    }
+    const defaultRouting = DEFAULT_ABILITY_ROUTING[abilityType];
+    if (defaultRouting) {
+      return {
+        hasRouting: true,
+        preferredProviders: defaultRouting,
+        source: "default"
+      };
+    }
+    return {
+      hasRouting: false,
+      preferredProviders: [],
+      source: "default"
+    };
+  }
+  /**
+   * Reorder providers based on ability routing
+   *
+   * If an ability has configured routing, reorders the available providers
+   * to prioritize those best suited for the ability type.
+   *
+   * @param options - Ability type and available providers
+   * @returns Reordered provider names, or original order if no routing
+   */
+  reorderByAbility(options) {
+    const { abilityType, availableProviders } = options;
+    if (availableProviders.length <= 1) {
+      return availableProviders;
+    }
+    const routing = this.getAbilityRouting(abilityType);
+    if (!routing.hasRouting || routing.preferredProviders.length === 0) {
+      logger.debug("No ability routing configured, using default order", {
+        abilityType,
+        source: routing.source
+      });
+      return availableProviders;
+    }
+    const reordered = [];
+    const used = /* @__PURE__ */ new Set();
+    for (const provider of routing.preferredProviders) {
+      if (availableProviders.includes(provider) && !used.has(provider)) {
+        reordered.push(provider);
+        used.add(provider);
+      }
+    }
+    for (const provider of availableProviders) {
+      if (!used.has(provider)) {
+        reordered.push(provider);
+        used.add(provider);
+      }
+    }
+    logger.debug("Providers reordered by ability", {
+      abilityType,
+      original: availableProviders,
+      reordered,
+      preferredProviders: routing.preferredProviders
+    });
+    return reordered;
+  }
+  /**
+   * Check if ability-based routing is enabled
+   */
+  isEnabled() {
+    return !!this.routingConfig?.autoConfigured && Object.keys(this.abilityRouting).length > 0;
+  }
+  /**
+   * Get all configured ability routings
+   */
+  getAllRoutings() {
+    return { ...this.abilityRouting };
+  }
+  /**
+   * Get ability routing statistics for observability
+   */
+  getStats() {
+    return {
+      enabled: this.isEnabled(),
+      abilityCount: Object.keys(this.abilityRouting).length,
+      strategy: this.routingConfig?.strategy,
+      lastConfiguredAt: this.routingConfig?.lastConfiguredAt,
+      configuredAbilities: Object.keys(this.abilityRouting)
+    };
+  }
+  /**
+   * Check if an ability type is valid/known
+   */
+  isKnownAbility(abilityType) {
+    return ABILITY_TYPES.includes(abilityType);
+  }
+  /**
+   * Get all known ability types
+   */
+  getKnownAbilities() {
+    return ABILITY_TYPES;
+  }
+};
+
+// src/core/router/dynamic-optimizer.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_CONFIG3 = {
+  enableAdaptivePriorities: true,
+  enableCostOptimization: true,
+  enableHealthReordering: true,
+  minRequestsForOptimization: 20,
+  optimizationIntervalMs: 5 * 60 * 1e3,
+  // 5 minutes
+  maxHistorySnapshots: 100,
+  weights: {
+    latency: 0.3,
+    quality: 0.35,
+    cost: 0.2,
+    availability: 0.15
+  }
+};
+var STATE_VERSION = 1;
+var DynamicOptimizer = class extends EventEmitter {
+  config;
+  state;
+  metricsTracker;
+  optimizationInterval;
+  isInitialized = false;
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.metricsTracker = getProviderMetricsTracker();
+    this.state = this.createEmptyState();
+    logger.debug("DynamicOptimizer created", {
+      enableAdaptivePriorities: this.config.enableAdaptivePriorities,
+      enableCostOptimization: this.config.enableCostOptimization,
+      enableHealthReordering: this.config.enableHealthReordering,
+      optimizationIntervalMs: this.config.optimizationIntervalMs
+    });
+  }
+  /**
+   * Initialize the optimizer (load persisted state, start optimization loop)
+   */
+  async initialize() {
+    if (this.isInitialized) return;
+    if (this.config.statePath) {
+      await this.loadState();
+    }
+    this.startOptimizationLoop();
+    this.metricsTracker.on("metrics-updated", (provider) => {
+      this.handleMetricsUpdate(provider);
+    });
+    this.isInitialized = true;
+    logger.info("DynamicOptimizer initialized", {
+      hasPersistedState: !!this.config.statePath,
+      providersTracked: Object.keys(this.state.performanceHistory).length
+    });
+  }
+  /**
+   * Get current performance snapshot for a provider
+   */
+  async getPerformanceSnapshot(provider) {
+    const metrics = await this.metricsTracker.getMetrics(provider);
+    if (!metrics) return null;
+    const priorityScore = await this.calculatePriorityScore(provider, metrics);
+    const qualityScore = metrics.quality.successRate * 0.7 + metrics.quality.properStopRate * 0.3;
+    return {
+      provider,
+      avgLatencyMs: metrics.latency.avg,
+      p95LatencyMs: metrics.latency.p95,
+      latency: {
+        avg: metrics.latency.avg,
+        p95: metrics.latency.p95
+      },
+      successRate: metrics.quality.successRate,
+      qualityScore,
+      avgCostPer1M: metrics.cost.avgCostPer1MTokens,
+      totalRequests: metrics.quality.totalRequests,
+      consecutiveFailures: metrics.availability.consecutiveFailures,
+      lastSuccessAt: metrics.availability.lastSuccess,
+      priorityScore,
+      timestamp: Date.now(),
+      lastUpdatedAt: new Date(metrics.lastUpdated).toISOString()
+    };
+  }
+  /**
+   * Get all provider performance snapshots
+   */
+  async getAllPerformanceSnapshots(providers) {
+    const snapshots = [];
+    for (const provider of providers) {
+      const snapshot = await this.getPerformanceSnapshot(provider);
+      if (snapshot) {
+        snapshots.push(snapshot);
+      }
+    }
+    return snapshots.sort((a, b) => b.priorityScore - a.priorityScore);
+  }
+  /**
+   * Calculate adaptive priority for a provider based on performance
+   */
+  async calculatePriorityScore(provider, metrics) {
+    const { weights } = this.config;
+    const latencyScore = this.normalizeLatency(metrics.latency.p95);
+    const qualityScore = metrics.quality.successRate * 0.7 + metrics.quality.properStopRate * 0.3;
+    const costScore = this.normalizeCost(metrics.cost.avgCostPer1MTokens);
+    const availabilityScore = metrics.availability.uptime * (1 - Math.min(metrics.availability.consecutiveFailures * 0.1, 0.5));
+    const score = weights.latency * latencyScore + weights.quality * qualityScore + weights.cost * costScore + weights.availability * availabilityScore;
+    return Math.round(score * 100) / 100;
+  }
+  /**
+   * Normalize latency to 0-1 score (lower latency = higher score)
+   */
+  normalizeLatency(p95Ms) {
+    if (p95Ms < 1e3) return 1;
+    if (p95Ms < 2e3) return 0.9;
+    if (p95Ms < 3e3) return 0.7;
+    if (p95Ms < 5e3) return 0.5;
+    if (p95Ms < 1e4) return 0.3;
+    return 0.1;
+  }
+  /**
+   * Normalize cost to 0-1 score (lower cost = higher score)
+   */
+  normalizeCost(costPer1M) {
+    if (costPer1M === 0) return 1;
+    if (costPer1M < 0.5) return 0.9;
+    if (costPer1M < 2) return 0.7;
+    if (costPer1M < 5) return 0.5;
+    if (costPer1M < 15) return 0.3;
+    return 0.1;
+  }
+  /**
+   * Generate optimization recommendations based on current performance
+   */
+  async generateRecommendations(providers) {
+    const recommendations = [];
+    const snapshots = await this.getAllPerformanceSnapshots(providers);
+    if (snapshots.length === 0) {
+      return recommendations;
+    }
+    const currentPriorities = { ...this.state.adaptivePriorities };
+    for (const snapshot of snapshots) {
+      const { provider, priorityScore, successRate, consecutiveFailures, avgCostPer1M } = snapshot;
+      if (consecutiveFailures >= 3) {
+        recommendations.push({
+          type: "health_warning",
+          provider,
+          currentValue: consecutiveFailures,
+          recommendedValue: 0,
+          reason: `Provider has ${consecutiveFailures} consecutive failures`,
+          confidence: 0.9,
+          impact: consecutiveFailures >= 5 ? "high" : "medium"
+        });
+      }
+      if (successRate < 0.5 && snapshot.totalRequests >= this.config.minRequestsForOptimization) {
+        recommendations.push({
+          type: "disable_provider",
+          provider,
+          currentValue: successRate,
+          recommendedValue: "disabled",
+          reason: `Success rate (${(successRate * 100).toFixed(1)}%) is below 50%`,
+          confidence: 0.85,
+          impact: "high"
+        });
+      }
+      if (this.config.enableAdaptivePriorities) {
+        const currentPriority = currentPriorities[provider] ?? 50;
+        const recommendedPriority = this.calculateRecommendedPriority(priorityScore);
+        if (Math.abs(recommendedPriority - currentPriority) >= 5) {
+          recommendations.push({
+            type: "priority_adjustment",
+            provider,
+            currentValue: currentPriority,
+            recommendedValue: recommendedPriority,
+            reason: `Performance score suggests priority change (score: ${priorityScore.toFixed(2)})`,
+            confidence: Math.min(snapshot.totalRequests / 100, 0.95),
+            impact: Math.abs(recommendedPriority - currentPriority) >= 20 ? "high" : "medium"
+          });
+        }
+      }
+      if (this.config.enableCostOptimization && avgCostPer1M > 10) {
+        const cheaperAlternatives = snapshots.filter(
+          (s) => s.provider !== provider && s.avgCostPer1M < avgCostPer1M * 0.5 && s.successRate >= successRate * 0.9
+        );
+        if (cheaperAlternatives.length > 0) {
+          const best = cheaperAlternatives[0];
+          if (best) {
+            recommendations.push({
+              type: "cost_optimization",
+              provider,
+              currentValue: avgCostPer1M,
+              recommendedValue: best.provider,
+              reason: `${best.provider} offers similar quality at ${((1 - best.avgCostPer1M / avgCostPer1M) * 100).toFixed(0)}% lower cost`,
+              confidence: 0.7,
+              impact: "medium"
+            });
+          }
+        }
+      }
+    }
+    return recommendations.sort((a, b) => {
+      const impactOrder = { high: 3, medium: 2, low: 1 };
+      const impactDiff = impactOrder[b.impact] - impactOrder[a.impact];
+      if (impactDiff !== 0) return impactDiff;
+      return b.confidence - a.confidence;
+    });
+  }
+  /**
+   * Calculate recommended priority based on score
+   */
+  calculateRecommendedPriority(score) {
+    return Math.round(100 - score * 90);
+  }
+  /**
+   * Apply an optimization recommendation
+   */
+  async applyRecommendation(recommendation) {
+    try {
+      switch (recommendation.type) {
+        case "priority_adjustment":
+          this.state.adaptivePriorities[recommendation.provider] = recommendation.recommendedValue;
+          break;
+        case "disable_provider":
+          this.state.adaptivePriorities[recommendation.provider] = 999;
+          break;
+        case "health_warning":
+        case "cost_optimization":
+          break;
+      }
+      this.state.appliedOptimizations.push({
+        recommendation,
+        appliedAt: Date.now()
+      });
+      await this.saveState();
+      this.emit("optimization-applied", recommendation);
+      logger.info("Optimization recommendation applied", {
+        type: recommendation.type,
+        provider: recommendation.provider,
+        recommendedValue: recommendation.recommendedValue
+      });
+      return true;
+    } catch (error) {
+      logger.error("Failed to apply optimization", {
+        recommendation,
+        error: error.message
+      });
+      return false;
+    }
+  }
+  /**
+   * Get adaptive priorities for provider reordering
+   */
+  getAdaptivePriorities() {
+    return { ...this.state.adaptivePriorities };
+  }
+  /**
+   * Reorder providers based on adaptive priorities and health
+   */
+  async reorderByPerformance(providers, healthStatus) {
+    if (!this.config.enableHealthReordering && !this.config.enableAdaptivePriorities) {
+      return providers;
+    }
+    const snapshots = await this.getAllPerformanceSnapshots(providers);
+    const snapshotMap = new Map(snapshots.map((s) => [s.provider, s]));
+    const sorted = [...providers].sort((a, b) => {
+      if (this.config.enableHealthReordering) {
+        const aHealthy = healthStatus.get(a) ?? true;
+        const bHealthy = healthStatus.get(b) ?? true;
+        if (aHealthy !== bHealthy) {
+          return aHealthy ? -1 : 1;
+        }
+      }
+      if (this.config.enableAdaptivePriorities) {
+        const aPriority = this.state.adaptivePriorities[a] ?? 50;
+        const bPriority = this.state.adaptivePriorities[b] ?? 50;
+        if (aPriority !== bPriority) {
+          return aPriority - bPriority;
+        }
+      }
+      const aSnapshot = snapshotMap.get(a);
+      const bSnapshot = snapshotMap.get(b);
+      const aScore = aSnapshot?.priorityScore ?? 0.5;
+      const bScore = bSnapshot?.priorityScore ?? 0.5;
+      return bScore - aScore;
+    });
+    logger.debug("Providers reordered by performance", {
+      original: providers,
+      reordered: sorted
+    });
+    return sorted;
+  }
+  /**
+   * Track cost for a request
+   */
+  trackCost(provider, costUsd) {
+    this.state.costTracking.totalCostUsd += costUsd;
+    this.state.costTracking.costByProvider[provider] = (this.state.costTracking.costByProvider[provider] ?? 0) + costUsd;
+  }
+  /**
+   * Get cost tracking summary
+   */
+  getCostSummary() {
+    const costByProvider = { ...this.state.costTracking.costByProvider };
+    const topSpenders = Object.entries(costByProvider).map(([provider, costUsd]) => ({ provider, costUsd })).sort((a, b) => b.costUsd - a.costUsd).slice(0, 5);
+    return {
+      totalCostUsd: this.state.costTracking.totalCostUsd,
+      costByProvider,
+      topSpenders
+    };
+  }
+  /**
+   * Get optimizer statistics
+   */
+  getStats() {
+    return {
+      isInitialized: this.isInitialized,
+      lastOptimizationAt: this.state.lastOptimizationAt,
+      providersTracked: Object.keys(this.state.performanceHistory).length,
+      totalAppliedOptimizations: this.state.appliedOptimizations.length,
+      adaptivePriorities: { ...this.state.adaptivePriorities },
+      costTracking: {
+        totalCostUsd: this.state.costTracking.totalCostUsd,
+        sinceReset: new Date(this.state.costTracking.lastResetAt).toISOString()
+      }
+    };
+  }
+  /**
+   * Reset cost tracking
+   */
+  resetCostTracking() {
+    this.state.costTracking = {
+      totalCostUsd: 0,
+      costByProvider: {},
+      lastResetAt: Date.now()
+    };
+    this.emit("cost-tracking-reset");
+  }
+  /**
+   * Handle metrics update event
+   */
+  async handleMetricsUpdate(provider) {
+    try {
+      const snapshot = await this.getPerformanceSnapshot(provider);
+      if (!snapshot) return;
+      if (!this.state.performanceHistory[provider]) {
+        this.state.performanceHistory[provider] = [];
+      }
+      const history = this.state.performanceHistory[provider];
+      history.push(snapshot);
+      if (history.length > this.config.maxHistorySnapshots) {
+        history.splice(0, history.length - this.config.maxHistorySnapshots);
+      }
+      this.emit("performance-updated", provider, snapshot);
+    } catch (error) {
+      logger.warn("Failed to handle metrics update", {
+        provider,
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Start the optimization loop
+   */
+  startOptimizationLoop() {
+    if (this.optimizationInterval) return;
+    this.optimizationInterval = setInterval(async () => {
+      try {
+        await this.runOptimization();
+      } catch (error) {
+        logger.error("Optimization loop failed", {
+          error: error.message
+        });
+      }
+    }, this.config.optimizationIntervalMs);
+    this.optimizationInterval.unref();
+    logger.debug("Optimization loop started", {
+      intervalMs: this.config.optimizationIntervalMs
+    });
+  }
+  /**
+   * Run optimization analysis
+   */
+  async runOptimization() {
+    const providers = Object.keys(this.state.performanceHistory);
+    if (providers.length === 0) return;
+    const hasEnoughData = providers.some((p) => {
+      const history = this.state.performanceHistory[p];
+      return history && history.length >= this.config.minRequestsForOptimization;
+    });
+    if (!hasEnoughData) return;
+    const recommendations = await this.generateRecommendations(providers);
+    this.state.lastOptimizationAt = Date.now();
+    if (recommendations.length > 0) {
+      this.emit("recommendations-generated", recommendations);
+      logger.info("Optimization recommendations generated", {
+        count: recommendations.length,
+        types: recommendations.map((r) => r.type)
+      });
+      for (const rec of recommendations) {
+        if (rec.type === "priority_adjustment" && rec.confidence >= 0.8 && this.config.enableAdaptivePriorities) {
+          await this.applyRecommendation(rec);
+        }
+      }
+    }
+    await this.saveState();
+  }
+  /**
+   * Create empty state
+   */
+  createEmptyState() {
+    return {
+      version: STATE_VERSION,
+      lastOptimizationAt: 0,
+      performanceHistory: {},
+      appliedOptimizations: [],
+      adaptivePriorities: {},
+      costTracking: {
+        totalCostUsd: 0,
+        costByProvider: {},
+        lastResetAt: Date.now()
+      }
+    };
+  }
+  /**
+   * Load state from disk
+   */
+  async loadState() {
+    if (!this.config.statePath) return;
+    try {
+      const data = await readFile(this.config.statePath, "utf-8");
+      const loaded = JSON.parse(data);
+      if (loaded.version !== STATE_VERSION) {
+        logger.warn("State version mismatch, starting fresh", {
+          expected: STATE_VERSION,
+          found: loaded.version
+        });
+        return;
+      }
+      this.state = loaded;
+      logger.info("DynamicOptimizer state loaded", {
+        providersTracked: Object.keys(this.state.performanceHistory).length,
+        appliedOptimizations: this.state.appliedOptimizations.length
+      });
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        logger.warn("Failed to load optimizer state", {
+          error: error.message
+        });
+      }
+    }
+  }
+  /**
+   * Save state to disk
+   */
+  async saveState() {
+    if (!this.config.statePath) return;
+    try {
+      await mkdir(dirname(this.config.statePath), { recursive: true });
+      const tmpPath = `${this.config.statePath}.tmp`;
+      await writeFile(tmpPath, JSON.stringify(this.state, null, 2));
+      const { rename: rename2 } = await import('fs/promises');
+      await rename2(tmpPath, this.config.statePath);
+      logger.debug("DynamicOptimizer state saved");
+    } catch (error) {
+      logger.warn("Failed to save optimizer state", {
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Stop the optimizer and clean up
+   */
+  destroy() {
+    if (this.optimizationInterval) {
+      clearInterval(this.optimizationInterval);
+      this.optimizationInterval = void 0;
+    }
+    this.removeAllListeners();
+    this.isInitialized = false;
+    logger.debug("DynamicOptimizer destroyed");
+  }
+};
+var globalOptimizer = null;
+function getDynamicOptimizer(config) {
+  if (!globalOptimizer) {
+    globalOptimizer = new DynamicOptimizer(config);
+  }
+  return globalOptimizer;
+}
+
 // src/core/router/trace-logger.ts
 init_esm_shims();
 init_logger();
@@ -12843,6 +13615,12 @@ var Router = class {
   tracer;
   // v9.0.2: Extracted circuit breaker (better modularity and testability)
   circuitBreaker;
+  // v13.1.0: Agent-provider affinity routing
+  affinityManager;
+  // v13.2.0: Ability-based provider routing
+  abilityManager;
+  // v14.0.0: Dynamic performance optimization
+  dynamicOptimizer;
   constructor(config) {
     this.routerConfig = config;
     this.providers = [...config.providers].sort((a, b) => {
@@ -12874,6 +13652,37 @@ var Router = class {
         weights: strategyManager.getWeights()
       });
     }
+    this.affinityManager = new RouterAffinityManager(config.agentAffinities);
+    if (this.affinityManager.isEnabled()) {
+      const stats = this.affinityManager.getStats();
+      logger.info("Agent affinity routing enabled", {
+        agentCount: stats.agentCount,
+        strategy: stats.strategy,
+        lastConfiguredAt: stats.lastConfiguredAt
+      });
+    }
+    this.abilityManager = new RouterAbilityManager(config.agentAffinities);
+    if (this.abilityManager.isEnabled()) {
+      const stats = this.abilityManager.getStats();
+      logger.info("Ability routing enabled", {
+        abilityCount: stats.abilityCount,
+        configuredAbilities: stats.configuredAbilities
+      });
+    }
+    if (config.enableDynamicOptimization) {
+      this.dynamicOptimizer = getDynamicOptimizer(config.dynamicOptimizer);
+      void this.dynamicOptimizer.initialize().then(() => {
+        const stats = this.dynamicOptimizer?.getStats();
+        logger.info("Dynamic optimization enabled", {
+          isInitialized: stats?.isInitialized,
+          providersTracked: stats?.providersTracked
+        });
+      }).catch((err) => {
+        logger.warn("Failed to initialize DynamicOptimizer", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }
     if (config.workspacePath && config.enableTracing !== false) {
       this.tracer = createTraceLogger(config.workspacePath, config.enableTracing ?? true);
       logger.debug("Router trace logging enabled", {
@@ -12936,8 +13745,12 @@ var Router = class {
   }
   /**
    * Execute request with automatic provider fallback
+   * v13.1.0: Added options parameter for agent-specific affinity routing
+   *
+   * @param request - Execution request
+   * @param options - Optional execution options including agentName for affinity routing
    */
-  async execute(request) {
+  async execute(request, options) {
     const timer = new PerformanceTimer(
       "Router" /* ROUTER */,
       "execute",
@@ -12997,6 +13810,42 @@ var Router = class {
       throw ProviderError.noAvailableProviders();
     }
     let providersToTry = availableProviders;
+    const agentName = options?.agentName;
+    if (agentName && this.affinityManager.isEnabled()) {
+      const providerNames = availableProviders.map((p) => p.name);
+      const reorderedNames = this.affinityManager.reorderByAffinity({
+        agentName,
+        availableProviders: providerNames
+      });
+      providersToTry = reorderedNames.map((name) => availableProviders.find((p) => p.name === name)).filter((p) => p !== void 0);
+      const firstProvider = providersToTry[0];
+      if (providersToTry.length > 0 && firstProvider) {
+        logger.debug("Provider order adjusted by agent affinity", {
+          agentName,
+          originalOrder: providerNames,
+          affinityOrder: reorderedNames,
+          selected: firstProvider.name
+        });
+      }
+    }
+    const abilityType = options?.abilityType;
+    if (abilityType && this.abilityManager.isEnabled()) {
+      const providerNames = providersToTry.map((p) => p.name);
+      const reorderedNames = this.abilityManager.reorderByAbility({
+        abilityType,
+        availableProviders: providerNames
+      });
+      providersToTry = reorderedNames.map((name) => availableProviders.find((p) => p.name === name)).filter((p) => p !== void 0);
+      const firstProvider = providersToTry[0];
+      if (providersToTry.length > 0 && firstProvider) {
+        logger.debug("Provider order adjusted by ability routing", {
+          abilityType,
+          originalOrder: providerNames,
+          abilityOrder: reorderedNames,
+          selected: firstProvider.name
+        });
+      }
+    }
     if (this.useMultiFactorRouting) {
       const strategyManager = getRoutingStrategyManager();
       const providerNames = providersToTry.map((p) => p.name);
@@ -13031,6 +13880,34 @@ var Router = class {
         });
       }
     }
+    if (this.dynamicOptimizer) {
+      try {
+        const providerNames = providersToTry.map((p) => p.name);
+        const healthStatus = /* @__PURE__ */ new Map();
+        for (const provider of providersToTry) {
+          const isHealthy = !this.circuitBreaker.isOpen(provider.name);
+          healthStatus.set(provider.name, isHealthy);
+        }
+        const optimizedOrder = await this.dynamicOptimizer.reorderByPerformance(
+          providerNames,
+          healthStatus
+        );
+        const originalOrder = providersToTry.map((p) => p.name);
+        providersToTry = optimizedOrder.map((name) => availableProviders.find((p) => p.name === name)).filter((p) => p !== void 0);
+        const firstProvider = providersToTry[0];
+        if (providersToTry.length > 0 && firstProvider && originalOrder[0] !== optimizedOrder[0]) {
+          logger.debug("Provider order adjusted by dynamic optimization", {
+            originalOrder,
+            optimizedOrder,
+            selected: firstProvider.name
+          });
+        }
+      } catch (optimizerError) {
+        logger.warn("Dynamic optimization failed, continuing with current order", {
+          error: optimizerError.message
+        });
+      }
+    }
     let lastError;
     let attemptNumber = 0;
     for (const provider of providersToTry) {
@@ -13485,12 +14362,32 @@ Run 'ax doctor' to diagnose provider setup.` : "";
   }
   /**
    * Select best provider based on health and availability
+   * v13.1.0: Added optional agentName for affinity-based selection
+   *
+   * @param agentName - Optional agent name for affinity-based selection
    */
-  async selectProvider() {
+  async selectProvider(agentName) {
     const availableProviders = await this.getAvailableProviders();
     if (availableProviders.length === 0) {
       return null;
     }
+    if (agentName && this.affinityManager.isEnabled()) {
+      const providerNames = availableProviders.map((p) => p.name);
+      const reorderedNames = this.affinityManager.reorderByAffinity({
+        agentName,
+        availableProviders: providerNames
+      });
+      for (const name of reorderedNames) {
+        const provider = availableProviders.find((p) => p.name === name);
+        if (provider) {
+          logger.debug("Provider selected by agent affinity", {
+            agentName,
+            selected: provider.name
+          });
+          return provider;
+        }
+      }
+    }
     return availableProviders[0] ?? null;
   }
   /**
@@ -13598,6 +14495,10 @@ Run 'ax doctor' to diagnose provider setup.` : "";
       this.tracer.close();
       logger.debug("Router trace logger closed");
     }
+    if (this.dynamicOptimizer) {
+      this.dynamicOptimizer.destroy();
+      logger.debug("Dynamic optimizer destroyed");
+    }
   }
   /**
    * Get circuit breaker stats for observability
@@ -13643,6 +14544,183 @@ Run 'ax doctor' to diagnose provider setup.` : "";
     }
     return Math.min(...limitedProviders.map((p) => p.resetAtMs));
   }
+  /**
+   * Get agent affinity routing stats
+   * v13.1.0: New API for affinity routing observability
+   */
+  getAffinityStats() {
+    return this.affinityManager.getStats();
+  }
+  /**
+   * Update agent affinity configuration at runtime
+   * v13.1.0: Allows updating affinities without recreating the router
+   *
+   * @param routingConfig - New routing configuration
+   */
+  updateAffinityConfig(routingConfig) {
+    this.affinityManager.updateConfig(routingConfig);
+    logger.info("Router affinity config updated", {
+      agentCount: Object.keys(routingConfig.agentAffinities ?? {}).length,
+      strategy: routingConfig.strategy
+    });
+  }
+  /**
+   * Get agent affinity for a specific agent
+   * v13.1.0: For debugging and inspection
+   *
+   * @param agentName - Name of the agent
+   */
+  getAgentAffinity(agentName) {
+    return this.affinityManager.getAgentAffinity(agentName);
+  }
+  /**
+   * Get ability routing stats
+   * v13.2.0: New API for ability routing observability
+   */
+  getAbilityStats() {
+    return this.abilityManager.getStats();
+  }
+  /**
+   * Update ability routing configuration at runtime
+   * v13.2.0: Allows updating ability routing without recreating the router
+   *
+   * @param routingConfig - New routing configuration
+   */
+  updateAbilityConfig(routingConfig) {
+    this.abilityManager.updateConfig(routingConfig);
+    logger.info("Router ability config updated", {
+      abilityCount: Object.keys(routingConfig.abilityRouting ?? {}).length,
+      strategy: routingConfig.strategy
+    });
+  }
+  /**
+   * Get ability routing for a specific ability type
+   * v13.2.0: For debugging and inspection
+   *
+   * @param abilityType - Type of ability (e.g., 'code-generation')
+   */
+  getAbilityRouting(abilityType) {
+    return this.abilityManager.getAbilityRouting(abilityType);
+  }
+  /**
+   * Get all known ability types
+   * v13.2.0: For discovery and validation
+   */
+  getKnownAbilities() {
+    return this.abilityManager.getKnownAbilities();
+  }
+  /**
+   * Check if an ability type is valid/known
+   * v13.2.0: For validation
+   */
+  isKnownAbility(abilityType) {
+    return this.abilityManager.isKnownAbility(abilityType);
+  }
+  // ============================================================================
+  // v14.0.0: Dynamic Optimization API
+  // ============================================================================
+  /**
+   * Check if dynamic optimization is enabled
+   * v14.0.0: For feature detection
+   */
+  isDynamicOptimizationEnabled() {
+    return this.dynamicOptimizer !== void 0;
+  }
+  /**
+   * Get dynamic optimizer stats
+   * v14.0.0: For monitoring and debugging
+   */
+  getDynamicOptimizerStats() {
+    if (!this.dynamicOptimizer) {
+      return null;
+    }
+    const stats = this.dynamicOptimizer.getStats();
+    const costSummary = this.dynamicOptimizer.getCostSummary();
+    return {
+      enabled: true,
+      isInitialized: stats.isInitialized,
+      lastOptimizationAt: stats.lastOptimizationAt > 0 ? new Date(stats.lastOptimizationAt).toISOString() : null,
+      providersTracked: stats.providersTracked,
+      totalCostUsd: costSummary.totalCostUsd,
+      adaptivePriorities: this.dynamicOptimizer.getAdaptivePriorities()
+    };
+  }
+  /**
+   * Get optimization recommendations for providers
+   * v14.0.0: Returns suggestions for improving provider performance
+   *
+   * @param providers - Optional list of providers to get recommendations for
+   */
+  async getOptimizationRecommendations(providers) {
+    if (!this.dynamicOptimizer) {
+      return [];
+    }
+    const targetProviders = providers ?? this.providers.map((p) => p.name);
+    return this.dynamicOptimizer.generateRecommendations(targetProviders);
+  }
+  /**
+   * Get performance snapshot for a specific provider
+   * v14.0.0: For detailed provider performance analysis
+   *
+   * @param providerName - Name of the provider
+   */
+  async getProviderPerformanceSnapshot(providerName) {
+    if (!this.dynamicOptimizer) {
+      return null;
+    }
+    return this.dynamicOptimizer.getPerformanceSnapshot(providerName);
+  }
+  /**
+   * Track cost for a provider
+   * v14.0.0: For cost optimization tracking
+   *
+   * @param providerName - Name of the provider
+   * @param costUsd - Cost in USD
+   */
+  trackProviderCost(providerName, costUsd) {
+    if (this.dynamicOptimizer) {
+      this.dynamicOptimizer.trackCost(providerName, costUsd);
+    }
+  }
+  /**
+   * Get cost summary across all providers
+   * v14.0.0: For cost monitoring
+   */
+  getCostSummary() {
+    if (!this.dynamicOptimizer) {
+      return null;
+    }
+    return this.dynamicOptimizer.getCostSummary();
+  }
+  /**
+   * Apply an optimization recommendation
+   * v14.0.0: Manually apply a generated recommendation
+   *
+   * @param recommendation - The recommendation to apply
+   */
+  async applyOptimizationRecommendation(recommendation) {
+    if (!this.dynamicOptimizer) {
+      return false;
+    }
+    return this.dynamicOptimizer.applyRecommendation(recommendation);
+  }
+  /**
+   * Update dynamic optimizer configuration at runtime
+   * v14.0.0: Allows updating optimizer settings without recreating the router
+   *
+   * @param config - Partial configuration to update
+   */
+  updateDynamicOptimizerConfig(config) {
+    if (!this.dynamicOptimizer) {
+      logger.warn("Cannot update optimizer config - dynamic optimization not enabled");
+      return;
+    }
+    logger.info("Dynamic optimizer config update requested", {
+      enableAdaptivePriorities: config.enableAdaptivePriorities,
+      enableCostOptimization: config.enableCostOptimization,
+      enableHealthReordering: config.enableHealthReordering
+    });
+  }
 };
 
 // src/core/memory/lazy-manager.ts
@@ -14891,9 +15969,9 @@ var MemoryManager = class _MemoryManager {
       throw new MemoryError("Memory manager not initialized", "DATABASE_ERROR");
     }
     try {
-      const { mkdir: mkdir5 } = await import('fs/promises');
+      const { mkdir: mkdir6 } = await import('fs/promises');
       const destDir = dirname3(destPath);
-      await mkdir5(destDir, { recursive: true });
+      await mkdir6(destDir, { recursive: true });
       await this.db.backup(destPath);
       logger.info("Database backup created", { destPath: normalizePath(destPath) });
     } catch (error) {
@@ -15049,9 +16127,9 @@ var MemoryManager = class _MemoryManager {
         },
         entries
       };
-      const { writeFile: writeFile7 } = await import('fs/promises');
+      const { writeFile: writeFile8 } = await import('fs/promises');
       const json = pretty ? JSON.stringify(exportData, null, 2) : JSON.stringify(exportData);
-      await writeFile7(filePath, json, "utf-8");
+      await writeFile8(filePath, json, "utf-8");
       const sizeBytes = Buffer.byteLength(json, "utf-8");
       logger.info("Memory exported to JSON", {
         filePath: normalizePath(filePath),
@@ -15100,8 +16178,8 @@ var MemoryManager = class _MemoryManager {
           { filePath }
         );
       }
-      const { readFile: readFile13 } = await import('fs/promises');
-      const content = await readFile13(filePath, "utf-8");
+      const { readFile: readFile14 } = await import('fs/promises');
+      const content = await readFile14(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)) {
@@ -16750,7 +17828,8 @@ init_esm_shims();
 init_esm_shims();
 init_logger();
 var MAX_CONTEXT_SIZE = 100 * 1024;
-var DEFAULT_CACHE_TTL = 3e5;
+var MAX_SUMMARY_SIZE = 10 * 1024;
+var DEFAULT_CACHE_TTL = 6e4;
 var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 var ProjectContextLoader = class {
   constructor(projectRoot, options) {
@@ -16762,6 +17841,11 @@ var ProjectContextLoader = class {
   cacheTTL;
   /**
    * Load project context with caching
+   *
+   * Token-saving strategy:
+   * 1. First try ax.summary.json (fast path, ~500 tokens)
+   * 2. Fall back to generating summary from ax.index.json if missing
+   * 3. Context prompt tells AI to read ax.index.json for full details
    */
   async load() {
     if (this.cache && this.cacheExpiry && Date.now() < this.cacheExpiry) {
@@ -16774,37 +17858,98 @@ var ProjectContextLoader = class {
       projectRoot: this.projectRoot
     });
     const context = {};
+    const summaryLoaded = await this.loadSummary(context);
+    await this.loadIndex(context);
+    if (!summaryLoaded && context.index) {
+      context.summary = this.generateDynamicSummary(context.index);
+      logger.info("Generated dynamic summary from ax.index.json");
+    }
+    await this.loadCustomInstructions(context);
+    context.contextPrompt = this.buildContextPrompt(context);
+    this.cache = context;
+    this.cacheExpiry = Date.now() + this.cacheTTL;
+    logger.info("Project context loaded", {
+      hasSummary: !!context.summary,
+      hasIndex: !!context.index,
+      hasCustomInstructions: !!context.customInstructions,
+      guardrails: context.guardrails?.length ?? 0,
+      guardrailConflicts: context.guardrailConflicts?.length ?? 0,
+      commands: Object.keys(context.commands ?? {}).length,
+      isStale: context.isStale
+    });
+    return context;
+  }
+  /**
+   * Load ax.summary.json (fast path)
+   * Returns true if summary was loaded successfully
+   */
+  async loadSummary(context) {
+    try {
+      const summaryPath = path4__default.join(this.projectRoot, "ax.summary.json");
+      const resolvedPath = await realpath(summaryPath).catch(() => null);
+      if (!resolvedPath) return false;
+      const rel = path4__default.relative(this.projectRoot, resolvedPath);
+      if (rel.startsWith("..") || path4__default.isAbsolute(rel)) return false;
+      const stats = await stat(resolvedPath);
+      if (stats.size > MAX_SUMMARY_SIZE) {
+        logger.warn("ax.summary.json too large, ignoring", {
+          size: stats.size,
+          limit: MAX_SUMMARY_SIZE
+        });
+        return false;
+      }
+      const summaryContent = await readFile(resolvedPath, "utf-8");
+      context.summary = JSON.parse(summaryContent);
+      if (context.summary.commands) {
+        context.commands = { ...context.summary.commands };
+      }
+      logger.info("Loaded ax.summary.json (fast path)", {
+        projectName: context.summary.project.name,
+        projectType: context.summary.project.type,
+        techStack: context.summary.techStack.length
+      });
+      return true;
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code !== "ENOENT") {
+        logger.warn("Error loading ax.summary.json", { error });
+      }
+      return false;
+    }
+  }
+  /**
+   * Load ax.index.json (full analysis)
+   * Used for staleness check and fallback summary generation
+   */
+  async loadIndex(context) {
     try {
       const indexPath = path4__default.join(this.projectRoot, "ax.index.json");
       const resolvedPath = await realpath(indexPath).catch(() => null);
-      if (resolvedPath) {
-        const rel = path4__default.relative(this.projectRoot, resolvedPath);
-        if (!rel.startsWith("..") && !path4__default.isAbsolute(rel)) {
-          const stats = await stat(resolvedPath);
-          if (stats.size > MAX_CONTEXT_SIZE) {
-            logger.warn("ax.index.json too large, ignoring", {
-              size: stats.size,
-              limit: MAX_CONTEXT_SIZE
-            });
-          } else {
-            const indexContent = await readFile(resolvedPath, "utf-8");
-            context.index = JSON.parse(indexContent);
-            context.lastUpdated = stats.mtime;
-            const age = Date.now() - stats.mtime.getTime();
-            context.isStale = age > STALE_THRESHOLD_MS;
-            logger.info("Loaded ax.index.json", {
-              projectName: context.index.projectName,
-              projectType: context.index.projectType,
-              isStale: context.isStale,
-              ageHours: Math.floor(age / (1e3 * 60 * 60))
-            });
-            if (context.index.commands) {
-              context.commands = {};
-              for (const [name, cmd] of Object.entries(context.index.commands)) {
-                context.commands[name] = cmd.script;
-              }
-            }
-          }
+      if (!resolvedPath) return;
+      const rel = path4__default.relative(this.projectRoot, resolvedPath);
+      if (rel.startsWith("..") || path4__default.isAbsolute(rel)) return;
+      const stats = await stat(resolvedPath);
+      if (stats.size > MAX_CONTEXT_SIZE) {
+        logger.warn("ax.index.json too large, ignoring", {
+          size: stats.size,
+          limit: MAX_CONTEXT_SIZE
+        });
+        return;
+      }
+      const indexContent = await readFile(resolvedPath, "utf-8");
+      context.index = JSON.parse(indexContent);
+      context.lastUpdated = stats.mtime;
+      const age = Date.now() - stats.mtime.getTime();
+      context.isStale = age > STALE_THRESHOLD_MS;
+      logger.debug("Loaded ax.index.json", {
+        projectName: context.index.projectName,
+        projectType: context.index.projectType,
+        isStale: context.isStale,
+        ageHours: Math.floor(age / (1e3 * 60 * 60))
+      });
+      if (!context.commands && context.index.commands) {
+        context.commands = {};
+        for (const [name, cmd] of Object.entries(context.index.commands)) {
+          context.commands[name] = cmd.script;
         }
       }
     } catch (error) {
@@ -16812,26 +17957,38 @@ var ProjectContextLoader = class {
         logger.warn("Error loading ax.index.json", { error });
       }
     }
+  }
+  /**
+   * Load .automatosx/CUSTOM.md
+   */
+  async loadCustomInstructions(context) {
     try {
       const customMdPath = path4__default.join(this.projectRoot, ".automatosx", "CUSTOM.md");
       const resolvedPath = await realpath(customMdPath).catch(() => null);
-      if (resolvedPath) {
-        const rel = path4__default.relative(this.projectRoot, resolvedPath);
-        if (!rel.startsWith("..") && !path4__default.isAbsolute(rel)) {
-          const stats = await stat(resolvedPath);
-          if (stats.size > MAX_CONTEXT_SIZE) {
-            logger.warn("CUSTOM.md too large, ignoring", {
-              size: stats.size,
-              limit: MAX_CONTEXT_SIZE
-            });
-          } else {
-            context.customInstructions = await readFile(resolvedPath, "utf-8");
-            logger.info("Loaded CUSTOM.md", {
-              size: stats.size,
-              lines: context.customInstructions.split("\n").length
-            });
-            context.guardrails = this.parseGuardrails(context.customInstructions);
-          }
+      if (!resolvedPath) return;
+      const rel = path4__default.relative(this.projectRoot, resolvedPath);
+      if (rel.startsWith("..") || path4__default.isAbsolute(rel)) return;
+      const stats = await stat(resolvedPath);
+      if (stats.size > MAX_CONTEXT_SIZE) {
+        logger.warn("CUSTOM.md too large, ignoring", {
+          size: stats.size,
+          limit: MAX_CONTEXT_SIZE
+        });
+        return;
+      }
+      context.customInstructions = await readFile(resolvedPath, "utf-8");
+      logger.info("Loaded CUSTOM.md", {
+        size: stats.size,
+        lines: context.customInstructions.split("\n").length
+      });
+      context.guardrails = this.parseGuardrails(context.customInstructions);
+      if (context.guardrails && context.guardrails.length > 1) {
+        context.guardrailConflicts = this.detectGuardrailConflicts(context.guardrails);
+        if (context.guardrailConflicts.length > 0) {
+          logger.warn("Guardrail conflicts detected", {
+            count: context.guardrailConflicts.length,
+            conflicts: context.guardrailConflicts.map((c) => c.description)
+          });
         }
       }
     } catch (error) {
@@ -16839,17 +17996,52 @@ var ProjectContextLoader = class {
         logger.warn("Error loading CUSTOM.md", { error });
       }
     }
-    context.contextPrompt = this.buildContextPrompt(context);
-    this.cache = context;
-    this.cacheExpiry = Date.now() + this.cacheTTL;
-    logger.info("Project context loaded", {
-      hasIndex: !!context.index,
-      hasCustomInstructions: !!context.customInstructions,
-      guardrails: context.guardrails?.length ?? 0,
-      commands: Object.keys(context.commands ?? {}).length,
-      isStale: context.isStale
-    });
-    return context;
+  }
+  /**
+   * Generate a dynamic summary from ax.index.json
+   * Used when ax.summary.json is missing
+   */
+  generateDynamicSummary(index) {
+    const techStack = [];
+    if (index.language) techStack.push(index.language);
+    if (index.framework) techStack.push(index.framework);
+    if (index.buildTool) techStack.push(index.buildTool);
+    if (index.testFramework) techStack.push(index.testFramework);
+    if (index.packageManager) techStack.push(index.packageManager);
+    const directories = {};
+    for (const mod of index.modules.slice(0, 5)) {
+      directories[mod.path] = mod.purpose;
+    }
+    const commands = {};
+    const cmdEntries = Object.entries(index.commands).slice(0, 5);
+    for (const [name, cmd] of cmdEntries) {
+      commands[name] = cmd.script;
+    }
+    const gotchas = [];
+    if (index.hasTypeScript) {
+      gotchas.push("TypeScript strict mode is enabled");
+    }
+    if (index.isMonorepo) {
+      gotchas.push("Monorepo structure - run commands from package directory");
+    }
+    if (index.packageManager === "pnpm") {
+      gotchas.push("Uses pnpm - ensure dependencies are installed with pnpm");
+    }
+    return {
+      schemaVersion: "1.0",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      project: {
+        name: index.projectName,
+        type: index.projectType,
+        language: index.language,
+        version: index.version
+      },
+      directories,
+      commands,
+      techStack,
+      gotchas: gotchas.slice(0, 5),
+      indexFile: "ax.index.json"
+    };
   }
   /**
    * Clear cache (useful for testing or file watching)
@@ -16931,15 +18123,163 @@ var ProjectContextLoader = class {
     }
     return guardrails;
   }
+  /**
+   * Detect semantic conflicts between guardrails
+   *
+   * Uses keyword-based heuristics to identify potential contradictions:
+   * - "never X" vs "always X"
+   * - "do X" vs "don't X"
+   * - Conflicting action verbs on same subject
+   *
+   * @param guardrails - List of guardrail rules
+   * @returns Detected conflicts
+   *
+   * @since v12.7.1
+   */
+  detectGuardrailConflicts(guardrails) {
+    const conflicts = [];
+    const contradictionPairs = [
+      [/\balways\b/i, /\bnever\b/i, "always/never"],
+      [/\bmust\b/i, /\bmust\s+not\b/i, "must/must not"],
+      [/\bshould\b/i, /\bshould\s+not\b/i, "should/should not"],
+      [/\bdo\b/i, /\bdon'?t\b/i, "do/don't"],
+      [/\buse\b/i, /\bnever\s+use\b/i, "use/never use"],
+      [/\brequire[ds]?\b/i, /\bforbidden\b/i, "required/forbidden"],
+      [/\ballow(ed)?\b/i, /\bprohibit(ed)?\b/i, "allowed/prohibited"],
+      [/\benable[ds]?\b/i, /\bdisable[ds]?\b/i, "enable/disable"]
+    ];
+    const extractSubject = (rule) => {
+      const subjects = [];
+      const patterns = [
+        /(?:use|run|execute|call|import|require|include|add|create|edit|modify|delete|remove)\s+[`"']?(\w+(?:[._-]\w+)*)[`"']?/gi,
+        /(?:never|always|must|should|do|don't)\s+(?:\w+\s+)?[`"']?(\w+(?:[._-]\w+)*)[`"']?/gi,
+        /[`"'](\w+(?:[._-]\w+)*)[`"']/g
+        // Backtick/quoted terms
+      ];
+      for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(rule)) !== null) {
+          if (match[1] && match[1].length > 2) {
+            subjects.push(match[1].toLowerCase());
+          }
+        }
+      }
+      return [...new Set(subjects)];
+    };
+    for (let i = 0; i < guardrails.length; i++) {
+      for (let j = i + 1; j < guardrails.length; j++) {
+        const rule1 = guardrails[i];
+        const rule2 = guardrails[j];
+        if (!rule1 || !rule2) continue;
+        const subjects1 = extractSubject(rule1);
+        const subjects2 = extractSubject(rule2);
+        const sharedSubjects = subjects1.filter((s) => subjects2.includes(s));
+        if (sharedSubjects.length === 0) {
+          continue;
+        }
+        for (const [positivePattern, negativePattern, patternName] of contradictionPairs) {
+          const rule1Positive = positivePattern.test(rule1);
+          const rule1Negative = negativePattern.test(rule1);
+          const rule2Positive = positivePattern.test(rule2);
+          const rule2Negative = negativePattern.test(rule2);
+          if (rule1Positive && rule2Negative || rule1Negative && rule2Positive) {
+            conflicts.push({
+              rule1,
+              rule2,
+              type: "contradiction",
+              description: `Potential ${patternName} conflict on subject: ${sharedSubjects.join(", ")}`
+            });
+            break;
+          }
+        }
+        if (sharedSubjects.length > 0 && conflicts.every((c) => c.rule1 !== rule1 || c.rule2 !== rule2)) {
+          const actionVerbs = /\b(use|run|edit|create|delete|modify|add|remove|enable|disable|require|allow|block)\b/gi;
+          const verbs1 = rule1.match(actionVerbs)?.map((v) => v.toLowerCase()) || [];
+          const verbs2 = rule2.match(actionVerbs)?.map((v) => v.toLowerCase()) || [];
+          const conflictingVerbs = verbs1.filter(
+            (v) => verbs2.some((v2) => {
+              const conflicts2 = {
+                "create": ["delete", "remove"],
+                "add": ["remove", "delete"],
+                "enable": ["disable", "block"],
+                "allow": ["block", "disable"],
+                "use": ["remove", "delete"]
+              };
+              return conflicts2[v]?.includes(v2) || conflicts2[v2]?.includes(v);
+            })
+          );
+          if (conflictingVerbs.length > 0) {
+            conflicts.push({
+              rule1,
+              rule2,
+              type: "ambiguity",
+              description: `Ambiguous actions (${conflictingVerbs.join(", ")}) on subject: ${sharedSubjects.join(", ")}`
+            });
+          }
+        }
+      }
+    }
+    return conflicts;
+  }
   /**
    * Build formatted context prompt for agent injection
+   *
+   * Uses ax.summary.json (compact ~500 tokens) for fast prompt injection.
+   * Tells AI to read ax.index.json for full project analysis if needed.
+   *
+   * @since v12.10.0 - Now uses summary instead of full index
    */
   buildContextPrompt(context) {
-    if (!context.index && !context.customInstructions) {
+    if (!context.summary && !context.index && !context.customInstructions) {
       return "";
     }
     let prompt = "\n# PROJECT CONTEXT\n\n";
-    if (context.index) {
+    if (context.summary) {
+      const summary = context.summary;
+      prompt += `**Project:** ${summary.project.name}`;
+      if (summary.project.version) {
+        prompt += ` v${summary.project.version}`;
+      }
+      prompt += "\n";
+      prompt += `**Type:** ${summary.project.type}
+`;
+      prompt += `**Language:** ${summary.project.language}
+`;
+      if (summary.techStack.length > 0) {
+        prompt += `**Tech:** ${summary.techStack.join(", ")}
+`;
+      }
+      prompt += "\n";
+      const dirEntries = Object.entries(summary.directories);
+      if (dirEntries.length > 0) {
+        prompt += "## Directories:\n";
+        for (const [dir, purpose] of dirEntries) {
+          prompt += `- \`${dir}/\` - ${purpose}
+`;
+        }
+        prompt += "\n";
+      }
+      const cmdEntries = Object.entries(summary.commands);
+      if (cmdEntries.length > 0) {
+        prompt += "## Commands:\n";
+        for (const [name, script] of cmdEntries) {
+          prompt += `- ${name}: \`${script}\`
+`;
+        }
+        prompt += "\n";
+      }
+      if (summary.gotchas.length > 0) {
+        prompt += "## Gotchas:\n";
+        for (const gotcha of summary.gotchas) {
+          prompt += `- ${gotcha}
+`;
+        }
+        prompt += "\n";
+      }
+      prompt += `**For full project analysis, read:** \`${summary.indexFile}\`
+
+`;
+    } else if (context.index) {
       prompt += `**Project:** ${context.index.projectName} v${context.index.version}
 `;
       prompt += `**Type:** ${context.index.projectType}
@@ -16950,32 +18290,46 @@ var ProjectContextLoader = class {
       }
       prompt += "\n\n";
       if (context.index.modules.length > 0) {
-        prompt += "## Project Structure:\n\n";
-        for (const mod of context.index.modules.slice(0, 10)) {
+        prompt += "## Directories:\n";
+        for (const mod of context.index.modules.slice(0, 5)) {
           prompt += `- \`${mod.path}/\` - ${mod.purpose}
 `;
         }
         prompt += "\n";
       }
       if (context.commands && Object.keys(context.commands).length > 0) {
-        prompt += "## Available Commands:\n\n";
-        for (const [name, script] of Object.entries(context.commands).slice(0, 10)) {
+        prompt += "## Commands:\n";
+        for (const [name, script] of Object.entries(context.commands).slice(0, 5)) {
           prompt += `- ${name}: \`${script}\`
 `;
         }
         prompt += "\n";
       }
+      prompt += "**For full project analysis, read:** `ax.index.json`\n\n";
     }
     if (context.guardrails && context.guardrails.length > 0) {
-      prompt += "## CRITICAL RULES (NEVER VIOLATE):\n\n";
+      prompt += "## CRITICAL RULES (NEVER VIOLATE):\n";
       for (const rule of context.guardrails) {
         prompt += `- ${rule}
 `;
       }
       prompt += "\n";
+      if (context.guardrailConflicts && context.guardrailConflicts.length > 0) {
+        prompt += "### Guardrail Conflicts Detected:\n";
+        prompt += "The following rules may conflict. Use your best judgment:\n";
+        for (const conflict of context.guardrailConflicts) {
+          prompt += `- **${conflict.type}**: ${conflict.description}
+`;
+          prompt += `  - Rule 1: "${conflict.rule1}"
+`;
+          prompt += `  - Rule 2: "${conflict.rule2}"
+`;
+        }
+        prompt += "\n";
+      }
     }
     if (context.isStale) {
-      prompt += "\u26A0\uFE0F **Note:** Project index is stale (>24h old). Run `ax init` to update.\n\n";
+      prompt += "**Note:** Project index is stale (>24h old). Run `ax init` to update.\n\n";
     }
     return prompt;
   }
@@ -17161,23 +18515,24 @@ var ContextManager = class {
     }
     const searchQuery = query || context.task;
     const MAX_QUERY_LENGTH = 1e3;
-    const truncatedQuery = searchQuery.length > MAX_QUERY_LENGTH ? searchQuery.substring(0, MAX_QUERY_LENGTH) : searchQuery;
-    if (truncatedQuery !== searchQuery) {
-      logger.debug("Memory search query truncated", {
+    const optimizedQuery = this.extractSearchKeywords(searchQuery, MAX_QUERY_LENGTH);
+    if (optimizedQuery !== searchQuery) {
+      logger.debug("Memory search query optimized", {
         originalLength: searchQuery.length,
-        truncatedLength: truncatedQuery.length,
-        maxLength: MAX_QUERY_LENGTH
+        optimizedLength: optimizedQuery.length,
+        maxLength: MAX_QUERY_LENGTH,
+        method: searchQuery.length > MAX_QUERY_LENGTH ? "keyword_extraction" : "passthrough"
       });
     }
     try {
       const results = await this.config.memoryManager.search({
-        text: truncatedQuery,
-        // Use truncated query
+        text: optimizedQuery,
+        // Use optimized query with keywords
         limit
       });
       context.memory = results.map((r) => r.entry);
       logger.debug("Memory injected", {
-        query: truncatedQuery.substring(0, 100) + (truncatedQuery.length > 100 ? "..." : ""),
+        query: optimizedQuery.substring(0, 100) + (optimizedQuery.length > 100 ? "..." : ""),
         count: context.memory.length
       });
     } catch (error) {
@@ -17187,6 +18542,156 @@ var ContextManager = class {
       context.memory = [];
     }
   }
+  /**
+   * Extract meaningful keywords from a query for memory search
+   *
+   * Instead of truncating long queries (which loses context at the end),
+   * this extracts the most meaningful terms for FTS5 search.
+   *
+   * @param query - The full query text
+   * @param maxLength - Maximum output length
+   * @returns Optimized search query with keywords
+   *
+   * @since v12.7.1
+   */
+  extractSearchKeywords(query, maxLength) {
+    if (query.length <= maxLength) {
+      return query;
+    }
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "and",
+      "or",
+      "but",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "of",
+      "with",
+      "by",
+      "from",
+      "as",
+      "is",
+      "was",
+      "are",
+      "were",
+      "been",
+      "be",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "must",
+      "shall",
+      "can",
+      "need",
+      "dare",
+      "ought",
+      "used",
+      "this",
+      "that",
+      "these",
+      "those",
+      "i",
+      "you",
+      "he",
+      "she",
+      "it",
+      "we",
+      "they",
+      "what",
+      "which",
+      "who",
+      "whom",
+      "when",
+      "where",
+      "why",
+      "how",
+      "all",
+      "each",
+      "every",
+      "both",
+      "few",
+      "more",
+      "most",
+      "other",
+      "some",
+      "such",
+      "no",
+      "nor",
+      "not",
+      "only",
+      "own",
+      "same",
+      "so",
+      "than",
+      "too",
+      "very",
+      "just",
+      "also",
+      "now",
+      "here",
+      "there",
+      "then",
+      "once",
+      "please",
+      "want",
+      "need",
+      "help",
+      "me",
+      "my",
+      "your",
+      "our",
+      "their",
+      "its"
+    ]);
+    const words = query.match(/[a-zA-Z0-9_-]+/g) || [];
+    const wordScores = /* @__PURE__ */ new Map();
+    for (const word of words) {
+      const lower = word.toLowerCase();
+      if (stopWords.has(lower) || word.length < 3) {
+        continue;
+      }
+      let score = wordScores.get(lower) || 0;
+      if (/[A-Z]/.test(word) && /[a-z]/.test(word)) score += 3;
+      if (word.includes("_") || word.includes("-")) score += 2;
+      if (/\d/.test(word)) score += 2;
+      if (word.length > 8) score += 2;
+      if (word.length > 5) score += 1;
+      score += 1;
+      wordScores.set(lower, score);
+    }
+    const sortedWords = Array.from(wordScores.entries()).sort((a, b) => b[1] - a[1]).map(([word]) => word);
+    const result = [];
+    let currentLength = 0;
+    for (const word of sortedWords) {
+      const wordWithSpace = result.length > 0 ? ` ${word}` : word;
+      if (currentLength + wordWithSpace.length > maxLength) {
+        break;
+      }
+      result.push(word);
+      currentLength += wordWithSpace.length;
+    }
+    if (result.length < 5) {
+      const prefix = query.substring(0, Math.min(200, maxLength - currentLength - 1));
+      if (prefix && currentLength + prefix.length + 1 <= maxLength) {
+        return `${prefix} ${result.join(" ")}`.trim();
+      }
+    }
+    return result.join(" ");
+  }
   /**
    * Select abilities based on task keywords (smart selection)
    */
@@ -22680,7 +24185,7 @@ ${context.task}`;
    * @param signal - Optional AbortSignal to cancel the sleep
    */
   sleep(ms, signal) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       if (signal?.aborted) {
         reject(new Error("Sleep cancelled"));
         return;
@@ -22690,7 +24195,7 @@ ${context.task}`;
         if (abortHandler && signal) {
           signal.removeEventListener("abort", abortHandler);
         }
-        resolve5();
+        resolve6();
       }, ms);
       if (signal) {
         abortHandler = () => {
@@ -25125,6 +26630,968 @@ init_logger();
 // src/core/bugfix/bug-detector.ts
 init_esm_shims();
 init_logger();
+
+// src/core/bugfix/ast-analyzer.ts
+init_esm_shims();
+var ts = null;
+async function loadTypeScript() {
+  if (!ts) {
+    ts = await import('typescript');
+  }
+  return ts;
+}
+function getTS() {
+  if (!ts) {
+    throw new Error("TypeScript not loaded. Call ASTAnalyzer.init() first.");
+  }
+  return ts;
+}
+var ASTAnalyzer = class {
+  cache = /* @__PURE__ */ new Map();
+  maxCacheSize;
+  initialized = false;
+  constructor(maxCacheSize = 100) {
+    this.maxCacheSize = maxCacheSize;
+  }
+  /**
+   * Initialize the analyzer by loading TypeScript.
+   * Must be called before any parse or analysis methods.
+   */
+  async init() {
+    if (!this.initialized) {
+      await loadTypeScript();
+      this.initialized = true;
+    }
+  }
+  /**
+   * Check if the analyzer is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Parse a TypeScript/JavaScript file into an AST.
+   * Note: init() must be called before this method.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parseFile(content, filePath) {
+    const hash = this.hashContent(content);
+    const cacheKey = filePath;
+    const cached = this.cache.get(cacheKey);
+    if (cached && cached.hash === hash) {
+      cached.accessedAt = Date.now();
+      return cached.sourceFile;
+    }
+    const typescript = getTS();
+    const sourceFile = typescript.createSourceFile(
+      filePath,
+      content,
+      typescript.ScriptTarget.Latest,
+      true,
+      // setParentNodes - needed for traversal
+      this.getScriptKind(filePath)
+    );
+    this.cache.set(cacheKey, {
+      sourceFile,
+      hash,
+      accessedAt: Date.now()
+    });
+    this.evictOldest();
+    return sourceFile;
+  }
+  /**
+   * Find all class declarations in the file
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  findClasses(sourceFile) {
+    const typescript = getTS();
+    const classes = [];
+    const visit = (node) => {
+      if (typescript.isClassDeclaration(node) && node.name) {
+        classes.push(this.extractClassInfo(node, sourceFile));
+      }
+      typescript.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return classes;
+  }
+  /**
+   * Find classes that extend a specific base class
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  findClassesExtending(sourceFile, baseClassName) {
+    const allClasses = this.findClasses(sourceFile);
+    return allClasses.filter((cls) => {
+      if (typeof baseClassName === "string") {
+        return cls.extendsClause.includes(baseClassName);
+      }
+      return cls.extendsClause.some((name) => baseClassName.test(name));
+    });
+  }
+  /**
+   * Check if a class has a specific method
+   */
+  classHasMethod(classInfo, methodName) {
+    return classInfo.methods.some((method) => {
+      if (typeof methodName === "string") {
+        return method.name === methodName;
+      }
+      return methodName.test(method.name);
+    });
+  }
+  /**
+   * Check if a class has destroy, dispose, or cleanup method
+   */
+  classHasDestroyMethod(classInfo) {
+    const destroyMethodPattern = /^(destroy|dispose|cleanup|close|shutdown|teardown)$/i;
+    return this.classHasMethod(classInfo, destroyMethodPattern);
+  }
+  /**
+   * Find all function calls matching a pattern
+   */
+  findCalls(sourceFile, functionName) {
+    const calls = [];
+    const visit = (node) => {
+      if (getTS().isCallExpression(node)) {
+        const callName = this.getCallExpressionName(node);
+        const matches = typeof functionName === "string" ? callName === functionName : functionName.test(callName);
+        if (matches) {
+          const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+          const isReturnCaptured = this.isReturnValueCaptured(node);
+          const hasChainedUnref = this.hasChainedUnrefCall(node);
+          calls.push({
+            name: callName,
+            line: line + 1,
+            column: character + 1,
+            arguments: node.arguments.map((arg) => arg.getText(sourceFile)),
+            isReturnCaptured,
+            capturedVariable: isReturnCaptured ? this.getCapturedVariableName(node) : void 0,
+            hasChainedUnref
+          });
+        }
+      }
+      getTS().forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return calls;
+  }
+  /**
+   * Find the enclosing function for a given line number
+   */
+  findEnclosingFunction(sourceFile, lineNumber) {
+    let result = null;
+    const position = sourceFile.getPositionOfLineAndCharacter(lineNumber - 1, 0);
+    const visit = (node) => {
+      sourceFile.getLineAndCharacterOfPosition(node.getStart());
+      sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+      if (position >= node.getStart() && position <= node.getEnd()) {
+        if (getTS().isFunctionDeclaration(node) || getTS().isFunctionExpression(node) || getTS().isArrowFunction(node) || getTS().isMethodDeclaration(node)) {
+          const funcInfo = this.extractFunctionInfo(node, sourceFile);
+          if (!result || funcInfo.startLine >= result.startLine) {
+            result = funcInfo;
+          }
+        }
+        getTS().forEachChild(node, visit);
+      }
+    };
+    visit(sourceFile);
+    return result;
+  }
+  /**
+   * Track variable usage throughout the file
+   */
+  trackVariableUsage(sourceFile, variableName) {
+    let declarationLine = -1;
+    const usageLines = [];
+    let usedInCleanup = false;
+    let cleanupMethod;
+    const cleanupMethods = ["clearInterval", "clearTimeout", "removeListener", "removeEventListener", "off", "destroy", "dispose", "close"];
+    const visit = (node) => {
+      if (getTS().isVariableDeclaration(node)) {
+        if (node.name.getText(sourceFile) === variableName) {
+          const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+          declarationLine = line + 1;
+        }
+      }
+      if (getTS().isIdentifier(node) && node.text === variableName) {
+        if (!getTS().isVariableDeclaration(node.parent) || node.parent.name !== node) {
+          const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+          usageLines.push(line + 1);
+          const parent = node.parent;
+          if (getTS().isCallExpression(parent)) {
+            const callName = this.getCallExpressionName(parent);
+            if (cleanupMethods.includes(callName)) {
+              usedInCleanup = true;
+              cleanupMethod = callName;
+            }
+          } else if (getTS().isCallExpression(parent?.parent)) {
+            const callName = this.getCallExpressionName(parent.parent);
+            if (cleanupMethods.includes(callName)) {
+              usedInCleanup = true;
+              cleanupMethod = callName;
+            }
+          }
+        }
+      }
+      getTS().forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    if (declarationLine === -1) {
+      return null;
+    }
+    return {
+      name: variableName,
+      declarationLine,
+      usageLines,
+      usedInCleanup,
+      cleanupMethod
+    };
+  }
+  /**
+   * Check if a method in a class calls clearInterval/clearTimeout on a variable
+   */
+  methodClearsTimer(sourceFile, classInfo, methodName, variableName) {
+    const method = classInfo.methods.find((m) => m.name === methodName);
+    if (!method) return false;
+    const startPos = sourceFile.getPositionOfLineAndCharacter(method.startLine - 1, 0);
+    const endPos = sourceFile.getPositionOfLineAndCharacter(method.endLine - 1, 0);
+    const methodText = sourceFile.text.substring(startPos, endPos);
+    const clearPatterns = [
+      new RegExp(`clearInterval\\s*\\(\\s*(?:this\\.)?${variableName}\\s*\\)`),
+      new RegExp(`clearTimeout\\s*\\(\\s*(?:this\\.)?${variableName}\\s*\\)`)
+    ];
+    return clearPatterns.some((pattern) => pattern.test(methodText));
+  }
+  /**
+   * Check if a file is a test file
+   */
+  isTestFile(filePath) {
+    const testPatterns = [
+      /\.test\.[tj]sx?$/,
+      /\.spec\.[tj]sx?$/,
+      /\.bench\.[tj]sx?$/,
+      /__tests__\//,
+      /test\/fixtures\//,
+      /tests?\//
+    ];
+    return testPatterns.some((pattern) => pattern.test(filePath));
+  }
+  /**
+   * Analyze Promise+setTimeout patterns for potential leaks
+   * v12.8.0: Phase 3 - Reduced false positives for simple sleep utilities
+   */
+  analyzePromiseTimeouts(sourceFile, content) {
+    const results = [];
+    for (const safePattern of ALLOWLISTS.promiseTimeout.safePatterns) {
+      if (safePattern.test(content)) ;
+    }
+    const visit = (node) => {
+      if (getTS().isNewExpression(node) && getTS().isIdentifier(node.expression) && node.expression.text === "Promise") {
+        const promisePos = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        const promiseLine = promisePos.line + 1;
+        const findTimerCalls = (innerNode) => {
+          if (getTS().isCallExpression(innerNode)) {
+            const callName = this.getCallExpressionName(innerNode);
+            if (callName === "setTimeout" || callName === "setInterval") {
+              const timerPos = sourceFile.getLineAndCharacterOfPosition(innerNode.getStart());
+              const timerLine = timerPos.line + 1;
+              const timeoutIdCaptured = this.isReturnValueCaptured(innerNode);
+              const hasCleanup = this.hasCleanupInPromise(node, sourceFile);
+              const enclosingFunc = this.findEnclosingFunction(sourceFile, promiseLine);
+              const { isAllowlisted, reason } = this.checkPromiseTimeoutAllowlist(
+                enclosingFunc?.name || "",
+                node,
+                sourceFile
+              );
+              results.push({
+                promiseLine,
+                timeoutLine: timerLine,
+                isAllowlisted,
+                allowlistReason: reason,
+                hasCleanup,
+                enclosingFunction: enclosingFunc?.name,
+                timeoutIdCaptured
+              });
+            }
+          }
+          getTS().forEachChild(innerNode, findTimerCalls);
+        };
+        getTS().forEachChild(node, findTimerCalls);
+      }
+      getTS().forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return results;
+  }
+  /**
+   * Check if a Promise has cleanup (finally/catch/then with clearTimeout, or clearTimeout in executor)
+   */
+  hasCleanupInPromise(promiseNode, sourceFile) {
+    const promiseText = promiseNode.getText(sourceFile);
+    if (/clearTimeout/i.test(promiseText)) {
+      return true;
+    }
+    let current = promiseNode;
+    while (current.parent) {
+      const parent = current.parent;
+      if (getTS().isCallExpression(parent) && getTS().isPropertyAccessExpression(parent.expression)) {
+        const propName = parent.expression.name.text;
+        if (propName === "finally" || propName === "catch" || propName === "then") {
+          const callText = parent.getText(sourceFile);
+          if (/clearTimeout/i.test(callText)) {
+            return true;
+          }
+        }
+      }
+      if (getTS().isTryStatement(parent)) {
+        if (parent.finallyBlock) {
+          const finallyText = parent.finallyBlock.getText(sourceFile);
+          if (/clearTimeout/i.test(finallyText)) {
+            return true;
+          }
+        }
+      }
+      current = parent;
+    }
+    return false;
+  }
+  /**
+   * Check if a Promise+setTimeout pattern is allowlisted
+   */
+  checkPromiseTimeoutAllowlist(functionName, promiseNode, sourceFile) {
+    if (functionName) {
+      const normalizedName = functionName.toLowerCase();
+      for (const allowedName of ALLOWLISTS.promiseTimeout.functionNames) {
+        const lowerAllowed = allowedName.toLowerCase();
+        if (normalizedName === lowerAllowed || normalizedName.startsWith(lowerAllowed)) {
+          return {
+            isAllowlisted: true,
+            reason: `Function name '${functionName}' matches allowlisted pattern '${allowedName}'`
+          };
+        }
+      }
+    }
+    const promiseText = promiseNode.getText(sourceFile);
+    for (const safePattern of ALLOWLISTS.promiseTimeout.safePatterns) {
+      if (safePattern.test(promiseText)) {
+        return {
+          isAllowlisted: true,
+          reason: "Simple sleep/delay pattern - timeout cleanup not needed"
+        };
+      }
+    }
+    const promiseArgs = promiseNode.arguments;
+    if (promiseArgs && promiseArgs.length > 0) {
+      const promiseArg = promiseArgs[0];
+      if (promiseArg && getTS().isArrowFunction(promiseArg)) {
+        const body = promiseArg.body;
+        if (getTS().isCallExpression(body)) {
+          const callName = this.getCallExpressionName(body);
+          if (callName === "setTimeout") {
+            const args2 = body.arguments;
+            if (args2.length >= 1) {
+              const firstArg = args2[0];
+              const params = promiseArg.parameters;
+              if (params.length >= 1) {
+                const resolveParam = params[0];
+                if (resolveParam && getTS().isIdentifier(resolveParam.name)) {
+                  const resolveParamName = resolveParam.name.text;
+                  if (firstArg && getTS().isIdentifier(firstArg) && firstArg.text === resolveParamName) {
+                    return {
+                      isAllowlisted: true,
+                      reason: "Simple Promise with direct resolve to setTimeout - no cleanup needed"
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (getTS().isAwaitExpression(promiseNode.parent)) {
+      if (promiseArgs && promiseArgs.length > 0) {
+        const promiseArg = promiseArgs[0];
+        if (promiseArg && getTS().isArrowFunction(promiseArg)) {
+          const body = promiseArg.body;
+          if (getTS().isCallExpression(body)) {
+            const callName = this.getCallExpressionName(body);
+            if (callName === "setTimeout") {
+              return {
+                isAllowlisted: true,
+                reason: "Awaited Promise with setTimeout - no leak possible when awaited"
+              };
+            }
+          }
+        }
+      }
+    }
+    return { isAllowlisted: false };
+  }
+  /**
+   * Analyze code for unreachable code patterns
+   * v12.8.0: Phase 4 - Control flow analysis to reduce false positives
+   */
+  analyzeUnreachableCode(sourceFile) {
+    const results = [];
+    const visit = (node) => {
+      if (getTS().isBlock(node)) {
+        this.analyzeBlockForUnreachable(node, sourceFile, results);
+      }
+      getTS().forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return results;
+  }
+  /**
+   * Analyze a block for unreachable statements
+   */
+  analyzeBlockForUnreachable(block, sourceFile, results) {
+    const statements = block.statements;
+    let foundTerminator = false;
+    let terminatorLine = 0;
+    let terminatorReason = "return";
+    for (let i = 0; i < statements.length; i++) {
+      const stmt = statements[i];
+      if (!stmt) continue;
+      const stmtPos = sourceFile.getLineAndCharacterOfPosition(stmt.getStart());
+      const stmtLine = stmtPos.line + 1;
+      if (foundTerminator) {
+        if (getTS().isCaseClause(stmt.parent) || getTS().isDefaultClause(stmt.parent)) {
+          results.push({
+            line: stmtLine,
+            code: stmt.getText(sourceFile).substring(0, 80),
+            reason: terminatorReason,
+            controlFlowLine: terminatorLine,
+            isFalsePositive: true,
+            falsePositiveReason: "Case/default clause in switch statement"
+          });
+          continue;
+        }
+        if (this.isInSwitchCase(stmt)) {
+          results.push({
+            line: stmtLine,
+            code: stmt.getText(sourceFile).substring(0, 80),
+            reason: terminatorReason,
+            controlFlowLine: terminatorLine,
+            isFalsePositive: true,
+            falsePositiveReason: "Statement in switch case after break belongs to next case"
+          });
+          continue;
+        }
+        const parentCase = this.findParentSwitchCase(block);
+        if (parentCase) {
+          foundTerminator = false;
+          continue;
+        }
+        results.push({
+          line: stmtLine,
+          code: stmt.getText(sourceFile).substring(0, 80),
+          reason: terminatorReason,
+          controlFlowLine: terminatorLine,
+          isFalsePositive: false
+        });
+      }
+      if (getTS().isReturnStatement(stmt)) {
+        foundTerminator = true;
+        terminatorLine = stmtLine;
+        terminatorReason = "return";
+      } else if (getTS().isThrowStatement(stmt)) {
+        foundTerminator = true;
+        terminatorLine = stmtLine;
+        terminatorReason = "throw";
+      } else if (getTS().isBreakStatement(stmt)) {
+        if (this.isInSwitchOrLoop(stmt)) ; else {
+          foundTerminator = true;
+          terminatorLine = stmtLine;
+          terminatorReason = "break";
+        }
+      } else if (getTS().isContinueStatement(stmt)) {
+        if (!this.isInLoop(stmt)) {
+          foundTerminator = true;
+          terminatorLine = stmtLine;
+          terminatorReason = "continue";
+        }
+      }
+    }
+  }
+  /**
+   * Check if a node is inside a switch case
+   */
+  isInSwitchCase(node) {
+    let current = node.parent;
+    while (current) {
+      if (getTS().isCaseClause(current) || getTS().isDefaultClause(current)) {
+        return true;
+      }
+      if (getTS().isSwitchStatement(current)) {
+        return false;
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  /**
+   * Find parent switch case clause
+   */
+  findParentSwitchCase(node) {
+    let current = node.parent;
+    while (current) {
+      if (getTS().isCaseClause(current) || getTS().isDefaultClause(current)) {
+        return current;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+  /**
+   * Check if a node is inside a switch statement or loop
+   */
+  isInSwitchOrLoop(node) {
+    let current = node.parent;
+    while (current) {
+      if (getTS().isSwitchStatement(current) || getTS().isForStatement(current) || getTS().isForInStatement(current) || getTS().isForOfStatement(current) || getTS().isWhileStatement(current) || getTS().isDoStatement(current)) {
+        return true;
+      }
+      if (getTS().isFunctionDeclaration(current) || getTS().isFunctionExpression(current) || getTS().isArrowFunction(current)) {
+        return false;
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  /**
+   * Check if a node is inside a loop
+   */
+  isInLoop(node) {
+    let current = node.parent;
+    while (current) {
+      if (getTS().isForStatement(current) || getTS().isForInStatement(current) || getTS().isForOfStatement(current) || getTS().isWhileStatement(current) || getTS().isDoStatement(current)) {
+        return true;
+      }
+      if (getTS().isFunctionDeclaration(current) || getTS().isFunctionExpression(current) || getTS().isArrowFunction(current)) {
+        return false;
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  /**
+   * Analyze setInterval/setTimeout calls for potential timer leaks
+   * v12.8.0: Phase 5 - Variable tracking and destroy() method analysis
+   */
+  analyzeTimerLeaks(sourceFile, content) {
+    const results = [];
+    const intervalCalls = this.findCalls(sourceFile, "setInterval");
+    for (const call of intervalCalls) {
+      const info = this.analyzeTimerCall(call, sourceFile, content, "setInterval");
+      results.push(info);
+    }
+    return results;
+  }
+  /**
+   * Analyze a single timer call for leak potential
+   */
+  analyzeTimerCall(call, sourceFile, content, timerType) {
+    content.split("\n");
+    const enclosingFunc = this.findEnclosingFunction(sourceFile, call.line);
+    const enclosingClass = this.findEnclosingClass(sourceFile, call.line);
+    const info = {
+      line: call.line,
+      timerType,
+      isValueCaptured: call.isReturnCaptured,
+      capturedVariable: call.capturedVariable,
+      hasClearCall: false,
+      hasUnref: false,
+      hasDestroyCleanup: false,
+      enclosingClass: enclosingClass?.name,
+      enclosingFunction: enclosingFunc?.name,
+      isFalsePositive: false,
+      falsePositiveReason: void 0
+    };
+    if (!call.isReturnCaptured) {
+      if (call.hasChainedUnref) {
+        info.hasUnref = true;
+        info.isFalsePositive = true;
+        info.falsePositiveReason = "Timer has .unref() chained directly";
+        return info;
+      }
+      return info;
+    }
+    const variableName = call.capturedVariable;
+    const variableUsage = this.trackVariableUsage(sourceFile, variableName);
+    if (variableUsage) {
+      if (variableUsage.usedInCleanup) {
+        info.hasClearCall = true;
+        info.isFalsePositive = true;
+        info.falsePositiveReason = `Timer is cleared via ${variableUsage.cleanupMethod}()`;
+        return info;
+      }
+    }
+    const unrefPattern = new RegExp(`${this.escapeRegex(variableName)}\\s*\\.\\s*unref\\s*\\(\\s*\\)`, "g");
+    if (unrefPattern.test(content)) {
+      info.hasUnref = true;
+      info.isFalsePositive = true;
+      info.falsePositiveReason = "Timer has .unref() called on it";
+      return info;
+    }
+    const optionalUnrefPattern = new RegExp(`${this.escapeRegex(variableName)}\\s*\\?\\.\\s*unref\\s*\\(\\s*\\)`, "g");
+    if (optionalUnrefPattern.test(content)) {
+      info.hasUnref = true;
+      info.isFalsePositive = true;
+      info.falsePositiveReason = "Timer has optional .unref?.() called on it";
+      return info;
+    }
+    if (enclosingClass) {
+      const extendsAllowlistedBase = enclosingClass.extendsClause.some(
+        (base) => ALLOWLISTS.timerLeak.baseClasses.includes(base)
+      );
+      if (extendsAllowlistedBase) {
+        for (const methodName of ALLOWLISTS.timerLeak.cleanupMethods) {
+          if (this.methodClearsTimer(sourceFile, enclosingClass, methodName, variableName)) {
+            info.hasDestroyCleanup = true;
+            info.isFalsePositive = true;
+            info.falsePositiveReason = `Timer is cleared in ${methodName}() method`;
+            return info;
+          }
+        }
+      }
+      for (const methodName of ALLOWLISTS.timerLeak.cleanupMethods) {
+        if (this.methodClearsTimer(sourceFile, enclosingClass, methodName, variableName)) {
+          info.hasDestroyCleanup = true;
+          info.isFalsePositive = true;
+          info.falsePositiveReason = `Timer is cleared in ${methodName}() method`;
+          return info;
+        }
+      }
+    }
+    if (enclosingFunc) {
+      const clearPattern = timerType === "setInterval" ? new RegExp(`clearInterval\\s*\\(\\s*${this.escapeRegex(variableName)}\\s*\\)`) : new RegExp(`clearTimeout\\s*\\(\\s*${this.escapeRegex(variableName)}\\s*\\)`);
+      if (clearPattern.test(enclosingFunc.body)) {
+        info.hasClearCall = true;
+        info.isFalsePositive = true;
+        info.falsePositiveReason = "Timer is cleared in the same function";
+        return info;
+      }
+    }
+    return info;
+  }
+  /**
+   * Find the enclosing class for a given line
+   */
+  findEnclosingClass(sourceFile, lineNumber) {
+    const allClasses = this.findClasses(sourceFile);
+    let result = null;
+    for (const cls of allClasses) {
+      if (lineNumber >= cls.startLine && lineNumber <= cls.endLine) {
+        if (!result || cls.startLine >= result.startLine) {
+          result = cls;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Escape special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Clear the AST cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxCacheSize
+    };
+  }
+  // Private helper methods
+  hashContent(content) {
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return hash.toString(16);
+  }
+  getScriptKind(filePath) {
+    if (filePath.endsWith(".tsx")) return getTS().ScriptKind.TSX;
+    if (filePath.endsWith(".ts")) return getTS().ScriptKind.TS;
+    if (filePath.endsWith(".jsx")) return getTS().ScriptKind.JSX;
+    if (filePath.endsWith(".mjs") || filePath.endsWith(".mts")) return getTS().ScriptKind.TS;
+    return getTS().ScriptKind.JS;
+  }
+  evictOldest() {
+    if (this.cache.size <= this.maxCacheSize) return;
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache) {
+      if (entry.accessedAt < oldestTime) {
+        oldestTime = entry.accessedAt;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.cache.delete(oldestKey);
+    }
+  }
+  extractClassInfo(node, sourceFile) {
+    const name = node.name?.getText(sourceFile) || "<anonymous>";
+    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    const extendsClause = [];
+    const implementsClause = [];
+    if (node.heritageClauses) {
+      for (const clause of node.heritageClauses) {
+        if (clause.token === getTS().SyntaxKind.ExtendsKeyword) {
+          for (const type of clause.types) {
+            extendsClause.push(type.expression.getText(sourceFile));
+          }
+        } else if (clause.token === getTS().SyntaxKind.ImplementsKeyword) {
+          for (const type of clause.types) {
+            implementsClause.push(type.expression.getText(sourceFile));
+          }
+        }
+      }
+    }
+    const methods = [];
+    const properties = [];
+    for (const member of node.members) {
+      if (getTS().isMethodDeclaration(member) || getTS().isConstructorDeclaration(member)) {
+        const methodName = getTS().isConstructorDeclaration(member) ? "constructor" : member.name?.getText(sourceFile) || "<anonymous>";
+        const { line: methodStart } = sourceFile.getLineAndCharacterOfPosition(member.getStart());
+        const { line: methodEnd } = sourceFile.getLineAndCharacterOfPosition(member.getEnd());
+        const modifiers = this.getModifiers(member);
+        methods.push({
+          name: methodName,
+          startLine: methodStart + 1,
+          endLine: methodEnd + 1,
+          modifiers,
+          isAbstract: modifiers.includes("abstract")
+        });
+      } else if (getTS().isPropertyDeclaration(member)) {
+        const propName = member.name?.getText(sourceFile) || "<anonymous>";
+        const { line } = sourceFile.getLineAndCharacterOfPosition(member.getStart());
+        properties.push({
+          name: propName,
+          line: line + 1,
+          type: member.type?.getText(sourceFile),
+          modifiers: this.getModifiers(member)
+        });
+      }
+    }
+    const isAbstract = node.modifiers?.some(
+      (mod) => mod.kind === getTS().SyntaxKind.AbstractKeyword
+    ) || false;
+    return {
+      name,
+      startLine: startLine + 1,
+      endLine: endLine + 1,
+      extendsClause,
+      implementsClause,
+      methods,
+      properties,
+      isAbstract
+    };
+  }
+  extractFunctionInfo(node, sourceFile) {
+    let name = "";
+    if (getTS().isFunctionDeclaration(node) || getTS().isMethodDeclaration(node)) {
+      name = node.name?.getText(sourceFile) || "";
+    } else if (getTS().isFunctionExpression(node)) {
+      name = node.name?.getText(sourceFile) || "";
+    }
+    if (!name && getTS().isVariableDeclaration(node.parent)) {
+      name = node.parent.name.getText(sourceFile);
+    }
+    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    const modifiers = getTS().canHaveModifiers(node) ? getTS().getModifiers(node) : void 0;
+    const isAsync = modifiers?.some((mod) => mod.kind === getTS().SyntaxKind.AsyncKeyword) || false;
+    const isGenerator = !!((getTS().isFunctionDeclaration(node) || getTS().isFunctionExpression(node)) && node.asteriskToken);
+    let body = "";
+    if ("body" in node && node.body) {
+      body = node.body.getText(sourceFile);
+    }
+    return {
+      name,
+      startLine: startLine + 1,
+      endLine: endLine + 1,
+      body,
+      isAsync,
+      isGenerator
+    };
+  }
+  getModifiers(node) {
+    const modifiers = [];
+    const mods = getTS().canHaveModifiers(node) ? getTS().getModifiers(node) : void 0;
+    if (!mods) return modifiers;
+    for (const mod of mods) {
+      switch (mod.kind) {
+        case getTS().SyntaxKind.PublicKeyword:
+          modifiers.push("public");
+          break;
+        case getTS().SyntaxKind.PrivateKeyword:
+          modifiers.push("private");
+          break;
+        case getTS().SyntaxKind.ProtectedKeyword:
+          modifiers.push("protected");
+          break;
+        case getTS().SyntaxKind.StaticKeyword:
+          modifiers.push("static");
+          break;
+        case getTS().SyntaxKind.AsyncKeyword:
+          modifiers.push("async");
+          break;
+        case getTS().SyntaxKind.AbstractKeyword:
+          modifiers.push("abstract");
+          break;
+        case getTS().SyntaxKind.ReadonlyKeyword:
+          modifiers.push("readonly");
+          break;
+      }
+    }
+    return modifiers;
+  }
+  getCallExpressionName(node) {
+    const expression = node.expression;
+    if (getTS().isIdentifier(expression)) {
+      return expression.text;
+    }
+    if (getTS().isPropertyAccessExpression(expression)) {
+      return expression.name.text;
+    }
+    return "";
+  }
+  isReturnValueCaptured(node) {
+    const parent = node.parent;
+    if (getTS().isVariableDeclaration(parent)) {
+      return true;
+    }
+    if (getTS().isPropertyAssignment(parent)) {
+      return true;
+    }
+    if (getTS().isBinaryExpression(parent) && parent.operatorToken.kind === getTS().SyntaxKind.EqualsToken) {
+      return true;
+    }
+    return false;
+  }
+  getCapturedVariableName(node) {
+    const parent = node.parent;
+    if (getTS().isVariableDeclaration(parent)) {
+      return parent.name.getText();
+    }
+    if (getTS().isBinaryExpression(parent) && parent.operatorToken.kind === getTS().SyntaxKind.EqualsToken) {
+      return parent.left.getText();
+    }
+    return void 0;
+  }
+  /**
+   * Check if a call expression has .unref() chained directly
+   * e.g., setInterval(...).unref() or setInterval(...).unref?.()
+   */
+  hasChainedUnrefCall(node) {
+    const parent = node.parent;
+    if (getTS().isPropertyAccessExpression(parent)) {
+      const propertyName = parent.name.text;
+      if (propertyName === "unref") {
+        const grandParent = parent.parent;
+        if (getTS().isCallExpression(grandParent) && grandParent.expression === parent) {
+          return true;
+        }
+      }
+    }
+    if (getTS().isCallChain && getTS().isCallChain(parent)) {
+      const expression = parent.expression;
+      if (getTS().isPropertyAccessExpression(expression) && expression.name.text === "unref") {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+var ALLOWLISTS = {
+  /**
+   * Patterns that indicate intentional Promise+setTimeout usage (not leaks)
+   */
+  promiseTimeout: {
+    /** Function names that are intentional delays */
+    // Note: 'wait' and 'timeout' removed as they are too generic
+    // 'waitForCondition' or 'fetchWithTimeout' would be wrongly allowlisted
+    functionNames: [
+      "sleep",
+      "delay",
+      "pause",
+      "debounce",
+      "throttle",
+      "rateLimitDelay",
+      "backoff"
+    ],
+    /** File patterns to skip entirely */
+    filePatterns: [
+      /\.test\.[tj]sx?$/,
+      /\.spec\.[tj]sx?$/,
+      /\.bench\.[tj]sx?$/,
+      /__tests__\//,
+      /test\/fixtures\//
+    ],
+    /** Code patterns that are safe (simple delay utilities) */
+    safePatterns: [
+      // Simple sleep: return new Promise(resolve => setTimeout(resolve, ms))
+      /return\s+new\s+Promise\s*\(\s*(?:resolve|r)\s*=>\s*setTimeout\s*\(\s*(?:resolve|r)\s*,\s*\w+\s*\)\s*\)/,
+      // Arrow function sleep: const sleep = (ms) => new Promise(r => setTimeout(r, ms))
+      /=>\s*new\s+Promise\s*\(\s*(?:resolve|r)\s*=>\s*setTimeout\s*\(\s*(?:resolve|r)\s*,\s*\w+\s*\)\s*\)/,
+      // Inline await: await new Promise(r => setTimeout(r, 100))
+      /await\s+new\s+Promise\s*\(\s*(?:resolve|r)\s*=>\s*setTimeout\s*\(\s*(?:resolve|r)\s*,\s*\d+\s*\)\s*\)/
+    ]
+  },
+  /**
+   * Patterns that indicate timer cleanup is handled elsewhere
+   */
+  timerLeak: {
+    /** Classes with known lifecycle management */
+    baseClasses: [
+      "Disposable",
+      "DisposableEventEmitter",
+      "SafeEventEmitter",
+      "Component",
+      // React
+      "BaseService"
+    ],
+    /** Methods that imply cleanup */
+    cleanupMethods: ["destroy", "dispose", "cleanup", "close", "shutdown", "teardown", "componentWillUnmount"]
+  },
+  /**
+   * Patterns that indicate destroy is handled by inheritance
+   */
+  missingDestroy: {
+    /** Base classes that already have destroy() */
+    baseClassesWithDestroy: [
+      "DisposableEventEmitter",
+      "Disposable",
+      "SafeEventEmitter"
+    ],
+    /** Interfaces that imply destroy() exists */
+    interfacesWithDestroy: [
+      "IDisposable",
+      "Destroyable",
+      "IClosable"
+    ]
+  }
+};
+function createASTAnalyzer(cacheSize = 100) {
+  return new ASTAnalyzer(cacheSize);
+}
+
+// src/core/bugfix/bug-detector.ts
 var IGNORE_PATTERNS = {
   // Match: // ax-ignore or // ax-ignore timer_leak
   nextLine: /\/\/\s*ax-ignore(?:\s+(\w+))?\s*$/,
@@ -25134,25 +27601,30 @@ var IGNORE_PATTERNS = {
   blockEnd: /\/\/\s*ax-ignore-end\s*$/
 };
 var DEFAULT_DETECTION_RULES = [
-  // Timer leak: setInterval without .unref()
-  // v12.6.0: 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
+  // Timer leak: setInterval without cleanup
+  // v12.8.0: Now uses AST-based detection with variable tracking and destroy() analysis
+  // This eliminates false positives from timers that are properly cleaned up
   {
     id: "timer-leak-interval",
     type: "timer_leak",
-    name: "setInterval without unref",
-    description: "setInterval() without .unref() blocks process exit",
+    name: "setInterval without cleanup",
+    description: "setInterval() without clearInterval or .unref() may block process exit",
     pattern: "setInterval\\s*\\(",
-    negativePattern: "\\.unref\\s*\\(\\)",
-    withinLines: 50,
-    confidence: 0.9,
+    // v12.8.0: negativePattern no longer used - AST handles cleanup detection
+    negativePattern: void 0,
+    withinLines: void 0,
+    confidence: 0.92,
+    // Higher confidence with AST-based detection
     severity: "high",
     autoFixable: true,
     fixTemplate: "add_unref",
-    fileExtensions: [".ts", ".js", ".mts", ".mjs"]
+    fileExtensions: [".ts", ".js", ".mts", ".mjs"],
+    // v12.8.0: Flag to use AST-based detection
+    useAST: true
   },
   // Timer leak: setTimeout in promise without cleanup
+  // v12.8.0: Now uses AST-based detection to identify safe sleep/delay patterns
+  // This reduces false positives from simple utilities like sleep() or delay()
   {
     id: "timer-leak-timeout-promise",
     type: "promise_timeout_leak",
@@ -25161,28 +27633,36 @@ var DEFAULT_DETECTION_RULES = [
     pattern: "new\\s+Promise[^}]*setTimeout\\s*\\(",
     negativePattern: "finally|clearTimeout",
     withinLines: 20,
-    confidence: 0.7,
+    confidence: 0.85,
+    // Higher with AST-based detection
     severity: "medium",
     autoFixable: false,
     // Complex, needs manual review
-    fileExtensions: [".ts", ".js", ".mts", ".mjs"]
+    fileExtensions: [".ts", ".js", ".mts", ".mjs"],
+    // v12.8.0: Flag to use AST-based detection
+    useAST: true
   },
   // Missing destroy: EventEmitter without destroy method
-  // v12.6.0: Increased withinLines from 100 to 800 to scan entire class
-  // Classes can be large - need to check the whole class for destroy() method
+  // v12.8.0: Now uses AST-based detection for accurate class boundary analysis
+  // The regex pattern is kept as a pre-filter, but actual detection is done via AST
+  // This eliminates false positives from large classes where destroy() is far from class declaration
   {
     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,
+    // v12.8.0: negativePattern no longer used - AST handles method detection
+    negativePattern: void 0,
+    withinLines: void 0,
+    confidence: 0.95,
+    // Higher confidence with AST-based detection
     severity: "high",
     autoFixable: true,
     fixTemplate: "add_destroy_method",
-    fileExtensions: [".ts", ".js", ".mts", ".mjs"]
+    fileExtensions: [".ts", ".js", ".mts", ".mjs"],
+    // v12.8.0: Flag to use AST-based detection
+    useAST: true
   },
   // Event leak: .on() without corresponding cleanup
   {
@@ -25218,9 +27698,12 @@ var DEFAULT_DETECTION_RULES = [
 var BugDetector = class {
   rules;
   config;
+  astAnalyzer;
+  astInitialized = false;
   constructor(config, customRules) {
     this.config = config;
     this.rules = customRules || DEFAULT_DETECTION_RULES;
+    this.astAnalyzer = createASTAnalyzer();
     if (config.bugTypes && config.bugTypes.length > 0) {
       this.rules = this.rules.filter(
         (rule) => config.bugTypes.includes(rule.type)
@@ -25229,9 +27712,19 @@ var BugDetector = class {
     logger.debug("BugDetector initialized", {
       ruleCount: this.rules.length,
       bugTypes: config.bugTypes,
-      scope: config.scope
+      scope: config.scope,
+      astEnabled: true
     });
   }
+  /**
+   * Initialize AST analyzer (lazy loading to avoid bundling issues)
+   */
+  async initAST() {
+    if (!this.astInitialized) {
+      await this.astAnalyzer.init();
+      this.astInitialized = true;
+    }
+  }
   /**
    * Parse ignore comments from file lines
    *
@@ -25363,8 +27856,13 @@ var BugDetector = class {
           continue;
         }
       }
-      const ruleFindings = this.applyRule(rule, content, lines, relativePath, ignoreState);
-      findings.push(...ruleFindings);
+      if (rule.useAST) {
+        const astFindings = await this.applyASTRule(rule, content, lines, filePath, relativePath, ignoreState);
+        findings.push(...astFindings);
+      } else {
+        const ruleFindings = this.applyRule(rule, content, lines, relativePath, ignoreState);
+        findings.push(...ruleFindings);
+      }
     }
     return findings;
   }
@@ -25439,6 +27937,282 @@ var BugDetector = class {
     }
     return findings;
   }
+  /**
+   * Apply AST-based detection rule
+   * v12.8.0: Uses TypeScript AST for accurate analysis
+   */
+  async applyASTRule(rule, content, lines, filePath, relativePath, ignoreState) {
+    await this.initAST();
+    try {
+      switch (rule.type) {
+        case "missing_destroy":
+          return this.detectMissingDestroyAST(rule, content, lines, filePath, relativePath, ignoreState);
+        case "promise_timeout_leak":
+          return this.detectPromiseTimeoutLeakAST(rule, content, lines, filePath, relativePath, ignoreState);
+        case "timer_leak":
+          return this.detectTimerLeakAST(rule, content, lines, filePath, relativePath, ignoreState);
+        default:
+          logger.warn("AST detection not implemented for rule type", { type: rule.type });
+          return this.applyRule(rule, content, lines, relativePath, ignoreState);
+      }
+    } catch (error) {
+      logger.warn("AST rule application failed", {
+        ruleId: rule.id,
+        file: filePath,
+        error: error.message
+      });
+      return this.applyRule(rule, content, lines, relativePath, ignoreState);
+    }
+  }
+  /**
+   * AST-based detection for missing_destroy bug type
+   * v12.8.0: Accurate class boundary detection eliminates false positives
+   */
+  detectMissingDestroyAST(rule, content, lines, filePath, relativePath, ignoreState) {
+    const findings = [];
+    const sourceFile = this.astAnalyzer.parseFile(content, filePath);
+    const eventEmitterPattern = /^(EventEmitter|DisposableEventEmitter|SafeEventEmitter)$/;
+    const classes = this.astAnalyzer.findClassesExtending(sourceFile, eventEmitterPattern);
+    for (const classInfo of classes) {
+      if (this.shouldIgnore(classInfo.startLine, rule.type, ignoreState)) {
+        logger.debug("Class ignored by comment", {
+          file: relativePath,
+          class: classInfo.name,
+          line: classInfo.startLine
+        });
+        continue;
+      }
+      if (this.astAnalyzer.classHasDestroyMethod(classInfo)) {
+        logger.debug("Class has destroy method - no bug", {
+          file: relativePath,
+          class: classInfo.name,
+          methods: classInfo.methods.map((m) => m.name)
+        });
+        continue;
+      }
+      const extendsAllowlistedBase = classInfo.extendsClause.some(
+        (base) => ALLOWLISTS.missingDestroy.baseClassesWithDestroy.includes(base)
+      );
+      if (extendsAllowlistedBase) {
+        logger.debug("Class extends base with destroy - no bug", {
+          file: relativePath,
+          class: classInfo.name,
+          extends: classInfo.extendsClause
+        });
+        continue;
+      }
+      const implementsDestroyInterface = classInfo.implementsClause.some(
+        (iface) => ALLOWLISTS.missingDestroy.interfacesWithDestroy.includes(iface)
+      );
+      if (implementsDestroyInterface) {
+        logger.debug("Class implements destroy interface - no bug", {
+          file: relativePath,
+          class: classInfo.name,
+          implements: classInfo.implementsClause
+        });
+        continue;
+      }
+      if (classInfo.isAbstract) {
+        logger.debug("Abstract class without destroy - flagging with lower confidence", {
+          file: relativePath,
+          class: classInfo.name
+        });
+      }
+      const contextStart = Math.max(0, classInfo.startLine - 2);
+      const contextEnd = Math.min(lines.length, classInfo.startLine + 5);
+      const context = lines.slice(contextStart, contextEnd).join("\n");
+      const finding = {
+        id: randomUUID(),
+        file: relativePath,
+        lineStart: classInfo.startLine,
+        lineEnd: Math.min(classInfo.startLine + 10, classInfo.endLine),
+        type: rule.type,
+        severity: rule.severity,
+        message: `Class '${classInfo.name}' extends ${classInfo.extendsClause.join(", ")} but has no destroy() method. EventEmitter subclasses should implement destroy() to clean up listeners.`,
+        context,
+        fixStrategy: rule.autoFixable ? rule.fixTemplate : void 0,
+        confidence: classInfo.isAbstract ? rule.confidence * 0.7 : rule.confidence,
+        detectionMethod: "ast",
+        metadata: {
+          ruleId: rule.id,
+          ruleName: rule.name,
+          className: classInfo.name,
+          extendsClause: classInfo.extendsClause,
+          implementsClause: classInfo.implementsClause,
+          isAbstract: classInfo.isAbstract,
+          existingMethods: classInfo.methods.map((m) => m.name)
+        },
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      findings.push(finding);
+      logger.debug("Missing destroy bug detected (AST)", {
+        file: relativePath,
+        class: classInfo.name,
+        line: classInfo.startLine,
+        confidence: finding.confidence
+      });
+    }
+    return findings;
+  }
+  /**
+   * AST-based detection for promise_timeout_leak bug type
+   * v12.8.0: Phase 3 - Identifies safe sleep/delay patterns to reduce false positives
+   */
+  detectPromiseTimeoutLeakAST(rule, content, lines, filePath, relativePath, ignoreState) {
+    const findings = [];
+    if (this.astAnalyzer.isTestFile(filePath)) {
+      logger.debug("Skipping test file for promise_timeout_leak", { file: relativePath });
+      return findings;
+    }
+    for (const pattern of ALLOWLISTS.promiseTimeout.filePatterns) {
+      if (pattern.test(filePath)) {
+        logger.debug("Skipping allowlisted file pattern", { file: relativePath, pattern: pattern.source });
+        return findings;
+      }
+    }
+    const sourceFile = this.astAnalyzer.parseFile(content, filePath);
+    const promiseTimeouts = this.astAnalyzer.analyzePromiseTimeouts(sourceFile, content);
+    for (const info of promiseTimeouts) {
+      if (this.shouldIgnore(info.promiseLine, rule.type, ignoreState)) {
+        logger.debug("Promise+setTimeout ignored by comment", {
+          file: relativePath,
+          line: info.promiseLine
+        });
+        continue;
+      }
+      if (info.isAllowlisted) {
+        logger.debug("Promise+setTimeout is allowlisted", {
+          file: relativePath,
+          line: info.promiseLine,
+          reason: info.allowlistReason
+        });
+        continue;
+      }
+      if (info.hasCleanup) {
+        logger.debug("Promise+setTimeout has cleanup", {
+          file: relativePath,
+          line: info.promiseLine
+        });
+        continue;
+      }
+      const contextStart = Math.max(0, info.promiseLine - 2);
+      const contextEnd = Math.min(lines.length, info.timeoutLine + 3);
+      const context = lines.slice(contextStart, contextEnd).join("\n");
+      let confidence = rule.confidence;
+      if (info.timeoutIdCaptured) {
+        confidence *= 0.8;
+      }
+      if (!info.enclosingFunction) {
+        confidence *= 0.9;
+      }
+      const finding = {
+        id: randomUUID(),
+        file: relativePath,
+        lineStart: info.promiseLine,
+        lineEnd: info.timeoutLine,
+        type: rule.type,
+        severity: rule.severity,
+        message: `Promise contains setTimeout without cleanup. If the Promise is rejected before the timeout fires, the timer will still run. Consider using try/finally with clearTimeout or Promise.race with AbortController.`,
+        context,
+        fixStrategy: void 0,
+        // Complex, needs manual review
+        confidence,
+        detectionMethod: "ast",
+        metadata: {
+          ruleId: rule.id,
+          ruleName: rule.name,
+          promiseLine: info.promiseLine,
+          timeoutLine: info.timeoutLine,
+          enclosingFunction: info.enclosingFunction,
+          timeoutIdCaptured: info.timeoutIdCaptured
+        },
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      findings.push(finding);
+      logger.debug("Promise timeout leak detected (AST)", {
+        file: relativePath,
+        line: info.promiseLine,
+        confidence: finding.confidence
+      });
+    }
+    return findings;
+  }
+  /**
+   * AST-based detection for timer_leak bug type
+   * v12.8.0: Phase 5 - Variable tracking and destroy() method analysis
+   */
+  detectTimerLeakAST(rule, content, lines, filePath, relativePath, ignoreState) {
+    const findings = [];
+    if (this.astAnalyzer.isTestFile(filePath)) {
+      logger.debug("Skipping test file for timer_leak", { file: relativePath });
+      return findings;
+    }
+    const sourceFile = this.astAnalyzer.parseFile(content, filePath);
+    const timerLeaks = this.astAnalyzer.analyzeTimerLeaks(sourceFile, content);
+    for (const info of timerLeaks) {
+      if (this.shouldIgnore(info.line, rule.type, ignoreState)) {
+        logger.debug("Timer leak ignored by comment", {
+          file: relativePath,
+          line: info.line
+        });
+        continue;
+      }
+      if (info.isFalsePositive) {
+        logger.debug("Timer has proper cleanup - not a leak", {
+          file: relativePath,
+          line: info.line,
+          reason: info.falsePositiveReason
+        });
+        continue;
+      }
+      const contextStart = Math.max(0, info.line - 2);
+      const contextEnd = Math.min(lines.length, info.line + 5);
+      const context = lines.slice(contextStart, contextEnd).join("\n");
+      let confidence = rule.confidence;
+      if (!info.isValueCaptured) {
+        confidence = 0.98;
+      }
+      let message = `setInterval() `;
+      if (!info.isValueCaptured) {
+        message += `return value is not captured - timer cannot be cleared and will block process exit. `;
+      } else {
+        message += `(${info.capturedVariable}) has no cleanup. `;
+        message += `No clearInterval() or .unref() found. `;
+      }
+      message += `Consider using .unref() for non-blocking timers or clearInterval() in a destroy() method.`;
+      const finding = {
+        id: randomUUID(),
+        file: relativePath,
+        lineStart: info.line,
+        lineEnd: info.line + 3,
+        type: rule.type,
+        severity: rule.severity,
+        message,
+        context,
+        fixStrategy: rule.autoFixable ? rule.fixTemplate : void 0,
+        confidence,
+        detectionMethod: "ast",
+        metadata: {
+          ruleId: rule.id,
+          ruleName: rule.name,
+          timerType: info.timerType,
+          isValueCaptured: info.isValueCaptured,
+          capturedVariable: info.capturedVariable,
+          enclosingClass: info.enclosingClass,
+          enclosingFunction: info.enclosingFunction
+        },
+        detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      findings.push(finding);
+      logger.debug("Timer leak detected (AST)", {
+        file: relativePath,
+        line: info.line,
+        confidence: finding.confidence,
+        capturedVariable: info.capturedVariable
+      });
+    }
+    return findings;
+  }
   /**
    * Get all files to scan
    */
@@ -25995,8 +28769,7 @@ var BugFixer = class {
     for (let i = 0; i < lines.length; i++) {
       const currentLine = lines[i];
       if (!currentLine) continue;
-      const match = currentLine.match(classPattern);
-      if (match && match[1]) {
+      if (classPattern.test(currentLine)) {
         classStartLine = i;
         break;
       }
@@ -26049,7 +28822,7 @@ var BugFixer = class {
   /**
    * Apply use DisposableEventEmitter fix
    */
-  applyUseDisposableEventEmitterFix(finding, originalContent, _lines) {
+  applyUseDisposableEventEmitterFix(_finding, originalContent, _lines) {
     let fixedContent = originalContent.replace(
       /extends\s+EventEmitter\b/g,
       "extends DisposableEventEmitter"
@@ -26236,14 +29009,14 @@ var VerificationGate = class {
    * Run a shell command
    */
   async runCommand(command, name) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       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"] });
+        resolve6({ success: false, errors: ["Empty command"] });
         return;
       }
       logger.debug(`Running ${name}`, { command });
@@ -26265,10 +29038,10 @@ var VerificationGate = class {
       proc.on("close", (code) => {
         clearTimeout(timeoutId);
         if (code === 0) {
-          resolve5({ success: true, errors: [] });
+          resolve6({ success: true, errors: [] });
         } else {
           const errorLines = stderr.split("\n").filter((line) => line.includes("error") || line.includes("Error") || line.includes("FAIL")).slice(0, 10);
-          resolve5({
+          resolve6({
             success: false,
             errors: errorLines.length > 0 ? errorLines : [`${name} failed with exit code ${code}`]
           });
@@ -26276,7 +29049,7 @@ var VerificationGate = class {
       });
       proc.on("error", (err) => {
         clearTimeout(timeoutId);
-        resolve5({
+        resolve6({
           success: false,
           errors: [err.message]
         });
@@ -28891,6 +31664,18 @@ function shouldIgnoreLine6(lineNum, type, ignoreState) {
 
 // src/core/refactor/detectors/dead-code-detector.ts
 init_esm_shims();
+var astAnalyzer = null;
+var astInitialized = false;
+async function getASTAnalyzer() {
+  if (!astAnalyzer) {
+    astAnalyzer = createASTAnalyzer(50);
+  }
+  if (!astInitialized) {
+    await astAnalyzer.init();
+    astInitialized = true;
+  }
+  return astAnalyzer;
+}
 var DEAD_CODE_RULES = [
   {
     id: "unused-import",
@@ -28916,12 +31701,15 @@ var DEAD_CODE_RULES = [
     suggestion: "Remove unused variable or prefix with underscore",
     fileExtensions: [".ts", ".tsx", ".js", ".jsx"]
   },
+  // v12.8.0: Changed to AST-based detection for better accuracy
+  // AST analysis correctly handles switch/case statements and nested blocks
   {
     id: "unreachable-code",
     type: "dead_code",
     description: "Code after return/throw/break is unreachable",
     pattern: /(?:return|throw|break|continue)\s+[^;]*;\s*\n\s*[^}\s]/,
-    detector: "regex",
+    detector: "ast",
+    // Changed from 'regex' to 'ast'
     severity: "medium",
     confidence: 0.95,
     autoFixable: true,
@@ -28953,11 +31741,11 @@ var DEAD_CODE_RULES = [
     suggestion: "Implement function or add TODO comment"
   }
 ];
-function detectDeadCode(filePath, content, lines, ignoreState, _config) {
+async function detectDeadCode(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   findings.push(...detectUnusedImports(filePath, content, lines, ignoreState));
   findings.push(...detectUnusedVariables(filePath, content, lines, ignoreState));
-  findings.push(...detectUnreachableCode(filePath, content, lines, ignoreState));
+  findings.push(...await detectUnreachableCode(filePath, content, lines, ignoreState));
   findings.push(...detectCommentedCode(filePath, content, lines, ignoreState));
   return findings;
 }
@@ -29068,7 +31856,42 @@ function detectUnusedVariables(filePath, content, lines, ignoreState) {
   }
   return findings;
 }
-function detectUnreachableCode(filePath, content, lines, ignoreState) {
+async function detectUnreachableCode(filePath, content, lines, ignoreState) {
+  const findings = [];
+  try {
+    const analyzer = await getASTAnalyzer();
+    const sourceFile = analyzer.parseFile(content, filePath);
+    const unreachableInfos = analyzer.analyzeUnreachableCode(sourceFile);
+    for (const info of unreachableInfos) {
+      if (info.isFalsePositive) {
+        continue;
+      }
+      if (shouldIgnoreLine7(info.line, "dead_code", ignoreState)) {
+        continue;
+      }
+      findings.push(
+        createFinding(
+          filePath,
+          info.line,
+          info.line,
+          "dead_code",
+          "medium",
+          `Unreachable code after ${info.reason} statement`,
+          info.code,
+          "unreachable-code",
+          0.95,
+          "static",
+          "Remove unreachable code",
+          { linesRemoved: 1 }
+        )
+      );
+    }
+  } catch {
+    findings.push(...detectUnreachableCodeFallback(filePath, lines, ignoreState));
+  }
+  return findings;
+}
+function detectUnreachableCodeFallback(filePath, lines, ignoreState) {
   const findings = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -29093,7 +31916,8 @@ function detectUnreachableCode(filePath, content, lines, ignoreState) {
             "Unreachable code after return/throw/break",
             lines[j] || "",
             "unreachable-code",
-            0.95,
+            0.85,
+            // Lower confidence for fallback
             "static",
             "Remove unreachable code",
             { linesRemoved: 1 }
@@ -29583,7 +32407,7 @@ var RefactorDetector = class {
         findings.push(...detectConditionals(filePath, content, lines, ignoreState, this.config));
         break;
       case "dead_code":
-        findings.push(...detectDeadCode(filePath, content, lines, ignoreState, this.config));
+        findings.push(...await detectDeadCode(filePath, content, lines, ignoreState, this.config));
         break;
       case "type_safety":
         findings.push(...detectTypeSafety(filePath, content, lines, ignoreState, this.config));
@@ -31916,7 +34740,7 @@ var NATIVE_MODULE_ERROR_PATTERNS = [
   "was compiled against a different Node.js version",
   "better_sqlite3.node"
 ];
-var DEFAULT_CONFIG3 = {
+var DEFAULT_CONFIG4 = {
   dbPath: `${AX_PATHS.TASKS}/tasks.db`,
   maxPayloadBytes: 1024 * 1024,
   // 1MB
@@ -32082,7 +34906,7 @@ var TaskStore = class {
   stmtCountByStatus;
   stmtFindByHash;
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.config = { ...DEFAULT_CONFIG4, ...config };
     this.db = DatabaseFactory.create(this.config.dbPath, {
       busyTimeout: this.config.busyTimeout,
       enableWal: true
@@ -32547,7 +35371,7 @@ var InMemoryTaskStore = class {
   config;
   closed = false;
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.config = { ...DEFAULT_CONFIG4, ...config };
     logger.warn("Using in-memory task store fallback (SQLite unavailable)", {
       nodeVersion: process.version
     });
@@ -32789,7 +35613,7 @@ function createTaskStore(config) {
 // src/core/task-engine/engine.ts
 init_esm_shims();
 init_logger();
-var DEFAULT_CONFIG4 = {
+var DEFAULT_CONFIG5 = {
   store: {},
   loopGuard: {},
   maxConcurrent: 50,
@@ -32820,10 +35644,10 @@ var TaskEngine = class extends EventEmitter {
   constructor(config = {}) {
     super();
     this.config = {
-      ...DEFAULT_CONFIG4,
+      ...DEFAULT_CONFIG5,
       ...config,
-      store: { ...DEFAULT_CONFIG4.store, ...config.store },
-      loopGuard: { ...DEFAULT_CONFIG4.loopGuard, ...config.loopGuard }
+      store: { ...DEFAULT_CONFIG5.store, ...config.store },
+      loopGuard: { ...DEFAULT_CONFIG5.loopGuard, ...config.loopGuard }
     };
     this.loopGuard = createLoopGuard(this.config.loopGuard);
     this.store = createTaskStore(this.config.store);
@@ -33269,7 +36093,7 @@ var TaskEngine = class extends EventEmitter {
     }
   }
   sleep(ms, signal) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       if (signal?.aborted) {
         reject(new Error("Aborted"));
         return;
@@ -33280,7 +36104,7 @@ var TaskEngine = class extends EventEmitter {
       };
       const timeoutId = setTimeout(() => {
         signal?.removeEventListener("abort", abortHandler);
-        resolve5();
+        resolve6();
       }, ms);
       signal?.addEventListener("abort", abortHandler, { once: true });
     });
@@ -33875,10 +36699,10 @@ var McpClient = class _McpClient extends EventEmitter {
       return;
     }
     if (this.state.status === "connecting") {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         const onConnected = () => {
           this.off("error", onError);
-          resolve5();
+          resolve6();
         };
         const onError = (err) => {
           this.off("connected", onConnected);
@@ -34053,14 +36877,14 @@ var McpClient = class _McpClient extends EventEmitter {
       method,
       params
     };
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const timeoutMs = timeout ?? this.config.timeout;
       const timeoutHandle = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(new Error(`Request timed out after ${timeoutMs}ms: ${method}`));
       }, timeoutMs);
       this.pendingRequests.set(id, {
-        resolve: resolve5,
+        resolve: resolve6,
         reject,
         timeout: timeoutHandle
       });
@@ -34263,7 +37087,7 @@ var ConnectionTimeoutError = class extends McpClientError {
 
 // src/providers/mcp/pool-manager.ts
 init_validation_limits();
-var DEFAULT_CONFIG6 = {
+var DEFAULT_CONFIG7 = {
   maxConnectionsPerProvider: 2,
   idleTimeoutMs: TIMEOUTS.IDLE_CONNECTION,
   // 5 minutes
@@ -34284,7 +37108,7 @@ var McpClientPool = class extends EventEmitter {
   drainHandler;
   constructor(config = {}) {
     super();
-    this.config = { ...DEFAULT_CONFIG6, ...config };
+    this.config = { ...DEFAULT_CONFIG7, ...config };
     this.startHealthChecks();
     this.startIdleCleanup();
     this.drainHandler = () => this.drain();
@@ -34556,15 +37380,15 @@ var McpClientPool = class extends EventEmitter {
     }
   }
   async waitForConnection(provider, pool) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const timeout = setTimeout(() => {
-        const index = pool.waitQueue.findIndex((w) => w.resolve === resolve5);
+        const index = pool.waitQueue.findIndex((w) => w.resolve === resolve6);
         if (index !== -1) {
           pool.waitQueue.splice(index, 1);
         }
         reject(new ConnectionTimeoutError(provider, this.config.acquireTimeoutMs));
       }, this.config.acquireTimeoutMs);
-      pool.waitQueue.push({ resolve: resolve5, reject, timeout });
+      pool.waitQueue.push({ resolve: resolve6, reject, timeout });
       logger.debug("[MCP Pool] Waiting for connection", {
         provider,
         queuePosition: pool.waitQueue.length