@defai.digital/automatosx 12.6.1 → 12.6.3

package/dist/index.js

@@ -2,7 +2,7 @@
 import * as path4 from 'path';
 import path4__default, { dirname, join, isAbsolute, basename, resolve, extname as extname$1, relative, sep, delimiter, normalize, parse as parse$1 } from 'path';
 import { fileURLToPath } from 'url';
-import { mkdir, appendFile, access as access$1, readFile, stat, rm, readdir, copyFile, writeFile, rename, unlink, constants as constants$1, realpath as realpath$1 } from 'fs/promises';
+import { mkdir, appendFile, access as access$1, stat, readFile, rm, readdir, copyFile, writeFile, rename, unlink, constants as constants$1, realpath as realpath$1 } from 'fs/promises';
 import * as fs4 from 'fs';
 import { access, realpath, existsSync, readFileSync, constants, writeFileSync, promises, mkdirSync, statSync, readdirSync, createWriteStream, unlinkSync } from 'fs';
 import Database2 from 'better-sqlite3';
@@ -20,15 +20,14 @@ import { promisify } from 'util';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import crypto4, { randomUUID, createHash, randomBytes } from 'crypto';
-import * as yaml4 from 'js-yaml';
-import yaml4__default, { load, dump } from 'js-yaml';
+import * as yaml3 from 'js-yaml';
+import yaml3__default, { load, dump } from 'js-yaml';
 import Table from 'cli-table3';
 import inquirer from 'inquirer';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 import { EventEmitter } from 'events';
 import * as sqliteVec from 'sqlite-vec';
-import yaml from 'yaml';
 import { gzipSync, gunzipSync } from 'zlib';
 import { parse } from '@iarna/toml';
 
@@ -1418,6 +1417,119 @@ var init_path_resolver = __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((resolve13, reject) => {
+    const timeoutId = setTimeout(() => {
+      resolve13();
+    }, ms);
+    if (timeoutId.unref) {
+      timeoutId.unref();
+    }
+  });
+}
+var init_safe_timers = __esm({
+  "src/shared/utils/safe-timers.ts"() {
+    init_esm_shims();
+    init_logger();
+  }
+});
+
 // src/core/workspace-indexer.ts
 var workspace_indexer_exports = {};
 __export(workspace_indexer_exports, {
@@ -2635,6 +2747,7 @@ function getRetryableErrors(provider) {
       return [...baseErrors, ...CODEX_RETRYABLE_ERRORS];
     case "glm":
     case "grok":
+    case "qwen":
       return [...baseErrors, ...OPENAI_RETRYABLE_ERRORS];
     case "base":
     default:
@@ -2737,6 +2850,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
       ];
@@ -3099,7 +3216,7 @@ var init_base_provider = __esm({
             if (readlineInterface) {
               try {
                 readlineInterface.close();
-              } catch (error) {
+              } catch {
               } finally {
                 readlineInterface = null;
               }
@@ -3107,7 +3224,7 @@ var init_base_provider = __esm({
             if (stderrInterface) {
               try {
                 stderrInterface.close();
-              } catch (error) {
+              } catch {
               } finally {
                 stderrInterface = null;
               }
@@ -3301,7 +3418,7 @@ ${fullPrompt}
             this.health.consecutiveSuccesses = 0;
           }
           return available;
-        } catch (error) {
+        } catch {
           this.health.available = false;
           this.health.errorRate = 1;
           this.health.lastCheck = Date.now();
@@ -3477,6 +3594,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);
       }
@@ -5551,6 +5670,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,
@@ -5705,7 +5825,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) {
@@ -5880,12 +6000,6 @@ var init_hybrid_adapter_base = __esm({
         } catch {
         }
       }
-      /**
-       * Sleep utility
-       */
-      sleep(ms) {
-        return new Promise((resolve13) => setTimeout(resolve13, ms));
-      }
       /**
        * Get current active mode
        */
@@ -5936,13 +6050,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";
   }
 });
@@ -6098,14 +6220,14 @@ var init_sdk_adapter2 = __esm({
     };
   }
 });
-var execAsync3, GLMCliWrapper;
+var execAsync4, GLMCliWrapper;
 var init_cli_wrapper2 = __esm({
   "src/integrations/ax-glm/cli-wrapper.ts"() {
     init_esm_shims();
     init_logger();
     init_validation_limits();
     init_types2();
-    execAsync3 = promisify(exec);
+    execAsync4 = promisify(exec);
     GLMCliWrapper = class {
       config;
       cliPath = null;
@@ -6126,13 +6248,13 @@ var init_cli_wrapper2 = __esm({
        */
       async isAvailable() {
         try {
-          const { stdout } = await execAsync3(`which ${this.config.command}`, {
+          const { stdout } = await execAsync4(`which ${this.config.command}`, {
             timeout: TIMEOUTS.PROVIDER_DETECTION
           });
           this.cliPath = stdout.trim();
           if (this.cliPath) {
             try {
-              const { stdout: versionOutput } = await execAsync3(
+              const { stdout: versionOutput } = await execAsync4(
                 `${this.config.command} --version`,
                 { timeout: TIMEOUTS.PROVIDER_DETECTION }
               );
@@ -6481,6 +6603,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 {
@@ -6560,7 +6683,7 @@ var init_sdk_only_adapter = __esm({
                 attempt: attempt + 1,
                 delayMs: delay
               });
-              await this.sleep(delay);
+              await sleep(delay);
               continue;
             }
             break;
@@ -6596,12 +6719,6 @@ var init_sdk_only_adapter = __esm({
         }
         return false;
       }
-      /**
-       * Sleep utility
-       */
-      sleep(ms) {
-        return new Promise((resolve13) => setTimeout(resolve13, ms));
-      }
       /**
        * Get the configured model
        */
@@ -6896,10 +7013,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";
   }
 });
@@ -7055,14 +7180,14 @@ var init_sdk_adapter3 = __esm({
     };
   }
 });
-var execAsync4, GrokCliWrapper;
+var execAsync5, GrokCliWrapper;
 var init_cli_wrapper3 = __esm({
   "src/integrations/ax-grok/cli-wrapper.ts"() {
     init_esm_shims();
     init_logger();
     init_validation_limits();
     init_types3();
-    execAsync4 = promisify(exec);
+    execAsync5 = promisify(exec);
     GrokCliWrapper = class {
       config;
       cliPath = null;
@@ -7083,13 +7208,13 @@ var init_cli_wrapper3 = __esm({
        */
       async isAvailable() {
         try {
-          const { stdout } = await execAsync4(`which ${this.config.command}`, {
+          const { stdout } = await execAsync5(`which ${this.config.command}`, {
             timeout: TIMEOUTS.PROVIDER_DETECTION
           });
           this.cliPath = stdout.trim();
           if (this.cliPath) {
             try {
-              const { stdout: versionOutput } = await execAsync4(
+              const { stdout: versionOutput } = await execAsync5(
                 `${this.config.command} --version`,
                 { timeout: TIMEOUTS.PROVIDER_DETECTION }
               );
@@ -7438,6 +7563,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 {
@@ -7517,7 +7643,7 @@ var init_sdk_only_adapter2 = __esm({
                 attempt: attempt + 1,
                 delayMs: delay
               });
-              await this.sleep(delay);
+              await sleep(delay);
               continue;
             }
             break;
@@ -7553,12 +7679,6 @@ var init_sdk_only_adapter2 = __esm({
         }
         return false;
       }
-      /**
-       * Sleep utility
-       */
-      sleep(ms) {
-        return new Promise((resolve13) => setTimeout(resolve13, ms));
-      }
       /**
        * Get the configured model
        */
@@ -7836,6 +7956,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((resolve13, reject) => {
+          const args = [];
+          if (this.config.vlmSwitchMode !== "once") {
+            args.push("--vlm-switch-mode", this.config.vlmSwitchMode);
+          }
+          if (this.config.yolo) {
+            args.push("--yolo");
+          }
+          logger.debug("[Qwen CLI] Spawning process", {
+            command: this.config.command,
+            args,
+            promptLength: request.prompt.length
+          });
+          const child = spawn(this.config.command, args, {
+            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 = readline2__default.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);
+              resolve13({
+                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/cli/index.ts
 init_esm_shims();
 init_logger();
@@ -8736,12 +9752,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;
@@ -8751,8 +9771,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;
     }
@@ -9394,7 +10417,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.6.1"
+  "version": "12.6.3"
 };
 
 // src/core/config/schemas.ts
@@ -12417,7 +13440,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;
@@ -12446,7 +13473,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());
@@ -12775,7 +13802,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
         });
@@ -12821,17 +13848,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}`
@@ -12841,22 +13869,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", {
@@ -12868,7 +13896,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", {
@@ -12877,32 +13905,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
     };
@@ -13160,14 +14188,17 @@ init_validation_limits();
 var execAsync2 = promisify(exec);
 var ProviderDetector = class _ProviderDetector {
   // v12.0.0: Removed ax-cli, added glm/grok (SDK-first providers)
+  // v12.7.0: Added qwen (SDK-first with CLI fallback)
   static PROVIDER_COMMANDS = {
     "claude-code": "claude",
     "gemini-cli": "gemini",
     "codex": "codex",
     "glm": "glm",
     // v12.0.0: Native GLM provider (SDK-first)
-    "grok": "grok"
+    "grok": "grok",
     // v12.0.0: Native Grok provider (SDK-first)
+    "qwen": "qwen"
+    // v12.7.0: Qwen Code provider (SDK-first with CLI fallback)
   };
   /**
    * Detect all supported AI provider CLIs
@@ -13192,16 +14223,22 @@ var ProviderDetector = class _ProviderDetector {
     const results = await Promise.all([
       this.isCommandAvailable("claude-code"),
       this.isCommandAvailable("gemini-cli"),
-      this.isCommandAvailable("codex")
+      this.isCommandAvailable("codex"),
+      this.isCommandAvailable("qwen")
     ]);
+    const qwenApiKeySet = !!(process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY);
+    const qwenCliAvailable = results[3];
+    const qwenAvailable = qwenApiKeySet || qwenCliAvailable;
     const detected = {
       "claude-code": results[0],
       "gemini-cli": results[1],
       "codex": results[2],
       "glm": true,
       // SDK-first: always available via SDK
-      "grok": true
+      "grok": true,
       // SDK-first: always available via SDK
+      "qwen": qwenAvailable
+      // v12.7.0: SDK-first with CLI fallback
     };
     const foundProviders = Object.entries(detected).filter(([_, isInstalled]) => isInstalled).map(([provider]) => provider);
     logger.info("Provider detection complete", {
@@ -13308,6 +14345,9 @@ var ProviderDetector = class _ProviderDetector {
     if (provider === "grok") {
       return this.getGrokVersion();
     }
+    if (provider === "qwen") {
+      return this.getQwenVersion();
+    }
     const command = _ProviderDetector.PROVIDER_COMMANDS[provider];
     try {
       const { stdout } = await execAsync2(`${command} --version`, {
@@ -13348,6 +14388,19 @@ var ProviderDetector = class _ProviderDetector {
     }
     return "SDK v1 (grok-3, API key not set)";
   }
+  /**
+   * Get Qwen provider version info (SDK-first with CLI fallback)
+   *
+   * v12.7.0: Qwen is an SDK-first provider using OpenAI-compatible API (DashScope).
+   * Returns SDK info with API key status or CLI availability.
+   */
+  getQwenVersion() {
+    const apiKey = process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY;
+    if (apiKey) {
+      return "SDK v1 (qwen-turbo, API ready)";
+    }
+    return "SDK v1 (qwen-turbo, CLI fallback)";
+  }
   /**
    * Get list of detected provider names
    *
@@ -13381,7 +14434,9 @@ var ProviderDetector = class _ProviderDetector {
       "gemini-cli": "Gemini CLI",
       "codex": "Codex CLI",
       "glm": "GLM (Zhipu AI)",
-      "grok": "Grok (xAI)"
+      "grok": "Grok (xAI)",
+      "qwen": "Qwen (Alibaba Cloud)"
+      // v12.7.0
     };
     return nameMap[provider] || provider;
   }
@@ -13474,8 +14529,9 @@ var setupCommand = {
         console.log(chalk5.gray("     - Claude Code"));
         console.log(chalk5.gray("     - Gemini CLI"));
         console.log(chalk5.gray("     - Codex CLI"));
-        console.log(chalk5.gray("     - GLM (SDK-first, requires ZAI_API_KEY)"));
+        console.log(chalk5.gray("     - GLM (SDK-first, requires GLM_API_KEY)"));
         console.log(chalk5.gray("     - Grok (SDK-first, requires XAI_API_KEY)"));
+        console.log(chalk5.gray("     - Qwen (SDK-first, requires DASHSCOPE_API_KEY or qwen CLI)"));
         console.log("");
         console.log(chalk5.cyan('   \u{1F4A1} After installing, run "ax setup" again to configure.\n'));
         if (process.stdout.isTTY && process.stdin.isTTY) {
@@ -13552,14 +14608,14 @@ var setupCommand = {
         console.log(chalk5.cyan("\u{1F50C} Setting up Gemini CLI integration..."));
         const geminiDir = join(projectDir, ".gemini");
         const geminiDirExistedBefore = await checkExists2(geminiDir);
-        geminiMcpStatus = await setupGeminiIntegration(projectDir, packageRoot);
+        geminiMcpStatus = await setupGeminiIntegration(projectDir, packageRoot, argv.force);
         if (!geminiDirExistedBefore) {
           createdResources.push(geminiDir);
         }
         if (geminiMcpStatus === "configured") {
-          console.log(chalk5.green("   \u2713 Gemini CLI MCP integration configured"));
+          console.log(chalk5.green("   \u2713 Gemini CLI MCP integration configured (gemini mcp add)"));
         } else if (geminiMcpStatus === "skipped") {
-          console.log(chalk5.yellow("   \u26A0 Gemini CLI MCP skipped (MCP server not found)"));
+          console.log(chalk5.yellow("   \u26A0 Gemini CLI not available, skipped MCP setup"));
           console.log(chalk5.gray("     CLI integration still works via subprocess"));
         } else {
           console.log(chalk5.yellow("   \u26A0 Gemini CLI MCP configuration failed"));
@@ -13581,34 +14637,26 @@ var setupCommand = {
       let codexMcpStatus = "skipped";
       if (providers["codex"]) {
         console.log(chalk5.cyan("\u{1F50C} Setting up Codex CLI MCP integration..."));
-        codexMcpStatus = await setupCodexGlobalMCPConfig();
+        codexMcpStatus = await setupCodexGlobalMCPConfig(argv.force);
         if (codexMcpStatus === "configured") {
-          console.log(chalk5.green("   \u2713 Codex CLI MCP integration configured"));
+          console.log(chalk5.green("   \u2713 Codex CLI MCP integration configured (codex mcp add)"));
         } else if (codexMcpStatus === "skipped") {
-          console.log(chalk5.yellow("   \u26A0 Codex CLI MCP skipped"));
+          console.log(chalk5.yellow("   \u26A0 Codex CLI not available, skipped MCP setup"));
         } else {
           console.log(chalk5.yellow("   \u26A0 Codex CLI MCP configuration failed"));
           console.log(chalk5.gray("     CLI integration still works via subprocess"));
         }
       }
-      let glmMcpStatus = "skipped";
-      if (providers["glm"]) {
-        console.log(chalk5.cyan("\u{1F50C} Setting up GLM (ax-glm) MCP integration..."));
-        glmMcpStatus = await setupGlmMCPConfig(projectDir);
-        if (glmMcpStatus === "configured") {
-          console.log(chalk5.green("   \u2713 GLM MCP integration configured (.ax-glm/.mcp.json)"));
-        } else {
-          console.log(chalk5.yellow("   \u26A0 GLM MCP configuration failed"));
-        }
-      }
-      let grokMcpStatus = "skipped";
-      if (providers["grok"]) {
-        console.log(chalk5.cyan("\u{1F50C} Setting up Grok (ax-grok) MCP integration..."));
-        grokMcpStatus = await setupGrokMCPConfig(projectDir);
-        if (grokMcpStatus === "configured") {
-          console.log(chalk5.green("   \u2713 Grok MCP integration configured (.ax-grok/.mcp.json)"));
+      let qwenMcpStatus = "skipped";
+      if (providers["qwen"]) {
+        console.log(chalk5.cyan("\u{1F50C} Setting up Qwen MCP integration..."));
+        qwenMcpStatus = await setupQwenMCPConfig(projectDir, argv.force);
+        if (qwenMcpStatus === "configured") {
+          console.log(chalk5.green("   \u2713 Qwen MCP integration configured (qwen mcp add)"));
+        } else if (qwenMcpStatus === "skipped") {
+          console.log(chalk5.yellow("   \u26A0 Qwen CLI not available, skipped MCP setup"));
         } else {
-          console.log(chalk5.yellow("   \u26A0 Grok MCP configuration failed"));
+          console.log(chalk5.yellow("   \u26A0 Qwen MCP configuration failed"));
         }
       }
       console.log(chalk5.cyan("\u{1F4DD} Updating .gitignore..."));
@@ -13639,9 +14687,11 @@ var setupCommand = {
           console.log(chalk5.gray("     This is fine - MCP discovery will work without manifests"));
         }
       }
-      console.log(chalk5.cyan("\u{1F50C} Creating MCP server configuration..."));
-      await createMcpConfig(projectDir);
-      console.log(chalk5.green("   \u2713 .mcp.json created for MCP discovery"));
+      if (providers["claude-code"]) {
+        console.log(chalk5.cyan("\u{1F50C} Setting up Claude Code MCP integration..."));
+        await createMcpConfig(projectDir, argv.force);
+        console.log(chalk5.green("   \u2713 Claude Code MCP integration configured (claude mcp add)"));
+      }
       console.log(chalk5.green.bold("\n\u2705 AutomatosX set up successfully!\n"));
       if (foundProviders.length > 0) {
         console.log(chalk5.cyan(`Configured for: ${foundProviders.join(", ")}
@@ -13650,14 +14700,15 @@ var setupCommand = {
         console.log(chalk5.yellow("\u26A0\uFE0F  No AI providers configured\n"));
       }
       console.log(chalk5.gray("Next steps:"));
-      console.log(chalk5.gray("  1. Review ax.config.json"));
-      console.log(chalk5.gray("  2. List agents: automatosx list agents"));
-      console.log(chalk5.gray('  3. Run an agent: automatosx run backend "Hello!"\n'));
-      console.log(chalk5.cyan("MCP Integration (v13.0.0):"));
-      console.log(chalk5.gray("  \u2022 .mcp.json created for automatic MCP server discovery"));
-      console.log(chalk5.gray("  \u2022 Claude Code/Gemini CLI will auto-connect to AutomatosX"));
+      console.log(chalk5.gray('  1. Run "ax init" to create project context files (AX.md, CUSTOM.md)'));
+      console.log(chalk5.gray("  2. Review ax.config.json"));
+      console.log(chalk5.gray("  3. List agents: automatosx list agents"));
+      console.log(chalk5.gray('  4. Run an agent: automatosx run backend "Hello!"\n'));
+      console.log(chalk5.cyan("MCP Integration (v12.8.0):"));
+      console.log(chalk5.gray("  \u2022 Native CLI commands used: claude/gemini/codex/qwen mcp add"));
+      console.log(chalk5.gray("  \u2022 View configured servers: <cli> mcp list"));
       console.log(chalk5.gray("  \u2022 Use get_capabilities tool to discover agents dynamically"));
-      console.log(chalk5.gray("  \u2022 No manual registration required\n"));
+      console.log(chalk5.gray("  \u2022 GLM/Grok are SDK-only (no MCP CLI setup needed)\n"));
       if (claudeCodeSetupSucceeded) {
         console.log(chalk5.yellow("Legacy Claude Code Manifests (deprecated):"));
         console.log(chalk5.gray("  \u2022 Slash commands: /agent-<name> (will be removed in v14.0.0)"));
@@ -13707,7 +14758,7 @@ var setupCommand = {
         console.log(chalk5.gray('  \u2022 Example: "Use ax agent backend to create a REST API"'));
         console.log(chalk5.gray("  \u2022 No special commands needed - just ask naturally!\n"));
       }
-      if (providers["glm"] || providers["grok"]) {
+      if (providers["glm"] || providers["grok"] || providers["qwen"]) {
         console.log(chalk5.cyan("SDK-First Providers (MCP Client Mode):"));
         if (providers["glm"]) {
           console.log(chalk5.gray("  \u2022 GLM (Zhipu AI) - API key: GLM_API_KEY"));
@@ -13717,8 +14768,12 @@ var setupCommand = {
           console.log(chalk5.gray("  \u2022 Grok (xAI) - API key: XAI_API_KEY"));
           console.log(chalk5.gray("    MCP: AxGrokWithMcp class connects to AutomatosX MCP server"));
         }
-        console.log(chalk5.gray('  \u2022 CLI: ax run <agent> "your task" --engine glm|grok'));
-        console.log(chalk5.gray("  \u2022 SDK: Import AxGlmWithMcp / AxGrokWithMcp for direct MCP integration\n"));
+        if (providers["qwen"]) {
+          console.log(chalk5.gray("  \u2022 Qwen (Alibaba Cloud) - API key: DASHSCOPE_API_KEY or QWEN_API_KEY"));
+          console.log(chalk5.gray("    Or install Qwen Code CLI: npm install -g @qwen-code/qwen-code"));
+        }
+        console.log(chalk5.gray('  \u2022 CLI: ax run <agent> "your task" --engine glm|grok|qwen'));
+        console.log(chalk5.gray("  \u2022 SDK: Import provider adapters for direct MCP integration\n"));
       }
       if (providers["codex"]) {
         console.log(chalk5.cyan("Codex CLI Integration:"));
@@ -14240,9 +15295,9 @@ async function initializeGitRepository(projectDir) {
       logger.info("Git repository already exists, skipping initialization");
       return true;
     }
-    const { spawn: spawn12 } = await import('child_process');
+    const { spawn: spawn13 } = await import('child_process');
     await new Promise((resolve13, reject) => {
-      const child = spawn12("git", ["init"], {
+      const child = spawn13("git", ["init"], {
         cwd: projectDir,
         stdio: "pipe",
         shell: false
@@ -14323,143 +15378,71 @@ async function updateGitignore(projectDir) {
     logger.warn("Failed to update .gitignore", { error: error.message });
   }
 }
-async function setupGeminiIntegration(_projectDir, _packageRoot) {
-  const mcpStatus = await setupGeminiGlobalMCPConfig();
+async function setupGeminiIntegration(projectDir, _packageRoot, force = false) {
+  const mcpStatus = await setupGeminiMCPViaCLI(projectDir, force);
   return mcpStatus;
 }
-async function setupGeminiGlobalMCPConfig() {
-  const homeDir = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
-  if (!homeDir) {
-    logger.warn("Could not determine home directory for Gemini CLI MCP configuration");
-    return "skipped";
-  }
-  const settingsPath = join(homeDir, ".gemini", "settings.json");
-  const geminiDir = join(homeDir, ".gemini");
+async function setupGeminiMCPViaCLI(projectDir, force = false) {
+  const { exec: exec9 } = await import('child_process');
+  const { promisify: promisify10 } = await import('util');
+  const execAsync9 = promisify10(exec9);
   try {
-    await mkdir(geminiDir, { recursive: true });
-    let settings = {};
-    if (await checkExists2(settingsPath)) {
-      const existingContent = await readFile(settingsPath, "utf-8");
-      try {
-        settings = JSON.parse(existingContent);
-      } catch (error) {
-        logger.warn("Failed to parse existing Gemini settings, will merge carefully", {
-          error: error.message
+    const { stdout: listOutput } = await execAsync9("gemini mcp list", { timeout: 1e4 });
+    if (listOutput.includes("automatosx")) {
+      if (force) {
+        logger.info("Force mode: removing existing Gemini MCP server");
+        await execAsync9("gemini mcp remove automatosx", { timeout: 1e4 }).catch(() => {
         });
+      } else {
+        logger.info("Gemini CLI MCP server already configured");
+        return "configured";
       }
     }
-    let mcpServers = settings["mcpServers"];
-    if (!mcpServers || typeof mcpServers !== "object") {
-      mcpServers = {};
-    }
-    mcpServers["automatosx"] = {
-      command: "automatosx",
-      args: ["mcp", "server"]
-    };
-    settings["mcpServers"] = mcpServers;
-    await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
-    logger.info("Configured Gemini CLI MCP in global settings", {
-      path: settingsPath
-    });
+    const addCommand2 = `gemini mcp add automatosx automatosx mcp server -s project -e "AUTOMATOSX_PROJECT_DIR=${projectDir}"`;
+    await execAsync9(addCommand2, { timeout: 3e4 });
+    logger.info("Configured Gemini CLI MCP via gemini mcp add");
     return "configured";
   } catch (error) {
+    const errorMessage = error.message;
+    if (errorMessage.includes("command not found") || errorMessage.includes("not recognized")) {
+      logger.debug("Gemini CLI not available, skipping MCP setup");
+      return "skipped";
+    }
     logger.warn("Failed to setup Gemini CLI MCP configuration", {
-      error: error.message,
-      path: settingsPath
+      error: errorMessage
     });
     return "failed";
   }
 }
-async function setupCodexGlobalMCPConfig() {
-  const homeDir = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
-  if (!homeDir) {
-    logger.warn("Could not determine home directory for Codex CLI MCP configuration");
-    return "skipped";
-  }
-  const codexDir = join(homeDir, ".codex");
-  const configPath = join(codexDir, "config.toml");
+async function setupCodexGlobalMCPConfig(force = false) {
+  const { exec: exec9 } = await import('child_process');
+  const { promisify: promisify10 } = await import('util');
+  const execAsync9 = promisify10(exec9);
   try {
-    await mkdir(codexDir, { recursive: true });
-    let existingContent = "";
-    if (await checkExists2(configPath)) {
-      existingContent = await readFile(configPath, "utf-8");
-    }
-    if (existingContent.includes("[mcp_servers.automatosx]")) {
-      logger.info("Codex CLI MCP already configured for automatosx");
-      return "configured";
-    }
-    const mcpConfig = `
-# AutomatosX MCP Server - Added by ax setup v12.2.0
-# Increased timeouts for lazy initialization (15-20s on first tool call)
-[mcp_servers.automatosx]
-command = "automatosx"
-args = ["mcp", "server"]
-startup_timeout_sec = 60
-tool_timeout_sec = 120
-`;
-    await writeFile(configPath, existingContent + mcpConfig, "utf-8");
-    logger.info("Configured Codex CLI MCP in global config", {
-      path: configPath
-    });
-    return "configured";
-  } catch (error) {
-    logger.warn("Failed to setup Codex CLI MCP configuration", {
-      error: error.message,
-      path: configPath
-    });
-    return "failed";
-  }
-}
-async function setupGlmMCPConfig(projectDir) {
-  const configDir = join(projectDir, ".ax-glm");
-  const configPath = join(configDir, ".mcp.json");
-  try {
-    await mkdir(configDir, { recursive: true });
-    const mcpConfig = {
-      mcpServers: {
-        automatosx: {
-          command: "automatosx",
-          args: ["mcp", "server"],
-          env: {
-            AUTOMATOSX_PROJECT_DIR: projectDir
-          }
-        }
-      }
-    };
-    await writeFile(configPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-    logger.info("Configured GLM MCP integration", { path: configPath });
-    return "configured";
-  } catch (error) {
-    logger.warn("Failed to setup GLM MCP configuration", {
-      error: error.message,
-      path: configPath
-    });
-    return "failed";
-  }
-}
-async function setupGrokMCPConfig(projectDir) {
-  const configDir = join(projectDir, ".ax-grok");
-  const configPath = join(configDir, ".mcp.json");
-  try {
-    await mkdir(configDir, { recursive: true });
-    const mcpConfig = {
-      mcpServers: {
-        automatosx: {
-          command: "automatosx",
-          args: ["mcp", "server"],
-          env: {
-            AUTOMATOSX_PROJECT_DIR: projectDir
-          }
-        }
+    const { stdout: listOutput } = await execAsync9("codex mcp list", { timeout: 1e4 });
+    if (listOutput.includes("automatosx")) {
+      if (force) {
+        logger.info("Force mode: removing existing Codex MCP server");
+        await execAsync9("codex mcp remove automatosx", { timeout: 1e4 }).catch(() => {
+        });
+      } else {
+        logger.info("Codex CLI MCP server already configured");
+        return "configured";
       }
-    };
-    await writeFile(configPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-    logger.info("Configured Grok MCP integration", { path: configPath });
+    }
+    const cwd = process.cwd();
+    const addCommand2 = `codex mcp add automatosx --env "AUTOMATOSX_PROJECT_DIR=${cwd}" -- automatosx mcp server`;
+    await execAsync9(addCommand2, { timeout: 3e4 });
+    logger.info("Configured Codex CLI MCP via codex mcp add");
     return "configured";
   } catch (error) {
-    logger.warn("Failed to setup Grok MCP configuration", {
-      error: error.message,
-      path: configPath
+    const errorMessage = error.message;
+    if (errorMessage.includes("command not found") || errorMessage.includes("not recognized")) {
+      logger.debug("Codex CLI not available, skipping MCP setup");
+      return "skipped";
+    }
+    logger.warn("Failed to setup Codex CLI MCP configuration", {
+      error: errorMessage
     });
     return "failed";
   }
@@ -14508,41 +15491,66 @@ Created by AutomatosX for organized scratch work.
     });
   }
 }
-async function createMcpConfig(projectDir) {
-  const mcpConfigPath = join(projectDir, ".mcp.json");
-  const mcpConfig = {
-    mcpServers: {
-      automatosx: {
-        command: "automatosx",
-        args: ["mcp", "server"],
-        env: {
-          AUTOMATOSX_PROJECT_DIR: projectDir
-        }
+async function createMcpConfig(projectDir, force = false) {
+  const { exec: exec9 } = await import('child_process');
+  const { promisify: promisify10 } = await import('util');
+  const execAsync9 = promisify10(exec9);
+  try {
+    const { stdout: listOutput } = await execAsync9("claude mcp list", { timeout: 1e4 });
+    if (listOutput.includes("automatosx")) {
+      if (force) {
+        logger.info("Force mode: removing existing Claude Code MCP server");
+        await execAsync9("claude mcp remove automatosx", { timeout: 1e4 }).catch(() => {
+        });
+      } else {
+        logger.info("Claude Code MCP server already configured");
+        return;
       }
     }
-  };
+    const addCommand2 = `claude mcp add automatosx -s local -e "AUTOMATOSX_PROJECT_DIR=${projectDir}" -- automatosx mcp server`;
+    await execAsync9(addCommand2, { timeout: 3e4 });
+    logger.info("Configured Claude Code MCP via claude mcp add");
+  } catch (error) {
+    const errorMessage = error.message;
+    if (errorMessage.includes("command not found") || errorMessage.includes("not recognized")) {
+      logger.debug("Claude Code not available, skipping MCP setup");
+      return;
+    }
+    logger.warn("Failed to setup Claude Code MCP configuration", {
+      error: errorMessage
+    });
+  }
+}
+async function setupQwenMCPConfig(projectDir, force = false) {
+  const { exec: exec9 } = await import('child_process');
+  const { promisify: promisify10 } = await import('util');
+  const execAsync9 = promisify10(exec9);
   try {
-    if (await checkExists2(mcpConfigPath)) {
-      const existingContent = await readFile(mcpConfigPath, "utf-8");
-      try {
-        const existingConfig = JSON.parse(existingContent);
-        if (existingConfig.mcpServers) {
-          existingConfig.mcpServers["automatosx"] = mcpConfig.mcpServers.automatosx;
-          await writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
-          logger.info("Updated existing .mcp.json with AutomatosX server", { path: mcpConfigPath });
-          return;
-        }
-      } catch {
-        logger.warn("Failed to parse existing .mcp.json, will overwrite", { path: mcpConfigPath });
+    const { stdout: listOutput } = await execAsync9("qwen mcp list", { timeout: 1e4 });
+    if (listOutput.includes("automatosx")) {
+      if (force) {
+        logger.info("Force mode: removing existing Qwen MCP server");
+        await execAsync9("qwen mcp remove automatosx", { timeout: 1e4 }).catch(() => {
+        });
+      } else {
+        logger.info("Qwen MCP server already configured");
+        return "configured";
       }
     }
-    await writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-    logger.info("Created .mcp.json for MCP discovery", { path: mcpConfigPath });
+    const addCommand2 = `qwen mcp add automatosx automatosx mcp server -s project -e "AUTOMATOSX_PROJECT_DIR=${projectDir}"`;
+    await execAsync9(addCommand2, { timeout: 3e4 });
+    logger.info("Configured Qwen MCP integration via qwen mcp add");
+    return "configured";
   } catch (error) {
-    logger.warn("Failed to create .mcp.json", {
-      error: error.message,
-      path: mcpConfigPath
+    const errorMessage = error.message;
+    if (errorMessage.includes("command not found") || errorMessage.includes("not recognized")) {
+      logger.debug("Qwen CLI not available, skipping MCP setup");
+      return "skipped";
+    }
+    logger.warn("Failed to setup Qwen MCP configuration", {
+      error: errorMessage
     });
+    return "failed";
   }
 }
 async function cleanupForceMode(projectDir) {
@@ -14697,7 +15705,7 @@ async function parsePackageJson(projectDir, info) {
     if (packageJson.workspaces || devDeps.includes("lerna") || devDeps.includes("nx") || devDeps.includes("turborepo") || existsSync(join(projectDir, "lerna.json")) || existsSync(join(projectDir, "nx.json"))) {
       info.isMonorepo = true;
     }
-  } catch (error) {
+  } catch {
   }
 }
 async function parseReadmeDescription(projectDir, info) {
@@ -14758,10 +15766,10 @@ async function parseReadmeDescription(projectDir, info) {
         info.teamSize = "Open source community";
       }
     }
-  } catch (error) {
+  } catch {
   }
 }
-function categorizeScripts(scripts, packageManager) {
+function categorizeScripts(scripts, _packageManager) {
   const categorized = {
     development: [],
     building: [],
@@ -14871,7 +15879,7 @@ async function analyzeFileStructure(projectDir) {
         if (name === "docs") {
           structure.docsDirectory = name;
         }
-      } catch (error) {
+      } catch {
       }
     }
   }
@@ -14901,7 +15909,7 @@ async function countFilesRecursive(dirPath, depth = 0) {
   }
   return count;
 }
-async function detectKeyComponents(projectDir, info) {
+async function detectKeyComponents(projectDir, _info) {
   const components = [];
   const srcDir = join(projectDir, "src");
   if (!existsSync(srcDir)) return components;
@@ -15200,7 +16208,7 @@ async function detectDatabaseSchema(projectDir, info) {
   }
   return void 0;
 }
-async function detectPrismaSchema(projectDir, schemaPath, info) {
+async function detectPrismaSchema(projectDir, schemaPath, _info) {
   const models = [];
   const migrations = await detectMigrations(projectDir, "prisma/migrations");
   try {
@@ -15254,7 +16262,7 @@ async function detectPrismaSchema(projectDir, schemaPath, info) {
         relations
       });
     }
-  } catch (error) {
+  } catch {
   }
   return {
     orm: "Prisma",
@@ -15342,347 +16350,66 @@ async function detectNextJSAPIRoutes(projectDir) {
             // Next.js API routes handle multiple methods
             path: `/api/${routePath}`,
             group: routePath.split("/")[0] || "api"
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  return endpoints;
-}
-async function detectExpressRoutes(projectDir) {
-  const endpoints = [];
-  const srcDir = join(projectDir, "src");
-  if (!existsSync(srcDir)) return endpoints;
-  try {
-    const routeFiles = await findFilesRecursive(srcDir, /route|controller|api/i, 3);
-    for (const file of routeFiles.slice(0, 10)) {
-      try {
-        const content = await readFile(file, "utf-8");
-        const routeRegex = /(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/g;
-        let match;
-        while ((match = routeRegex.exec(content)) !== null) {
-          if (match[1] && match[2]) {
-            const method = match[1].toUpperCase();
-            const path9 = match[2];
-            endpoints.push({
-              method,
-              path: path9,
-              group: path9.split("/")[1] || "api"
-            });
-          }
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return endpoints;
-}
-async function findFilesRecursive(dir, pattern, maxDepth = 3, currentDepth = 0) {
-  if (currentDepth > maxDepth) return [];
-  const files = [];
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = join(dir, entry.name);
-      if (entry.isFile() && pattern.test(entry.name)) {
-        files.push(fullPath);
-      } else if (entry.isDirectory()) {
-        const subFiles = await findFilesRecursive(fullPath, pattern, maxDepth, currentDepth + 1);
-        files.push(...subFiles);
-      }
-    }
-  } catch {
-  }
-  return files;
-}
-
-// src/cli/commands/init-parser.ts
-init_esm_shims();
-function parseAXMD(content) {
-  const result = {
-    dependencies: [],
-    scripts: {},
-    hasCustomContent: false,
-    customSections: []
-  };
-  const versionMatch = content.match(/Project:.*?\(v([\d.]+)\)/);
-  if (versionMatch) {
-    result.version = versionMatch[1];
-  }
-  const nameMatch = content.match(/# Project Context for (.+)/);
-  if (nameMatch) {
-    result.projectName = nameMatch[1];
-  }
-  const descMatch = content.match(/## Project Overview\n\n\*\*(.+?)\*\*/);
-  if (descMatch) {
-    result.description = descMatch[1];
-  }
-  const archMatch = content.match(/\*\*Architecture:\*\* (.+)/);
-  if (archMatch) {
-    result.architecture = archMatch[1];
-  }
-  const stackMatch = content.match(/\*\*Stack:\*\* (.+)/);
-  if (stackMatch && stackMatch[1]) {
-    result.stack = stackMatch[1];
-    result.dependencies = stackMatch[1].split(",").map((d) => d.trim().toLowerCase()).filter(Boolean);
-  }
-  const teamMatch = content.match(/\*\*Team:\*\* (.+)/);
-  if (teamMatch) {
-    result.team = teamMatch[1];
-  }
-  const testMatch = content.match(/- Framework: (.+)/);
-  if (testMatch) {
-    result.testFramework = testMatch[1];
-  }
-  const linterMatch = content.match(/- Linter: (.+)/);
-  if (linterMatch) {
-    result.linter = linterMatch[1];
-  }
-  const formatterMatch = content.match(/- Formatter: (.+)/);
-  if (formatterMatch) {
-    result.formatter = formatterMatch[1];
-  }
-  const commandsMatch = content.match(/## Canonical Commands\n\n```bash\n([\s\S]*?)```/);
-  if (commandsMatch && commandsMatch[1]) {
-    const commandsSection = commandsMatch[1];
-    const lines = commandsSection.split("\n");
-    for (const line of lines) {
-      const cmdMatch = line.match(/^([^\s#]+(?:\s+[^\s#]+)*)\s*#/);
-      if (cmdMatch && cmdMatch[1]) {
-        const cmd = cmdMatch[1].trim();
-        result.scripts[cmd] = cmd;
-      }
-    }
-  }
-  const customMarkers = [
-    /<!-- USER-EDITED -->/,
-    /## Our Custom/,
-    /## Notes/,
-    /## Team Guidelines/
-  ];
-  for (const marker of customMarkers) {
-    if (marker.test(content)) {
-      result.hasCustomContent = true;
-      break;
-    }
-  }
-  const sections = content.split(/^## /m);
-  const standardSections = [
-    "Project Overview",
-    "Agent Delegation Rules",
-    "Coding Conventions",
-    "Critical Guardrails",
-    "Canonical Commands",
-    "Useful Links"
-  ];
-  for (const section of sections) {
-    const sectionName = section.split("\n")[0] ?? "";
-    if (sectionName && !standardSections.includes(sectionName)) {
-      result.customSections.push(sectionName);
-    }
-  }
-  return result;
-}
-function detectDetailedChanges(parsed, current) {
-  const changes = [];
-  if (parsed.version !== current.version && current.version) {
-    changes.push({
-      type: "version",
-      field: "version",
-      oldValue: parsed.version,
-      newValue: current.version
-    });
-  }
-  const currentDeps = current.dependencies.map((d) => d.toLowerCase());
-  const addedDeps = currentDeps.filter((d) => !parsed.dependencies.includes(d));
-  if (addedDeps.length > 0) {
-    changes.push({
-      type: "dependency-added",
-      field: "dependencies",
-      items: addedDeps
-    });
-  }
-  const removedDeps = parsed.dependencies.filter((d) => !currentDeps.includes(d));
-  if (removedDeps.length > 0) {
-    changes.push({
-      type: "dependency-removed",
-      field: "dependencies",
-      items: removedDeps
-    });
-  }
-  const currentScriptKeys = Object.keys(current.scripts);
-  const parsedScriptKeys = Object.keys(parsed.scripts);
-  const addedScripts = currentScriptKeys.filter((s) => !parsedScriptKeys.includes(s));
-  if (addedScripts.length > 0) {
-    changes.push({
-      type: "script-added",
-      field: "scripts",
-      items: addedScripts
-    });
-  }
-  const removedScripts = parsedScriptKeys.filter((s) => !currentScriptKeys.includes(s));
-  if (removedScripts.length > 0) {
-    changes.push({
-      type: "script-removed",
-      field: "scripts",
-      items: removedScripts
-    });
-  }
-  if (current.linter && !parsed.linter) {
-    changes.push({
-      type: "tool-added",
-      field: "linter",
-      newValue: current.linter
-    });
-  }
-  if (current.formatter && !parsed.formatter) {
-    changes.push({
-      type: "tool-added",
-      field: "formatter",
-      newValue: current.formatter
-    });
-  }
-  if (current.testFramework && !parsed.testFramework) {
-    changes.push({
-      type: "tool-added",
-      field: "test framework",
-      newValue: current.testFramework
-    });
-  }
-  if (parsed.architecture && parsed.architecture !== current.architecture) {
-    changes.push({
-      type: "architecture",
-      field: "architecture",
-      oldValue: parsed.architecture,
-      newValue: current.architecture
-    });
-  }
-  return changes;
-}
-function formatChangeSummary(changes) {
-  if (changes.length === 0) return "";
-  const summaries = [];
-  for (const change of changes) {
-    switch (change.type) {
-      case "version":
-        summaries.push(`version ${change.oldValue} \u2192 ${change.newValue}`);
-        break;
-      case "dependency-added":
-        summaries.push(`+${change.items.length} dep${change.items.length > 1 ? "s" : ""}`);
-        break;
-      case "dependency-removed":
-        summaries.push(`-${change.items.length} dep${change.items.length > 1 ? "s" : ""}`);
-        break;
-      case "script-added":
-        summaries.push(`+${change.items.length} script${change.items.length > 1 ? "s" : ""}`);
-        break;
-      case "tool-added":
-        summaries.push(`+${change.field}`);
-        break;
-      case "architecture":
-        summaries.push("architecture");
-        break;
-    }
-  }
-  if (summaries.length === 0) return "";
-  if (summaries.length === 1) return `(${summaries[0]})`;
-  if (summaries.length === 2) return `(${summaries[0]}, ${summaries[1]})`;
-  return `(${summaries.length} changes)`;
-}
-
-// src/cli/commands/init.ts
-function generateAXMD(info) {
-  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return `# Project Context for ${info.name}
-
-> Last updated: ${today}
-> Project: ${info.name}${info.version ? ` (v${info.version})` : ""}
-
-## Project Overview
-
-${generateProjectOverview(info)}
-
-## Architecture
-
-${generateArchitecture(info)}
-
-## File Structure
-
-${generateFileStructure(info)}
-
-${generateGettingStarted(info)}
-
-${generateTroubleshooting(info)}
-
-${generateDevWorkflow(info)}
-
-${generateDatabaseSchema(info)}
-
-${generateAPIDocumentation(info)}
-
-${generateAgentRules(info)}
-
-${generateCodingConventions(info)}
-
-${generateCriticalGuardrails(info)}
-
-${generateCommands(info)}
-
-${generateUsefulLinks(info)}
-
----
-
-**Generated by \`ax init\` \u2022 Run regularly to keep up-to-date**
-`;
-}
-function generateProjectOverview(info) {
-  const sections = [];
-  if (info.detailedDescription) {
-    sections.push(info.detailedDescription);
-  } else if (info.description) {
-    sections.push(`**${info.description}**`);
-  } else {
-    sections.push(`**${info.framework || "Node.js"} project${info.hasTypeScript ? " with TypeScript" : ""}**`);
-  }
-  const keyInfo = [];
-  keyInfo.push(`**Version:** ${info.version || "Not specified"}`);
-  keyInfo.push(`**Language:** ${info.language}`);
-  if (info.framework) keyInfo.push(`**Framework:** ${info.framework}`);
-  if (info.buildTool) keyInfo.push(`**Build Tool:** ${info.buildTool}`);
-  if (info.testFramework) keyInfo.push(`**Test Framework:** ${info.testFramework}`);
-  if (info.isMonorepo) keyInfo.push(`**Type:** Monorepo`);
-  sections.push("\n" + keyInfo.join("  \n"));
-  sections.push(`
-**Stack:** ${info.stack}`);
-  if (info.teamSize) {
-    sections.push(`
-**Team:** ${info.teamSize}`);
+          });
+        }
+      }
+    } catch {
+    }
   }
-  return sections.join("\n");
+  return endpoints;
 }
-function generateArchitecture(info) {
-  const sections = [];
-  sections.push(`**Type:** ${detectArchitectureType(info)}`);
-  if (info.architectureFlow) {
-    sections.push("\n**Flow:**\n```");
-    sections.push(info.architectureFlow.trim());
-    sections.push("```");
+async function detectExpressRoutes(projectDir) {
+  const endpoints = [];
+  const srcDir = join(projectDir, "src");
+  if (!existsSync(srcDir)) return endpoints;
+  try {
+    const routeFiles = await findFilesRecursive(srcDir, /route|controller|api/i, 3);
+    for (const file of routeFiles.slice(0, 10)) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const routeRegex = /(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/g;
+        let match;
+        while ((match = routeRegex.exec(content)) !== null) {
+          if (match[1] && match[2]) {
+            const method = match[1].toUpperCase();
+            const path9 = match[2];
+            endpoints.push({
+              method,
+              path: path9,
+              group: path9.split("/")[1] || "api"
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
   }
-  if (info.keyComponents && info.keyComponents.length > 0) {
-    sections.push("\n**Key Components:**");
-    for (const comp of info.keyComponents) {
-      if (comp.purpose) {
-        sections.push(`- \`${comp.path}\` - ${comp.purpose}`);
-      } else {
-        sections.push(`- \`${comp.path}\``);
+  return endpoints;
+}
+async function findFilesRecursive(dir, pattern, maxDepth = 3, currentDepth = 0) {
+  if (currentDepth > maxDepth) return [];
+  const files = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const fullPath = join(dir, entry.name);
+      if (entry.isFile() && pattern.test(entry.name)) {
+        files.push(fullPath);
+      } else if (entry.isDirectory()) {
+        const subFiles = await findFilesRecursive(fullPath, pattern, maxDepth, currentDepth + 1);
+        files.push(...subFiles);
       }
     }
+  } catch {
   }
-  return sections.join("\n");
+  return files;
 }
+
+// src/cli/commands/init.ts
+var execAsync3 = promisify(exec);
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 function detectArchitectureType(info) {
   if (info.dependencies.includes("next") || info.dependencies.includes("nuxt")) {
     return "Full-stack framework (SSR/SSG)";
@@ -15704,459 +16431,424 @@ function detectArchitectureType(info) {
   }
   return "Node.js application";
 }
-function generateFileStructure(info) {
-  if (!info.fileStructure || info.fileStructure.directories.length === 0) {
-    return "";
-  }
-  const sections = [];
-  if (info.fileStructure.entryPoint) {
-    sections.push(`**Entry Point:** \`${info.fileStructure.entryPoint}\``);
-  }
-  sections.push("\n**Directories:**");
-  for (const dir of info.fileStructure.directories) {
-    if (dir.purpose) {
-      sections.push(`- \`${dir.path}/\` - ${dir.purpose} (${dir.fileCount} files)`);
-    } else {
-      sections.push(`- \`${dir.path}/\` - ${dir.fileCount} files`);
-    }
-  }
-  sections.push(`
-**Total Files:** ${info.fileStructure.totalFiles}`);
-  return sections.join("\n");
-}
-function generateGettingStarted(info) {
-  if (!info.gettingStarted) {
-    return "";
-  }
-  const sections = ["## Getting Started", ""];
-  if (info.gettingStarted.prerequisites.length > 0) {
-    sections.push("### Prerequisites");
-    for (const prereq of info.gettingStarted.prerequisites) {
-      sections.push(`- ${prereq}`);
-    }
-    sections.push("");
-  }
-  if (info.gettingStarted.setupSteps.length > 0) {
-    sections.push("### First Time Setup");
-    for (const step of info.gettingStarted.setupSteps) {
-      sections.push(step);
+function generateAxIndex(info) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const modules = [];
+  if (info.fileStructure?.directories) {
+    for (const dir of info.fileStructure.directories) {
+      modules.push({
+        path: dir.path,
+        purpose: dir.purpose || `Contains ${dir.fileCount} files`,
+        patterns: [],
+        exports: []
+      });
     }
-    sections.push("");
   }
-  if (info.gettingStarted.envVars.length > 0) {
-    sections.push("### Environment Variables");
-    sections.push("");
-    const required = info.gettingStarted.envVars.filter((v) => v.required);
-    const optional = info.gettingStarted.envVars.filter((v) => !v.required);
-    if (required.length > 0) {
-      sections.push("**Required:**");
-      for (const envVar of required) {
-        sections.push(`- \`${envVar.name}\`${envVar.description ? ` - ${envVar.description}` : ""}`);
-        if (envVar.example) {
-          sections.push(`  - Example: \`${envVar.example}\``);
-        }
-      }
-      sections.push("");
-    }
-    if (optional.length > 0) {
-      sections.push("**Optional:**");
-      for (const envVar of optional) {
-        sections.push(`- \`${envVar.name}\`${envVar.description ? ` - ${envVar.description}` : ""}`);
-        if (envVar.example) {
-          sections.push(`  - Example: \`${envVar.example}\``);
-        }
+  const abstractions = [];
+  if (info.keyComponents) {
+    for (const comp of info.keyComponents) {
+      abstractions.push({
+        name: comp.path.split("/").pop() || comp.path,
+        type: "pattern",
+        location: comp.path,
+        description: comp.purpose
+      });
+    }
+  }
+  const commands = {};
+  if (info.categorizedScripts) {
+    const categoryMap = {
+      development: "development",
+      testing: "testing",
+      building: "building",
+      quality: "quality",
+      deployment: "deployment",
+      other: "other"
+    };
+    for (const [category, scripts] of Object.entries(info.categorizedScripts)) {
+      if (!scripts) continue;
+      for (const script of scripts) {
+        commands[script.name] = {
+          script: `${info.packageManager} run ${script.name}`,
+          description: script.description,
+          category: categoryMap[category] || "other"
+        };
       }
-      sections.push("");
     }
   }
-  return sections.join("\n");
+  const prodDeps = info.dependencies.filter((d) => !d.startsWith("@types/"));
+  const devDeps = info.dependencies.filter((d) => d.startsWith("@types/"));
+  return {
+    projectName: info.name,
+    version: info.version || "0.0.0",
+    projectType: detectArchitectureType(info),
+    language: info.language,
+    framework: info.framework,
+    buildTool: info.buildTool,
+    testFramework: info.testFramework,
+    packageManager: info.packageManager,
+    hasTypeScript: info.hasTypeScript,
+    isMonorepo: info.isMonorepo || false,
+    entryPoint: info.fileStructure?.entryPoint,
+    sourceDirectory: info.fileStructure?.directories.find((d) => d.path === "src")?.path,
+    testDirectory: info.fileStructure?.directories.find(
+      (d) => d.path === "tests" || d.path === "test" || d.path === "__tests__"
+    )?.path,
+    modules,
+    abstractions,
+    commands,
+    dependencies: {
+      production: prodDeps.slice(0, 20),
+      // Limit to top 20
+      development: devDeps.slice(0, 10),
+      // Limit to top 10
+      total: info.dependencies.length
+    },
+    repository: info.repository,
+    createdAt: now,
+    updatedAt: now,
+    analysisTier: 3
+    // Default to comprehensive analysis
+  };
 }
-function generateTroubleshooting(info) {
-  const sections = ["## Troubleshooting", ""];
-  sections.push("### Common Issues");
+function generateCustomMD(info) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const sections = [];
+  sections.push(`# Custom Instructions for ${info.name}`);
   sections.push("");
-  sections.push("**Problem**: `npm install` fails with EACCES");
-  sections.push("**Solution**: Fix npm permissions: `sudo chown -R $USER ~/.npm`");
+  sections.push(`> Generated: ${today}`);
+  sections.push(`> Project: ${info.name}${info.version ? ` v${info.version}` : ""}`);
   sections.push("");
-  if (info.dependencies.includes("prisma") || info.dependencies.includes("typeorm") || info.dependencies.includes("pg") || info.dependencies.includes("mongodb")) {
-    sections.push("**Problem**: Database connection refused");
-    sections.push("**Solution**:");
-    sections.push("1. Check Docker is running: `docker ps`");
-    sections.push("2. Start services: `docker-compose up -d`");
-    if (info.scripts["db:ping"]) {
-      sections.push(`3. Verify connection: \`${info.packageManager} run db:ping\``);
-    }
-    sections.push("");
-  }
-  sections.push("**Problem**: Port already in use");
-  sections.push("**Solution**: Kill process: `lsof -ti:3000 | xargs kill`");
+  sections.push("> **Note:** This file is protected from auto-rebuild. Edit freely to customize AI behavior.");
   sections.push("");
-  if (info.hasTypeScript) {
-    sections.push("**Problem**: TypeScript errors after `git pull`");
-    sections.push("**Solution**: Clean install: `rm -rf node_modules && npm install`");
-    sections.push("");
-  }
-  if (info.framework === "React" || info.framework === "Next.js" || info.framework === "Vue") {
-    sections.push("**Problem**: Hot reload not working");
-    sections.push("**Solution**: Check file watcher limits: `echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf`");
-    sections.push("");
-  }
-  sections.push("### Debug Mode");
-  sections.push("Run with verbose logging:");
-  sections.push("```bash");
-  sections.push("DEBUG=* npm run dev");
-  if (info.scripts.test) {
-    sections.push("LOG_LEVEL=debug npm test");
+  sections.push("## Project Overview");
+  sections.push("");
+  if (info.detailedDescription) {
+    const firstParagraph = info.detailedDescription.split("\n\n")[0];
+    sections.push(firstParagraph ?? "");
+  } else if (info.description) {
+    sections.push(info.description);
+  } else {
+    sections.push(`${info.framework || info.language} project${info.hasTypeScript ? " with TypeScript" : ""}`);
   }
-  sections.push("```");
-  return sections.join("\n");
-}
-function generateDevWorkflow(info) {
-  const sections = ["## Development Workflow", ""];
-  sections.push("### Daily Workflow");
-  sections.push("1. Pull latest: `git pull origin main`");
-  sections.push("2. Create feature branch: `git checkout -b feature/my-feature`");
-  sections.push("3. Make changes");
-  if (info.scripts.test) {
-    sections.push(`4. Run tests: \`${info.packageManager} test\``);
-  }
-  sections.push('5. Commit: `git commit -m "feat: add my feature"`');
-  sections.push("6. Push: `git push origin feature/my-feature`");
-  sections.push("7. Open PR on GitHub");
-  sections.push("8. Wait for CI + reviews");
-  sections.push("9. Merge to main (squash merge)");
   sections.push("");
-  sections.push("### Code Review Process");
-  sections.push("- Minimum 1 approval required");
-  sections.push("- CI must pass (tests + lint)");
-  sections.push("- No merge conflicts");
+  sections.push("## Critical Rules");
   sections.push("");
-  sections.push("### Hot Reload");
-  if (info.framework === "React" || info.framework === "Vue") {
-    if (info.buildTool === "Vite") {
-      sections.push("- Frontend: Vite HMR (instant)");
-    } else {
-      sections.push("- Frontend: Hot module replacement enabled");
-    }
-  }
-  if (info.dependencies.includes("express") || info.dependencies.includes("fastify")) {
-    sections.push("- Backend: Nodemon (restart on save)");
-  }
-  if (info.framework === "Next.js") {
-    sections.push("- Next.js Fast Refresh (instant updates)");
-  }
+  sections.push("### DO");
   sections.push("");
-  if (info.testFramework) {
-    sections.push("### Testing Strategy");
-    if (info.scripts["test:unit"]) {
-      sections.push(`- Unit tests: \`${info.packageManager} run test:unit\` (fast, no DB)`);
-    }
-    if (info.scripts["test:integration"]) {
-      sections.push(`- Integration tests: \`${info.packageManager} run test:integration\` (with test DB)`);
-    }
-    if (info.scripts["test:e2e"]) {
-      sections.push(`- E2E tests: \`${info.packageManager} run test:e2e\` (full stack)`);
-    }
-    if (info.scripts.test) {
-      sections.push(`- Run all: \`${info.packageManager} test\``);
-    }
+  sections.push(`- Run \`${info.packageManager} test\` before pushing`);
+  if (info.linter) {
+    sections.push(`- Run \`${info.packageManager} run lint\` to check code style`);
   }
-  return sections.join("\n");
-}
-function generateDatabaseSchema(info) {
-  if (!info.databaseSchema || info.databaseSchema.models.length === 0) {
-    return "";
+  if (info.hasTypeScript) {
+    sections.push("- Use TypeScript strict mode conventions");
   }
-  const sections = ["## Database Schema", ""];
-  const schema = info.databaseSchema;
-  if (schema.orm) {
-    sections.push(`**ORM:** ${schema.orm}`);
-    sections.push("");
+  sections.push("- Follow conventional commits (feat/fix/chore/docs)");
+  sections.push("- Add tests for new features");
+  sections.push("");
+  sections.push("### DON'T");
+  sections.push("");
+  sections.push("- Commit directly to main/production branches");
+  sections.push("- Skip tests before pushing");
+  sections.push("- Expose API keys or credentials in code");
+  if (info.dependencies.includes("prisma") || info.dependencies.includes("typeorm")) {
+    sections.push("- Modify database migrations without approval");
   }
-  if (schema.models.length > 0) {
-    sections.push("### Models");
+  sections.push("");
+  if (info.categorizedScripts) {
+    sections.push("## Key Commands");
     sections.push("");
-    for (const model of schema.models.slice(0, 10)) {
-      sections.push(`**${model.name}**`);
-      if (model.fields.length > 0) {
-        for (const field of model.fields) {
-          let fieldDesc = `- \`${field.name}\`: ${field.type}`;
-          const attrs = [];
-          if (field.isPrimaryKey) attrs.push("PK");
-          if (field.isUnique) attrs.push("unique");
-          if (field.isOptional) attrs.push("optional");
-          if (field.defaultValue) attrs.push(`default: ${field.defaultValue}`);
-          if (attrs.length > 0) {
-            fieldDesc += ` (${attrs.join(", ")})`;
-          }
-          sections.push(fieldDesc);
-        }
-      }
-      if (model.relations.length > 0) {
-        for (const rel of model.relations) {
-          sections.push(`- \`${rel.name}\`: ${rel.type} \u2192 ${rel.relatedModel}`);
-        }
-      }
-      sections.push("");
-    }
-    if (schema.models.length > 10) {
-      sections.push(`*... and ${schema.models.length - 10} more models*`);
-      sections.push("");
+    sections.push("```bash");
+    const allScripts = [
+      ...info.categorizedScripts.development || [],
+      ...info.categorizedScripts.testing || [],
+      ...info.categorizedScripts.building || [],
+      ...info.categorizedScripts.quality || []
+    ].slice(0, 5);
+    for (const script of allScripts) {
+      sections.push(`${info.packageManager} run ${script.name}  # ${script.description}`);
     }
+    sections.push("```");
+    sections.push("");
   }
-  if (schema.migrations.directory && schema.migrations.files.length > 0) {
-    sections.push("### Migrations");
-    sections.push(`- Location: \`${schema.migrations.directory}\``);
-    sections.push(`- Total: ${schema.migrations.files.length} migrations`);
-    if (info.scripts["db:migrate"] || info.scripts["migrate"] || info.scripts["prisma:migrate"]) {
-      const migrateCmd = info.scripts["db:migrate"] ? "db:migrate" : info.scripts["migrate"] ? "migrate" : "prisma:migrate";
-      sections.push(`- Run: \`${info.packageManager} run ${migrateCmd}\``);
-    }
+  sections.push("## Troubleshooting");
+  sections.push("");
+  sections.push(`**Build fails**: Run \`rm -rf node_modules && ${info.packageManager} install\``);
+  sections.push("");
+  sections.push("**Tests fail**: Check for missing environment variables");
+  sections.push("");
+  if (info.hasTypeScript) {
+    sections.push(`**Type errors**: Run \`${info.packageManager} run typecheck\` for details`);
     sections.push("");
   }
+  sections.push("---");
+  sections.push("");
+  sections.push("*Generated by `ax init` \u2022 Edit this file to customize AI behavior*");
   return sections.join("\n");
 }
-function generateAPIDocumentation(info) {
-  if (!info.apiDocumentation) {
-    return "";
+async function atomicWrite(filePath, content) {
+  const tempPath = `${filePath}.tmp`;
+  await writeFile(tempPath, content, "utf-8");
+  await rename(tempPath, filePath);
+}
+function formatAge(ms) {
+  const hours = Math.floor(ms / (1e3 * 60 * 60));
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  return `${days}d`;
+}
+function getVersionCachePath() {
+  return join(homedir(), ".automatosx", "version-cache.json");
+}
+async function readVersionCache() {
+  try {
+    const cachePath = getVersionCachePath();
+    const content = await readFile(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
   }
-  const sections = ["## API Documentation", ""];
-  const api = info.apiDocumentation;
-  if (api.framework) {
-    sections.push(`**Framework:** ${api.framework}`);
-    sections.push("");
+}
+async function writeVersionCache(cache) {
+  const cachePath = getVersionCachePath();
+  const cacheDir = join(homedir(), ".automatosx");
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(cachePath, JSON.stringify(cache, null, 2), "utf-8");
+}
+function isNewer(a, b) {
+  const stripPrerelease = (v) => v.split("-")[0] || v;
+  const parseVersion = (v) => stripPrerelease(v).split(".").map(Number);
+  const [aMajor = 0, aMinor = 0, aPatch = 0] = parseVersion(a);
+  const [bMajor = 0, bMinor = 0, bPatch = 0] = parseVersion(b);
+  if (aMajor !== bMajor) return aMajor > bMajor;
+  if (aMinor !== bMinor) return aMinor > bMinor;
+  return aPatch > bPatch;
+}
+async function getCurrentVersion() {
+  try {
+    const { stdout } = await execAsync3("npm list -g @defai.digital/automatosx --depth=0 --json 2>/dev/null");
+    const result = JSON.parse(stdout);
+    const version = result.dependencies?.["@defai.digital/automatosx"]?.version;
+    if (version) return version;
+  } catch {
   }
-  if (api.hasOpenAPI && api.openAPIPath) {
-    sections.push(`**OpenAPI Spec:** \`${api.openAPIPath}\``);
-    sections.push("");
+  try {
+    const { dirname: dirname16 } = await import('path');
+    const { fileURLToPath: fileURLToPath5 } = await import('url');
+    const __filename3 = fileURLToPath5(import.meta.url);
+    const __dirname4 = dirname16(__filename3);
+    const pkgPath = join(__dirname4, "../../../package.json");
+    const content = await readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version || null;
+  } catch {
+    return null;
   }
-  if (api.endpoints.length > 0) {
-    sections.push("### Endpoints");
-    sections.push("");
-    const grouped = /* @__PURE__ */ new Map();
-    for (const endpoint of api.endpoints) {
-      const group = endpoint.group || "other";
-      if (!grouped.has(group)) {
-        grouped.set(group, []);
-      }
-      grouped.get(group)?.push(endpoint);
+}
+async function getLatestVersion() {
+  try {
+    const { stdout } = await execAsync3("npm view @defai.digital/automatosx version 2>/dev/null");
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function updateAutomatosx(version) {
+  try {
+    console.log(chalk5.cyan(`\u{1F4E5} Updating AutomatosX to v${version}...`));
+    await execAsync3(`npm install -g @defai.digital/automatosx@${version}`, {
+      maxBuffer: 10 * 1024 * 1024
+    });
+    console.log(chalk5.green(`\u2713 AutomatosX updated to v${version}`));
+    return true;
+  } catch (error) {
+    logger.warn("Failed to update AutomatosX", { error: error.message });
+    console.log(chalk5.yellow(`\u26A0 Could not update AutomatosX: ${error.message}`));
+    return false;
+  }
+}
+async function checkAutomatosxUpdate() {
+  try {
+    const currentVersion = await getCurrentVersion();
+    if (!currentVersion) {
+      logger.debug("Could not determine current AutomatosX version");
+      return false;
     }
-    for (const [group, endpoints] of grouped) {
-      if (group !== "other") {
-        sections.push(`**${group.charAt(0).toUpperCase() + group.slice(1)}**`);
-      }
-      for (const endpoint of endpoints.slice(0, 20)) {
-        let line = `- \`${endpoint.method} ${endpoint.path}\``;
-        if (endpoint.description) {
-          line += ` - ${endpoint.description}`;
+    const cache = await readVersionCache();
+    const now = Date.now();
+    let latestVersion = null;
+    let cacheIsValid = false;
+    if (cache) {
+      const lastCheckTime = new Date(cache.lastCheck).getTime();
+      const age = now - lastCheckTime;
+      if (age < STALE_THRESHOLD_MS && cache.currentVersion === currentVersion) {
+        cacheIsValid = true;
+        latestVersion = cache.latestVersion;
+        logger.debug("AutomatosX version check using cache", {
+          currentVersion,
+          latestVersion,
+          cacheAge: formatAge(age),
+          updateAttempted: cache.updateAttempted
+        });
+        if (!isNewer(latestVersion, currentVersion)) {
+          return false;
         }
-        if (endpoint.auth) {
-          line += " \u{1F512}";
+        if (cache.updateAttempted) {
+          console.log(chalk5.gray(`AutomatosX update available: ${currentVersion} \u2192 ${latestVersion} (run 'npm i -g @defai.digital/automatosx' to update)`));
+          return false;
         }
-        sections.push(line);
       }
-      sections.push("");
-    }
-    if (api.endpoints.length > 20) {
-      sections.push(`*... and ${api.endpoints.length - 20} more endpoints*`);
-      sections.push("");
     }
-  }
-  return sections.join("\n");
-}
-function generateAgentRules(info) {
-  const rules = ["## Agent Delegation Rules", ""];
-  rules.push("### Development");
-  if (info.framework === "React" || info.framework === "Vue" || info.framework === "Next.js") {
-    rules.push(`- **Frontend/UI (${info.framework})** \u2192 @frontend (Frank)`);
-  }
-  if (info.dependencies.includes("express") || info.dependencies.includes("fastify") || info.dependencies.includes("koa")) {
-    rules.push("- **Backend/API** \u2192 @backend (Bob) or @fullstack (Felix)");
-  }
-  if (info.hasTypeScript) {
-    rules.push("- **TypeScript issues** \u2192 @fullstack (Felix)");
-  }
-  if (info.dependencies.some((d) => d.includes("react-native") || d.includes("expo"))) {
-    rules.push("- **Mobile** \u2192 @mobile (Maya)");
-  }
-  rules.push("- **Infrastructure/DevOps** \u2192 @devops (Oliver)");
-  rules.push("");
-  rules.push("### Quality & Architecture");
-  rules.push("- **Tests/QA** \u2192 @quality (Queenie)");
-  rules.push("- **Security audits** \u2192 @security (Steve) - mandatory for: auth, payments, PII");
-  rules.push("- **Architecture/ADR** \u2192 @architecture (Avery)");
-  rules.push("");
-  rules.push("### Documentation & Product");
-  rules.push("- **Technical writing** \u2192 @writer (Wendy)");
-  rules.push("- **Product management** \u2192 @product (Paris)");
-  return rules.join("\n");
-}
-function generateCodingConventions(info) {
-  const conventions = ["## Coding Conventions", ""];
-  conventions.push("### Testing");
-  if (info.testFramework) {
-    conventions.push(`- **Framework:** ${info.testFramework}`);
-    conventions.push("- **Coverage:** 80% minimum");
-    conventions.push(`- **Run:** \`${info.packageManager} test\``);
-  } else {
-    conventions.push("- Run tests before pushing");
-  }
-  conventions.push("");
-  conventions.push("### Code Style");
-  if (info.linter) {
-    conventions.push(`- **Linter:** ${info.linter}`);
-  }
-  if (info.formatter) {
-    conventions.push(`- **Formatter:** ${info.formatter}`);
-  }
-  if (info.hasTypeScript) {
-    conventions.push("- **TypeScript:** Strict mode enabled");
-  }
-  conventions.push("- **Indent:** 2 spaces");
-  conventions.push("- **Max line:** 100 chars");
-  conventions.push("");
-  conventions.push("### Git Workflow");
-  conventions.push("- **Branch naming:** `feature/description` or `fix/description`");
-  conventions.push("- **Commits:** Conventional commits format (feat/fix/chore/docs)");
-  conventions.push("- **PRs:** Review required before merge");
-  return conventions.join("\n");
-}
-function generateCriticalGuardrails(info) {
-  const guardrails = ["## Critical Guardrails", ""];
-  guardrails.push("\u26A0\uFE0F **NEVER:**");
-  guardrails.push("- Commit to main/production branches directly");
-  guardrails.push("- Skip tests before pushing");
-  guardrails.push("- Expose API keys or credentials in code");
-  if (info.dependencies.includes("prisma") || info.dependencies.includes("typeorm")) {
-    guardrails.push("- Modify database migrations without approval");
-  }
-  guardrails.push("");
-  guardrails.push("\u2705 **ALWAYS:**");
-  guardrails.push(`- Run \`${info.packageManager} test\` before pushing`);
-  if (info.linter) {
-    guardrails.push(`- Run \`${info.packageManager} run lint\` to check code style`);
-  }
-  if (info.formatter) {
-    guardrails.push(`- Format code with ${info.formatter} before committing`);
-  }
-  guardrails.push("- Document breaking changes");
-  guardrails.push("- Add tests for new features");
-  return guardrails.join("\n");
-}
-function generateCommands(info) {
-  const sections = ["## Canonical Commands", ""];
-  if (!info.categorizedScripts) {
-    return sections.join("\n") + "```bash\n# No scripts detected\n```";
-  }
-  const categories = [
-    { key: "development", title: "Development" },
-    { key: "building", title: "Building" },
-    { key: "testing", title: "Testing" },
-    { key: "quality", title: "Quality Checks" },
-    { key: "deployment", title: "Deployment" }
-  ];
-  sections.push("```bash");
-  for (const { key, title } of categories) {
-    const scripts = info.categorizedScripts[key];
-    if (scripts && scripts.length > 0) {
-      sections.push(`# ${title}`);
-      for (const script of scripts) {
-        const cmd = `${info.packageManager} run ${script.name}`;
-        const padding = " ".repeat(Math.max(35 - cmd.length, 1));
-        sections.push(`${cmd}${padding}# ${script.description}`);
+    if (!cacheIsValid) {
+      console.log(chalk5.gray("Checking for AutomatosX updates..."));
+      latestVersion = await getLatestVersion();
+      if (!latestVersion) {
+        logger.debug("Could not fetch latest AutomatosX version");
+        return false;
+      }
+      await writeVersionCache({
+        lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+        currentVersion,
+        latestVersion,
+        updateAttempted: false
+      });
+      logger.info("AutomatosX version check completed", {
+        currentVersion,
+        latestVersion,
+        updateAvailable: isNewer(latestVersion, currentVersion)
+      });
+      if (!isNewer(latestVersion, currentVersion)) {
+        console.log(chalk5.gray(`AutomatosX is up to date (v${currentVersion})`));
+        return false;
       }
-      sections.push("");
-    }
-  }
-  const other = info.categorizedScripts.other;
-  if (other && other.length > 0) {
-    sections.push("# Other");
-    for (const script of other) {
-      const cmd = `${info.packageManager} run ${script.name}`;
-      const padding = " ".repeat(Math.max(35 - cmd.length, 1));
-      sections.push(`${cmd}${padding}# ${script.description}`);
     }
+    console.log(chalk5.yellow(`\u{1F4E6} AutomatosX update available: ${currentVersion} \u2192 ${latestVersion}`));
+    const updated = await updateAutomatosx(latestVersion);
+    await writeVersionCache({
+      lastCheck: cache?.lastCheck || (/* @__PURE__ */ new Date()).toISOString(),
+      currentVersion: updated ? latestVersion : currentVersion,
+      latestVersion,
+      updateAttempted: true
+    });
+    return updated;
+  } catch (error) {
+    logger.debug("AutomatosX version check failed", { error: error.message });
+    return false;
   }
-  sections.push("```");
-  return sections.join("\n");
-}
-function generateUsefulLinks(info) {
-  const links = ["## Useful Links", ""];
-  if (info.repository) {
-    links.push(`- [Repository](${info.repository})`);
-  }
-  if (info.fileStructure?.docsDirectory) {
-    links.push(`- [Documentation](${info.fileStructure.docsDirectory}/)`);
-  }
-  return links.join("\n");
-}
-async function atomicWrite(filePath, content) {
-  const tempPath = `${filePath}.tmp`;
-  await writeFile(tempPath, content, "utf-8");
-  await rename(tempPath, filePath);
 }
 var initCommand = {
   command: "init",
-  describe: "Initialize AX.md project context file",
+  describe: "Initialize project index (ax.index.json) and custom instructions",
   builder: (yargs2) => {
     return yargs2.option("force", {
       alias: "f",
-      describe: "Regenerate AX.md from scratch",
+      describe: "Regenerate all files including CUSTOM.md",
+      type: "boolean",
+      default: false
+    }).option("skip-update", {
+      describe: "Skip AutomatosX version check",
       type: "boolean",
       default: false
     }).example([
-      ["$0 init", "Create or update AX.md with current project info"],
-      ["$0 init --force", "Regenerate AX.md from scratch"]
+      ["$0 init", "Create or update ax.index.json (auto-rebuilds if >24h old)"],
+      ["$0 init --force", "Regenerate all files including CUSTOM.md"],
+      ["$0 init --skip-update", "Skip AutomatosX version check"]
     ]);
   },
   handler: async (argv) => {
     const projectDir = process.cwd();
-    const axMdPath = join(projectDir, "AX.md");
+    if (!argv.skipUpdate) {
+      const wasUpdated = await checkAutomatosxUpdate();
+      if (wasUpdated) {
+        console.log(chalk5.cyan("\n\u{1F504} Re-running ax init --force with updated AutomatosX...\n"));
+        try {
+          const { stdout } = await execAsync3("automatosx init --force --skip-update");
+          console.log(stdout);
+          return;
+        } catch (error) {
+          try {
+            const { stdout } = await execAsync3("ax init --force --skip-update");
+            console.log(stdout);
+            return;
+          } catch {
+            logger.warn("Could not re-run init with updated version, continuing with current process");
+            argv.force = true;
+          }
+        }
+      }
+    }
+    const indexPath = join(projectDir, "ax.index.json");
+    const automatosxDir = join(projectDir, ".automatosx");
+    const customMdPath = join(automatosxDir, "CUSTOM.md");
     try {
+      const indexExists = await access$1(indexPath, constants.F_OK).then(() => true).catch(() => false);
+      let indexAge = null;
+      if (indexExists) {
+        try {
+          const stats = await stat(indexPath);
+          indexAge = Date.now() - stats.mtime.getTime();
+        } catch {
+        }
+      }
+      const isStale = indexAge !== null && indexAge > STALE_THRESHOLD_MS;
+      const shouldRebuildIndex = !indexExists || isStale || argv.force;
+      if (!shouldRebuildIndex && !argv.force) {
+        console.log(chalk5.green(`\u2713 ax.index.json is up to date (${indexAge ? formatAge(indexAge) : "0h"} old)`));
+        console.log(chalk5.gray("  Use --force to regenerate"));
+        return;
+      }
       const projectInfo = await detectProjectInfo(projectDir);
-      const axMdExists = await access$1(axMdPath, constants.F_OK).then(() => true).catch(() => false);
-      if (axMdExists && !argv.force) {
-        const existingContent = await readFile(axMdPath, "utf-8");
-        const parsed = parseAXMD(existingContent);
-        const changes = detectDetailedChanges(parsed, {
-          version: projectInfo.version,
-          dependencies: projectInfo.dependencies,
-          scripts: projectInfo.scripts,
-          framework: projectInfo.framework,
-          architecture: detectArchitectureType(projectInfo),
-          linter: projectInfo.linter,
-          formatter: projectInfo.formatter,
-          testFramework: projectInfo.testFramework
-        });
-        if (changes.length === 0) {
-          console.log(chalk5.green("\u2713 AX.md is up to date"));
-          logger.info("AX.md unchanged", { projectName: projectInfo.name });
-          return;
+      let indexContent;
+      if (indexExists && !argv.force) {
+        try {
+          const existingIndex = JSON.parse(await readFile(indexPath, "utf-8"));
+          indexContent = {
+            ...generateAxIndex(projectInfo),
+            createdAt: existingIndex.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+          };
+        } catch {
+          indexContent = generateAxIndex(projectInfo);
         }
-        const axMdContent = generateAXMD(projectInfo);
-        await atomicWrite(axMdPath, axMdContent);
-        const summary = formatChangeSummary(changes);
-        console.log(chalk5.green(`\u2713 Updated AX.md ${summary}`));
-        logger.info("AX.md updated", {
-          projectName: projectInfo.name,
-          changes: changes.length,
-          changeTypes: changes.map((c) => c.type)
-        });
       } else {
-        const axMdContent = generateAXMD(projectInfo);
-        await atomicWrite(axMdPath, axMdContent);
+        indexContent = generateAxIndex(projectInfo);
+      }
+      await atomicWrite(indexPath, JSON.stringify(indexContent, null, 2));
+      if (isStale) {
+        console.log(chalk5.green(`\u2713 Rebuilt ax.index.json (was ${formatAge(indexAge)} old)`));
+      } else if (indexExists) {
+        console.log(chalk5.green("\u2713 Updated ax.index.json"));
+      } else {
         const projectType = projectInfo.framework || projectInfo.language;
-        console.log(chalk5.green(`\u2713 Created AX.md (${projectType} project)`));
-        logger.info("AX.md created", {
-          projectName: projectInfo.name,
-          framework: projectInfo.framework,
-          language: projectInfo.language,
-          forced: argv.force
-        });
+        console.log(chalk5.green(`\u2713 Created ax.index.json (${projectType} project)`));
+      }
+      await mkdir(automatosxDir, { recursive: true });
+      const customMdExists = await access$1(customMdPath, constants.F_OK).then(() => true).catch(() => false);
+      if (!customMdExists || argv.force) {
+        const customMdContent = generateCustomMD(projectInfo);
+        await atomicWrite(customMdPath, customMdContent);
+        if (argv.force && customMdExists) {
+          console.log(chalk5.yellow("\u2713 Regenerated .automatosx/CUSTOM.md (--force)"));
+        } else {
+          console.log(chalk5.green("\u2713 Created .automatosx/CUSTOM.md"));
+        }
+      } else {
+        console.log(chalk5.gray("  .automatosx/CUSTOM.md preserved (use --force to regenerate)"));
       }
+      console.log("");
+      console.log(chalk5.cyan("Project initialized:"));
+      console.log(chalk5.gray("  \u2022 ax.index.json    - Shared project index (auto-rebuilds after 24h)"));
+      console.log(chalk5.gray("  \u2022 CUSTOM.md        - Custom AI instructions (edit to customize)"));
+      console.log("");
+      console.log(chalk5.gray("Agents will use ax.index.json to understand your project."));
+      logger.info("Project initialized", {
+        projectName: projectInfo.name,
+        indexRebuilt: shouldRebuildIndex,
+        wasStale: isStale,
+        force: argv.force
+      });
     } catch (error) {
-      console.log(chalk5.red("\u2717 Error with AX.md"));
-      logger.error("AX.md initialization failed", { error });
+      console.log(chalk5.red("\u2717 Error initializing project"));
+      logger.error("Project initialization failed", { error });
       if (process.env.DEBUG || process.env.AUTOMATOSX_DEBUG) {
         printError(error);
       }
@@ -16677,107 +17369,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 = [];
@@ -19968,7 +20560,7 @@ var MemoryManager = class _MemoryManager {
       if (this.db) {
         try {
           this.db.close();
-        } catch (closeError) {
+        } catch {
         }
         this.initialized = false;
         this.entryCount = 0;
@@ -20722,9 +21314,9 @@ var MemoryManager = class _MemoryManager {
       throw new MemoryError("Memory manager not initialized", "DATABASE_ERROR");
     }
     try {
-      const { mkdir: mkdir14 } = await import('fs/promises');
+      const { mkdir: mkdir15 } = await import('fs/promises');
       const destDir = dirname4(destPath);
-      await mkdir14(destDir, { recursive: true });
+      await mkdir15(destDir, { recursive: true });
       await this.db.backup(destPath);
       logger.info("Database backup created", { destPath: normalizePath(destPath) });
     } catch (error) {
@@ -20809,9 +21401,9 @@ var MemoryManager = class _MemoryManager {
       }
     }
     const {
-      includeEmbeddings = false,
+      includeEmbeddings: _includeEmbeddings = false,
       filters = {},
-      batchSize = 1e3,
+      batchSize: _batchSize = 1e3,
       pretty = false
     } = options || {};
     try {
@@ -21969,7 +22561,7 @@ var SessionManager = class _SessionManager {
       if (this.pendingSave) {
         try {
           await this.pendingSave;
-        } catch (err) {
+        } catch {
         }
       }
       this.pendingSave = this.doSave().finally(() => {
@@ -22037,7 +22629,7 @@ var SessionManager = class _SessionManager {
         }
         try {
           await unlink(tempPath);
-        } catch (unlinkError) {
+        } catch {
         }
         throw renameError;
       }
@@ -22045,7 +22637,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),
@@ -22584,6 +23176,7 @@ init_esm_shims();
 init_logger();
 var MAX_CONTEXT_SIZE = 100 * 1024;
 var DEFAULT_CACHE_TTL = 3e5;
+var STALE_THRESHOLD_MS2 = 24 * 60 * 60 * 1e3;
 var ProjectContextLoader = class {
   constructor(projectRoot, options) {
     this.projectRoot = projectRoot;
@@ -22607,76 +23200,79 @@ var ProjectContextLoader = class {
     });
     const context = {};
     try {
-      const mdPath = path4__default.join(this.projectRoot, "AX.md");
-      const resolvedPath = await realpath$1(mdPath).catch(() => null);
+      const indexPath = path4__default.join(this.projectRoot, "ax.index.json");
+      const resolvedPath = await realpath$1(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_MS2;
+            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$1(ymlPath).catch(() => null);
+      const customMdPath = path4__default.join(this.projectRoot, ".automatosx", "CUSTOM.md");
+      const resolvedPath = await realpath$1(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;
   }
@@ -22692,8 +23288,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 checkExists3 = async (filePath) => {
       try {
         await access$1(filePath, constants.F_OK);
@@ -22702,57 +23298,48 @@ var ProjectContextLoader = class {
         return false;
       }
     };
-    const [mdExists, ymlExists] = await Promise.all([
-      checkExists3(mdPath),
-      checkExists3(ymlPath)
+    const [indexExists, customMdExists] = await Promise.all([
+      checkExists3(indexPath),
+      checkExists3(customMdPath)
     ]);
-    return mdExists || ymlExists;
+    return indexExists || customMdExists;
   }
   /**
-   * Parse agent delegation rules from markdown
-   *
-   * Looks for patterns like:
-   * - Backend changes → @backend
-   * - API endpoints → @backend, @security
+   * Check if ax.index.json is stale (older than 24 hours)
    */
-  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
-        });
-      }
+  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_MS2;
+    } 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;
@@ -22762,106 +23349,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;
   }
@@ -23285,10 +23824,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
@@ -23301,15 +23840,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) {
@@ -26239,6 +26778,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();
@@ -26276,16 +26833,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;
       }
     }
   }
@@ -28643,7 +29193,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)));
@@ -28875,8 +29425,8 @@ var BugDetector = class {
   async loadRulesFromFile(filePath) {
     try {
       const content = await readFile(filePath, "utf-8");
-      const yaml5 = await import('js-yaml');
-      const parsed = yaml5.load(content);
+      const yaml4 = await import('js-yaml');
+      const parsed = yaml4.load(content);
       if (parsed.rules && Array.isArray(parsed.rules)) {
         for (const rule of parsed.rules) {
           this.addRule(rule);
@@ -29308,7 +29858,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()"
@@ -29335,7 +29884,6 @@ var BugFixer = class {
       const match = currentLine.match(classPattern);
       if (match && match[1]) {
         classStartLine = i;
-        match[1];
         break;
       }
     }
@@ -29387,7 +29935,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"
@@ -30309,7 +30857,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));
@@ -30336,7 +30884,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];
@@ -30385,7 +30933,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];
@@ -30548,7 +31096,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));
@@ -30924,7 +31472,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));
@@ -31339,7 +31887,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));
@@ -31695,7 +32243,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));
@@ -31978,7 +32526,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));
@@ -32291,7 +32839,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));
@@ -32585,7 +33133,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;
@@ -33191,6 +33739,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;
@@ -33200,10 +33751,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 {
         }
       }
     }
@@ -36659,6 +37217,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();
@@ -36783,7 +37342,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) {
@@ -39333,6 +39892,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,
@@ -40894,6 +41464,7 @@ function createResourceEnforcer(config) {
 
 // src/mcp/unified-manager.ts
 init_validation_limits();
+init_safe_timers();
 var UnifiedMCPManager = class {
   constructor(config) {
     this.config = config;
@@ -41013,7 +41584,7 @@ var UnifiedMCPManager = class {
       };
       this.setupProcessHandlers(config.name, childProcess, serverProcess);
       this.servers.set(config.name, serverProcess);
-      await new Promise((resolve13) => setTimeout(resolve13, 100));
+      await sleep(100);
       if (childProcess.killed || childProcess.exitCode !== null) {
         throw new Error(
           `Server process exited immediately with code ${childProcess.exitCode}`
@@ -41124,7 +41695,7 @@ var UnifiedMCPManager = class {
   async restartServer(serverName) {
     logger.info("UnifiedMCPManager: Restarting server", { name: serverName });
     await this.stopServer(serverName);
-    await new Promise((resolve13) => setTimeout(resolve13, 1e3));
+    await sleep(1e3);
     const serverConfig = this.config.servers.find((s) => s.name === serverName);
     if (!serverConfig) {
       throw new Error(`Server configuration not found: ${serverName}`);
@@ -42895,7 +43466,7 @@ var CheckpointManager = class {
     if (checkpoint.schemaVersion === CURRENT_SCHEMA_VERSION) {
       return checkpoint;
     }
-    let migrated = { ...checkpoint };
+    const migrated = { ...checkpoint };
     if (checkpointVersion.major === 1 && checkpointVersion.minor === 0) ;
     migrated.schemaVersion = CURRENT_SCHEMA_VERSION;
     migrated.checksum = this.calculateChecksum(migrated);
@@ -43001,7 +43572,7 @@ var CheckpointManager = class {
    * @returns Hex-encoded checksum
    */
   calculateChecksum(checkpoint) {
-    const { checksum, updatedAt, ...dataForChecksum } = checkpoint;
+    const { checksum: _checksum, updatedAt: _updatedAt, ...dataForChecksum } = checkpoint;
     const hash = createHash("sha256");
     hash.update(JSON.stringify(dataForChecksum));
     return hash.digest("hex");
@@ -43650,6 +44221,7 @@ var ProgressRenderer = class {
 
 // src/core/stage-execution-controller.ts
 init_logger();
+init_safe_timers();
 var StageExecutionController = class {
   // Dependencies
   agentExecutor;
@@ -44316,9 +44888,9 @@ ${action.modifications}`;
               )
             );
             console.log(chalk5.gray(`   Waiting ${delay}ms before retry...`));
-            await new Promise((resolve13) => setTimeout(resolve13, delay));
+            await sleep(delay);
           } else {
-            await new Promise((resolve13) => setTimeout(resolve13, delay));
+            await sleep(delay);
           }
         }
         const executionOptions = {
@@ -45744,7 +46316,7 @@ var IterateModeController = class {
       }
     });
     const responseContents = [];
-    let totalTokensUsed = { prompt: 0, completion: 0, total: 0 };
+    const totalTokensUsed = { prompt: 0, completion: 0, total: 0 };
     let lastResponse;
     try {
       if (this.checkTimeBudget()) {
@@ -48023,7 +48595,7 @@ var runCommand = {
       }
       try {
         const workflowContent = readFileSync(workflowPath, "utf-8");
-        workflowConfig = yaml4__default.load(workflowContent);
+        workflowConfig = yaml3__default.load(workflowContent);
         if (workflowConfig?.iterate?.enabled !== false) {
           argv.iterate = true;
         }
@@ -49244,7 +49816,7 @@ var statusCommand4 = {
       const agentCount = await countFiles(agentsDir, [".yaml", ".yml"]);
       const abilityCount = await countFiles(abilitiesDir, [".md"]);
       const projectInfo = await getProjectInfo(detectedProjectDir);
-      let limitData = {
+      const limitData = {
         limits: [],
         manualOverride: null,
         envOverrides: []
@@ -49635,7 +50207,7 @@ function formatUptime2(seconds) {
 // src/cli/commands/update.ts
 init_esm_shims();
 init_logger();
-var execAsync5 = promisify(exec);
+var execAsync6 = promisify(exec);
 var updateCommand = {
   command: "update",
   describe: "Check for updates and upgrade AutomatosX to the latest version",
@@ -49654,17 +50226,17 @@ var updateCommand = {
   handler: async (argv) => {
     console.log(chalk5.blue.bold("\n\u{1F504} AutomatosX Update Checker\n"));
     try {
-      const currentVersion = await getCurrentVersion();
+      const currentVersion = await getCurrentVersion2();
       console.log(chalk5.gray(`Current version: ${currentVersion}`));
       console.log(chalk5.cyan("Checking for updates..."));
-      const latestVersion = await getLatestVersion();
+      const latestVersion = await getLatestVersion2();
       console.log(chalk5.gray(`Latest version:  ${latestVersion}
 `));
       if (currentVersion === latestVersion) {
         console.log(chalk5.green("\u2705 You are already running the latest version!\n"));
         return;
       }
-      if (isNewer(latestVersion, currentVersion)) {
+      if (isNewer2(latestVersion, currentVersion)) {
         console.log(chalk5.yellow(`\u{1F4E6} New version available: ${currentVersion} \u2192 ${latestVersion}
 `));
         await showChangelog(currentVersion, latestVersion);
@@ -49709,28 +50281,28 @@ var updateCommand = {
     }
   }
 };
-async function getCurrentVersion() {
+async function getCurrentVersion2() {
   try {
-    const { stdout } = await execAsync5("npm list -g @defai.digital/automatosx --depth=0 --json");
+    const { stdout } = await execAsync6("npm list -g @defai.digital/automatosx --depth=0 --json");
     const result = JSON.parse(stdout);
     return result.dependencies["@defai.digital/automatosx"]?.version || "unknown";
   } catch (error) {
     const { readFile: readFile24 } = await import('fs/promises');
-    const { dirname: dirname18, join: join57 } = await import('path');
+    const { dirname: dirname16, join: join57 } = await import('path');
     const { fileURLToPath: fileURLToPath5 } = await import('url');
     const __filename3 = fileURLToPath5(import.meta.url);
-    const __dirname4 = dirname18(__filename3);
+    const __dirname4 = dirname16(__filename3);
     const pkgPath = join57(__dirname4, "../../../package.json");
     const content = await readFile24(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version;
   }
 }
-async function getLatestVersion() {
-  const { stdout } = await execAsync5("npm view @defai.digital/automatosx version");
+async function getLatestVersion2() {
+  const { stdout } = await execAsync6("npm view @defai.digital/automatosx version");
   return stdout.trim();
 }
-function isNewer(a, b) {
+function isNewer2(a, b) {
   const stripPrerelease = (v) => v.split("-")[0] || v;
   const parseVersion = (v) => stripPrerelease(v).split(".").map(Number);
   const [aMajor = 0, aMinor = 0, aPatch = 0] = parseVersion(a);
@@ -49742,7 +50314,7 @@ function isNewer(a, b) {
 async function showChangelog(from, to) {
   try {
     console.log(chalk5.cyan("What's new:\n"));
-    const { stdout } = await execAsync5(
+    const { stdout } = await execAsync6(
       `curl -s https://api.github.com/repos/defai-digital/automatosx/releases/tags/v${to}`
     );
     const release = JSON.parse(stdout);
@@ -49764,7 +50336,7 @@ async function showChangelog(from, to) {
 }
 async function installUpdate(version) {
   try {
-    const { stdout, stderr } = await execAsync5(
+    const { stdout, stderr } = await execAsync6(
       `npm install -g @defai.digital/automatosx@${version}`,
       { maxBuffer: 10 * 1024 * 1024 }
     );
@@ -49922,6 +50494,7 @@ init_esm_shims();
 // src/cli/commands/agent/helpers.ts
 init_esm_shims();
 init_logger();
+var YAML_EXT_REGEX = /\.(yaml|yml)$/;
 var BUILTIN_TEMPLATE_METADATA = {
   "basic-agent": {
     name: "basic-agent",
@@ -49958,7 +50531,7 @@ async function listAvailableTemplates(baseDir) {
       const files = await readdir(projectTemplatesDir);
       for (const file of files) {
         if (extname$1(file) === ".yaml" || extname$1(file) === ".yml") {
-          const name = file.replace(/\.(yaml|yml)$/, "");
+          const name = file.replace(YAML_EXT_REGEX, "");
           templates.push({
             name,
             path: join(projectTemplatesDir, file),
@@ -49977,7 +50550,7 @@ async function listAvailableTemplates(baseDir) {
       const files = await readdir(builtinTemplatesDir);
       for (const file of files) {
         if (extname$1(file) === ".yaml" || extname$1(file) === ".yml") {
-          const name = file.replace(/\.(yaml|yml)$/, "");
+          const name = file.replace(YAML_EXT_REGEX, "");
           if (templates.find((t) => t.name === name)) {
             continue;
           }
@@ -52623,7 +53196,7 @@ var CommandTranslator = class {
     if (baseDir === void 0) {
       try {
         baseDir = await realpath$1(dir);
-      } catch (error) {
+      } catch {
         return commands;
       }
     }
@@ -52641,7 +53214,7 @@ var CommandTranslator = class {
         let realPath;
         try {
           realPath = await realpath$1(fullPath);
-        } catch (error) {
+        } catch {
           console.warn(`[Security] Cannot resolve path: ${fullPath}`);
           continue;
         }
@@ -52684,7 +53257,7 @@ var CommandTranslator = class {
           }
         }
       }
-    } catch (error) {
+    } catch {
     }
     return commands;
   }
@@ -53997,7 +54570,7 @@ async function handleSpecExplain(workspacePath, options) {
   console.log(chalk5.blue.bold("\n\u{1F4D6} Spec-Kit: Explain Spec\n"));
   try {
     const specContent = readFileSync(options.file, "utf-8");
-    const spec = yaml4.load(specContent);
+    const spec = yaml3.load(specContent);
     const validation = validateSpec(spec);
     if (!validation.valid) {
       console.error(chalk5.red("\n\u2717 Spec validation failed:\n"));
@@ -56099,7 +56672,7 @@ async function handleGenPlan(specFile, argv) {
       process.exit(1);
     }
     const specContent = readFileSync(specFile, "utf-8");
-    const spec = yaml4.load(specContent);
+    const spec = yaml3.load(specContent);
     const validation = validateSpec(spec);
     if (!validation.valid) {
       spinner.fail("Spec validation failed");
@@ -56157,7 +56730,7 @@ async function handleGenDag(specFile, argv) {
       process.exit(1);
     }
     const specContent = readFileSync(specFile, "utf-8");
-    const spec = yaml4.load(specContent);
+    const spec = yaml3.load(specContent);
     const validation = validateSpec(spec);
     if (!validation.valid) {
       spinner.fail("Spec validation failed");
@@ -56244,7 +56817,7 @@ async function handleGenScaffold(specFile, argv) {
       process.exit(1);
     }
     const specContent = readFileSync(specFile, "utf-8");
-    const spec = yaml4.load(specContent);
+    const spec = yaml3.load(specContent);
     const validation = validateSpec(spec);
     if (!validation.valid) {
       spinner.fail("Spec validation failed");
@@ -56316,7 +56889,7 @@ async function handleGenTests(specFile, argv) {
       process.exit(1);
     }
     const specContent = readFileSync(specFile, "utf-8");
-    const spec = yaml4.load(specContent);
+    const spec = yaml3.load(specContent);
     const validation = validateSpec(spec);
     if (!validation.valid) {
       spinner.fail("Spec validation failed");
@@ -56551,7 +57124,7 @@ async function handleList(config, argv) {
       });
     }
   }
-  let displayProviders2 = argv.available ? providers.filter((p) => p.enabled && !p.limitInfo?.isBlocked) : providers;
+  const displayProviders2 = argv.available ? providers.filter((p) => p.enabled && !p.limitInfo?.isBlocked) : providers;
   switch (argv.sort) {
     case "cost":
       displayProviders2.sort((a, b) => {
@@ -58194,8 +58767,8 @@ async function runMcpDiagnostics(verbose) {
   let serverStarts = false;
   if (cliAvailable) {
     try {
-      const { spawn: spawn12 } = await import('child_process');
-      const proc = spawn12("automatosx", ["mcp", "server"], { stdio: ["pipe", "pipe", "pipe"] });
+      const { spawn: spawn13 } = await import('child_process');
+      const proc = spawn13("automatosx", ["mcp", "server"], { stdio: ["pipe", "pipe", "pipe"] });
       const initResult = await new Promise((resolve13) => {
         let output = "";
         proc.stderr?.on("data", (data) => {
@@ -58294,7 +58867,8 @@ async function runMcpDiagnostics(verbose) {
 // src/cli/commands/cleanup.ts
 init_esm_shims();
 init_logger();
-var execAsync6 = promisify(exec);
+init_safe_timers();
+var execAsync7 = promisify(exec);
 var cleanupCommand2 = {
   command: "cleanup [provider]",
   describe: "Clean up orphaned provider processes (v6.0.7 Phase 3)",
@@ -58423,7 +58997,7 @@ async function findProcesses(processName, verbose) {
     throw new Error(`Invalid process name: ${processName}. Only alphanumeric characters, dashes, and underscores are allowed.`);
   }
   try {
-    const { stdout } = await execAsync6("ps -eo pid,comm,etime,rss");
+    const { stdout } = await execAsync7("ps -eo pid,comm,etime,rss");
     if (!stdout.trim()) {
       return processes;
     }
@@ -58486,7 +59060,7 @@ async function killProcess(pid, verbose) {
       });
       proc.on("error", reject);
     });
-    await new Promise((resolve13) => setTimeout(resolve13, 1e3));
+    await sleep(1e3);
     try {
       await new Promise((resolve13, reject) => {
         const proc = spawn("ps", ["-p", String(pid)], {
@@ -59737,6 +60311,7 @@ init_esm_shims();
 init_flags();
 init_logger();
 init_validation_limits();
+init_safe_timers();
 var flagsCommand = {
   command: "flags <command>",
   describe: "Manage feature flags",
@@ -59886,7 +60461,7 @@ async function handleKill(argv) {
 `);
   console.log(chalk5.yellow("This will immediately disable the feature for ALL users."));
   console.log(chalk5.gray("Press Ctrl+C to cancel, or wait 5 seconds to confirm...\n"));
-  await new Promise((resolve13) => setTimeout(resolve13, TIMEOUTS.KILL_SWITCH_DELAY));
+  await sleep(TIMEOUTS.KILL_SWITCH_DELAY);
   try {
     await flagManager.killSwitch(flagName, reason);
     console.log(chalk5.red("\u2713 Kill switch activated"));
@@ -61896,42 +62471,20 @@ var AgentInstructionInjector = class {
       this.lastQualityCheckTurn = context.turnCount;
     }
     const taskText = this.extractTaskText(context);
-    if (this.config.delegationDetection) {
-      if (taskText !== this.recentTaskText) {
-        this.recentTaskText = taskText;
-        const delegationContent = this.checkAndFormatDelegation(template, taskText);
-        if (delegationContent) {
-          instructions.push({
-            type: "delegation",
-            priority: "high",
-            content: delegationContent,
-            source: INSTRUCTION_SOURCE,
-            createdAt: Date.now(),
-            createdAtTurn: context.turnCount,
-            expiresAfter: 3,
-            id: `agent-delegation-${Date.now()}`
-          });
-        }
-      }
+    const delegationInstruction = this.tryCreateDelegationInstruction(
+      template,
+      taskText,
+      context.turnCount
+    );
+    if (delegationInstruction) {
+      instructions.push(delegationInstruction);
     }
-    if (this.config.contextAwareBoosting && taskText) {
-      const detectedCategories = this.detectContextCategories(taskText);
-      const contextBoostContent = this.formatContextBoost(detectedCategories);
-      if (contextBoostContent) {
-        instructions.push({
-          type: "context",
-          priority: "normal",
-          content: contextBoostContent,
-          source: INSTRUCTION_SOURCE,
-          createdAt: Date.now(),
-          createdAtTurn: context.turnCount,
-          expiresAfter: 5,
-          id: `agent-context-boost-${Date.now()}`
-        });
-        logger.debug("Context-aware boost applied", {
-          categories: detectedCategories.map((c) => c.name)
-        });
-      }
+    const contextInstruction = this.tryCreateContextBoostInstruction(
+      taskText,
+      context.turnCount
+    );
+    if (contextInstruction) {
+      instructions.push(contextInstruction);
     }
     logger.debug("Agent instructions generated", {
       domain,
@@ -62032,6 +62585,62 @@ var AgentInstructionInjector = class {
     lines.push("Use `DELEGATE TO @agent: task` or `@agent task` syntax to delegate.");
     return lines.join("\n");
   }
+  /**
+   * Try to create a delegation instruction
+   * Returns null if delegation detection is disabled or no delegation is needed
+   * @since v12.6.1 - Extracted to reduce nesting
+   */
+  tryCreateDelegationInstruction(template, taskText, turnCount) {
+    if (!this.config.delegationDetection) {
+      return null;
+    }
+    if (taskText === this.recentTaskText) {
+      return null;
+    }
+    this.recentTaskText = taskText;
+    const delegationContent = this.checkAndFormatDelegation(template, taskText);
+    if (!delegationContent) {
+      return null;
+    }
+    return {
+      type: "delegation",
+      priority: "high",
+      content: delegationContent,
+      source: INSTRUCTION_SOURCE,
+      createdAt: Date.now(),
+      createdAtTurn: turnCount,
+      expiresAfter: 3,
+      id: `agent-delegation-${Date.now()}`
+    };
+  }
+  /**
+   * Try to create a context boost instruction
+   * Returns null if context boosting is disabled or no boost is needed
+   * @since v12.6.1 - Extracted to reduce nesting
+   */
+  tryCreateContextBoostInstruction(taskText, turnCount) {
+    if (!this.config.contextAwareBoosting || !taskText) {
+      return null;
+    }
+    const detectedCategories = this.detectContextCategories(taskText);
+    const contextBoostContent = this.formatContextBoost(detectedCategories);
+    if (!contextBoostContent) {
+      return null;
+    }
+    logger.debug("Context-aware boost applied", {
+      categories: detectedCategories.map((c) => c.name)
+    });
+    return {
+      type: "context",
+      priority: "normal",
+      content: contextBoostContent,
+      source: INSTRUCTION_SOURCE,
+      createdAt: Date.now(),
+      createdAtTurn: turnCount,
+      expiresAfter: 5,
+      id: `agent-context-boost-${Date.now()}`
+    };
+  }
   /**
    * Detect context categories from task text
    * @since v11.3.1
@@ -62870,10 +63479,10 @@ init_esm_shims();
 // src/core/bugfix/git-utils.ts
 init_esm_shims();
 init_logger();
-var execAsync7 = promisify(exec);
+var execAsync8 = promisify(exec);
 async function isGitRepo(cwd) {
   try {
-    await execAsync7("git rev-parse --is-inside-work-tree", { cwd });
+    await execAsync8("git rev-parse --is-inside-work-tree", { cwd });
     return true;
   } catch {
     return false;
@@ -62891,14 +63500,14 @@ async function getChangedFiles(options) {
       command = "git diff --cached --name-only --diff-filter=ACMR";
     } else if (options.since) {
       const mergeBaseCmd = `git merge-base HEAD ${options.since}`;
-      const { stdout: mergeBase } = await execAsync7(mergeBaseCmd, { cwd });
+      const { stdout: mergeBase } = await execAsync8(mergeBaseCmd, { cwd });
       command = `git diff --name-only ${mergeBase.trim()}..HEAD`;
     } else if (options.changed) {
       command = "git diff --name-only HEAD";
     } else {
       command = "git diff --name-only HEAD";
     }
-    const { stdout } = await execAsync7(command, { cwd });
+    const { stdout } = await execAsync8(command, { cwd });
     const files = stdout.split("\n").map((f) => f.trim()).filter((f) => f.length > 0);
     logger.debug("Git changed files", {
       command,