@defai.digital/automatosx 12.6.1 → 12.6.3

package/dist/mcp/index.js

@@ -22,7 +22,6 @@ import { EventEmitter } from 'events';
 import { findUp } from 'find-up';
 import * as sqliteVec from 'sqlite-vec';
 import { randomUUID, randomBytes, createHash } from 'crypto';
-import yaml from 'yaml';
 import { gzipSync, gunzipSync } from 'zlib';
 
 var __defProp = Object.defineProperty;
@@ -772,6 +771,119 @@ var init_errors = __esm({
   }
 });
 
+// src/shared/utils/safe-timers.ts
+function createSafeInterval(callback, intervalMs, options = {}) {
+  const { ref = false, name, signal, immediate = false } = options;
+  if (signal?.aborted) {
+    logger.debug("createSafeInterval: already aborted", { name });
+    return () => {
+    };
+  }
+  let cleared = false;
+  let intervalId = null;
+  const safeCallback = async () => {
+    if (cleared) return;
+    try {
+      await callback();
+    } catch (error) {
+      logger.error("Safe interval callback error", {
+        name,
+        error: error.message
+      });
+    }
+  };
+  if (immediate) {
+    setImmediate(() => {
+      if (!cleared) {
+        safeCallback();
+      }
+    });
+  }
+  intervalId = setInterval(safeCallback, intervalMs);
+  if (!ref && intervalId.unref) {
+    intervalId.unref();
+  }
+  const cleanup = () => {
+    if (cleared) return;
+    cleared = true;
+    if (intervalId !== null) {
+      clearInterval(intervalId);
+      intervalId = null;
+      logger.debug("Safe interval cleared", { name });
+    }
+  };
+  if (signal) {
+    signal.addEventListener("abort", cleanup, { once: true });
+  }
+  logger.debug("Safe interval created", {
+    name,
+    intervalMs,
+    ref,
+    immediate
+  });
+  return cleanup;
+}
+function createSafeTimeout(callback, delayMs, options = {}) {
+  const { ref = false, name, signal } = options;
+  if (signal?.aborted) {
+    logger.debug("createSafeTimeout: already aborted", { name });
+    return () => {
+    };
+  }
+  let cleared = false;
+  let timeoutId = null;
+  const safeCallback = async () => {
+    if (cleared) return;
+    cleared = true;
+    try {
+      await callback();
+    } catch (error) {
+      logger.error("Safe timeout callback error", {
+        name,
+        error: error.message
+      });
+    }
+  };
+  timeoutId = setTimeout(safeCallback, delayMs);
+  if (!ref && timeoutId.unref) {
+    timeoutId.unref();
+  }
+  const cleanup = () => {
+    if (cleared) return;
+    cleared = true;
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+      logger.debug("Safe timeout cleared", { name });
+    }
+  };
+  if (signal) {
+    signal.addEventListener("abort", cleanup, { once: true });
+  }
+  logger.debug("Safe timeout created", {
+    name,
+    delayMs,
+    ref
+  });
+  return cleanup;
+}
+async function sleep(ms, signal) {
+  return new Promise((resolve5, reject) => {
+    const timeoutId = setTimeout(() => {
+      resolve5();
+    }, ms);
+    if (timeoutId.unref) {
+      timeoutId.unref();
+    }
+  });
+}
+var init_safe_timers = __esm({
+  "src/shared/utils/safe-timers.ts"() {
+    init_esm_shims();
+    init_logger();
+  }
+});
+
 // src/shared/process/process-manager.ts
 var process_manager_exports = {};
 __export(process_manager_exports, {
@@ -2379,6 +2491,7 @@ function getRetryableErrors(provider) {
       return [...baseErrors, ...CODEX_RETRYABLE_ERRORS];
     case "glm":
     case "grok":
+    case "qwen":
       return [...baseErrors, ...OPENAI_RETRYABLE_ERRORS];
     case "base":
     default:
@@ -2481,6 +2594,10 @@ var init_base_provider = __esm({
         // v12.0.0: Native Grok provider (xAI)
         "ax-grok",
         // v12.0.0: Alias for grok
+        "qwen",
+        // v12.7.0: Qwen Code provider (Alibaba Cloud)
+        "qwen-code",
+        // v12.7.0: Alias for qwen
         "test-provider"
         // For unit tests
       ];
@@ -2843,7 +2960,7 @@ var init_base_provider = __esm({
             if (readlineInterface) {
               try {
                 readlineInterface.close();
-              } catch (error) {
+              } catch {
               } finally {
                 readlineInterface = null;
               }
@@ -2851,7 +2968,7 @@ var init_base_provider = __esm({
             if (stderrInterface) {
               try {
                 stderrInterface.close();
-              } catch (error) {
+              } catch {
               } finally {
                 stderrInterface = null;
               }
@@ -3045,7 +3162,7 @@ ${fullPrompt}
             this.health.consecutiveSuccesses = 0;
           }
           return available;
-        } catch (error) {
+        } catch {
           this.health.available = false;
           this.health.errorRate = 1;
           this.health.lastCheck = Date.now();
@@ -3221,6 +3338,8 @@ ${fullPrompt}
           retryableProvider = "glm";
         } else if (providerName === "grok" || providerName === "ax-grok") {
           retryableProvider = "grok";
+        } else if (providerName === "qwen" || providerName === "qwen-code") {
+          retryableProvider = "qwen";
         }
         return shouldRetryError(error, retryableProvider);
       }
@@ -5295,6 +5414,7 @@ var init_hybrid_adapter_base = __esm({
     init_flags();
     init_fallback_decision();
     init_provider_metrics();
+    init_safe_timers();
     DEFAULT_CIRCUIT_BREAKER_CONFIG = {
       failureThreshold: 3,
       resetTimeout: 6e4,
@@ -5449,7 +5569,7 @@ var init_hybrid_adapter_base = __esm({
             });
             if (classification.decision === "retry_sdk" /* RETRY_SDK */ && attempt < this.maxRetries) {
               const delay = classification.retryDelayMs || 1e3;
-              await this.sleep(delay);
+              await sleep(delay);
               continue;
             }
             if (classification.decision === "use_cli" /* USE_CLI */ || classification.decision === "retry_sdk" /* RETRY_SDK */ && attempt >= this.maxRetries) {
@@ -5624,12 +5744,6 @@ var init_hybrid_adapter_base = __esm({
         } catch {
         }
       }
-      /**
-       * Sleep utility
-       */
-      sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
-      }
       /**
        * Get current active mode
        */
@@ -5680,13 +5794,21 @@ var init_types2 = __esm({
   "src/integrations/ax-glm/types.ts"() {
     init_esm_shims();
     GLM_MODEL_MAPPING = {
+      // Convenience aliases (ax-cli v4.3.15)
+      "glm-latest": "glm-4.6",
+      "glm-vision": "glm-4.6v",
+      "glm-fast": "glm-4-flash",
+      "glm-image": "cogview-4",
+      // Legacy aliases (deprecated)
       "glm-4-plus": "glm-4.6",
-      "glm-4v": "glm-4.5v",
+      "glm-4.5v": "glm-4.6v",
+      "glm-4v": "glm-4.6v",
+      "glm-4": "glm-4.6",
       "glm-4-air": "glm-4-flash",
       "glm-4-airx": "glm-4-flash"
     };
     GLM_DEFAULT_BASE_URL = "https://open.bigmodel.cn/api/paas/v4";
-    GLM_DEFAULT_MODEL = "glm-4";
+    GLM_DEFAULT_MODEL = "glm-4.6";
     GLM_DEFAULT_COMMAND = "ax-glm";
   }
 });
@@ -6225,6 +6347,7 @@ var init_sdk_only_adapter = __esm({
   "src/integrations/ax-glm/sdk-only-adapter.ts"() {
     init_esm_shims();
     init_logger();
+    init_safe_timers();
     init_sdk_adapter2();
     init_types2();
     GLMSdkOnlyAdapter = class {
@@ -6304,7 +6427,7 @@ var init_sdk_only_adapter = __esm({
                 attempt: attempt + 1,
                 delayMs: delay
               });
-              await this.sleep(delay);
+              await sleep(delay);
               continue;
             }
             break;
@@ -6340,12 +6463,6 @@ var init_sdk_only_adapter = __esm({
         }
         return false;
       }
-      /**
-       * Sleep utility
-       */
-      sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
-      }
       /**
        * Get the configured model
        */
@@ -6640,10 +6757,18 @@ var init_types3 = __esm({
   "src/integrations/ax-grok/types.ts"() {
     init_esm_shims();
     GROK_MODEL_MAPPING = {
-      "grok-beta": "grok-3"
+      // Convenience aliases (ax-cli v4.3.15)
+      "grok-latest": "grok-4-0709",
+      "grok-fast": "grok-4.1-fast",
+      "grok-mini": "grok-3-mini",
+      "grok-vision": "grok-2-vision-1212",
+      "grok-image": "grok-2-image-1212",
+      // Legacy aliases (deprecated)
+      "grok-beta": "grok-3",
+      "grok-2-vision": "grok-2-vision-1212"
     };
     GROK_DEFAULT_BASE_URL = "https://api.x.ai/v1";
-    GROK_DEFAULT_MODEL = "grok-3";
+    GROK_DEFAULT_MODEL = "grok-4-0709";
     GROK_DEFAULT_COMMAND = "ax-grok";
   }
 });
@@ -7182,6 +7307,7 @@ var init_sdk_only_adapter2 = __esm({
   "src/integrations/ax-grok/sdk-only-adapter.ts"() {
     init_esm_shims();
     init_logger();
+    init_safe_timers();
     init_sdk_adapter3();
     init_types3();
     GrokSdkOnlyAdapter = class {
@@ -7261,7 +7387,7 @@ var init_sdk_only_adapter2 = __esm({
                 attempt: attempt + 1,
                 delayMs: delay
               });
-              await this.sleep(delay);
+              await sleep(delay);
               continue;
             }
             break;
@@ -7297,12 +7423,6 @@ var init_sdk_only_adapter2 = __esm({
         }
         return false;
       }
-      /**
-       * Sleep utility
-       */
-      sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
-      }
       /**
        * Get the configured model
        */
@@ -7580,6 +7700,902 @@ Mode: ${this.grokConfig.mode || "auto"}`;
   }
 });
 
+// src/integrations/qwen-code/types.ts
+function normalizeQwenModel(model) {
+  return QWEN_MODEL_MAPPING[model] || model;
+}
+function isVisionModel(model) {
+  return model.includes("qwen3-coder") || model.includes("qwen-max");
+}
+function getModelContextWindow(model) {
+  const normalizedModel = normalizeQwenModel(model);
+  if (normalizedModel.includes("480b")) return 128e3;
+  if (normalizedModel.includes("30b")) return 64e3;
+  if (normalizedModel.includes("qwen-max")) return 128e3;
+  if (normalizedModel.includes("qwen-plus")) return 128e3;
+  if (normalizedModel.includes("qwen-turbo")) return 128e3;
+  return 64e3;
+}
+var QWEN_DEFAULT_BASE_URL, QWEN_DEFAULT_MODEL, QWEN_DEFAULT_COMMAND, QWEN_MODEL_MAPPING;
+var init_types4 = __esm({
+  "src/integrations/qwen-code/types.ts"() {
+    init_esm_shims();
+    QWEN_DEFAULT_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+    QWEN_DEFAULT_MODEL = "qwen-turbo";
+    QWEN_DEFAULT_COMMAND = "qwen";
+    QWEN_MODEL_MAPPING = {
+      // Normalize common aliases
+      "qwen-coder": "qwen3-coder-480b-a35b-instruct",
+      "qwen-coder-480b": "qwen3-coder-480b-a35b-instruct",
+      "qwen-coder-30b": "qwen3-coder-30b-a3b-instruct",
+      "qwen2.5-coder": "qwen2.5-coder-32b-instruct"
+    };
+  }
+});
+
+// src/integrations/qwen-code/sdk-adapter.ts
+var QwenSdkAdapter;
+var init_sdk_adapter4 = __esm({
+  "src/integrations/qwen-code/sdk-adapter.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_validation_limits();
+    init_types4();
+    QwenSdkAdapter = class {
+      client = null;
+      config;
+      initialized = false;
+      constructor(config = {}) {
+        const apiKey = config.apiKey || process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY || "";
+        this.config = {
+          apiKey,
+          baseUrl: config.baseUrl || QWEN_DEFAULT_BASE_URL,
+          model: config.model || QWEN_DEFAULT_MODEL,
+          timeout: config.timeout || TIMEOUTS.PROVIDER_DEFAULT
+        };
+        logger.debug("[Qwen SDK] Adapter created", {
+          model: this.config.model,
+          baseUrl: this.config.baseUrl,
+          hasApiKey: !!this.config.apiKey
+        });
+      }
+      /**
+       * Check if SDK is available (OpenAI package installed and API key configured)
+       */
+      async isAvailable() {
+        try {
+          if (!this.config.apiKey) {
+            logger.debug("[Qwen SDK] No API key configured (set DASHSCOPE_API_KEY or QWEN_API_KEY)");
+            return false;
+          }
+          await import('openai');
+          return true;
+        } catch (error) {
+          logger.debug("[Qwen SDK] OpenAI SDK not available", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Initialize the SDK client
+       */
+      async initialize() {
+        if (this.initialized) {
+          return;
+        }
+        try {
+          const OpenAI = (await import('openai')).default;
+          this.client = new OpenAI({
+            apiKey: this.config.apiKey,
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeout
+          });
+          this.initialized = true;
+          logger.debug("[Qwen SDK] Client initialized", {
+            model: this.config.model
+          });
+        } catch (error) {
+          throw new Error(
+            `Failed to initialize Qwen SDK: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * Execute a request using the Qwen SDK
+       */
+      async execute(request) {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        const startTime = Date.now();
+        try {
+          const messages = [];
+          if (request.systemPrompt) {
+            messages.push({
+              role: "system",
+              content: request.systemPrompt
+            });
+          }
+          messages.push({
+            role: "user",
+            content: request.prompt
+          });
+          const model = normalizeQwenModel(request.model || this.config.model);
+          logger.debug("[Qwen SDK] Executing request", {
+            model,
+            messageCount: messages.length,
+            promptLength: request.prompt.length
+          });
+          const openaiClient = this.client;
+          const response = await openaiClient.chat.completions.create({
+            model,
+            messages,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stream: false
+          });
+          const latencyMs = Date.now() - startTime;
+          if (!response.choices || response.choices.length === 0) {
+            throw new Error("Qwen API returned empty choices array");
+          }
+          const choice = response.choices[0];
+          const content = choice?.message?.content || "";
+          const finishReason = choice?.finish_reason || "unknown";
+          logger.debug("[Qwen SDK] Request completed", {
+            model: response.model,
+            latencyMs,
+            tokensUsed: response.usage?.total_tokens
+          });
+          return {
+            content,
+            model: response.model,
+            tokensUsed: response.usage ? {
+              prompt: response.usage.prompt_tokens,
+              completion: response.usage.completion_tokens,
+              total: response.usage.total_tokens
+            } : { prompt: 0, completion: 0, total: 0 },
+            latencyMs,
+            finishReason,
+            cached: false
+          };
+        } catch (error) {
+          const latencyMs = Date.now() - startTime;
+          logger.error("[Qwen SDK] Request failed", {
+            error: error instanceof Error ? error.message : String(error),
+            latencyMs
+          });
+          throw error;
+        }
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.config.model;
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        this.client = null;
+        this.initialized = false;
+        logger.debug("[Qwen SDK] Adapter destroyed");
+      }
+    };
+  }
+});
+var NON_INTERACTIVE_ENV, SIGKILL_ESCALATION_MS, QwenCliWrapper;
+var init_cli_wrapper4 = __esm({
+  "src/integrations/qwen-code/cli-wrapper.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_validation_limits();
+    init_cli_provider_detector();
+    init_types4();
+    NON_INTERACTIVE_ENV = {
+      TERM: "dumb",
+      NO_COLOR: "1",
+      FORCE_COLOR: "0",
+      CI: "true",
+      NO_UPDATE_NOTIFIER: "1",
+      DEBIAN_FRONTEND: "noninteractive"
+    };
+    SIGKILL_ESCALATION_MS = 5e3;
+    QwenCliWrapper = class {
+      config;
+      constructor(config = {}) {
+        this.config = {
+          command: config.command || QWEN_DEFAULT_COMMAND,
+          vlmSwitchMode: config.vlmSwitchMode || "once",
+          yolo: config.yolo || false,
+          timeout: config.timeout || TIMEOUTS.PROVIDER_DEFAULT
+        };
+        logger.debug("[Qwen CLI] Wrapper created", {
+          command: this.config.command,
+          timeout: this.config.timeout
+        });
+      }
+      /**
+       * Check if Qwen CLI is available on PATH
+       */
+      async isAvailable() {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          return true;
+        }
+        try {
+          const result = findOnPath(this.config.command);
+          logger.debug("[Qwen CLI] Availability check", {
+            available: result.found,
+            path: result.path
+          });
+          return result.found;
+        } catch (error) {
+          logger.debug("[Qwen CLI] Availability check failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Execute a prompt using the Qwen CLI
+       *
+       * Since Qwen CLI is interactive, we:
+       * 1. Spawn the process
+       * 2. Send the prompt via stdin
+       * 3. Capture output until we detect completion
+       * 4. Return the response
+       */
+      async execute(request) {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          return this.createMockResponse(request.prompt);
+        }
+        const startTime = Date.now();
+        return new Promise((resolve5, reject) => {
+          const args2 = [];
+          if (this.config.vlmSwitchMode !== "once") {
+            args2.push("--vlm-switch-mode", this.config.vlmSwitchMode);
+          }
+          if (this.config.yolo) {
+            args2.push("--yolo");
+          }
+          logger.debug("[Qwen CLI] Spawning process", {
+            command: this.config.command,
+            args: args2,
+            promptLength: request.prompt.length
+          });
+          const child = spawn(this.config.command, args2, {
+            env: { ...process.env, ...NON_INTERACTIVE_ENV }
+          });
+          let stdout = "";
+          let stderr = "";
+          let timeoutId = null;
+          let forceKillTimer = null;
+          let readlineInterface = null;
+          let responseStarted = false;
+          const cleanup = () => {
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              timeoutId = null;
+            }
+            if (forceKillTimer) {
+              clearTimeout(forceKillTimer);
+              forceKillTimer = null;
+            }
+            if (readlineInterface) {
+              try {
+                readlineInterface.close();
+              } catch {
+              }
+              readlineInterface = null;
+            }
+          };
+          if (child.stdout) {
+            readlineInterface = readline.createInterface({
+              input: child.stdout,
+              crlfDelay: Infinity
+            });
+            readlineInterface.on("line", (line) => {
+              if (line.startsWith(">") && !responseStarted) {
+                responseStarted = true;
+                return;
+              }
+              if (responseStarted) {
+                stdout += line + "\n";
+              }
+            });
+            readlineInterface.on("error", (error) => {
+              logger.debug("[Qwen CLI] Readline error", {
+                error: error.message
+              });
+            });
+          }
+          if (child.stderr) {
+            child.stderr.on("data", (data) => {
+              stderr += data.toString();
+            });
+          }
+          if (child.stdin) {
+            try {
+              let fullPrompt = request.prompt;
+              if (request.systemPrompt) {
+                fullPrompt = `${request.systemPrompt}
+
+${request.prompt}`;
+              }
+              child.stdin.write(fullPrompt);
+              child.stdin.write("\n");
+              child.stdin.end();
+            } catch (error) {
+              cleanup();
+              child.kill("SIGTERM");
+              reject(new Error(`Failed to write to Qwen stdin: ${error instanceof Error ? error.message : String(error)}`));
+              return;
+            }
+          } else {
+            cleanup();
+            reject(new Error("Qwen CLI stdin not available"));
+            return;
+          }
+          child.on("close", (code, signal) => {
+            cleanup();
+            const latencyMs = Date.now() - startTime;
+            if (stderr) {
+              logger.debug("[Qwen CLI] stderr output", { stderr: stderr.trim() });
+            }
+            if ((code === 0 || code === null) && !signal) {
+              const content = this.parseResponse(stdout);
+              resolve5({
+                content: content.trim(),
+                model: "qwen-code-cli",
+                tokensUsed: {
+                  prompt: this.estimateTokens(request.prompt),
+                  completion: this.estimateTokens(content),
+                  total: this.estimateTokens(request.prompt) + this.estimateTokens(content)
+                },
+                latencyMs,
+                finishReason: "stop",
+                cached: false
+              });
+            } else if (signal) {
+              reject(new Error(`Qwen CLI killed by signal ${signal}. stderr: ${stderr || "none"}`));
+            } else {
+              reject(new Error(`Qwen CLI exited with code ${code}. stderr: ${stderr || "none"}`));
+            }
+          });
+          child.on("error", (error) => {
+            cleanup();
+            logger.error("[Qwen CLI] Process error", {
+              error: error.message
+            });
+            reject(new Error(`Failed to spawn Qwen CLI: ${error.message}`));
+          });
+          timeoutId = setTimeout(() => {
+            if (child.pid && !child.killed) {
+              logger.warn("[Qwen CLI] Killing process due to timeout", {
+                pid: child.pid,
+                timeout: this.config.timeout
+              });
+              child.kill("SIGTERM");
+              forceKillTimer = setTimeout(() => {
+                if (child.pid) {
+                  try {
+                    process.kill(child.pid, 0);
+                    logger.warn("[Qwen CLI] Force killing process", { pid: child.pid });
+                    child.kill("SIGKILL");
+                  } catch {
+                  }
+                }
+              }, SIGKILL_ESCALATION_MS);
+            }
+          }, this.config.timeout);
+        });
+      }
+      /**
+       * Parse response from CLI output
+       *
+       * Qwen CLI outputs include prompts and formatting that we need to strip.
+       */
+      parseResponse(output) {
+        let content = output.trim();
+        content = content.replace(/\x1B\[[0-9;]*[mGKH]/g, "");
+        content = content.replace(/^>\s*/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+        return content;
+      }
+      /**
+       * Estimate token count
+       */
+      estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+      }
+      /**
+       * Create mock response for testing
+       */
+      createMockResponse(prompt) {
+        return {
+          content: `[Mock Qwen Response]
+
+This is a mock response from Qwen Code CLI.
+Prompt length: ${prompt.length} characters.`,
+          model: "qwen-code-cli-mock",
+          tokensUsed: {
+            prompt: this.estimateTokens(prompt),
+            completion: 50,
+            total: this.estimateTokens(prompt) + 50
+          },
+          latencyMs: 10,
+          finishReason: "stop",
+          cached: false
+        };
+      }
+      /**
+       * Get CLI command
+       */
+      getCommand() {
+        return this.config.command;
+      }
+    };
+  }
+});
+
+// src/integrations/qwen-code/hybrid-adapter.ts
+var QwenHybridAdapter;
+var init_hybrid_adapter4 = __esm({
+  "src/integrations/qwen-code/hybrid-adapter.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_sdk_adapter4();
+    init_cli_wrapper4();
+    QwenHybridAdapter = class {
+      sdkAdapter = null;
+      cliWrapper = null;
+      options;
+      activeMode = null;
+      // Circuit breakers for each mode
+      sdkCircuitBreaker = {
+        failures: 0,
+        lastFailure: 0,
+        isOpen: false
+      };
+      cliCircuitBreaker = {
+        failures: 0,
+        lastFailure: 0,
+        isOpen: false
+      };
+      // Circuit breaker configuration
+      FAILURE_THRESHOLD = 3;
+      RECOVERY_TIMEOUT_MS = 6e4;
+      // 1 minute
+      constructor(options = {}) {
+        this.options = {
+          mode: options.mode || "auto",
+          model: options.model || "qwen-turbo",
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          command: options.command || "qwen",
+          timeout: options.timeout
+        };
+        logger.debug("[Qwen Hybrid] Adapter created", {
+          mode: this.options.mode,
+          model: this.options.model
+        });
+      }
+      /**
+       * Get or create SDK adapter
+       */
+      getSdkAdapter() {
+        if (!this.sdkAdapter) {
+          const config = {
+            apiKey: this.options.apiKey,
+            baseUrl: this.options.baseUrl,
+            model: this.options.model,
+            timeout: this.options.timeout
+          };
+          this.sdkAdapter = new QwenSdkAdapter(config);
+        }
+        return this.sdkAdapter;
+      }
+      /**
+       * Get or create CLI wrapper
+       */
+      getCliWrapper() {
+        if (!this.cliWrapper) {
+          const config = {
+            command: this.options.command,
+            timeout: this.options.timeout
+          };
+          this.cliWrapper = new QwenCliWrapper(config);
+        }
+        return this.cliWrapper;
+      }
+      /**
+       * Check if a circuit breaker should allow requests
+       */
+      isCircuitClosed(breaker) {
+        if (!breaker.isOpen) {
+          return true;
+        }
+        if (Date.now() - breaker.lastFailure > this.RECOVERY_TIMEOUT_MS) {
+          breaker.isOpen = false;
+          breaker.failures = 0;
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Record a failure on a circuit breaker
+       */
+      recordFailure(breaker) {
+        breaker.failures++;
+        breaker.lastFailure = Date.now();
+        if (breaker.failures >= this.FAILURE_THRESHOLD) {
+          breaker.isOpen = true;
+          logger.warn("[Qwen Hybrid] Circuit breaker opened", {
+            failures: breaker.failures
+          });
+        }
+      }
+      /**
+       * Record a success on a circuit breaker
+       */
+      recordSuccess(breaker) {
+        breaker.failures = 0;
+        breaker.isOpen = false;
+      }
+      /**
+       * Execute a request using the appropriate mode
+       */
+      async execute(request) {
+        const mode = this.options.mode;
+        if (mode === "sdk") {
+          return this.executeWithSdk(request);
+        }
+        if (mode === "cli") {
+          return this.executeWithCli(request);
+        }
+        return this.executeWithAuto(request);
+      }
+      /**
+       * Execute with SDK only
+       */
+      async executeWithSdk(request) {
+        const adapter = this.getSdkAdapter();
+        if (!await adapter.isAvailable()) {
+          throw new Error("Qwen SDK is not available. Check DASHSCOPE_API_KEY or QWEN_API_KEY.");
+        }
+        this.activeMode = "sdk";
+        return adapter.execute(request);
+      }
+      /**
+       * Execute with CLI only
+       */
+      async executeWithCli(request) {
+        const wrapper = this.getCliWrapper();
+        if (!await wrapper.isAvailable()) {
+          throw new Error("Qwen CLI is not available. Run: npm install -g @qwen-code/qwen-code@latest");
+        }
+        this.activeMode = "cli";
+        return wrapper.execute(request);
+      }
+      /**
+       * Execute with automatic mode selection
+       */
+      async executeWithAuto(request) {
+        if (this.isCircuitClosed(this.sdkCircuitBreaker)) {
+          const adapter = this.getSdkAdapter();
+          try {
+            if (await adapter.isAvailable()) {
+              logger.debug("[Qwen Hybrid] Using SDK mode");
+              this.activeMode = "sdk";
+              const response = await adapter.execute(request);
+              this.recordSuccess(this.sdkCircuitBreaker);
+              return response;
+            }
+          } catch (error) {
+            logger.warn("[Qwen Hybrid] SDK execution failed, trying CLI", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+            this.recordFailure(this.sdkCircuitBreaker);
+          }
+        }
+        if (this.isCircuitClosed(this.cliCircuitBreaker)) {
+          const wrapper = this.getCliWrapper();
+          try {
+            if (await wrapper.isAvailable()) {
+              logger.debug("[Qwen Hybrid] Using CLI mode (fallback)");
+              this.activeMode = "cli";
+              const response = await wrapper.execute(request);
+              this.recordSuccess(this.cliCircuitBreaker);
+              return response;
+            }
+          } catch (error) {
+            logger.error("[Qwen Hybrid] CLI execution also failed", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+            this.recordFailure(this.cliCircuitBreaker);
+            throw error;
+          }
+        }
+        throw new Error(
+          "Qwen execution failed: Both SDK and CLI modes are unavailable or have failed too many times. Ensure DASHSCOPE_API_KEY is set or Qwen CLI is installed."
+        );
+      }
+      /**
+       * Get the currently active execution mode
+       */
+      getActiveMode() {
+        return this.activeMode;
+      }
+      /**
+       * Reset circuit breakers
+       */
+      resetCircuitBreakers() {
+        this.sdkCircuitBreaker = { failures: 0, lastFailure: 0, isOpen: false };
+        this.cliCircuitBreaker = { failures: 0, lastFailure: 0, isOpen: false };
+        logger.debug("[Qwen Hybrid] Circuit breakers reset");
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        if (this.sdkAdapter) {
+          await this.sdkAdapter.destroy();
+          this.sdkAdapter = null;
+        }
+        this.cliWrapper = null;
+        this.activeMode = null;
+        logger.debug("[Qwen Hybrid] Adapter destroyed");
+      }
+    };
+  }
+});
+
+// src/integrations/qwen-code/index.ts
+var init_qwen_code = __esm({
+  "src/integrations/qwen-code/index.ts"() {
+    init_esm_shims();
+    init_hybrid_adapter4();
+    init_sdk_adapter4();
+    init_cli_wrapper4();
+    init_types4();
+  }
+});
+
+// src/providers/qwen-provider.ts
+var qwen_provider_exports = {};
+__export(qwen_provider_exports, {
+  QwenProvider: () => QwenProvider,
+  default: () => QwenProvider
+});
+var SUPPORTED_MODELS, QwenProvider;
+var init_qwen_provider = __esm({
+  "src/providers/qwen-provider.ts"() {
+    init_esm_shims();
+    init_base_provider();
+    init_logger();
+    init_qwen_code();
+    SUPPORTED_MODELS = [
+      "qwen3-coder-480b-a35b-instruct",
+      "qwen3-coder-30b-a3b-instruct",
+      "qwen2.5-coder-32b-instruct",
+      "qwen-max",
+      "qwen-plus",
+      "qwen-turbo"
+    ];
+    QwenProvider = class extends BaseProvider {
+      /** Selected model */
+      model;
+      /** SDK adapter for direct execution */
+      sdkAdapter = null;
+      /** Hybrid adapter for 'auto' mode */
+      hybridAdapter = null;
+      /** Provider configuration */
+      qwenConfig;
+      /** Supported models */
+      static SUPPORTED_MODELS = SUPPORTED_MODELS;
+      constructor(config) {
+        super({
+          ...config,
+          command: "qwen"
+        });
+        this.qwenConfig = config;
+        const requestedModel = config.model || QWEN_DEFAULT_MODEL;
+        if (!SUPPORTED_MODELS.includes(requestedModel)) {
+          logger.warn(`[Qwen] Unknown model: ${requestedModel}. Using ${QWEN_DEFAULT_MODEL}.`);
+          this.model = QWEN_DEFAULT_MODEL;
+        } else {
+          this.model = requestedModel;
+        }
+        logger.debug("[Qwen Provider] Initialized", {
+          model: this.model,
+          mode: config.mode || "sdk"
+        });
+      }
+      /**
+       * Get the normalized model name
+       */
+      getNormalizedModel() {
+        return normalizeQwenModel(this.model);
+      }
+      /**
+       * Get or create SDK adapter
+       */
+      getSdkAdapter() {
+        if (!this.sdkAdapter) {
+          this.sdkAdapter = new QwenSdkAdapter({
+            model: this.model,
+            apiKey: this.qwenConfig.apiKey,
+            baseUrl: this.qwenConfig.baseUrl,
+            timeout: this.qwenConfig.timeout
+          });
+        }
+        return this.sdkAdapter;
+      }
+      /**
+       * Get or create hybrid adapter
+       */
+      getHybridAdapter() {
+        if (!this.hybridAdapter) {
+          const options = {
+            mode: this.qwenConfig.mode || "auto",
+            model: this.model,
+            apiKey: this.qwenConfig.apiKey,
+            baseUrl: this.qwenConfig.baseUrl,
+            command: "qwen",
+            timeout: this.qwenConfig.timeout
+          };
+          this.hybridAdapter = new QwenHybridAdapter(options);
+        }
+        return this.hybridAdapter;
+      }
+      /**
+       * Execute a task using Qwen
+       *
+       * Execution flow:
+       * 1. Mock mode → return mock response
+       * 2. mode='sdk' (default) → use SDK adapter
+       * 3. mode='auto' → use hybrid adapter (SDK with CLI fallback)
+       * 4. mode='cli' → use CLI via BaseProvider
+       */
+      async execute(request) {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          return this.createMockResponse(request.prompt);
+        }
+        const effectiveMode = this.qwenConfig.mode || "sdk";
+        if (effectiveMode === "cli") {
+          logger.debug("[Qwen Provider] Executing via CLI", {
+            model: this.model
+          });
+          return super.execute(request);
+        }
+        if (effectiveMode === "auto") {
+          logger.debug("[Qwen Provider] Executing via hybrid adapter", {
+            promptLength: request.prompt.length,
+            model: this.model
+          });
+          const adapter2 = this.getHybridAdapter();
+          return adapter2.execute(request);
+        }
+        logger.debug("[Qwen Provider] Executing via SDK adapter", {
+          promptLength: request.prompt.length,
+          model: this.model
+        });
+        const adapter = this.getSdkAdapter();
+        if (!await adapter.isAvailable()) {
+          throw new Error(
+            'Qwen SDK is not available. Set DASHSCOPE_API_KEY or QWEN_API_KEY environment variable, or use mode: "cli" to use Qwen Code CLI.'
+          );
+        }
+        return adapter.execute(request);
+      }
+      /**
+       * Get CLI command
+       */
+      getCLICommand() {
+        const activeMode = this.hybridAdapter?.getActiveMode();
+        if (activeMode === "sdk") {
+          return "qwen-sdk";
+        }
+        return "qwen";
+      }
+      /**
+       * Get CLI arguments for Qwen Code CLI
+       *
+       * Note: Qwen Code CLI is interactive by default.
+       * We pass the prompt via stdin instead of command-line args.
+       */
+      getCLIArgs() {
+        return [];
+      }
+      /**
+       * Create mock response for testing
+       */
+      createMockResponse(prompt) {
+        return {
+          content: this.getMockResponse(),
+          model: this.getNormalizedModel(),
+          tokensUsed: {
+            prompt: this.estimateTokens(prompt),
+            completion: 50,
+            total: this.estimateTokens(prompt) + 50
+          },
+          latencyMs: 10,
+          finishReason: "stop",
+          cached: false
+        };
+      }
+      /**
+       * Estimate token count
+       */
+      estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+      }
+      /**
+       * Get mock response for testing
+       */
+      getMockResponse() {
+        return `[Mock Qwen Response]
+
+This is a mock response from the Qwen provider (${this.getNormalizedModel()}).
+In production, this would be a response from ${this.qwenConfig.mode === "sdk" ? "Qwen SDK" : "Qwen Code CLI"}.
+
+Model: ${this.getNormalizedModel()}
+Provider: Qwen (Alibaba Cloud)
+Mode: ${this.qwenConfig.mode || "sdk"}`;
+      }
+      /**
+       * Get provider capabilities
+       */
+      get capabilities() {
+        const model = this.getNormalizedModel();
+        const hasVision = isVisionModel(model);
+        const maxContextTokens = getModelContextWindow(model);
+        const activeMode = this.hybridAdapter?.getActiveMode();
+        const integrationMode = activeMode === "sdk" ? "sdk" : "cli";
+        return {
+          ...super.capabilities,
+          supportsStreaming: true,
+          supportsVision: hasVision,
+          maxContextTokens,
+          supportedModels: SUPPORTED_MODELS,
+          integrationMode
+        };
+      }
+      /**
+       * Get the active execution mode
+       */
+      getActiveMode() {
+        return this.hybridAdapter?.getActiveMode() || null;
+      }
+      /**
+       * Reset circuit breakers
+       */
+      resetCircuitBreakers() {
+        this.hybridAdapter?.resetCircuitBreakers();
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        if (this.sdkAdapter) {
+          await this.sdkAdapter.destroy();
+          this.sdkAdapter = null;
+        }
+        if (this.hybridAdapter) {
+          await this.hybridAdapter.destroy();
+          this.hybridAdapter = null;
+        }
+      }
+      /**
+       * Get the list of supported models
+       */
+      static getSupportedModels() {
+        return [...SUPPORTED_MODELS];
+      }
+    };
+  }
+});
+
 // src/mcp/index.ts
 init_esm_shims();
 
@@ -8032,12 +9048,16 @@ init_logger();
 
 // src/shared/helpers/deep-merge.ts
 init_esm_shims();
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
 function deepMerge(defaults, user) {
   if (user === null || user === void 0) {
-    return defaults;
+    return { ...defaults };
   }
-  const result = { ...defaults };
-  for (const key in user) {
+  const result = Object.assign({}, defaults);
+  const userKeys = Object.keys(user);
+  for (const key of userKeys) {
     const userValue = user[key];
     if (userValue === null) {
       result[key] = void 0;
@@ -8047,8 +9067,11 @@ function deepMerge(defaults, user) {
       continue;
     }
     const defaultValue = defaults[key];
-    if (typeof userValue === "object" && typeof defaultValue === "object" && !Array.isArray(userValue) && !Array.isArray(defaultValue) && userValue !== null && defaultValue !== null) {
-      result[key] = deepMerge(defaultValue, userValue);
+    if (isPlainObject(userValue) && isPlainObject(defaultValue)) {
+      result[key] = deepMerge(
+        defaultValue,
+        userValue
+      );
     } else {
       result[key] = userValue;
     }
@@ -8690,7 +9713,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.6.1"
+  "version": "12.6.3"
 };
 
 // src/core/config/schemas.ts
@@ -9565,107 +10588,7 @@ init_logger();
 // src/shared/utils/disposable.ts
 init_esm_shims();
 init_logger();
-
-// src/shared/utils/safe-timers.ts
-init_esm_shims();
-init_logger();
-function createSafeInterval(callback, intervalMs, options = {}) {
-  const { ref = false, name, signal, immediate = false } = options;
-  if (signal?.aborted) {
-    logger.debug("createSafeInterval: already aborted", { name });
-    return () => {
-    };
-  }
-  let cleared = false;
-  let intervalId = null;
-  const safeCallback = async () => {
-    if (cleared) return;
-    try {
-      await callback();
-    } catch (error) {
-      logger.error("Safe interval callback error", {
-        name,
-        error: error.message
-      });
-    }
-  };
-  if (immediate) {
-    setImmediate(() => {
-      if (!cleared) {
-        safeCallback();
-      }
-    });
-  }
-  intervalId = setInterval(safeCallback, intervalMs);
-  if (!ref && intervalId.unref) {
-    intervalId.unref();
-  }
-  const cleanup = () => {
-    if (cleared) return;
-    cleared = true;
-    if (intervalId !== null) {
-      clearInterval(intervalId);
-      intervalId = null;
-      logger.debug("Safe interval cleared", { name });
-    }
-  };
-  if (signal) {
-    signal.addEventListener("abort", cleanup, { once: true });
-  }
-  logger.debug("Safe interval created", {
-    name,
-    intervalMs,
-    ref,
-    immediate
-  });
-  return cleanup;
-}
-function createSafeTimeout(callback, delayMs, options = {}) {
-  const { ref = false, name, signal } = options;
-  if (signal?.aborted) {
-    logger.debug("createSafeTimeout: already aborted", { name });
-    return () => {
-    };
-  }
-  let cleared = false;
-  let timeoutId = null;
-  const safeCallback = async () => {
-    if (cleared) return;
-    cleared = true;
-    try {
-      await callback();
-    } catch (error) {
-      logger.error("Safe timeout callback error", {
-        name,
-        error: error.message
-      });
-    }
-  };
-  timeoutId = setTimeout(safeCallback, delayMs);
-  if (!ref && timeoutId.unref) {
-    timeoutId.unref();
-  }
-  const cleanup = () => {
-    if (cleared) return;
-    cleared = true;
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-      logger.debug("Safe timeout cleared", { name });
-    }
-  };
-  if (signal) {
-    signal.addEventListener("abort", cleanup, { once: true });
-  }
-  logger.debug("Safe timeout created", {
-    name,
-    delayMs,
-    ref
-  });
-  return cleanup;
-}
-
-// src/shared/utils/disposable.ts
+init_safe_timers();
 var DisposableEventEmitter = class extends EventEmitter {
   /** Registered cleanup tasks */
   cleanupTasks = [];
@@ -13213,7 +14136,7 @@ var MemoryManager = class _MemoryManager {
       if (this.db) {
         try {
           this.db.close();
-        } catch (closeError) {
+        } catch {
         }
         this.initialized = false;
         this.entryCount = 0;
@@ -14054,9 +14977,9 @@ var MemoryManager = class _MemoryManager {
       }
     }
     const {
-      includeEmbeddings = false,
+      includeEmbeddings: _includeEmbeddings = false,
       filters = {},
-      batchSize = 1e3,
+      batchSize: _batchSize = 1e3,
       pretty = false
     } = options || {};
     try {
@@ -15213,7 +16136,7 @@ var SessionManager = class _SessionManager {
       if (this.pendingSave) {
         try {
           await this.pendingSave;
-        } catch (err) {
+        } catch {
         }
       }
       this.pendingSave = this.doSave().finally(() => {
@@ -15281,7 +16204,7 @@ var SessionManager = class _SessionManager {
         }
         try {
           await unlink(tempPath);
-        } catch (unlinkError) {
+        } catch {
         }
         throw renameError;
       }
@@ -15289,7 +16212,7 @@ var SessionManager = class _SessionManager {
       const tempPath = `${this.persistencePath}.tmp`;
       try {
         await unlink(tempPath);
-      } catch (unlinkError) {
+      } catch {
       }
       logger.error("Failed to save sessions to persistence", {
         path: normalizePath(this.persistencePath),
@@ -15827,6 +16750,7 @@ init_esm_shims();
 init_logger();
 var MAX_CONTEXT_SIZE = 100 * 1024;
 var DEFAULT_CACHE_TTL = 3e5;
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 var ProjectContextLoader = class {
   constructor(projectRoot, options) {
     this.projectRoot = projectRoot;
@@ -15850,76 +16774,79 @@ var ProjectContextLoader = class {
     });
     const context = {};
     try {
-      const mdPath = path4__default.join(this.projectRoot, "AX.md");
-      const resolvedPath = await realpath(mdPath).catch(() => null);
+      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.md too large, ignoring", {
+            logger.warn("ax.index.json too large, ignoring", {
               size: stats.size,
               limit: MAX_CONTEXT_SIZE
             });
           } else {
-            context.markdown = await readFile(resolvedPath, "utf-8");
-            logger.info("Loaded AX.md", {
-              size: stats.size,
-              lines: context.markdown.split("\n").length
+            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))
             });
-            context.agentRules = this.parseAgentRules(context.markdown);
-            context.guardrails = this.parseGuardrails(context.markdown);
-            context.commands = this.parseCommands(context.markdown);
-            context.metadata = this.parseMetadata(context.markdown);
+            if (context.index.commands) {
+              context.commands = {};
+              for (const [name, cmd] of Object.entries(context.index.commands)) {
+                context.commands[name] = cmd.script;
+              }
+            }
           }
         }
       }
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code !== "ENOENT") {
-        logger.warn("Error loading AX.md", { error });
+        logger.warn("Error loading ax.index.json", { error });
       }
     }
     try {
-      const ymlPath = path4__default.join(this.projectRoot, "ax.config.yml");
-      const resolvedPath = await realpath(ymlPath).catch(() => null);
+      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("ax.config.yml too large, ignoring", {
+            logger.warn("CUSTOM.md too large, ignoring", {
               size: stats.size,
               limit: MAX_CONTEXT_SIZE
             });
           } else {
-            const ymlContent = await readFile(resolvedPath, "utf-8");
-            context.config = yaml.parse(ymlContent);
-            logger.info("Loaded ax.config.yml", {
-              size: stats.size
+            context.customInstructions = await readFile(resolvedPath, "utf-8");
+            logger.info("Loaded CUSTOM.md", {
+              size: stats.size,
+              lines: context.customInstructions.split("\n").length
             });
-            if (context.config.commands) {
-              context.commands = { ...context.commands, ...context.config.commands };
-            }
-            if (context.config.project) {
-              context.metadata = { ...context.metadata, ...context.config.project };
-            }
+            context.guardrails = this.parseGuardrails(context.customInstructions);
           }
         }
       }
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code !== "ENOENT") {
-        logger.warn("Error loading ax.config.yml", { error });
+        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", {
-      hasMarkdown: !!context.markdown,
-      hasConfig: !!context.config,
-      agentRules: context.agentRules?.length ?? 0,
+      hasIndex: !!context.index,
+      hasCustomInstructions: !!context.customInstructions,
       guardrails: context.guardrails?.length ?? 0,
-      commands: Object.keys(context.commands ?? {}).length
+      commands: Object.keys(context.commands ?? {}).length,
+      isStale: context.isStale
     });
     return context;
   }
@@ -15935,8 +16862,8 @@ var ProjectContextLoader = class {
    * Check if context exists (without loading)
    */
   async exists() {
-    const mdPath = path4__default.join(this.projectRoot, "AX.md");
-    const ymlPath = path4__default.join(this.projectRoot, "ax.config.yml");
+    const indexPath = path4__default.join(this.projectRoot, "ax.index.json");
+    const customMdPath = path4__default.join(this.projectRoot, ".automatosx", "CUSTOM.md");
     const checkExists = async (filePath) => {
       try {
         await access(filePath, constants.F_OK);
@@ -15945,57 +16872,48 @@ var ProjectContextLoader = class {
         return false;
       }
     };
-    const [mdExists, ymlExists] = await Promise.all([
-      checkExists(mdPath),
-      checkExists(ymlPath)
+    const [indexExists, customMdExists] = await Promise.all([
+      checkExists(indexPath),
+      checkExists(customMdPath)
     ]);
-    return mdExists || ymlExists;
+    return indexExists || customMdExists;
   }
   /**
-   * Parse agent delegation rules from markdown
-   *
-   * Looks for patterns like:
-   * - Backend changes → @backend
-   * - API endpoints → @backend, @security
-   */
-  parseAgentRules(markdown) {
-    const rules = [];
-    const sectionRegex = /##\s+Agent\s+Delegation\s+Rules[^\n]*\n([\s\S]*?)(?=\n##|$)/i;
-    const match = markdown.match(sectionRegex);
-    if (!match || !match[1]) {
-      return rules;
-    }
-    const section = match[1];
-    const lineRegex = /^[-*]\s+(.+?)\s+(?:→|->)+\s+(.+?)$/gm;
-    let lineMatch;
-    while ((lineMatch = lineRegex.exec(section)) !== null) {
-      const taskType = lineMatch[1]?.trim() ?? "";
-      const agentsText = lineMatch[2]?.trim() ?? "";
-      const agents = agentsText.split(",").map((a) => a.trim()).filter(Boolean);
-      const defaultAgent = agents[0];
-      if (defaultAgent) {
-        rules.push({
-          taskType,
-          patterns: [],
-          // TODO: Parse file patterns if specified
-          defaultAgent,
-          autoReview: agents.length > 1
-        });
-      }
+   * Check if ax.index.json is stale (older than 24 hours)
+   */
+  async isStale() {
+    try {
+      const indexPath = path4__default.join(this.projectRoot, "ax.index.json");
+      const stats = await stat(indexPath);
+      const age = Date.now() - stats.mtime.getTime();
+      return age > STALE_THRESHOLD_MS;
+    } catch {
+      return true;
     }
-    return rules;
   }
   /**
-   * Parse guardrails/prohibitions from markdown
+   * Parse guardrails from CUSTOM.md
    *
-   * Looks for "## Critical Guardrails" or "## Critical Rules" section
-   * Extracts items marked with ⚠️ or under NEVER headings
+   * Looks for DO/DON'T sections in ax-cli format
    */
   parseGuardrails(markdown) {
     const guardrails = [];
-    const sectionRegex = /##\s+(Critical\s+Guardrails|Critical\s+Rules|Never)[^\n]*\n([\s\S]*?)(?=\n##|$)/gi;
+    const dontRegex = /###\s+DON'T[^\n]*\n([\s\S]*?)(?=\n###|$)/i;
+    const dontMatch = markdown.match(dontRegex);
+    if (dontMatch && dontMatch[1]) {
+      const section = dontMatch[1];
+      const bulletRegex = /^[-*]\s+(.+?)$/gm;
+      let bulletMatch;
+      while ((bulletMatch = bulletRegex.exec(section)) !== null) {
+        const rule = bulletMatch[1]?.trim();
+        if (rule) {
+          guardrails.push(rule);
+        }
+      }
+    }
+    const criticalRegex = /##\s+(Critical\s+Guardrails|Critical\s+Rules|Never)[^\n]*\n([\s\S]*?)(?=\n##|$)/gi;
     let match;
-    while ((match = sectionRegex.exec(markdown)) !== null) {
+    while ((match = criticalRegex.exec(markdown)) !== null) {
       const section = match[2];
       if (!section) continue;
       const bulletRegex = /^[-*]\s+(.+?)$/gm;
@@ -16005,106 +16923,58 @@ var ProjectContextLoader = class {
         rule = rule.replace(/^[⚠️❌✅✓⚡🔒]+\s*/, "");
         rule = rule.replace(/\*\*(.+?)\*\*/g, "$1");
         rule = rule.replace(/`(.+?)`/g, "$1");
-        if (rule.length > 0) {
+        if (rule.length > 0 && !guardrails.includes(rule)) {
           guardrails.push(rule);
         }
       }
     }
     return guardrails;
   }
-  /**
-   * Parse commands from markdown code blocks
-   *
-   * Looks for "## Commands" or "## Canonical Commands" section
-   */
-  parseCommands(markdown) {
-    const commands = {};
-    const sectionRegex = /##\s+(Canonical\s+)?Commands[^\n]*\n([\s\S]*?)(?=\n##|$)/i;
-    const match = markdown.match(sectionRegex);
-    if (!match) {
-      return commands;
-    }
-    const section = match[2];
-    if (!section) {
-      return commands;
-    }
-    const codeBlockRegex = /```(?:bash|sh|shell)?\n([\s\S]*?)```/;
-    const codeMatch = section.match(codeBlockRegex);
-    if (codeMatch && codeMatch[1]) {
-      const lines = codeMatch[1].split("\n");
-      for (const line of lines) {
-        const cmdMatch = line.match(/^([^\s#]+(?:\s+[^\s#]+)*)\s*#?\s*(.*)$/);
-        if (cmdMatch && cmdMatch[1]) {
-          const cmd = cmdMatch[1].trim();
-          const desc = cmdMatch[2]?.trim() ?? "";
-          const key = desc || cmd;
-          commands[key] = cmd;
-        }
-      }
-    }
-    return commands;
-  }
-  /**
-   * Parse project metadata from markdown frontmatter or first section
-   */
-  parseMetadata(markdown) {
-    const metadata = {};
-    const lastUpdatedMatch = markdown.match(/>\s*Last\s+updated:\s*(.+?)$/im);
-    if (lastUpdatedMatch && lastUpdatedMatch[1]) {
-      metadata.lastUpdated = lastUpdatedMatch[1].trim();
-    }
-    const projectMatch = markdown.match(/>\s*Project:\s*(.+?)$/im);
-    if (projectMatch && projectMatch[1]) {
-      const parts = projectMatch[1].trim().split(/\s+v/);
-      metadata.name = parts[0] || "";
-      if (parts.length > 1 && parts[1]) {
-        metadata.version = parts[1];
-      }
-    }
-    const h1Match = markdown.match(/^#\s+(.+?)$/m);
-    if (h1Match && h1Match[1] && !metadata.name) {
-      metadata.name = h1Match[1].replace(/Project Context for AutomatosX/i, "").trim();
-    }
-    return metadata;
-  }
   /**
    * Build formatted context prompt for agent injection
    */
   buildContextPrompt(context) {
-    if (!context.markdown && !context.config) {
+    if (!context.index && !context.customInstructions) {
       return "";
     }
     let prompt = "\n# PROJECT CONTEXT\n\n";
-    if (context.guardrails && context.guardrails.length > 0) {
-      prompt += "## CRITICAL RULES (NEVER VIOLATE):\n\n";
-      context.guardrails.forEach((rule) => {
-        prompt += `- ${rule}
+    if (context.index) {
+      prompt += `**Project:** ${context.index.projectName} v${context.index.version}
 `;
-      });
-      prompt += "\n";
-    }
-    if (context.agentRules && context.agentRules.length > 0) {
-      prompt += "## Agent Delegation Rules:\n\n";
-      context.agentRules.forEach((rule) => {
-        prompt += `- ${rule.taskType} \u2192 ${rule.defaultAgent}
+      prompt += `**Type:** ${context.index.projectType}
 `;
-      });
-      prompt += "\n";
+      prompt += `**Language:** ${context.index.language}`;
+      if (context.index.framework) {
+        prompt += ` + ${context.index.framework}`;
+      }
+      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 += `- \`${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 += `- ${name}: \`${script}\`
+`;
+        }
+        prompt += "\n";
+      }
     }
-    if (context.commands && Object.keys(context.commands).length > 0) {
-      prompt += "## Available Commands:\n\n";
-      Object.entries(context.commands).forEach(([desc, cmd]) => {
-        prompt += `- ${desc}: \`${cmd}\`
+    if (context.guardrails && context.guardrails.length > 0) {
+      prompt += "## CRITICAL RULES (NEVER VIOLATE):\n\n";
+      for (const rule of context.guardrails) {
+        prompt += `- ${rule}
 `;
-      });
+      }
       prompt += "\n";
     }
-    if (context.markdown) {
-      const MAX_PROMPT_LENGTH = 1e4;
-      const contextToAdd = context.markdown.length > MAX_PROMPT_LENGTH ? context.markdown.substring(0, MAX_PROMPT_LENGTH) + "\n\n[... context truncated for length ...]" : context.markdown;
-      prompt += "## Full Project Context:\n\n";
-      prompt += contextToAdd;
-      prompt += "\n";
+    if (context.isStale) {
+      prompt += "\u26A0\uFE0F **Note:** Project index is stale (>24h old). Run `ax init` to update.\n\n";
     }
     return prompt;
   }
@@ -16528,10 +17398,10 @@ var ContextManager = class {
     return provider;
   }
   /**
-   * Load project context from AX.md (v7.1.0+)
+   * Load project context from ax.index.json (v12.9.0+)
    *
-   * Loads project-specific instructions from AX.md file if it exists.
-   * Falls back gracefully if file doesn't exist.
+   * Loads project-specific context from ax.index.json and CUSTOM.md.
+   * Falls back gracefully if files don't exist.
    *
    * @param projectDir - Project root directory
    * @returns Project context or null if not found
@@ -16544,15 +17414,15 @@ var ContextManager = class {
       const loader = this.projectContextLoader;
       const exists = await loader.exists();
       if (!exists) {
-        logger.debug("No AX.md found, skipping project context");
+        logger.debug("No ax.index.json or CUSTOM.md found, skipping project context");
         return null;
       }
       const context = await loader.load();
-      logger.debug("Project context loaded from AX.md", {
-        hasMarkdown: !!context.markdown,
-        hasConfig: !!context.config,
-        agentRules: context.agentRules?.length ?? 0,
-        guardrails: context.guardrails?.length ?? 0
+      logger.debug("Project context loaded", {
+        hasIndex: !!context.index,
+        hasCustomInstructions: !!context.customInstructions,
+        guardrails: context.guardrails?.length ?? 0,
+        isStale: context.isStale
       });
       return context;
     } catch (error) {
@@ -16922,7 +17792,11 @@ var ProfileLoader = class {
           continue;
         }
         const data = load(content);
-        return data && typeof data === "object" && !Array.isArray(data) && "displayName" in data ? data.displayName || null : null;
+        if (data && typeof data === "object" && !Array.isArray(data) && "displayName" in data) {
+          const profile = data;
+          return profile.displayName ?? null;
+        }
+        return null;
       } catch (error) {
         if (error.code === "ENOENT") {
           continue;
@@ -16951,7 +17825,7 @@ var ProfileLoader = class {
       });
       return identifier;
     } catch (error) {
-      if (error.name === "AgentNotFoundError") {
+      if (error instanceof Error && error.name === "AgentNotFoundError") {
         logger.debug("Direct profile load failed, trying displayName lookup", { identifier });
         await this.buildDisplayNameMap();
         const resolved = this.displayNameMap.get(identifier.toLowerCase());
@@ -17280,7 +18154,7 @@ var ProfileLoader = class {
       if (typeof orch !== "object" || orch === null || Array.isArray(orch)) {
         throw new AgentValidationError("orchestration must be an object");
       }
-      if (orch.canDelegate !== void 0) {
+      if ("canDelegate" in orch && orch.canDelegate !== void 0) {
         logger.warn("orchestration.canDelegate is deprecated and ignored (v4.9.0+). All agents can delegate by default.", {
           agent: profile.name
         });
@@ -17326,17 +18200,18 @@ var ProfileLoader = class {
     if (!data || typeof data !== "object" || Array.isArray(data)) {
       throw new AgentValidationError(`Invalid profile data for ${name}: expected object, got ${typeof data}`);
     }
-    if (data.name && typeof data.name === "string") {
-      if (!/^[a-zA-Z0-9_-]+$/.test(data.name)) {
-        if (!data.displayName) {
-          data.displayName = data.name;
+    const profileData = data;
+    if (profileData.name && typeof profileData.name === "string") {
+      if (!/^[a-zA-Z0-9_-]+$/.test(profileData.name)) {
+        if (!profileData.displayName) {
+          profileData.displayName = profileData.name;
         }
-        data.name = name;
+        profileData.name = name;
       }
-    } else if (!data.name) {
-      data.name = name;
+    } else if (!profileData.name) {
+      profileData.name = name;
     }
-    const validationResult = safeValidateAgentProfile(data);
+    const validationResult = safeValidateAgentProfile(profileData);
     if (!validationResult.success) {
       const validationErrors = validationResult.error.issues.map(
         (e) => `${e.path.join(".")}: ${e.message}`
@@ -17346,22 +18221,22 @@ var ProfileLoader = class {
       );
     }
     let teamConfig;
-    if (data.team && this.teamManager) {
+    if (profileData.team && this.teamManager) {
       try {
-        teamConfig = await this.teamManager.loadTeam(data.team);
+        teamConfig = await this.teamManager.loadTeam(profileData.team);
         logger.debug("Team configuration loaded for agent", {
           agent: name,
-          team: data.team
+          team: profileData.team
         });
       } catch (error) {
         logger.warn("Failed to load team configuration, using agent defaults", {
           agent: name,
-          team: data.team,
+          team: profileData.team,
           error: error.message
         });
       }
     }
-    const abilities = data.abilities || [];
+    const abilities = profileData.abilities || [];
     if (teamConfig?.sharedAbilities) {
       const allAbilities = [.../* @__PURE__ */ new Set([...teamConfig.sharedAbilities, ...abilities])];
       logger.debug("Merged abilities from team", {
@@ -17373,7 +18248,7 @@ var ProfileLoader = class {
       });
       abilities.splice(0, abilities.length, ...allAbilities);
     }
-    let orchestration = data.orchestration;
+    let orchestration = profileData.orchestration;
     if (teamConfig?.orchestration && !orchestration) {
       orchestration = teamConfig.orchestration;
       logger.debug("Using team orchestration defaults", {
@@ -17382,32 +18257,32 @@ var ProfileLoader = class {
       });
     }
     const profile = {
-      name: data.name || name,
-      displayName: data.displayName,
-      role: data.role,
-      description: data.description,
+      name: profileData.name || name,
+      displayName: profileData.displayName,
+      role: profileData.role,
+      description: profileData.description,
       // v4.10.0+: Team field
-      team: data.team,
-      systemPrompt: data.systemPrompt,
+      team: profileData.team,
+      systemPrompt: profileData.systemPrompt,
       abilities,
-      dependencies: data.dependencies,
-      parallel: data.parallel,
+      dependencies: profileData.dependencies,
+      parallel: profileData.parallel,
       // Enhanced v4.1+ features
-      stages: data.stages,
-      personality: data.personality,
-      thinking_patterns: data.thinking_patterns,
-      abilitySelection: data.abilitySelection,
+      stages: profileData.stages,
+      personality: profileData.personality,
+      thinking_patterns: profileData.thinking_patterns,
+      abilitySelection: profileData.abilitySelection,
       // v5.7.0+: Agent Selection Metadata
-      selectionMetadata: data.selectionMetadata,
+      selectionMetadata: profileData.selectionMetadata,
       // Provider preferences (deprecated, kept for backward compatibility)
-      provider: data.provider,
-      model: data.model,
-      temperature: data.temperature,
-      maxTokens: data.maxTokens,
+      provider: profileData.provider,
+      model: profileData.model,
+      temperature: profileData.temperature,
+      maxTokens: profileData.maxTokens,
       // Optional
-      tags: data.tags,
-      version: data.version,
-      metadata: data.metadata,
+      tags: profileData.tags,
+      version: profileData.version,
+      metadata: profileData.metadata,
       // v4.7.0+ Orchestration (merged with team defaults)
       orchestration
     };
@@ -20579,6 +21454,24 @@ ${context.task}`;
 // src/agents/agent-selector.ts
 init_esm_shims();
 init_logger();
+var regexCache = /* @__PURE__ */ new Map();
+function getCachedRegex(pattern) {
+  if (regexCache.has(pattern)) {
+    return regexCache.get(pattern) ?? null;
+  }
+  try {
+    const regex = new RegExp(pattern, "i");
+    regexCache.set(pattern, regex);
+    return regex;
+  } catch (error) {
+    logger.debug("Invalid regex pattern cached as null", {
+      pattern,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    regexCache.set(pattern, null);
+    return null;
+  }
+}
 function scoreAgent(task, profile) {
   let score = 0;
   const taskLower = task.toLowerCase();
@@ -20616,16 +21509,9 @@ function scoreAgent(task, profile) {
   }
   if (profile.selectionMetadata?.redirectWhen) {
     for (const rule of profile.selectionMetadata.redirectWhen) {
-      try {
-        const regex = new RegExp(rule.phrase, "i");
-        if (regex.test(task)) {
-          score -= 15;
-        }
-      } catch (error) {
-        logger.debug("Invalid regex pattern in redirectWhen rule", {
-          pattern: rule.phrase,
-          error: error instanceof Error ? error.message : String(error)
-        });
+      const regex = getCachedRegex(rule.phrase);
+      if (regex && regex.test(task)) {
+        score -= 15;
       }
     }
   }
@@ -22983,7 +23869,7 @@ var BugDetector = class {
     });
     let files;
     if (fileFilter && fileFilter.length > 0) {
-      files = fileFilter.map((f) => f.startsWith("/") ? f : join(rootDir, f)).filter((f) => {
+      files = fileFilter.map((f) => isAbsolute(f) ? f : join(rootDir, f)).filter((f) => {
         const ext = extname$1(f);
         return [".ts", ".js", ".mts", ".mjs", ".tsx", ".jsx"].includes(ext);
       }).filter((f) => !this.isExcluded(relative(rootDir, f)));
@@ -23215,8 +24101,8 @@ var BugDetector = class {
   async loadRulesFromFile(filePath) {
     try {
       const content = await readFile(filePath, "utf-8");
-      const yaml2 = await import('js-yaml');
-      const parsed = yaml2.load(content);
+      const yaml = await import('js-yaml');
+      const parsed = yaml.load(content);
       if (parsed.rules && Array.isArray(parsed.rules)) {
         for (const rule of parsed.rules) {
           this.addRule(rule);
@@ -23648,7 +24534,6 @@ var BugFixer = class {
     }
     const directSetIntervalPattern = /setInterval\s*\(/;
     if (directSetIntervalPattern.test(line)) {
-      line.match(/^(\s*)/)?.[1] || "";
       const newLine = line.replace(
         /(setInterval\s*\([^)]+\))/,
         "const _interval = $1; if (_interval.unref) _interval.unref()"
@@ -23675,7 +24560,6 @@ var BugFixer = class {
       const match = currentLine.match(classPattern);
       if (match && match[1]) {
         classStartLine = i;
-        match[1];
         break;
       }
     }
@@ -23727,7 +24611,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"
@@ -24649,7 +25533,7 @@ var DUPLICATION_RULES = [
     suggestion: "Extract to a named constant"
   }
 ];
-function detectDuplication(filePath, content, lines, ignoreState, config) {
+function detectDuplication(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   findings.push(...detectDuplicateBlocks(filePath, content, lines, ignoreState));
   findings.push(...detectRepeatedConditionals(filePath, content, lines, ignoreState));
@@ -24676,7 +25560,7 @@ function detectDuplicateBlocks(filePath, content, lines, ignoreState) {
     }
     blockHashes.get(blockHash).push({ start: i + 1, end: i + MIN_BLOCK_SIZE });
   }
-  for (const [hash, locations] of blockHashes) {
+  for (const [_hash, locations] of blockHashes) {
     if (locations.length > 1) {
       for (let i = 1; i < locations.length; i++) {
         const loc = locations[i];
@@ -24725,7 +25609,7 @@ function detectRepeatedConditionals(filePath, content, lines, ignoreState) {
     }
     conditionPattern.lastIndex = 0;
   }
-  for (const [condition, lineNums] of conditionalCounts) {
+  for (const [_condition, lineNums] of conditionalCounts) {
     if (lineNums.length >= 2) {
       const firstLine = lineNums[0];
       const secondLine = lineNums[1];
@@ -24888,7 +25772,7 @@ var THRESHOLDS = {
   maxCyclomaticComplexity: 10,
   maxChainedCalls: 4
 };
-function detectReadability(filePath, content, lines, ignoreState, config) {
+function detectReadability(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   findings.push(...detectLongFunctions(filePath, content, lines, ignoreState));
   findings.push(...detectDeepNesting(filePath, content, lines, ignoreState));
@@ -25264,7 +26148,7 @@ var PERFORMANCE_RULES = [
     suggestion: "Remove await - async functions automatically wrap return values in promises"
   }
 ];
-function detectPerformance(filePath, content, lines, ignoreState, config) {
+function detectPerformance(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   findings.push(...detectSyncInAsync(filePath, content, lines, ignoreState));
   findings.push(...detectNPlusOne(filePath, content, lines, ignoreState));
@@ -25679,7 +26563,7 @@ var HARDCODE_RULES = [
     suggestion: "Extract timeout to a named constant or config"
   }
 ];
-function detectHardcode(filePath, content, lines, ignoreState, config) {
+function detectHardcode(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   findings.push(...detectMagicNumbers(filePath, content, lines, ignoreState));
   findings.push(...detectHardcodedUrls(filePath, content, lines, ignoreState));
@@ -26035,7 +26919,7 @@ var NAMING_RULES = [
     suggestion: "Use is/has/can/should prefix for boolean variables"
   }
 ];
-function detectNaming(filePath, content, lines, ignoreState, config) {
+function detectNaming(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   findings.push(...detectSingleLetterVariables(filePath, content, lines, ignoreState));
   findings.push(...detectHungarianNotation(filePath, content, lines, ignoreState));
@@ -26318,7 +27202,7 @@ var CONDITIONAL_RULES = [
     suggestion: "Use the condition directly (or negate it)"
   }
 ];
-function detectConditionals(filePath, content, lines, ignoreState, config) {
+function detectConditionals(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   findings.push(...detectDeeplyNestedIf(filePath, content, lines, ignoreState));
   findings.push(...detectComplexConditions(filePath, content, lines, ignoreState));
@@ -26631,7 +27515,7 @@ var DEAD_CODE_RULES = [
     suggestion: "Implement function or add TODO comment"
   }
 ];
-function detectDeadCode(filePath, content, lines, ignoreState, config) {
+function detectDeadCode(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   findings.push(...detectUnusedImports(filePath, content, lines, ignoreState));
   findings.push(...detectUnusedVariables(filePath, content, lines, ignoreState));
@@ -26925,7 +27809,7 @@ var TYPE_SAFETY_RULES = [
     fileExtensions: [".ts", ".tsx"]
   }
 ];
-function detectTypeSafety(filePath, content, lines, ignoreState, config) {
+function detectTypeSafety(filePath, content, lines, ignoreState, _config) {
   const findings = [];
   if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) {
     return findings;
@@ -27531,6 +28415,9 @@ function countAnyTypes(code) {
   }
   return count;
 }
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function countUnusedImports(code) {
   const importMatches = code.match(/import\s+{([^}]+)}\s+from/g);
   if (!importMatches) return 0;
@@ -27540,10 +28427,17 @@ function countUnusedImports(code) {
     const namedImports = importMatch.match(/{([^}]+)}/);
     const namedImportContent = namedImports?.[1];
     if (namedImportContent) {
-      const names = namedImportContent.split(",").map((n) => n.trim().split(/\s+as\s+/).pop()?.trim() ?? "");
+      const names = namedImportContent.split(",").map((n) => {
+        const trimmed = n.trim();
+        const withoutType = trimmed.replace(/^type\s+/, "");
+        return withoutType.split(/\s+as\s+/).pop()?.trim() ?? "";
+      }).filter((name) => name.length > 0 && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name));
       for (const name of names) {
-        if (name && !new RegExp(`\\b${name}\\b`).test(codeWithoutImports)) {
-          unusedCount++;
+        try {
+          if (!new RegExp(`\\b${escapeRegex2(name)}\\b`).test(codeWithoutImports)) {
+            unusedCount++;
+          }
+        } catch {
         }
       }
     }
@@ -30999,6 +31893,7 @@ init_logger();
 // src/core/task-engine/task-queue.ts
 init_esm_shims();
 init_logger();
+init_safe_timers();
 
 // src/mcp/tools/task/create-task.ts
 init_logger();
@@ -31123,7 +32018,7 @@ var createTaskSchema = {
 // src/mcp/tools/task/run-task.ts
 init_esm_shims();
 init_logger();
-function createRunTaskHandler(deps) {
+function createRunTaskHandler(_deps) {
   return async (input, context) => {
     const startTime = Date.now();
     if (context?.signal?.aborted) {
@@ -33673,6 +34568,17 @@ Use this tool first to understand what AutomatosX offers.`,
         mode: "sdk"
       }));
     }
+    if (config.providers["qwen"]?.enabled) {
+      const { QwenProvider: QwenProvider2 } = await Promise.resolve().then(() => (init_qwen_provider(), qwen_provider_exports));
+      const qwenConfig = config.providers["qwen"];
+      providers.push(new QwenProvider2({
+        name: "qwen",
+        enabled: true,
+        priority: qwenConfig.priority,
+        timeout: qwenConfig.timeout,
+        mode: qwenConfig.mode || "sdk"
+      }));
+    }
     const healthCheckInterval = config.router?.healthCheckInterval;
     this.router = new Router({
       providers,