@defai.digital/automatosx 12.6.2 → 12.7.0

package/dist/mcp/index.js

@@ -22,7 +22,6 @@ import { EventEmitter } from 'events';
 import { findUp } from 'find-up';
 import * as sqliteVec from 'sqlite-vec';
 import { randomUUID, randomBytes, createHash } from 'crypto';
-import yaml from 'yaml';
 import { gzipSync, gunzipSync } from 'zlib';
 
 var __defProp = Object.defineProperty;
@@ -2492,6 +2491,7 @@ function getRetryableErrors(provider) {
       return [...baseErrors, ...CODEX_RETRYABLE_ERRORS];
     case "glm":
     case "grok":
+    case "qwen":
       return [...baseErrors, ...OPENAI_RETRYABLE_ERRORS];
     case "base":
     default:
@@ -2594,6 +2594,10 @@ var init_base_provider = __esm({
         // v12.0.0: Native Grok provider (xAI)
         "ax-grok",
         // v12.0.0: Alias for grok
+        "qwen",
+        // v12.7.0: Qwen Code provider (Alibaba Cloud)
+        "qwen-code",
+        // v12.7.0: Alias for qwen
         "test-provider"
         // For unit tests
       ];
@@ -2956,7 +2960,7 @@ var init_base_provider = __esm({
             if (readlineInterface) {
               try {
                 readlineInterface.close();
-              } catch (error) {
+              } catch {
               } finally {
                 readlineInterface = null;
               }
@@ -2964,7 +2968,7 @@ var init_base_provider = __esm({
             if (stderrInterface) {
               try {
                 stderrInterface.close();
-              } catch (error) {
+              } catch {
               } finally {
                 stderrInterface = null;
               }
@@ -3158,7 +3162,7 @@ ${fullPrompt}
             this.health.consecutiveSuccesses = 0;
           }
           return available;
-        } catch (error) {
+        } catch {
           this.health.available = false;
           this.health.errorRate = 1;
           this.health.lastCheck = Date.now();
@@ -3334,6 +3338,8 @@ ${fullPrompt}
           retryableProvider = "glm";
         } else if (providerName === "grok" || providerName === "ax-grok") {
           retryableProvider = "grok";
+        } else if (providerName === "qwen" || providerName === "qwen-code") {
+          retryableProvider = "qwen";
         }
         return shouldRetryError(error, retryableProvider);
       }
@@ -5788,13 +5794,21 @@ var init_types2 = __esm({
   "src/integrations/ax-glm/types.ts"() {
     init_esm_shims();
     GLM_MODEL_MAPPING = {
+      // Convenience aliases (ax-cli v4.3.15)
+      "glm-latest": "glm-4.6",
+      "glm-vision": "glm-4.6v",
+      "glm-fast": "glm-4-flash",
+      "glm-image": "cogview-4",
+      // Legacy aliases (deprecated)
       "glm-4-plus": "glm-4.6",
-      "glm-4v": "glm-4.5v",
+      "glm-4.5v": "glm-4.6v",
+      "glm-4v": "glm-4.6v",
+      "glm-4": "glm-4.6",
       "glm-4-air": "glm-4-flash",
       "glm-4-airx": "glm-4-flash"
     };
     GLM_DEFAULT_BASE_URL = "https://open.bigmodel.cn/api/paas/v4";
-    GLM_DEFAULT_MODEL = "glm-4";
+    GLM_DEFAULT_MODEL = "glm-4.6";
     GLM_DEFAULT_COMMAND = "ax-glm";
   }
 });
@@ -6743,10 +6757,18 @@ var init_types3 = __esm({
   "src/integrations/ax-grok/types.ts"() {
     init_esm_shims();
     GROK_MODEL_MAPPING = {
-      "grok-beta": "grok-3"
+      // Convenience aliases (ax-cli v4.3.15)
+      "grok-latest": "grok-4-0709",
+      "grok-fast": "grok-4.1-fast",
+      "grok-mini": "grok-3-mini",
+      "grok-vision": "grok-2-vision-1212",
+      "grok-image": "grok-2-image-1212",
+      // Legacy aliases (deprecated)
+      "grok-beta": "grok-3",
+      "grok-2-vision": "grok-2-vision-1212"
     };
     GROK_DEFAULT_BASE_URL = "https://api.x.ai/v1";
-    GROK_DEFAULT_MODEL = "grok-3";
+    GROK_DEFAULT_MODEL = "grok-4-0709";
     GROK_DEFAULT_COMMAND = "ax-grok";
   }
 });
@@ -7678,6 +7700,902 @@ Mode: ${this.grokConfig.mode || "auto"}`;
   }
 });
 
+// src/integrations/qwen-code/types.ts
+function normalizeQwenModel(model) {
+  return QWEN_MODEL_MAPPING[model] || model;
+}
+function isVisionModel(model) {
+  return model.includes("qwen3-coder") || model.includes("qwen-max");
+}
+function getModelContextWindow(model) {
+  const normalizedModel = normalizeQwenModel(model);
+  if (normalizedModel.includes("480b")) return 128e3;
+  if (normalizedModel.includes("30b")) return 64e3;
+  if (normalizedModel.includes("qwen-max")) return 128e3;
+  if (normalizedModel.includes("qwen-plus")) return 128e3;
+  if (normalizedModel.includes("qwen-turbo")) return 128e3;
+  return 64e3;
+}
+var QWEN_DEFAULT_BASE_URL, QWEN_DEFAULT_MODEL, QWEN_DEFAULT_COMMAND, QWEN_MODEL_MAPPING;
+var init_types4 = __esm({
+  "src/integrations/qwen-code/types.ts"() {
+    init_esm_shims();
+    QWEN_DEFAULT_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+    QWEN_DEFAULT_MODEL = "qwen-turbo";
+    QWEN_DEFAULT_COMMAND = "qwen";
+    QWEN_MODEL_MAPPING = {
+      // Normalize common aliases
+      "qwen-coder": "qwen3-coder-480b-a35b-instruct",
+      "qwen-coder-480b": "qwen3-coder-480b-a35b-instruct",
+      "qwen-coder-30b": "qwen3-coder-30b-a3b-instruct",
+      "qwen2.5-coder": "qwen2.5-coder-32b-instruct"
+    };
+  }
+});
+
+// src/integrations/qwen-code/sdk-adapter.ts
+var QwenSdkAdapter;
+var init_sdk_adapter4 = __esm({
+  "src/integrations/qwen-code/sdk-adapter.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_validation_limits();
+    init_types4();
+    QwenSdkAdapter = class {
+      client = null;
+      config;
+      initialized = false;
+      constructor(config = {}) {
+        const apiKey = config.apiKey || process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY || "";
+        this.config = {
+          apiKey,
+          baseUrl: config.baseUrl || QWEN_DEFAULT_BASE_URL,
+          model: config.model || QWEN_DEFAULT_MODEL,
+          timeout: config.timeout || TIMEOUTS.PROVIDER_DEFAULT
+        };
+        logger.debug("[Qwen SDK] Adapter created", {
+          model: this.config.model,
+          baseUrl: this.config.baseUrl,
+          hasApiKey: !!this.config.apiKey
+        });
+      }
+      /**
+       * Check if SDK is available (OpenAI package installed and API key configured)
+       */
+      async isAvailable() {
+        try {
+          if (!this.config.apiKey) {
+            logger.debug("[Qwen SDK] No API key configured (set DASHSCOPE_API_KEY or QWEN_API_KEY)");
+            return false;
+          }
+          await import('openai');
+          return true;
+        } catch (error) {
+          logger.debug("[Qwen SDK] OpenAI SDK not available", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Initialize the SDK client
+       */
+      async initialize() {
+        if (this.initialized) {
+          return;
+        }
+        try {
+          const OpenAI = (await import('openai')).default;
+          this.client = new OpenAI({
+            apiKey: this.config.apiKey,
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeout
+          });
+          this.initialized = true;
+          logger.debug("[Qwen SDK] Client initialized", {
+            model: this.config.model
+          });
+        } catch (error) {
+          throw new Error(
+            `Failed to initialize Qwen SDK: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * Execute a request using the Qwen SDK
+       */
+      async execute(request) {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        const startTime = Date.now();
+        try {
+          const messages = [];
+          if (request.systemPrompt) {
+            messages.push({
+              role: "system",
+              content: request.systemPrompt
+            });
+          }
+          messages.push({
+            role: "user",
+            content: request.prompt
+          });
+          const model = normalizeQwenModel(request.model || this.config.model);
+          logger.debug("[Qwen SDK] Executing request", {
+            model,
+            messageCount: messages.length,
+            promptLength: request.prompt.length
+          });
+          const openaiClient = this.client;
+          const response = await openaiClient.chat.completions.create({
+            model,
+            messages,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stream: false
+          });
+          const latencyMs = Date.now() - startTime;
+          if (!response.choices || response.choices.length === 0) {
+            throw new Error("Qwen API returned empty choices array");
+          }
+          const choice = response.choices[0];
+          const content = choice?.message?.content || "";
+          const finishReason = choice?.finish_reason || "unknown";
+          logger.debug("[Qwen SDK] Request completed", {
+            model: response.model,
+            latencyMs,
+            tokensUsed: response.usage?.total_tokens
+          });
+          return {
+            content,
+            model: response.model,
+            tokensUsed: response.usage ? {
+              prompt: response.usage.prompt_tokens,
+              completion: response.usage.completion_tokens,
+              total: response.usage.total_tokens
+            } : { prompt: 0, completion: 0, total: 0 },
+            latencyMs,
+            finishReason,
+            cached: false
+          };
+        } catch (error) {
+          const latencyMs = Date.now() - startTime;
+          logger.error("[Qwen SDK] Request failed", {
+            error: error instanceof Error ? error.message : String(error),
+            latencyMs
+          });
+          throw error;
+        }
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.config.model;
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        this.client = null;
+        this.initialized = false;
+        logger.debug("[Qwen SDK] Adapter destroyed");
+      }
+    };
+  }
+});
+var NON_INTERACTIVE_ENV, SIGKILL_ESCALATION_MS, QwenCliWrapper;
+var init_cli_wrapper4 = __esm({
+  "src/integrations/qwen-code/cli-wrapper.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_validation_limits();
+    init_cli_provider_detector();
+    init_types4();
+    NON_INTERACTIVE_ENV = {
+      TERM: "dumb",
+      NO_COLOR: "1",
+      FORCE_COLOR: "0",
+      CI: "true",
+      NO_UPDATE_NOTIFIER: "1",
+      DEBIAN_FRONTEND: "noninteractive"
+    };
+    SIGKILL_ESCALATION_MS = 5e3;
+    QwenCliWrapper = class {
+      config;
+      constructor(config = {}) {
+        this.config = {
+          command: config.command || QWEN_DEFAULT_COMMAND,
+          vlmSwitchMode: config.vlmSwitchMode || "once",
+          yolo: config.yolo || false,
+          timeout: config.timeout || TIMEOUTS.PROVIDER_DEFAULT
+        };
+        logger.debug("[Qwen CLI] Wrapper created", {
+          command: this.config.command,
+          timeout: this.config.timeout
+        });
+      }
+      /**
+       * Check if Qwen CLI is available on PATH
+       */
+      async isAvailable() {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          return true;
+        }
+        try {
+          const result = findOnPath(this.config.command);
+          logger.debug("[Qwen CLI] Availability check", {
+            available: result.found,
+            path: result.path
+          });
+          return result.found;
+        } catch (error) {
+          logger.debug("[Qwen CLI] Availability check failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Execute a prompt using the Qwen CLI
+       *
+       * Since Qwen CLI is interactive, we:
+       * 1. Spawn the process
+       * 2. Send the prompt via stdin
+       * 3. Capture output until we detect completion
+       * 4. Return the response
+       */
+      async execute(request) {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          return this.createMockResponse(request.prompt);
+        }
+        const startTime = Date.now();
+        return new Promise((resolve5, reject) => {
+          const args2 = [];
+          if (this.config.vlmSwitchMode !== "once") {
+            args2.push("--vlm-switch-mode", this.config.vlmSwitchMode);
+          }
+          if (this.config.yolo) {
+            args2.push("--yolo");
+          }
+          logger.debug("[Qwen CLI] Spawning process", {
+            command: this.config.command,
+            args: args2,
+            promptLength: request.prompt.length
+          });
+          const child = spawn(this.config.command, args2, {
+            env: { ...process.env, ...NON_INTERACTIVE_ENV }
+          });
+          let stdout = "";
+          let stderr = "";
+          let timeoutId = null;
+          let forceKillTimer = null;
+          let readlineInterface = null;
+          let responseStarted = false;
+          const cleanup = () => {
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              timeoutId = null;
+            }
+            if (forceKillTimer) {
+              clearTimeout(forceKillTimer);
+              forceKillTimer = null;
+            }
+            if (readlineInterface) {
+              try {
+                readlineInterface.close();
+              } catch {
+              }
+              readlineInterface = null;
+            }
+          };
+          if (child.stdout) {
+            readlineInterface = readline.createInterface({
+              input: child.stdout,
+              crlfDelay: Infinity
+            });
+            readlineInterface.on("line", (line) => {
+              if (line.startsWith(">") && !responseStarted) {
+                responseStarted = true;
+                return;
+              }
+              if (responseStarted) {
+                stdout += line + "\n";
+              }
+            });
+            readlineInterface.on("error", (error) => {
+              logger.debug("[Qwen CLI] Readline error", {
+                error: error.message
+              });
+            });
+          }
+          if (child.stderr) {
+            child.stderr.on("data", (data) => {
+              stderr += data.toString();
+            });
+          }
+          if (child.stdin) {
+            try {
+              let fullPrompt = request.prompt;
+              if (request.systemPrompt) {
+                fullPrompt = `${request.systemPrompt}
+
+${request.prompt}`;
+              }
+              child.stdin.write(fullPrompt);
+              child.stdin.write("\n");
+              child.stdin.end();
+            } catch (error) {
+              cleanup();
+              child.kill("SIGTERM");
+              reject(new Error(`Failed to write to Qwen stdin: ${error instanceof Error ? error.message : String(error)}`));
+              return;
+            }
+          } else {
+            cleanup();
+            reject(new Error("Qwen CLI stdin not available"));
+            return;
+          }
+          child.on("close", (code, signal) => {
+            cleanup();
+            const latencyMs = Date.now() - startTime;
+            if (stderr) {
+              logger.debug("[Qwen CLI] stderr output", { stderr: stderr.trim() });
+            }
+            if ((code === 0 || code === null) && !signal) {
+              const content = this.parseResponse(stdout);
+              resolve5({
+                content: content.trim(),
+                model: "qwen-code-cli",
+                tokensUsed: {
+                  prompt: this.estimateTokens(request.prompt),
+                  completion: this.estimateTokens(content),
+                  total: this.estimateTokens(request.prompt) + this.estimateTokens(content)
+                },
+                latencyMs,
+                finishReason: "stop",
+                cached: false
+              });
+            } else if (signal) {
+              reject(new Error(`Qwen CLI killed by signal ${signal}. stderr: ${stderr || "none"}`));
+            } else {
+              reject(new Error(`Qwen CLI exited with code ${code}. stderr: ${stderr || "none"}`));
+            }
+          });
+          child.on("error", (error) => {
+            cleanup();
+            logger.error("[Qwen CLI] Process error", {
+              error: error.message
+            });
+            reject(new Error(`Failed to spawn Qwen CLI: ${error.message}`));
+          });
+          timeoutId = setTimeout(() => {
+            if (child.pid && !child.killed) {
+              logger.warn("[Qwen CLI] Killing process due to timeout", {
+                pid: child.pid,
+                timeout: this.config.timeout
+              });
+              child.kill("SIGTERM");
+              forceKillTimer = setTimeout(() => {
+                if (child.pid) {
+                  try {
+                    process.kill(child.pid, 0);
+                    logger.warn("[Qwen CLI] Force killing process", { pid: child.pid });
+                    child.kill("SIGKILL");
+                  } catch {
+                  }
+                }
+              }, SIGKILL_ESCALATION_MS);
+            }
+          }, this.config.timeout);
+        });
+      }
+      /**
+       * Parse response from CLI output
+       *
+       * Qwen CLI outputs include prompts and formatting that we need to strip.
+       */
+      parseResponse(output) {
+        let content = output.trim();
+        content = content.replace(/\x1B\[[0-9;]*[mGKH]/g, "");
+        content = content.replace(/^>\s*/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+        return content;
+      }
+      /**
+       * Estimate token count
+       */
+      estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+      }
+      /**
+       * Create mock response for testing
+       */
+      createMockResponse(prompt) {
+        return {
+          content: `[Mock Qwen Response]
+
+This is a mock response from Qwen Code CLI.
+Prompt length: ${prompt.length} characters.`,
+          model: "qwen-code-cli-mock",
+          tokensUsed: {
+            prompt: this.estimateTokens(prompt),
+            completion: 50,
+            total: this.estimateTokens(prompt) + 50
+          },
+          latencyMs: 10,
+          finishReason: "stop",
+          cached: false
+        };
+      }
+      /**
+       * Get CLI command
+       */
+      getCommand() {
+        return this.config.command;
+      }
+    };
+  }
+});
+
+// src/integrations/qwen-code/hybrid-adapter.ts
+var QwenHybridAdapter;
+var init_hybrid_adapter4 = __esm({
+  "src/integrations/qwen-code/hybrid-adapter.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_sdk_adapter4();
+    init_cli_wrapper4();
+    QwenHybridAdapter = class {
+      sdkAdapter = null;
+      cliWrapper = null;
+      options;
+      activeMode = null;
+      // Circuit breakers for each mode
+      sdkCircuitBreaker = {
+        failures: 0,
+        lastFailure: 0,
+        isOpen: false
+      };
+      cliCircuitBreaker = {
+        failures: 0,
+        lastFailure: 0,
+        isOpen: false
+      };
+      // Circuit breaker configuration
+      FAILURE_THRESHOLD = 3;
+      RECOVERY_TIMEOUT_MS = 6e4;
+      // 1 minute
+      constructor(options = {}) {
+        this.options = {
+          mode: options.mode || "auto",
+          model: options.model || "qwen-turbo",
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          command: options.command || "qwen",
+          timeout: options.timeout
+        };
+        logger.debug("[Qwen Hybrid] Adapter created", {
+          mode: this.options.mode,
+          model: this.options.model
+        });
+      }
+      /**
+       * Get or create SDK adapter
+       */
+      getSdkAdapter() {
+        if (!this.sdkAdapter) {
+          const config = {
+            apiKey: this.options.apiKey,
+            baseUrl: this.options.baseUrl,
+            model: this.options.model,
+            timeout: this.options.timeout
+          };
+          this.sdkAdapter = new QwenSdkAdapter(config);
+        }
+        return this.sdkAdapter;
+      }
+      /**
+       * Get or create CLI wrapper
+       */
+      getCliWrapper() {
+        if (!this.cliWrapper) {
+          const config = {
+            command: this.options.command,
+            timeout: this.options.timeout
+          };
+          this.cliWrapper = new QwenCliWrapper(config);
+        }
+        return this.cliWrapper;
+      }
+      /**
+       * Check if a circuit breaker should allow requests
+       */
+      isCircuitClosed(breaker) {
+        if (!breaker.isOpen) {
+          return true;
+        }
+        if (Date.now() - breaker.lastFailure > this.RECOVERY_TIMEOUT_MS) {
+          breaker.isOpen = false;
+          breaker.failures = 0;
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Record a failure on a circuit breaker
+       */
+      recordFailure(breaker) {
+        breaker.failures++;
+        breaker.lastFailure = Date.now();
+        if (breaker.failures >= this.FAILURE_THRESHOLD) {
+          breaker.isOpen = true;
+          logger.warn("[Qwen Hybrid] Circuit breaker opened", {
+            failures: breaker.failures
+          });
+        }
+      }
+      /**
+       * Record a success on a circuit breaker
+       */
+      recordSuccess(breaker) {
+        breaker.failures = 0;
+        breaker.isOpen = false;
+      }
+      /**
+       * Execute a request using the appropriate mode
+       */
+      async execute(request) {
+        const mode = this.options.mode;
+        if (mode === "sdk") {
+          return this.executeWithSdk(request);
+        }
+        if (mode === "cli") {
+          return this.executeWithCli(request);
+        }
+        return this.executeWithAuto(request);
+      }
+      /**
+       * Execute with SDK only
+       */
+      async executeWithSdk(request) {
+        const adapter = this.getSdkAdapter();
+        if (!await adapter.isAvailable()) {
+          throw new Error("Qwen SDK is not available. Check DASHSCOPE_API_KEY or QWEN_API_KEY.");
+        }
+        this.activeMode = "sdk";
+        return adapter.execute(request);
+      }
+      /**
+       * Execute with CLI only
+       */
+      async executeWithCli(request) {
+        const wrapper = this.getCliWrapper();
+        if (!await wrapper.isAvailable()) {
+          throw new Error("Qwen CLI is not available. Run: npm install -g @qwen-code/qwen-code@latest");
+        }
+        this.activeMode = "cli";
+        return wrapper.execute(request);
+      }
+      /**
+       * Execute with automatic mode selection
+       */
+      async executeWithAuto(request) {
+        if (this.isCircuitClosed(this.sdkCircuitBreaker)) {
+          const adapter = this.getSdkAdapter();
+          try {
+            if (await adapter.isAvailable()) {
+              logger.debug("[Qwen Hybrid] Using SDK mode");
+              this.activeMode = "sdk";
+              const response = await adapter.execute(request);
+              this.recordSuccess(this.sdkCircuitBreaker);
+              return response;
+            }
+          } catch (error) {
+            logger.warn("[Qwen Hybrid] SDK execution failed, trying CLI", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+            this.recordFailure(this.sdkCircuitBreaker);
+          }
+        }
+        if (this.isCircuitClosed(this.cliCircuitBreaker)) {
+          const wrapper = this.getCliWrapper();
+          try {
+            if (await wrapper.isAvailable()) {
+              logger.debug("[Qwen Hybrid] Using CLI mode (fallback)");
+              this.activeMode = "cli";
+              const response = await wrapper.execute(request);
+              this.recordSuccess(this.cliCircuitBreaker);
+              return response;
+            }
+          } catch (error) {
+            logger.error("[Qwen Hybrid] CLI execution also failed", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+            this.recordFailure(this.cliCircuitBreaker);
+            throw error;
+          }
+        }
+        throw new Error(
+          "Qwen execution failed: Both SDK and CLI modes are unavailable or have failed too many times. Ensure DASHSCOPE_API_KEY is set or Qwen CLI is installed."
+        );
+      }
+      /**
+       * Get the currently active execution mode
+       */
+      getActiveMode() {
+        return this.activeMode;
+      }
+      /**
+       * Reset circuit breakers
+       */
+      resetCircuitBreakers() {
+        this.sdkCircuitBreaker = { failures: 0, lastFailure: 0, isOpen: false };
+        this.cliCircuitBreaker = { failures: 0, lastFailure: 0, isOpen: false };
+        logger.debug("[Qwen Hybrid] Circuit breakers reset");
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        if (this.sdkAdapter) {
+          await this.sdkAdapter.destroy();
+          this.sdkAdapter = null;
+        }
+        this.cliWrapper = null;
+        this.activeMode = null;
+        logger.debug("[Qwen Hybrid] Adapter destroyed");
+      }
+    };
+  }
+});
+
+// src/integrations/qwen-code/index.ts
+var init_qwen_code = __esm({
+  "src/integrations/qwen-code/index.ts"() {
+    init_esm_shims();
+    init_hybrid_adapter4();
+    init_sdk_adapter4();
+    init_cli_wrapper4();
+    init_types4();
+  }
+});
+
+// src/providers/qwen-provider.ts
+var qwen_provider_exports = {};
+__export(qwen_provider_exports, {
+  QwenProvider: () => QwenProvider,
+  default: () => QwenProvider
+});
+var SUPPORTED_MODELS, QwenProvider;
+var init_qwen_provider = __esm({
+  "src/providers/qwen-provider.ts"() {
+    init_esm_shims();
+    init_base_provider();
+    init_logger();
+    init_qwen_code();
+    SUPPORTED_MODELS = [
+      "qwen3-coder-480b-a35b-instruct",
+      "qwen3-coder-30b-a3b-instruct",
+      "qwen2.5-coder-32b-instruct",
+      "qwen-max",
+      "qwen-plus",
+      "qwen-turbo"
+    ];
+    QwenProvider = class extends BaseProvider {
+      /** Selected model */
+      model;
+      /** SDK adapter for direct execution */
+      sdkAdapter = null;
+      /** Hybrid adapter for 'auto' mode */
+      hybridAdapter = null;
+      /** Provider configuration */
+      qwenConfig;
+      /** Supported models */
+      static SUPPORTED_MODELS = SUPPORTED_MODELS;
+      constructor(config) {
+        super({
+          ...config,
+          command: "qwen"
+        });
+        this.qwenConfig = config;
+        const requestedModel = config.model || QWEN_DEFAULT_MODEL;
+        if (!SUPPORTED_MODELS.includes(requestedModel)) {
+          logger.warn(`[Qwen] Unknown model: ${requestedModel}. Using ${QWEN_DEFAULT_MODEL}.`);
+          this.model = QWEN_DEFAULT_MODEL;
+        } else {
+          this.model = requestedModel;
+        }
+        logger.debug("[Qwen Provider] Initialized", {
+          model: this.model,
+          mode: config.mode || "sdk"
+        });
+      }
+      /**
+       * Get the normalized model name
+       */
+      getNormalizedModel() {
+        return normalizeQwenModel(this.model);
+      }
+      /**
+       * Get or create SDK adapter
+       */
+      getSdkAdapter() {
+        if (!this.sdkAdapter) {
+          this.sdkAdapter = new QwenSdkAdapter({
+            model: this.model,
+            apiKey: this.qwenConfig.apiKey,
+            baseUrl: this.qwenConfig.baseUrl,
+            timeout: this.qwenConfig.timeout
+          });
+        }
+        return this.sdkAdapter;
+      }
+      /**
+       * Get or create hybrid adapter
+       */
+      getHybridAdapter() {
+        if (!this.hybridAdapter) {
+          const options = {
+            mode: this.qwenConfig.mode || "auto",
+            model: this.model,
+            apiKey: this.qwenConfig.apiKey,
+            baseUrl: this.qwenConfig.baseUrl,
+            command: "qwen",
+            timeout: this.qwenConfig.timeout
+          };
+          this.hybridAdapter = new QwenHybridAdapter(options);
+        }
+        return this.hybridAdapter;
+      }
+      /**
+       * Execute a task using Qwen
+       *
+       * Execution flow:
+       * 1. Mock mode → return mock response
+       * 2. mode='sdk' (default) → use SDK adapter
+       * 3. mode='auto' → use hybrid adapter (SDK with CLI fallback)
+       * 4. mode='cli' → use CLI via BaseProvider
+       */
+      async execute(request) {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          return this.createMockResponse(request.prompt);
+        }
+        const effectiveMode = this.qwenConfig.mode || "sdk";
+        if (effectiveMode === "cli") {
+          logger.debug("[Qwen Provider] Executing via CLI", {
+            model: this.model
+          });
+          return super.execute(request);
+        }
+        if (effectiveMode === "auto") {
+          logger.debug("[Qwen Provider] Executing via hybrid adapter", {
+            promptLength: request.prompt.length,
+            model: this.model
+          });
+          const adapter2 = this.getHybridAdapter();
+          return adapter2.execute(request);
+        }
+        logger.debug("[Qwen Provider] Executing via SDK adapter", {
+          promptLength: request.prompt.length,
+          model: this.model
+        });
+        const adapter = this.getSdkAdapter();
+        if (!await adapter.isAvailable()) {
+          throw new Error(
+            'Qwen SDK is not available. Set DASHSCOPE_API_KEY or QWEN_API_KEY environment variable, or use mode: "cli" to use Qwen Code CLI.'
+          );
+        }
+        return adapter.execute(request);
+      }
+      /**
+       * Get CLI command
+       */
+      getCLICommand() {
+        const activeMode = this.hybridAdapter?.getActiveMode();
+        if (activeMode === "sdk") {
+          return "qwen-sdk";
+        }
+        return "qwen";
+      }
+      /**
+       * Get CLI arguments for Qwen Code CLI
+       *
+       * Note: Qwen Code CLI is interactive by default.
+       * We pass the prompt via stdin instead of command-line args.
+       */
+      getCLIArgs() {
+        return [];
+      }
+      /**
+       * Create mock response for testing
+       */
+      createMockResponse(prompt) {
+        return {
+          content: this.getMockResponse(),
+          model: this.getNormalizedModel(),
+          tokensUsed: {
+            prompt: this.estimateTokens(prompt),
+            completion: 50,
+            total: this.estimateTokens(prompt) + 50
+          },
+          latencyMs: 10,
+          finishReason: "stop",
+          cached: false
+        };
+      }
+      /**
+       * Estimate token count
+       */
+      estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+      }
+      /**
+       * Get mock response for testing
+       */
+      getMockResponse() {
+        return `[Mock Qwen Response]
+
+This is a mock response from the Qwen provider (${this.getNormalizedModel()}).
+In production, this would be a response from ${this.qwenConfig.mode === "sdk" ? "Qwen SDK" : "Qwen Code CLI"}.
+
+Model: ${this.getNormalizedModel()}
+Provider: Qwen (Alibaba Cloud)
+Mode: ${this.qwenConfig.mode || "sdk"}`;
+      }
+      /**
+       * Get provider capabilities
+       */
+      get capabilities() {
+        const model = this.getNormalizedModel();
+        const hasVision = isVisionModel(model);
+        const maxContextTokens = getModelContextWindow(model);
+        const activeMode = this.hybridAdapter?.getActiveMode();
+        const integrationMode = activeMode === "sdk" ? "sdk" : "cli";
+        return {
+          ...super.capabilities,
+          supportsStreaming: true,
+          supportsVision: hasVision,
+          maxContextTokens,
+          supportedModels: SUPPORTED_MODELS,
+          integrationMode
+        };
+      }
+      /**
+       * Get the active execution mode
+       */
+      getActiveMode() {
+        return this.hybridAdapter?.getActiveMode() || null;
+      }
+      /**
+       * Reset circuit breakers
+       */
+      resetCircuitBreakers() {
+        this.hybridAdapter?.resetCircuitBreakers();
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        if (this.sdkAdapter) {
+          await this.sdkAdapter.destroy();
+          this.sdkAdapter = null;
+        }
+        if (this.hybridAdapter) {
+          await this.hybridAdapter.destroy();
+          this.hybridAdapter = null;
+        }
+      }
+      /**
+       * Get the list of supported models
+       */
+      static getSupportedModels() {
+        return [...SUPPORTED_MODELS];
+      }
+    };
+  }
+});
+
 // src/mcp/index.ts
 init_esm_shims();
 
@@ -8130,12 +9048,16 @@ init_logger();
 
 // src/shared/helpers/deep-merge.ts
 init_esm_shims();
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
 function deepMerge(defaults, user) {
   if (user === null || user === void 0) {
-    return defaults;
+    return { ...defaults };
   }
-  const result = { ...defaults };
-  for (const key in user) {
+  const result = Object.assign({}, defaults);
+  const userKeys = Object.keys(user);
+  for (const key of userKeys) {
     const userValue = user[key];
     if (userValue === null) {
       result[key] = void 0;
@@ -8145,8 +9067,11 @@ function deepMerge(defaults, user) {
       continue;
     }
     const defaultValue = defaults[key];
-    if (typeof userValue === "object" && typeof defaultValue === "object" && !Array.isArray(userValue) && !Array.isArray(defaultValue) && userValue !== null && defaultValue !== null) {
-      result[key] = deepMerge(defaultValue, userValue);
+    if (isPlainObject(userValue) && isPlainObject(defaultValue)) {
+      result[key] = deepMerge(
+        defaultValue,
+        userValue
+      );
     } else {
       result[key] = userValue;
     }
@@ -8788,7 +9713,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.6.1"
+  "version": "12.7.0"
 };
 
 // src/core/config/schemas.ts
@@ -9221,10 +10146,11 @@ async function loadConfigFile(path9) {
     if (error instanceof ConfigError) {
       throw error;
     }
-    if (error.code === "ENOENT") {
+    const nodeError = error;
+    if (nodeError.code === "ENOENT") {
       throw ConfigError.notFound(path9);
     }
-    if (error.code === "EACCES") {
+    if (nodeError.code === "EACCES") {
       throw new ConfigError(
         `Permission denied reading config: ${path9}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
@@ -13211,7 +14137,7 @@ var MemoryManager = class _MemoryManager {
       if (this.db) {
         try {
           this.db.close();
-        } catch (closeError) {
+        } catch {
         }
         this.initialized = false;
         this.entryCount = 0;
@@ -14052,9 +14978,9 @@ var MemoryManager = class _MemoryManager {
       }
     }
     const {
-      includeEmbeddings = false,
+      includeEmbeddings: _includeEmbeddings = false,
       filters = {},
-      batchSize = 1e3,
+      batchSize: _batchSize = 1e3,
       pretty = false
     } = options || {};
     try {
@@ -15211,7 +16137,7 @@ var SessionManager = class _SessionManager {
       if (this.pendingSave) {
         try {
           await this.pendingSave;
-        } catch (err) {
+        } catch {
         }
       }
       this.pendingSave = this.doSave().finally(() => {
@@ -15279,7 +16205,7 @@ var SessionManager = class _SessionManager {
         }
         try {
           await unlink(tempPath);
-        } catch (unlinkError) {
+        } catch {
         }
         throw renameError;
       }
@@ -15287,7 +16213,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),
@@ -15825,6 +16751,7 @@ init_esm_shims();
 init_logger();
 var MAX_CONTEXT_SIZE = 100 * 1024;
 var DEFAULT_CACHE_TTL = 3e5;
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 var ProjectContextLoader = class {
   constructor(projectRoot, options) {
     this.projectRoot = projectRoot;
@@ -15848,76 +16775,79 @@ var ProjectContextLoader = class {
     });
     const context = {};
     try {
-      const mdPath = path4__default.join(this.projectRoot, "AX.md");
-      const resolvedPath = await realpath(mdPath).catch(() => null);
+      const indexPath = path4__default.join(this.projectRoot, "ax.index.json");
+      const resolvedPath = await realpath(indexPath).catch(() => null);
       if (resolvedPath) {
         const rel = path4__default.relative(this.projectRoot, resolvedPath);
         if (!rel.startsWith("..") && !path4__default.isAbsolute(rel)) {
           const stats = await stat(resolvedPath);
           if (stats.size > MAX_CONTEXT_SIZE) {
-            logger.warn("AX.md too large, ignoring", {
+            logger.warn("ax.index.json too large, ignoring", {
               size: stats.size,
               limit: MAX_CONTEXT_SIZE
             });
           } else {
-            context.markdown = await readFile(resolvedPath, "utf-8");
-            logger.info("Loaded AX.md", {
-              size: stats.size,
-              lines: context.markdown.split("\n").length
+            const indexContent = await readFile(resolvedPath, "utf-8");
+            context.index = JSON.parse(indexContent);
+            context.lastUpdated = stats.mtime;
+            const age = Date.now() - stats.mtime.getTime();
+            context.isStale = age > STALE_THRESHOLD_MS;
+            logger.info("Loaded ax.index.json", {
+              projectName: context.index.projectName,
+              projectType: context.index.projectType,
+              isStale: context.isStale,
+              ageHours: Math.floor(age / (1e3 * 60 * 60))
             });
-            context.agentRules = this.parseAgentRules(context.markdown);
-            context.guardrails = this.parseGuardrails(context.markdown);
-            context.commands = this.parseCommands(context.markdown);
-            context.metadata = this.parseMetadata(context.markdown);
+            if (context.index.commands) {
+              context.commands = {};
+              for (const [name, cmd] of Object.entries(context.index.commands)) {
+                context.commands[name] = cmd.script;
+              }
+            }
           }
         }
       }
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code !== "ENOENT") {
-        logger.warn("Error loading AX.md", { error });
+        logger.warn("Error loading ax.index.json", { error });
       }
     }
     try {
-      const ymlPath = path4__default.join(this.projectRoot, "ax.config.yml");
-      const resolvedPath = await realpath(ymlPath).catch(() => null);
+      const customMdPath = path4__default.join(this.projectRoot, ".automatosx", "CUSTOM.md");
+      const resolvedPath = await realpath(customMdPath).catch(() => null);
       if (resolvedPath) {
         const rel = path4__default.relative(this.projectRoot, resolvedPath);
         if (!rel.startsWith("..") && !path4__default.isAbsolute(rel)) {
           const stats = await stat(resolvedPath);
           if (stats.size > MAX_CONTEXT_SIZE) {
-            logger.warn("ax.config.yml too large, ignoring", {
+            logger.warn("CUSTOM.md too large, ignoring", {
               size: stats.size,
               limit: MAX_CONTEXT_SIZE
             });
           } else {
-            const ymlContent = await readFile(resolvedPath, "utf-8");
-            context.config = yaml.parse(ymlContent);
-            logger.info("Loaded ax.config.yml", {
-              size: stats.size
+            context.customInstructions = await readFile(resolvedPath, "utf-8");
+            logger.info("Loaded CUSTOM.md", {
+              size: stats.size,
+              lines: context.customInstructions.split("\n").length
             });
-            if (context.config.commands) {
-              context.commands = { ...context.commands, ...context.config.commands };
-            }
-            if (context.config.project) {
-              context.metadata = { ...context.metadata, ...context.config.project };
-            }
+            context.guardrails = this.parseGuardrails(context.customInstructions);
           }
         }
       }
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code !== "ENOENT") {
-        logger.warn("Error loading ax.config.yml", { error });
+        logger.warn("Error loading CUSTOM.md", { error });
       }
     }
     context.contextPrompt = this.buildContextPrompt(context);
     this.cache = context;
     this.cacheExpiry = Date.now() + this.cacheTTL;
     logger.info("Project context loaded", {
-      hasMarkdown: !!context.markdown,
-      hasConfig: !!context.config,
-      agentRules: context.agentRules?.length ?? 0,
+      hasIndex: !!context.index,
+      hasCustomInstructions: !!context.customInstructions,
       guardrails: context.guardrails?.length ?? 0,
-      commands: Object.keys(context.commands ?? {}).length
+      commands: Object.keys(context.commands ?? {}).length,
+      isStale: context.isStale
     });
     return context;
   }
@@ -15933,8 +16863,8 @@ var ProjectContextLoader = class {
    * Check if context exists (without loading)
    */
   async exists() {
-    const mdPath = path4__default.join(this.projectRoot, "AX.md");
-    const ymlPath = path4__default.join(this.projectRoot, "ax.config.yml");
+    const indexPath = path4__default.join(this.projectRoot, "ax.index.json");
+    const customMdPath = path4__default.join(this.projectRoot, ".automatosx", "CUSTOM.md");
     const checkExists = async (filePath) => {
       try {
         await access(filePath, constants.F_OK);
@@ -15943,57 +16873,48 @@ var ProjectContextLoader = class {
         return false;
       }
     };
-    const [mdExists, ymlExists] = await Promise.all([
-      checkExists(mdPath),
-      checkExists(ymlPath)
+    const [indexExists, customMdExists] = await Promise.all([
+      checkExists(indexPath),
+      checkExists(customMdPath)
     ]);
-    return mdExists || ymlExists;
+    return indexExists || customMdExists;
   }
   /**
-   * Parse agent delegation rules from markdown
-   *
-   * Looks for patterns like:
-   * - Backend changes → @backend
-   * - API endpoints → @backend, @security
-   */
-  parseAgentRules(markdown) {
-    const rules = [];
-    const sectionRegex = /##\s+Agent\s+Delegation\s+Rules[^\n]*\n([\s\S]*?)(?=\n##|$)/i;
-    const match = markdown.match(sectionRegex);
-    if (!match || !match[1]) {
-      return rules;
-    }
-    const section = match[1];
-    const lineRegex = /^[-*]\s+(.+?)\s+(?:→|->)+\s+(.+?)$/gm;
-    let lineMatch;
-    while ((lineMatch = lineRegex.exec(section)) !== null) {
-      const taskType = lineMatch[1]?.trim() ?? "";
-      const agentsText = lineMatch[2]?.trim() ?? "";
-      const agents = agentsText.split(",").map((a) => a.trim()).filter(Boolean);
-      const defaultAgent = agents[0];
-      if (defaultAgent) {
-        rules.push({
-          taskType,
-          patterns: [],
-          // TODO: Parse file patterns if specified
-          defaultAgent,
-          autoReview: agents.length > 1
-        });
-      }
+   * Check if ax.index.json is stale (older than 24 hours)
+   */
+  async isStale() {
+    try {
+      const indexPath = path4__default.join(this.projectRoot, "ax.index.json");
+      const stats = await stat(indexPath);
+      const age = Date.now() - stats.mtime.getTime();
+      return age > STALE_THRESHOLD_MS;
+    } catch {
+      return true;
     }
-    return rules;
   }
   /**
-   * Parse guardrails/prohibitions from markdown
+   * Parse guardrails from CUSTOM.md
    *
-   * Looks for "## Critical Guardrails" or "## Critical Rules" section
-   * Extracts items marked with ⚠️ or under NEVER headings
+   * Looks for DO/DON'T sections in ax-cli format
    */
   parseGuardrails(markdown) {
     const guardrails = [];
-    const sectionRegex = /##\s+(Critical\s+Guardrails|Critical\s+Rules|Never)[^\n]*\n([\s\S]*?)(?=\n##|$)/gi;
+    const dontRegex = /###\s+DON'T[^\n]*\n([\s\S]*?)(?=\n###|$)/i;
+    const dontMatch = markdown.match(dontRegex);
+    if (dontMatch && dontMatch[1]) {
+      const section = dontMatch[1];
+      const bulletRegex = /^[-*]\s+(.+?)$/gm;
+      let bulletMatch;
+      while ((bulletMatch = bulletRegex.exec(section)) !== null) {
+        const rule = bulletMatch[1]?.trim();
+        if (rule) {
+          guardrails.push(rule);
+        }
+      }
+    }
+    const criticalRegex = /##\s+(Critical\s+Guardrails|Critical\s+Rules|Never)[^\n]*\n([\s\S]*?)(?=\n##|$)/gi;
     let match;
-    while ((match = sectionRegex.exec(markdown)) !== null) {
+    while ((match = criticalRegex.exec(markdown)) !== null) {
       const section = match[2];
       if (!section) continue;
       const bulletRegex = /^[-*]\s+(.+?)$/gm;
@@ -16003,106 +16924,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;
   }
@@ -16526,10 +17399,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
@@ -16542,15 +17415,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) {
@@ -16798,6 +17671,1374 @@ function getPackageRoot(startDir) {
   return startDir || __dirname3;
 }
 
+// src/agents/cognitive/prompt-composer.ts
+init_esm_shims();
+
+// src/agents/cognitive/reasoning-scaffolds.ts
+init_esm_shims();
+var PROVER_STEPS = [
+  {
+    id: "1_intake",
+    name: "INTAKE",
+    description: "Understand before acting",
+    requiredActions: [
+      "Restate the goal, constraints, and success criteria in your own words",
+      "Read relevant files and cite them (path:line) - do NOT hypothesize without evidence",
+      "List your assumptions and unknowns explicitly",
+      "If blockers exist that prevent progress, ask 1-3 focused clarifying questions"
+    ],
+    skipWhen: ["Task is trivial and self-explanatory"]
+  },
+  {
+    id: "2_risk_scan",
+    name: "RISK SCAN",
+    description: "Anticipate failure modes before they occur",
+    requiredActions: [
+      "Run through your domain-specific checklist (see DOMAIN CHECKLIST section)",
+      "Flag any high-risk items explicitly with [RISK] tag",
+      "Propose mitigations for critical risks before proceeding",
+      "If risks are unacceptable, STOP and discuss with user"
+    ]
+  },
+  {
+    id: "3_options",
+    name: "OPTIONS",
+    description: "Consider alternatives before committing",
+    requiredActions: [
+      "Generate 2-3 viable approaches (skip only if truly trivial)",
+      "Compare each against: complexity, performance, risk, maintainability",
+      "Choose one approach with explicit rationale",
+      "Document what was rejected and why (prevents revisiting)"
+    ],
+    skipWhen: ["Single obvious solution exists", "Task is a simple bug fix"]
+  },
+  {
+    id: "4_plan",
+    name: "PLAN",
+    description: "Decompose before executing",
+    requiredActions: [
+      "Break work into ordered steps (even if small)",
+      "Identify dependencies between steps",
+      "Note which steps are reversible vs. irreversible",
+      'For trivial tasks: "Plan: Single-step execution"'
+    ]
+  },
+  {
+    id: "5_execute",
+    name: "EXECUTE",
+    description: "Implement with discipline",
+    requiredActions: [
+      "Follow the plan step-by-step",
+      "Cite existing patterns in codebase when applicable",
+      "Keep changes minimal and focused - resist scope creep",
+      "Document non-obvious decisions with brief inline comments",
+      "If blocked during execution, update plan rather than improvising"
+    ]
+  },
+  {
+    id: "6_validate",
+    name: "VALIDATE",
+    description: "Verify before delivering - never ship unvalidated work",
+    requiredActions: [
+      "Run verification commands (typecheck, tests, lint)",
+      "State explicitly what WAS validated",
+      "State explicitly what was NOT validated (gaps)",
+      "Note residual risks that remain after validation",
+      "If validation fails, diagnose and fix before reporting"
+    ]
+  },
+  {
+    id: "7_report",
+    name: "REPORT",
+    description: "Structured delivery with full transparency",
+    requiredActions: [
+      "Use the OUTPUT FORMAT structure (see OUTPUT FORMAT section)",
+      "Be concise but complete - no hand-waving",
+      "Include file references with paths for all changes",
+      "Specify concrete follow-up actions if any"
+    ]
+  }
+];
+var PROVER_TEMPLATE = `## MANDATORY REASONING LOOP (PROVER)
+
+For EVERY task, follow this sequence. Skipping steps leads to mistakes.
+
+### 1. INTAKE (before touching code)
+**Purpose**: Understand before acting
+
+- **Restate**: Goal, constraints, success criteria in your own words
+- **Recon**: Read relevant files (cite \`path:line\`) - do NOT hypothesize without evidence
+- **Unknowns**: List assumptions explicitly
+- **Blockers**: If blockers exist, ask 1-3 focused clarifying questions
+
+### 2. RISK SCAN
+**Purpose**: Anticipate failure modes
+
+- Run through your DOMAIN CHECKLIST (see below)
+- Flag high-risk items with [RISK] tag
+- Propose mitigations for critical risks
+- If risks are unacceptable, STOP and discuss
+
+### 3. OPTIONS (skip if truly trivial)
+**Purpose**: Consider alternatives before committing
+
+- Generate 2-3 viable approaches
+- Compare: complexity, performance, risk, maintainability
+- Choose one with explicit rationale
+- Note what was rejected and why
+
+### 4. PLAN
+**Purpose**: Decompose before executing
+
+- Break work into ordered steps
+- Identify dependencies between steps
+- Note reversible vs. irreversible steps
+- For trivial tasks: "Plan: Single-step execution"
+
+### 5. EXECUTE
+**Purpose**: Implement with discipline
+
+- Follow plan step-by-step
+- Cite existing patterns in codebase
+- Keep changes minimal - resist scope creep
+- If blocked, update plan rather than improvising
+
+### 6. VALIDATE
+**Purpose**: Never ship unvalidated work
+
+- Run: typecheck, tests, lint (as applicable)
+- State what WAS validated
+- State what was NOT validated (gaps)
+- If validation fails, fix before reporting
+
+### 7. REPORT
+**Purpose**: Structured delivery
+
+- Use the OUTPUT FORMAT structure
+- Include file paths for all changes
+- Specify follow-up actions
+
+---
+
+**CRITICAL**: If uncertain at any step, ASK rather than assume.
+If proceeding with assumptions, LIST THEM EXPLICITLY.
+`;
+var LITE_STEPS = [
+  {
+    id: "1_understand",
+    name: "UNDERSTAND",
+    description: "Quick comprehension",
+    requiredActions: [
+      "Confirm what needs to be done",
+      "Check relevant file if needed"
+    ]
+  },
+  {
+    id: "2_do",
+    name: "DO",
+    description: "Execute the task",
+    requiredActions: [
+      "Make the change",
+      "Follow existing patterns"
+    ]
+  },
+  {
+    id: "3_verify",
+    name: "VERIFY",
+    description: "Quick validation",
+    requiredActions: [
+      "Run typecheck/tests if applicable",
+      "Note if verification was skipped and why"
+    ]
+  },
+  {
+    id: "4_report",
+    name: "REPORT",
+    description: "Brief summary",
+    requiredActions: [
+      "State what was done",
+      "Note any caveats or follow-ups"
+    ]
+  }
+];
+var LITE_TEMPLATE = `## REASONING LOOP (LITE)
+
+For simple tasks, follow this streamlined process:
+
+### 1. UNDERSTAND
+- Confirm what needs to be done
+- Check relevant file if needed
+
+### 2. DO
+- Make the change
+- Follow existing patterns
+
+### 3. VERIFY
+- Run typecheck/tests if applicable
+- Note if skipped and why
+
+### 4. REPORT
+- State what was done
+- Note any caveats
+
+---
+
+**Escalate to PROVER scaffold if task is more complex than expected.**
+`;
+var SCAFFOLDS = {
+  prover: {
+    id: "prover",
+    name: "PROVER",
+    description: "Full reasoning loop: Plan-Risk-Options-Validate-Execute-Report",
+    steps: PROVER_STEPS,
+    template: PROVER_TEMPLATE
+  },
+  lite: {
+    id: "lite",
+    name: "LITE",
+    description: "Lightweight reasoning: Understand-Do-Verify-Report",
+    steps: LITE_STEPS,
+    template: LITE_TEMPLATE
+  }
+};
+function getReasoningScaffold(type) {
+  const scaffold = SCAFFOLDS[type];
+  if (!scaffold) {
+    throw new Error(`Unknown reasoning scaffold: ${type}`);
+  }
+  return scaffold;
+}
+function getScaffoldTemplate(type) {
+  return getReasoningScaffold(type).template;
+}
+
+// src/agents/cognitive/role-checklists.ts
+init_esm_shims();
+var BACKEND_CHECKLIST = {
+  id: "backend",
+  name: "Backend Checklist",
+  role: "Backend Developer",
+  categories: {
+    security: [
+      { id: "be-sec-1", category: "security", text: "Authentication: Are endpoints properly protected?", severity: "critical", triggers: ["api", "endpoint", "route"] },
+      { id: "be-sec-2", category: "security", text: "Authorization: Is access control enforced (who can do what)?", severity: "critical", triggers: ["user", "role", "permission"] },
+      { id: "be-sec-3", category: "security", text: "Input validation: Are all inputs validated and sanitized?", severity: "critical", triggers: ["input", "request", "body", "params"] },
+      { id: "be-sec-4", category: "security", text: "Secrets: No hardcoded credentials, tokens, or keys?", severity: "critical", triggers: ["config", "env", "secret", "key"] }
+    ],
+    data_integrity: [
+      { id: "be-data-1", category: "data_integrity", text: "Migrations: Are database migrations reversible and safe?", severity: "high", triggers: ["migration", "schema", "database", "table"] },
+      { id: "be-data-2", category: "data_integrity", text: "Transactions: Are operations atomic where needed?", severity: "high", triggers: ["transaction", "update", "insert", "delete"] },
+      { id: "be-data-3", category: "data_integrity", text: "Idempotency: Can operations be safely retried?", severity: "medium", triggers: ["retry", "idempotent", "duplicate"] },
+      { id: "be-data-4", category: "data_integrity", text: "Data validation: Are data constraints enforced at DB level?", severity: "medium", triggers: ["constraint", "schema", "validate"] }
+    ],
+    performance: [
+      { id: "be-perf-1", category: "performance", text: "N+1 queries: Are database calls optimized (no loops of queries)?", severity: "high", triggers: ["query", "loop", "database", "fetch"] },
+      { id: "be-perf-2", category: "performance", text: "Caching: Is caching strategy appropriate for this data?", severity: "medium", triggers: ["cache", "redis", "memory"] },
+      { id: "be-perf-3", category: "performance", text: "Indexing: Are queries using appropriate indexes?", severity: "medium", triggers: ["query", "search", "filter", "where"] },
+      { id: "be-perf-4", category: "performance", text: "Connection pooling: Are database connections managed properly?", severity: "medium", triggers: ["connection", "pool", "database"] }
+    ],
+    reliability: [
+      { id: "be-rel-1", category: "reliability", text: "Error handling: Are errors caught, logged, and handled gracefully?", severity: "high", triggers: ["error", "catch", "exception"] },
+      { id: "be-rel-2", category: "reliability", text: "Retry logic: Is there backoff for transient failures?", severity: "medium", triggers: ["retry", "backoff", "timeout"] },
+      { id: "be-rel-3", category: "reliability", text: "Circuit breakers: Are external service calls protected?", severity: "medium", triggers: ["external", "api", "service", "http"] },
+      { id: "be-rel-4", category: "reliability", text: "Observability: Are metrics, logs, and traces in place?", severity: "medium", triggers: ["log", "metric", "trace", "monitor"] }
+    ]
+  },
+  template: `## DOMAIN CHECKLIST: Backend
+
+Before finalizing, verify each applicable item:
+
+**Security** (CRITICAL)
+- [ ] Authentication: Are endpoints properly protected?
+- [ ] Authorization: Is access control enforced?
+- [ ] Input validation: Are all inputs sanitized?
+- [ ] Secrets: No hardcoded credentials?
+
+**Data Integrity** (HIGH)
+- [ ] Migrations: Reversible and safe?
+- [ ] Transactions: Atomic where needed?
+- [ ] Idempotency: Safe to retry?
+- [ ] Data validation: Constraints enforced?
+
+**Performance** (MEDIUM-HIGH)
+- [ ] N+1 queries: Optimized database calls?
+- [ ] Caching: Appropriate strategy?
+- [ ] Indexing: Queries using indexes?
+- [ ] Connection pooling: Managed properly?
+
+**Reliability** (HIGH)
+- [ ] Error handling: Graceful failures?
+- [ ] Retry logic: Backoff for transient failures?
+- [ ] Circuit breakers: External calls protected?
+- [ ] Observability: Logs, metrics, traces?
+
+Mark items as [x] when verified, or note [N/A] if not applicable.
+Flag any concerns with [RISK].
+`
+};
+var FRONTEND_CHECKLIST = {
+  id: "frontend",
+  name: "Frontend Checklist",
+  role: "Frontend Developer",
+  categories: {
+    accessibility: [
+      { id: "fe-a11y-1", category: "accessibility", text: "Semantic HTML: Are elements properly labeled (headings, landmarks)?", severity: "high", triggers: ["html", "element", "component"] },
+      { id: "fe-a11y-2", category: "accessibility", text: "Keyboard navigation: Is everything navigable without mouse?", severity: "high", triggers: ["button", "link", "interactive", "focus"] },
+      { id: "fe-a11y-3", category: "accessibility", text: "Screen reader: Are ARIA labels and roles correct?", severity: "high", triggers: ["aria", "label", "role"] },
+      { id: "fe-a11y-4", category: "accessibility", text: "Color contrast: Does it meet WCAG AA standards?", severity: "medium", triggers: ["color", "text", "background", "style"] }
+    ],
+    user_experience: [
+      { id: "fe-ux-1", category: "user_experience", text: "Loading states: Are async operations indicated to user?", severity: "high", triggers: ["async", "fetch", "load", "api"] },
+      { id: "fe-ux-2", category: "user_experience", text: "Error states: Are failures communicated clearly?", severity: "high", triggers: ["error", "fail", "catch"] },
+      { id: "fe-ux-3", category: "user_experience", text: "Empty states: Is there guidance when no data exists?", severity: "medium", triggers: ["empty", "no data", "list", "table"] },
+      { id: "fe-ux-4", category: "user_experience", text: "Responsive: Does it work on all screen sizes?", severity: "high", triggers: ["layout", "grid", "flex", "responsive"] }
+    ],
+    performance: [
+      { id: "fe-perf-1", category: "performance", text: "Bundle size: Are imports optimized (no full library imports)?", severity: "medium", triggers: ["import", "library", "package"] },
+      { id: "fe-perf-2", category: "performance", text: "Lazy loading: Are heavy components/routes deferred?", severity: "medium", triggers: ["route", "component", "heavy", "large"] },
+      { id: "fe-perf-3", category: "performance", text: "Memoization: Are expensive renders cached (useMemo, React.memo)?", severity: "medium", triggers: ["render", "memo", "expensive", "computation"] },
+      { id: "fe-perf-4", category: "performance", text: "Images: Are they optimized and lazy-loaded?", severity: "medium", triggers: ["image", "img", "picture", "media"] }
+    ],
+    security: [
+      { id: "fe-sec-1", category: "security", text: "XSS: Is user-generated content sanitized before rendering?", severity: "critical", triggers: ["user", "content", "html", "dangerously"] },
+      { id: "fe-sec-2", category: "security", text: "CSRF: Are forms and state-changing requests protected?", severity: "high", triggers: ["form", "submit", "post", "put", "delete"] },
+      { id: "fe-sec-3", category: "security", text: "Sensitive data: Is PII handled correctly (not logged, masked)?", severity: "high", triggers: ["password", "email", "personal", "sensitive"] },
+      { id: "fe-sec-4", category: "security", text: "Dependencies: No known vulnerable packages?", severity: "medium", triggers: ["dependency", "package", "npm"] }
+    ]
+  },
+  template: `## DOMAIN CHECKLIST: Frontend
+
+Before finalizing, verify each applicable item:
+
+**Accessibility** (HIGH)
+- [ ] Semantic HTML: Proper labels and landmarks?
+- [ ] Keyboard navigation: Works without mouse?
+- [ ] Screen reader: ARIA labels correct?
+- [ ] Color contrast: Meets WCAG AA?
+
+**User Experience** (HIGH)
+- [ ] Loading states: Async operations indicated?
+- [ ] Error states: Failures communicated clearly?
+- [ ] Empty states: Guidance when no data?
+- [ ] Responsive: Works on all screen sizes?
+
+**Performance** (MEDIUM)
+- [ ] Bundle size: Imports optimized?
+- [ ] Lazy loading: Heavy components deferred?
+- [ ] Memoization: Expensive renders cached?
+- [ ] Images: Optimized and lazy-loaded?
+
+**Security** (CRITICAL-HIGH)
+- [ ] XSS: User content sanitized?
+- [ ] CSRF: Forms protected?
+- [ ] Sensitive data: PII handled correctly?
+- [ ] Dependencies: No known vulnerabilities?
+
+Mark items as [x] when verified, or note [N/A] if not applicable.
+Flag any concerns with [RISK].
+`
+};
+var SECURITY_CHECKLIST = {
+  id: "security",
+  name: "Security Checklist",
+  role: "Security Engineer",
+  categories: {
+    threat_model: [
+      { id: "sec-tm-1", category: "threat_model", text: "Attack surface: What can be attacked? (inputs, APIs, data stores)", severity: "critical", triggers: ["api", "input", "endpoint"] },
+      { id: "sec-tm-2", category: "threat_model", text: "Threat actors: Who would attack this? (script kiddies, insiders, nation states)", severity: "high", triggers: ["user", "access", "public"] },
+      { id: "sec-tm-3", category: "threat_model", text: "Assets: What valuable data/access is at risk?", severity: "critical", triggers: ["data", "pii", "credential", "secret"] },
+      { id: "sec-tm-4", category: "threat_model", text: "STRIDE: Spoofing, Tampering, Repudiation, Info Disclosure, DoS, Elevation?", severity: "high", triggers: ["security", "threat", "vulnerability"] }
+    ],
+    owasp_top_10: [
+      { id: "sec-owasp-1", category: "owasp_top_10", text: "Injection: SQL, NoSQL, OS, LDAP injection possible?", severity: "critical", triggers: ["query", "sql", "database", "command"] },
+      { id: "sec-owasp-2", category: "owasp_top_10", text: "Broken Auth: Session management, credential handling secure?", severity: "critical", triggers: ["auth", "login", "session", "token"] },
+      { id: "sec-owasp-3", category: "owasp_top_10", text: "Sensitive Data: Encryption at rest and in transit?", severity: "critical", triggers: ["encrypt", "https", "data", "store"] },
+      { id: "sec-owasp-4", category: "owasp_top_10", text: "XXE: External entity processing disabled?", severity: "high", triggers: ["xml", "parse", "entity"] },
+      { id: "sec-owasp-5", category: "owasp_top_10", text: "Broken Access Control: Privilege escalation possible?", severity: "critical", triggers: ["role", "permission", "admin", "access"] },
+      { id: "sec-owasp-6", category: "owasp_top_10", text: "Misconfiguration: Default settings, errors exposed?", severity: "high", triggers: ["config", "default", "error", "debug"] },
+      { id: "sec-owasp-7", category: "owasp_top_10", text: "XSS: Reflected, stored, DOM-based XSS possible?", severity: "critical", triggers: ["html", "script", "render", "output"] },
+      { id: "sec-owasp-8", category: "owasp_top_10", text: "Deserialization: Untrusted data deserialized safely?", severity: "high", triggers: ["json", "deserialize", "parse", "object"] },
+      { id: "sec-owasp-9", category: "owasp_top_10", text: "Components: Using components with known vulnerabilities?", severity: "high", triggers: ["dependency", "package", "library", "npm"] },
+      { id: "sec-owasp-10", category: "owasp_top_10", text: "Logging: Insufficient monitoring and logging?", severity: "medium", triggers: ["log", "audit", "monitor", "alert"] }
+    ],
+    secrets: [
+      { id: "sec-secret-1", category: "secrets", text: "No hardcoded secrets in code or config files?", severity: "critical", triggers: ["key", "token", "password", "secret"] },
+      { id: "sec-secret-2", category: "secrets", text: "Environment variables for sensitive config?", severity: "high", triggers: ["env", "config", "setting"] },
+      { id: "sec-secret-3", category: "secrets", text: "Secrets rotation policy in place?", severity: "medium", triggers: ["rotate", "expire", "refresh"] },
+      { id: "sec-secret-4", category: "secrets", text: "Audit logging for secret access?", severity: "medium", triggers: ["audit", "access", "log"] }
+    ]
+  },
+  template: `## DOMAIN CHECKLIST: Security
+
+Before finalizing, verify each applicable item:
+
+**Threat Model** (CRITICAL)
+- [ ] Attack surface: What can be attacked?
+- [ ] Threat actors: Who would attack this?
+- [ ] Assets: What valuable data is at risk?
+- [ ] STRIDE: Spoofing, Tampering, Repudiation, Info Disclosure, DoS, Elevation?
+
+**OWASP Top 10** (CRITICAL)
+- [ ] Injection: SQL/NoSQL/OS/LDAP injection possible?
+- [ ] Broken Auth: Session/credential handling secure?
+- [ ] Sensitive Data: Encrypted at rest and in transit?
+- [ ] XXE: External entity processing disabled?
+- [ ] Broken Access Control: Privilege escalation possible?
+- [ ] Misconfiguration: Defaults secured, errors hidden?
+- [ ] XSS: Reflected/stored/DOM XSS prevented?
+- [ ] Deserialization: Untrusted data handled safely?
+- [ ] Components: No known vulnerable dependencies?
+- [ ] Logging: Sufficient monitoring and alerting?
+
+**Secrets Management** (CRITICAL)
+- [ ] No hardcoded secrets in code?
+- [ ] Env vars for sensitive config?
+- [ ] Rotation policy exists?
+- [ ] Audit logging for access?
+
+Mark items as [x] when verified, or note [N/A] if not applicable.
+Flag any concerns with [RISK].
+`
+};
+var QUALITY_CHECKLIST = {
+  id: "quality",
+  name: "Quality Checklist",
+  role: "QA Engineer",
+  categories: {
+    test_scope: [
+      { id: "qa-scope-1", category: "test_scope", text: "Requirements: Are all requirements covered by tests?", severity: "high", triggers: ["requirement", "spec", "feature"] },
+      { id: "qa-scope-2", category: "test_scope", text: "Edge cases: Are boundary conditions tested?", severity: "high", triggers: ["edge", "boundary", "limit", "max", "min"] },
+      { id: "qa-scope-3", category: "test_scope", text: "Error paths: Are failure scenarios tested?", severity: "high", triggers: ["error", "fail", "exception", "invalid"] },
+      { id: "qa-scope-4", category: "test_scope", text: "Integration points: Are interfaces tested?", severity: "medium", triggers: ["api", "interface", "integration", "external"] }
+    ],
+    test_quality: [
+      { id: "qa-qual-1", category: "test_quality", text: "Isolation: Are tests independent (no shared state)?", severity: "high", triggers: ["test", "describe", "it"] },
+      { id: "qa-qual-2", category: "test_quality", text: "Determinism: Do tests pass consistently (no flakiness)?", severity: "high", triggers: ["flaky", "random", "timeout", "intermittent"] },
+      { id: "qa-qual-3", category: "test_quality", text: "Speed: Are tests fast enough for CI feedback loop?", severity: "medium", triggers: ["slow", "timeout", "performance"] },
+      { id: "qa-qual-4", category: "test_quality", text: "Readability: Can failures be diagnosed quickly?", severity: "medium", triggers: ["message", "assert", "expect"] }
+    ],
+    regression: [
+      { id: "qa-reg-1", category: "regression", text: "Existing tests: Do all existing tests still pass?", severity: "critical", triggers: ["change", "modify", "update"] },
+      { id: "qa-reg-2", category: "regression", text: "Coverage: Has test coverage decreased?", severity: "high", triggers: ["coverage", "uncovered", "gap"] },
+      { id: "qa-reg-3", category: "regression", text: "Breaking changes: Are APIs backward compatible?", severity: "high", triggers: ["api", "interface", "contract", "public"] },
+      { id: "qa-reg-4", category: "regression", text: "Performance: Has latency/memory regressed?", severity: "medium", triggers: ["performance", "latency", "memory", "slow"] }
+    ],
+    validation: [
+      { id: "qa-val-1", category: "validation", text: "Reproducibility: Can the bug/behavior be reproduced?", severity: "high", triggers: ["bug", "issue", "reproduce"] },
+      { id: "qa-val-2", category: "validation", text: "Root cause: Is the fix addressing the root cause?", severity: "high", triggers: ["fix", "patch", "resolve"] },
+      { id: "qa-val-3", category: "validation", text: "Side effects: Are there unintended changes?", severity: "medium", triggers: ["change", "affect", "impact"] },
+      { id: "qa-val-4", category: "validation", text: "Documentation: Are test changes documented?", severity: "low", triggers: ["doc", "comment", "readme"] }
+    ]
+  },
+  template: `## DOMAIN CHECKLIST: Quality
+
+Before finalizing, verify each applicable item:
+
+**Test Scope** (HIGH)
+- [ ] Requirements: All requirements covered?
+- [ ] Edge cases: Boundary conditions tested?
+- [ ] Error paths: Failure scenarios tested?
+- [ ] Integration points: Interfaces tested?
+
+**Test Quality** (HIGH)
+- [ ] Isolation: Tests independent (no shared state)?
+- [ ] Determinism: Tests pass consistently?
+- [ ] Speed: Fast enough for CI?
+- [ ] Readability: Failures diagnosable?
+
+**Regression** (CRITICAL)
+- [ ] Existing tests: All still pass?
+- [ ] Coverage: Not decreased?
+- [ ] Breaking changes: APIs compatible?
+- [ ] Performance: No regression?
+
+**Validation** (HIGH)
+- [ ] Reproducibility: Bug reproducible?
+- [ ] Root cause: Fix addresses cause?
+- [ ] Side effects: No unintended changes?
+- [ ] Documentation: Changes documented?
+
+Mark items as [x] when verified, or note [N/A] if not applicable.
+Flag any concerns with [RISK].
+`
+};
+var ARCHITECTURE_CHECKLIST = {
+  id: "architecture",
+  name: "Architecture Checklist",
+  role: "Software Architect",
+  categories: {
+    design: [
+      { id: "arch-des-1", category: "design", text: "Requirements alignment: Does it solve the right problem?", severity: "critical", triggers: ["design", "architecture", "system"] },
+      { id: "arch-des-2", category: "design", text: "Simplicity: Is this the simplest viable solution?", severity: "high", triggers: ["complex", "simple", "pattern"] },
+      { id: "arch-des-3", category: "design", text: "Extensibility: Can it evolve with future needs?", severity: "medium", triggers: ["future", "extend", "scale"] },
+      { id: "arch-des-4", category: "design", text: "Consistency: Does it follow existing patterns?", severity: "high", triggers: ["pattern", "convention", "style"] }
+    ],
+    trade_offs: [
+      { id: "arch-trade-1", category: "trade_offs", text: "Performance vs. complexity trade-off documented?", severity: "high", triggers: ["performance", "complexity", "trade"] },
+      { id: "arch-trade-2", category: "trade_offs", text: "Build vs. buy decision documented?", severity: "medium", triggers: ["build", "buy", "library", "vendor"] },
+      { id: "arch-trade-3", category: "trade_offs", text: "Technology choices justified?", severity: "high", triggers: ["technology", "framework", "language"] },
+      { id: "arch-trade-4", category: "trade_offs", text: "Rejected alternatives documented?", severity: "medium", triggers: ["alternative", "option", "consider"] }
+    ],
+    risk: [
+      { id: "arch-risk-1", category: "risk", text: "Single points of failure identified?", severity: "critical", triggers: ["single", "failure", "dependency"] },
+      { id: "arch-risk-2", category: "risk", text: "Scalability bottlenecks identified?", severity: "high", triggers: ["scale", "bottleneck", "limit"] },
+      { id: "arch-risk-3", category: "risk", text: "Security implications considered?", severity: "critical", triggers: ["security", "auth", "data"] },
+      { id: "arch-risk-4", category: "risk", text: "Operational complexity acceptable?", severity: "medium", triggers: ["ops", "deploy", "maintain"] }
+    ],
+    governance: [
+      { id: "arch-gov-1", category: "governance", text: "ADR created for significant decisions?", severity: "high", triggers: ["decision", "adr", "architecture"] },
+      { id: "arch-gov-2", category: "governance", text: "Stakeholders consulted?", severity: "medium", triggers: ["stakeholder", "team", "review"] },
+      { id: "arch-gov-3", category: "governance", text: "Migration path defined?", severity: "high", triggers: ["migrate", "transition", "phase"] },
+      { id: "arch-gov-4", category: "governance", text: "Rollback strategy exists?", severity: "high", triggers: ["rollback", "revert", "undo"] }
+    ]
+  },
+  template: `## DOMAIN CHECKLIST: Architecture
+
+Before finalizing, verify each applicable item:
+
+**Design** (CRITICAL-HIGH)
+- [ ] Requirements alignment: Solves the right problem?
+- [ ] Simplicity: Simplest viable solution?
+- [ ] Extensibility: Can evolve with future needs?
+- [ ] Consistency: Follows existing patterns?
+
+**Trade-offs** (HIGH)
+- [ ] Performance vs. complexity documented?
+- [ ] Build vs. buy decision documented?
+- [ ] Technology choices justified?
+- [ ] Rejected alternatives documented?
+
+**Risk** (CRITICAL)
+- [ ] Single points of failure identified?
+- [ ] Scalability bottlenecks identified?
+- [ ] Security implications considered?
+- [ ] Operational complexity acceptable?
+
+**Governance** (HIGH)
+- [ ] ADR created for significant decisions?
+- [ ] Stakeholders consulted?
+- [ ] Migration path defined?
+- [ ] Rollback strategy exists?
+
+Mark items as [x] when verified, or note [N/A] if not applicable.
+Flag any concerns with [RISK].
+`
+};
+var DEVOPS_CHECKLIST = {
+  id: "devops",
+  name: "DevOps Checklist",
+  role: "DevOps Engineer",
+  categories: {
+    deployment: [
+      { id: "devops-dep-1", category: "deployment", text: "Zero-downtime: Can deploy without service interruption?", severity: "high", triggers: ["deploy", "release", "rollout"] },
+      { id: "devops-dep-2", category: "deployment", text: "Rollback: Can quickly revert if issues arise?", severity: "critical", triggers: ["rollback", "revert", "fail"] },
+      { id: "devops-dep-3", category: "deployment", text: "Configuration: Env-specific configs separated from code?", severity: "high", triggers: ["config", "env", "environment"] },
+      { id: "devops-dep-4", category: "deployment", text: "Secrets: Managed securely (not in code/config)?", severity: "critical", triggers: ["secret", "key", "credential"] }
+    ],
+    infrastructure: [
+      { id: "devops-infra-1", category: "infrastructure", text: "IaC: Infrastructure defined as code?", severity: "high", triggers: ["infrastructure", "terraform", "kubernetes"] },
+      { id: "devops-infra-2", category: "infrastructure", text: "Scaling: Auto-scaling configured correctly?", severity: "high", triggers: ["scale", "auto", "capacity"] },
+      { id: "devops-infra-3", category: "infrastructure", text: "Resources: CPU/memory limits appropriate?", severity: "medium", triggers: ["resource", "memory", "cpu", "limit"] },
+      { id: "devops-infra-4", category: "infrastructure", text: "Networking: Security groups and firewalls configured?", severity: "high", triggers: ["network", "firewall", "security group"] }
+    ],
+    observability: [
+      { id: "devops-obs-1", category: "observability", text: "Logging: Structured logs with correlation IDs?", severity: "high", triggers: ["log", "logging", "trace"] },
+      { id: "devops-obs-2", category: "observability", text: "Metrics: Key metrics exposed and collected?", severity: "high", triggers: ["metric", "prometheus", "grafana"] },
+      { id: "devops-obs-3", category: "observability", text: "Alerting: Alerts configured for critical conditions?", severity: "high", triggers: ["alert", "notify", "oncall"] },
+      { id: "devops-obs-4", category: "observability", text: "Dashboards: Visibility into system health?", severity: "medium", triggers: ["dashboard", "monitor", "visualize"] }
+    ],
+    reliability: [
+      { id: "devops-rel-1", category: "reliability", text: "Health checks: Liveness and readiness probes configured?", severity: "high", triggers: ["health", "probe", "check"] },
+      { id: "devops-rel-2", category: "reliability", text: "Disaster recovery: Backup and restore tested?", severity: "critical", triggers: ["backup", "restore", "disaster"] },
+      { id: "devops-rel-3", category: "reliability", text: "Failover: Multi-region/AZ redundancy?", severity: "high", triggers: ["failover", "redundancy", "region", "availability"] },
+      { id: "devops-rel-4", category: "reliability", text: "Runbooks: Incident response procedures documented?", severity: "medium", triggers: ["runbook", "incident", "procedure"] }
+    ]
+  },
+  template: `## DOMAIN CHECKLIST: DevOps
+
+Before finalizing, verify each applicable item:
+
+**Deployment** (CRITICAL-HIGH)
+- [ ] Zero-downtime: Deploy without interruption?
+- [ ] Rollback: Can quickly revert?
+- [ ] Configuration: Env-specific configs separated?
+- [ ] Secrets: Managed securely?
+
+**Infrastructure** (HIGH)
+- [ ] IaC: Infrastructure as code?
+- [ ] Scaling: Auto-scaling configured?
+- [ ] Resources: CPU/memory limits appropriate?
+- [ ] Networking: Security groups configured?
+
+**Observability** (HIGH)
+- [ ] Logging: Structured with correlation IDs?
+- [ ] Metrics: Key metrics collected?
+- [ ] Alerting: Critical alerts configured?
+- [ ] Dashboards: System health visible?
+
+**Reliability** (CRITICAL-HIGH)
+- [ ] Health checks: Probes configured?
+- [ ] Disaster recovery: Backup/restore tested?
+- [ ] Failover: Multi-region redundancy?
+- [ ] Runbooks: Incident procedures documented?
+
+Mark items as [x] when verified, or note [N/A] if not applicable.
+Flag any concerns with [RISK].
+`
+};
+var DATA_CHECKLIST = {
+  id: "data",
+  name: "Data Checklist",
+  role: "Data Engineer",
+  categories: {
+    data_quality: [
+      { id: "data-qual-1", category: "data_quality", text: "Schema validation: Data conforms to expected schema?", severity: "high", triggers: ["schema", "type", "validate"] },
+      { id: "data-qual-2", category: "data_quality", text: "Null handling: Missing values handled appropriately?", severity: "high", triggers: ["null", "missing", "empty"] },
+      { id: "data-qual-3", category: "data_quality", text: "Duplicates: Deduplication strategy in place?", severity: "medium", triggers: ["duplicate", "unique", "distinct"] },
+      { id: "data-qual-4", category: "data_quality", text: "Freshness: Data SLAs defined and monitored?", severity: "medium", triggers: ["fresh", "stale", "latency", "sla"] }
+    ],
+    pipeline: [
+      { id: "data-pipe-1", category: "pipeline", text: "Idempotency: Pipeline can be safely re-run?", severity: "high", triggers: ["pipeline", "etl", "process"] },
+      { id: "data-pipe-2", category: "pipeline", text: "Error handling: Failed records captured for review?", severity: "high", triggers: ["error", "fail", "dead letter"] },
+      { id: "data-pipe-3", category: "pipeline", text: "Backfill: Historical data can be reprocessed?", severity: "medium", triggers: ["backfill", "historical", "reprocess"] },
+      { id: "data-pipe-4", category: "pipeline", text: "Monitoring: Pipeline health and progress visible?", severity: "high", triggers: ["monitor", "alert", "status"] }
+    ],
+    governance: [
+      { id: "data-gov-1", category: "governance", text: "Lineage: Data origin and transformations documented?", severity: "medium", triggers: ["lineage", "origin", "source"] },
+      { id: "data-gov-2", category: "governance", text: "Privacy: PII identified and protected?", severity: "critical", triggers: ["pii", "privacy", "gdpr", "personal"] },
+      { id: "data-gov-3", category: "governance", text: "Retention: Data lifecycle and deletion policies?", severity: "high", triggers: ["retention", "delete", "archive"] },
+      { id: "data-gov-4", category: "governance", text: "Access control: Data access properly restricted?", severity: "high", triggers: ["access", "permission", "role"] }
+    ],
+    performance: [
+      { id: "data-perf-1", category: "performance", text: "Partitioning: Data partitioned for query efficiency?", severity: "high", triggers: ["partition", "query", "large"] },
+      { id: "data-perf-2", category: "performance", text: "Indexing: Appropriate indexes for access patterns?", severity: "high", triggers: ["index", "search", "filter"] },
+      { id: "data-perf-3", category: "performance", text: "Compression: Storage optimized with compression?", severity: "medium", triggers: ["compress", "storage", "size"] },
+      { id: "data-perf-4", category: "performance", text: "Caching: Frequently accessed data cached?", severity: "medium", triggers: ["cache", "frequent", "hot"] }
+    ]
+  },
+  template: `## DOMAIN CHECKLIST: Data
+
+Before finalizing, verify each applicable item:
+
+**Data Quality** (HIGH)
+- [ ] Schema validation: Conforms to expected schema?
+- [ ] Null handling: Missing values handled?
+- [ ] Duplicates: Deduplication in place?
+- [ ] Freshness: Data SLAs defined?
+
+**Pipeline** (HIGH)
+- [ ] Idempotency: Safe to re-run?
+- [ ] Error handling: Failed records captured?
+- [ ] Backfill: Historical reprocessing possible?
+- [ ] Monitoring: Pipeline health visible?
+
+**Governance** (CRITICAL-HIGH)
+- [ ] Lineage: Origin and transforms documented?
+- [ ] Privacy: PII identified and protected?
+- [ ] Retention: Lifecycle policies defined?
+- [ ] Access control: Properly restricted?
+
+**Performance** (HIGH)
+- [ ] Partitioning: Query-efficient partitions?
+- [ ] Indexing: Appropriate indexes?
+- [ ] Compression: Storage optimized?
+- [ ] Caching: Hot data cached?
+
+Mark items as [x] when verified, or note [N/A] if not applicable.
+Flag any concerns with [RISK].
+`
+};
+var PRODUCT_CHECKLIST = {
+  id: "product",
+  name: "Product Checklist",
+  role: "Product Manager",
+  categories: {
+    requirements: [
+      { id: "prod-req-1", category: "requirements", text: "User problem: Is the problem clearly defined?", severity: "critical", triggers: ["user", "problem", "pain"] },
+      { id: "prod-req-2", category: "requirements", text: "Success criteria: How will we measure success?", severity: "high", triggers: ["success", "metric", "kpi"] },
+      { id: "prod-req-3", category: "requirements", text: "Scope: Is scope clearly bounded?", severity: "high", triggers: ["scope", "feature", "requirement"] },
+      { id: "prod-req-4", category: "requirements", text: 'Acceptance criteria: What defines "done"?', severity: "high", triggers: ["done", "accept", "criteria"] }
+    ],
+    stakeholders: [
+      { id: "prod-stake-1", category: "stakeholders", text: "Alignment: Key stakeholders aligned on approach?", severity: "high", triggers: ["stakeholder", "team", "align"] },
+      { id: "prod-stake-2", category: "stakeholders", text: "Dependencies: Cross-team dependencies identified?", severity: "medium", triggers: ["dependency", "team", "coordinate"] },
+      { id: "prod-stake-3", category: "stakeholders", text: "Communication: Rollout communication planned?", severity: "medium", triggers: ["communicate", "announce", "rollout"] },
+      { id: "prod-stake-4", category: "stakeholders", text: "Feedback: User feedback collection planned?", severity: "medium", triggers: ["feedback", "user", "research"] }
+    ],
+    delivery: [
+      { id: "prod-del-1", category: "delivery", text: "Timeline: Realistic timeline established?", severity: "high", triggers: ["timeline", "deadline", "schedule"] },
+      { id: "prod-del-2", category: "delivery", text: "Risks: Key risks identified and mitigated?", severity: "high", triggers: ["risk", "blocker", "issue"] },
+      { id: "prod-del-3", category: "delivery", text: "MVP: Minimum viable scope defined?", severity: "high", triggers: ["mvp", "minimum", "viable"] },
+      { id: "prod-del-4", category: "delivery", text: "Rollback: Can we undo if issues arise?", severity: "medium", triggers: ["rollback", "undo", "revert"] }
+    ]
+  },
+  template: `## DOMAIN CHECKLIST: Product
+
+Before finalizing, verify each applicable item:
+
+**Requirements** (CRITICAL-HIGH)
+- [ ] User problem: Problem clearly defined?
+- [ ] Success criteria: How measured?
+- [ ] Scope: Clearly bounded?
+- [ ] Acceptance criteria: What defines "done"?
+
+**Stakeholders** (HIGH-MEDIUM)
+- [ ] Alignment: Key stakeholders aligned?
+- [ ] Dependencies: Cross-team deps identified?
+- [ ] Communication: Rollout planned?
+- [ ] Feedback: Collection planned?
+
+**Delivery** (HIGH)
+- [ ] Timeline: Realistic?
+- [ ] Risks: Identified and mitigated?
+- [ ] MVP: Minimum scope defined?
+- [ ] Rollback: Can undo if needed?
+
+Mark items as [x] when verified, or note [N/A] if not applicable.
+Flag any concerns with [RISK].
+`
+};
+var NONE_CHECKLIST = {
+  id: "none",
+  name: "No Checklist",
+  role: "General",
+  categories: {},
+  template: ""
+};
+var CHECKLISTS = {
+  backend: BACKEND_CHECKLIST,
+  frontend: FRONTEND_CHECKLIST,
+  security: SECURITY_CHECKLIST,
+  quality: QUALITY_CHECKLIST,
+  architecture: ARCHITECTURE_CHECKLIST,
+  devops: DEVOPS_CHECKLIST,
+  data: DATA_CHECKLIST,
+  product: PRODUCT_CHECKLIST,
+  none: NONE_CHECKLIST
+};
+function getRoleChecklist(type) {
+  const checklist = CHECKLISTS[type];
+  if (!checklist) {
+    throw new Error(`Unknown checklist type: ${type}`);
+  }
+  return checklist;
+}
+function getChecklistTemplate(type) {
+  return getRoleChecklist(type).template;
+}
+function applyChecklistOverrides(type, overrides) {
+  let template = getChecklistTemplate(type);
+  if (overrides.remove && overrides.remove.length > 0) {
+    for (const item of overrides.remove) {
+      const regex = new RegExp(`^- \\[ \\] .*${item}.*$`, "gm");
+      template = template.replace(regex, "");
+    }
+    template = template.replace(/\n\n+/g, "\n\n");
+  }
+  if (overrides.add && overrides.add.length > 0) {
+    const customSection = `
+**Custom Checks**
+${overrides.add.map((item) => `- [ ] ${item}`).join("\n")}
+`;
+    template = template.replace(/Mark items as \[x\]/, customSection + "\nMark items as [x]");
+  }
+  return template;
+}
+
+// src/agents/cognitive/output-contracts.ts
+init_esm_shims();
+var STANDARD_SECTIONS = [
+  {
+    name: "Context",
+    required: true,
+    description: "What was understood about the task",
+    format: `**Context**
+- Goal: [restated objective in your own words]
+- Constraints: [key limitations or requirements]
+- Assumptions: [what was assumed - be explicit]`
+  },
+  {
+    name: "Plan",
+    required: true,
+    description: "What will be/was done",
+    format: `**Plan**
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+...
+(For trivial tasks: "Plan: Single-step execution")`
+  },
+  {
+    name: "Actions",
+    required: true,
+    description: "What was actually done",
+    format: `**Actions**
+- [Action 1]: \`path/to/file.ts:line\` - [brief description]
+- [Action 2]: \`path/to/file.ts:line\` - [brief description]
+- [Command run]: \`pnpm test\` - [result summary]
+...`
+  },
+  {
+    name: "Verification",
+    required: true,
+    description: "How the work was validated",
+    format: `**Verification**
+- Validated:
+  - [x] [What was tested/checked]
+  - [x] [Another validation]
+- Commands run:
+  - \`pnpm typecheck\` - [result]
+  - \`pnpm test path/to/test\` - [result]
+- Gaps (not validated):
+  - [ ] [What was NOT tested and why]`
+  },
+  {
+    name: "Risks",
+    required: true,
+    description: "What could go wrong or needs attention",
+    format: `**Risks**
+- [Risk 1]: [SEVERITY: LOW/MEDIUM/HIGH/CRITICAL] - [mitigation or note]
+- [Risk 2]: [SEVERITY] - [mitigation or note]
+(If none: "Risks: None identified for this change")`
+  },
+  {
+    name: "Next Steps",
+    required: true,
+    description: "What should happen after this",
+    format: `**Next Steps**
+- [ ] [Recommended action 1]
+- [ ] [Recommended action 2]
+(If complete: "Next Steps: Ready for review/merge")`
+  }
+];
+var FAILURE_SECTIONS = [
+  {
+    name: "Failure",
+    required: true,
+    description: "What failed and why",
+    format: `**Failure**
+- What failed: [description of the failure]
+- Root cause: [analysis of why it failed]
+- Attempted recovery: [what was tried to fix it]
+- Blocked: [yes/no] - [what's needed to proceed]`
+  }
+];
+var STANDARD_CONTRACT = {
+  id: "standard",
+  name: "Standard Output",
+  description: "Full structured output with all sections for complete transparency",
+  sections: STANDARD_SECTIONS,
+  failureSections: FAILURE_SECTIONS,
+  template: `## OUTPUT FORMAT
+
+Structure your response with these sections:
+
+**Context**
+- Goal: [restated objective]
+- Constraints: [key limitations]
+- Assumptions: [what was assumed]
+
+**Plan**
+1. [Step 1]
+2. [Step 2]
+(For trivial tasks: "Plan: Single-step execution")
+
+**Actions**
+- [Action]: \`path/to/file.ts:line\` - [description]
+- [Command]: \`command\` - [result]
+
+**Verification**
+- Validated:
+  - [x] [What was tested]
+- Commands: \`pnpm typecheck\`, \`pnpm test\`
+- Gaps: [What was NOT tested]
+
+**Risks**
+- [Risk]: [SEVERITY] - [mitigation]
+(If none: "Risks: None identified")
+
+**Next Steps**
+- [ ] [Action item]
+(If complete: "Ready for review")
+
+---
+
+**If something fails, add:**
+
+**Failure**
+- What failed: [description]
+- Root cause: [analysis]
+- Attempted recovery: [what was tried]
+- Blocked: [yes/no, what's needed]
+`
+};
+var MINIMAL_SECTIONS = [
+  {
+    name: "Done",
+    required: true,
+    description: "What was done",
+    format: `**Done**
+- [Action]: \`file:line\``
+  },
+  {
+    name: "Verified",
+    required: true,
+    description: "How it was verified",
+    format: `**Verified**: [command or check]`
+  },
+  {
+    name: "Note",
+    required: false,
+    description: "Any important notes",
+    format: `**Note**: [anything important]`
+  }
+];
+var MINIMAL_CONTRACT = {
+  id: "minimal",
+  name: "Minimal Output",
+  description: "Condensed output for simple tasks",
+  sections: MINIMAL_SECTIONS,
+  template: `## OUTPUT FORMAT (MINIMAL)
+
+For simple tasks, use this condensed format:
+
+**Done**
+- [Action]: \`file:line\`
+
+**Verified**: [command or "visual check"]
+
+**Note**: [anything important, or omit if none]
+`
+};
+var DETAILED_SECTIONS = [
+  ...STANDARD_SECTIONS,
+  {
+    name: "Options Considered",
+    required: false,
+    description: "Alternatives that were evaluated",
+    format: `**Options Considered**
+| Option | Pros | Cons | Why Chosen/Rejected |
+|--------|------|------|---------------------|
+| [Option 1] | [pros] | [cons] | [rationale] |
+| [Option 2] | [pros] | [cons] | [rationale] |`
+  },
+  {
+    name: "Dependencies",
+    required: false,
+    description: "Dependencies and related changes",
+    format: `**Dependencies**
+- Upstream: [what this depends on]
+- Downstream: [what depends on this]
+- Related: [related tickets/PRs]`
+  },
+  {
+    name: "Rollback Plan",
+    required: false,
+    description: "How to undo if needed",
+    format: `**Rollback Plan**
+1. [Step to revert]
+2. [Step to verify revert]`
+  }
+];
+var DETAILED_CONTRACT = {
+  id: "detailed",
+  name: "Detailed Output",
+  description: "Extended output for complex tasks requiring more documentation",
+  sections: DETAILED_SECTIONS,
+  failureSections: FAILURE_SECTIONS,
+  template: `## OUTPUT FORMAT (DETAILED)
+
+For complex tasks, use this extended format:
+
+**Context**
+- Goal: [restated objective]
+- Constraints: [key limitations]
+- Assumptions: [what was assumed]
+
+**Options Considered** (if applicable)
+| Option | Pros | Cons | Decision |
+|--------|------|------|----------|
+| [Option 1] | [pros] | [cons] | [Chosen/Rejected: why] |
+
+**Plan**
+1. [Step 1]
+2. [Step 2]
+
+**Actions**
+- [Action]: \`path/to/file.ts:line\` - [description]
+- [Command]: \`command\` - [result]
+
+**Verification**
+- Validated:
+  - [x] [What was tested]
+- Commands: \`pnpm typecheck\`, \`pnpm test\`
+- Gaps: [What was NOT tested]
+
+**Dependencies** (if applicable)
+- Upstream: [what this depends on]
+- Downstream: [what depends on this]
+
+**Risks**
+- [Risk]: [SEVERITY] - [mitigation]
+
+**Rollback Plan** (if applicable)
+1. [How to undo]
+
+**Next Steps**
+- [ ] [Action item]
+`
+};
+var CONTRACTS = {
+  standard: STANDARD_CONTRACT,
+  minimal: MINIMAL_CONTRACT,
+  detailed: DETAILED_CONTRACT
+};
+function getOutputContract(type) {
+  const contract = CONTRACTS[type];
+  if (!contract) {
+    throw new Error(`Unknown output contract: ${type}`);
+  }
+  return contract;
+}
+function getContractTemplate(type) {
+  return getOutputContract(type).template;
+}
+
+// src/agents/cognitive/uncertainty-protocol.ts
+init_esm_shims();
+var ASK_FIRST_PROTOCOL = {
+  id: "ask_first",
+  name: "Ask First",
+  askWhen: [
+    "Requirements are ambiguous or could be interpreted multiple ways",
+    "Security or data implications require explicit authorization",
+    "Change scope significantly exceeds the original request",
+    "Irreversible actions are required (delete, migrate, deploy to production)",
+    "You need access to resources, credentials, or information not available",
+    "Multiple valid approaches exist and user preference is unknown",
+    "The task involves user-facing changes where UX matters",
+    "You are making assumptions about business logic"
+  ],
+  proceedWhen: [
+    "The request is completely unambiguous",
+    "You are applying a well-documented standard or best practice",
+    "The change is trivial and easily reversible"
+  ],
+  assumptionFormat: `**Clarification Needed**
+
+Before proceeding, I need to clarify:
+
+1. [Question 1 - be specific about what you need to know]
+2. [Question 2 - if applicable]
+
+This will help ensure I deliver exactly what you need.`,
+  template: `## UNCERTAINTY HANDLING (ASK FIRST)
+
+**Default behavior**: Ask for clarification when uncertain.
+
+**Ask when** (any of these apply):
+- Requirements could be interpreted multiple ways
+- Security or data implications exist
+- Change scope exceeds original request
+- Irreversible actions required
+- Multiple valid approaches exist
+- Business logic assumptions needed
+
+**Only proceed without asking when**:
+- Request is completely unambiguous
+- Applying documented standard/best practice
+- Change is trivial and reversible
+
+**When asking, use this format:**
+
+**Clarification Needed**
+
+Before proceeding, I need to clarify:
+
+1. [Specific question]
+2. [Specific question if needed]
+
+This ensures I deliver exactly what you need.
+
+---
+
+**Confidence Tagging**: Tag recommendations with confidence level.
+- **[HIGH]**: Well-established pattern, verified approach
+- **[MEDIUM]**: Reasonable approach, some assumptions
+- **[LOW]**: Exploratory, needs validation
+`
+};
+var PROCEED_PROTOCOL = {
+  id: "proceed_with_assumptions",
+  name: "Proceed With Assumptions",
+  askWhen: [
+    "Security-critical decisions require explicit authorization",
+    "Irreversible actions that cannot be undone (data deletion, production deploy)",
+    "Change would break existing functionality or APIs",
+    "You are completely blocked and cannot make progress"
+  ],
+  proceedWhen: [
+    "Best practice clearly applies to the situation",
+    "Change is safely reversible (can be undone easily)",
+    "Scope is well-defined and bounded",
+    "Similar patterns exist in the codebase",
+    "You can make reasonable assumptions based on context",
+    "The risk of proceeding is low"
+  ],
+  assumptionFormat: `**Assumptions Made**
+
+I proceeded with these assumptions:
+- [Assumption 1]: [rationale for this assumption]
+- [Assumption 2]: [rationale]
+
+If any are incorrect, let me know and I'll adjust.`,
+  template: `## UNCERTAINTY HANDLING (PROCEED WITH ASSUMPTIONS)
+
+**Default behavior**: Proceed and document assumptions.
+
+**Only stop and ask when**:
+- Security-critical decisions need authorization
+- Irreversible actions that cannot be undone
+- Change would break existing functionality
+- Completely blocked with no path forward
+
+**Proceed (with documented assumptions) when**:
+- Best practice clearly applies
+- Change is safely reversible
+- Similar patterns exist in codebase
+- Reasonable assumptions can be made
+- Risk of proceeding is low
+
+**When proceeding with assumptions:**
+
+**Assumptions Made**
+
+I proceeded with these assumptions:
+- [Assumption 1]: [rationale]
+- [Assumption 2]: [rationale]
+
+If any are incorrect, let me know and I'll adjust.
+
+---
+
+**Confidence Tagging**: Tag recommendations with confidence level.
+- **[HIGH]**: Well-established pattern, verified approach
+- **[MEDIUM]**: Reasonable approach, some assumptions
+- **[LOW]**: Exploratory, needs validation
+`
+};
+var BALANCED_PROTOCOL = {
+  id: "balanced",
+  name: "Balanced",
+  askWhen: [
+    "Security implications exist (auth, data access, secrets)",
+    "Data integrity could be affected (migrations, deletions, updates)",
+    "Irreversible actions are involved",
+    "User explicitly requested confirmation before changes",
+    "Multiple fundamentally different approaches exist",
+    "You are unsure which of several options the user would prefer",
+    "The scope is larger than expected (> 2x original estimate)"
+  ],
+  proceedWhen: [
+    "Clear best practice applies",
+    "Change is low-risk and reversible",
+    "You have high confidence in the approach",
+    "Similar pattern exists in codebase",
+    "Scope is well-defined and matches expectations",
+    "Edge cases are handled or documented"
+  ],
+  assumptionFormat: `**Assumptions**
+- [Assumption]: [brief rationale]
+
+Proceeding with the above assumptions. Correct me if any are wrong.`,
+  template: `## UNCERTAINTY HANDLING (BALANCED)
+
+**Default behavior**: Use risk-based judgment.
+
+**Stop and ask when** (HIGH RISK):
+- Security implications (auth, data, secrets)
+- Data integrity at risk (migrations, deletions)
+- Irreversible actions involved
+- User requested confirmation
+- Scope significantly larger than expected
+- Multiple fundamentally different approaches
+
+**Proceed with documented assumptions when** (LOW RISK):
+- Clear best practice applies
+- Change is low-risk and reversible
+- High confidence in approach
+- Similar pattern in codebase
+- Scope matches expectations
+
+**When proceeding with assumptions:**
+
+**Assumptions**
+- [Assumption]: [brief rationale]
+
+Proceeding with the above. Correct me if any are wrong.
+
+---
+
+**Risk Assessment Quick Check**:
+Before deciding to ask vs proceed, consider:
+1. What's the worst case if I'm wrong? (severity)
+2. How likely is it that I'm wrong? (probability)
+3. Can it be easily undone? (reversibility)
+
+If severity HIGH or probability HIGH and reversibility LOW \u2192 ASK
+Otherwise \u2192 PROCEED with documented assumptions
+
+---
+
+**Confidence Tagging**: Tag recommendations with confidence level.
+- **[HIGH]**: Well-established pattern, verified approach
+- **[MEDIUM]**: Reasonable approach, some assumptions
+- **[LOW]**: Exploratory, needs validation
+`
+};
+var PROTOCOLS = {
+  ask_first: ASK_FIRST_PROTOCOL,
+  proceed_with_assumptions: PROCEED_PROTOCOL,
+  balanced: BALANCED_PROTOCOL
+};
+function getUncertaintyProtocol(mode) {
+  const protocol = PROTOCOLS[mode];
+  if (!protocol) {
+    throw new Error(`Unknown uncertainty mode: ${mode}`);
+  }
+  return protocol;
+}
+function getProtocolTemplate(mode) {
+  return getUncertaintyProtocol(mode).template;
+}
+
+// src/agents/cognitive/prompt-composer.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function cleanPersonaSection(basePrompt) {
+  let cleaned = basePrompt;
+  cleaned = cleaned.replace(
+    /Your thinking patterns:[\s\S]*?(?=\n\n|\n##|\n\*\*[A-Z]|$)/gi,
+    ""
+  );
+  cleaned = cleaned.replace(
+    /Thinking patterns:[\s\S]*?(?=\n\n|\n##|\n\*\*[A-Z]|$)/gi,
+    ""
+  );
+  cleaned = cleaned.replace(
+    /## Thinking Patterns[\s\S]*?(?=\n##|$)/gi,
+    ""
+  );
+  const lines = cleaned.split("\n");
+  const seenCommunicationStyle = /* @__PURE__ */ new Set();
+  const dedupedLines = lines.filter((line) => {
+    if (line.trim().startsWith("Communication style:")) {
+      const key = line.trim();
+      if (seenCommunicationStyle.has(key)) {
+        return false;
+      }
+      seenCommunicationStyle.add(key);
+    }
+    return true;
+  });
+  cleaned = dedupedLines.join("\n");
+  cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+  return cleaned.trim();
+}
+function formatRepoContext(context) {
+  const lines = ["**Repository Context**"];
+  if (context.packageManager) {
+    lines.push(`- Package manager: ${context.packageManager}`);
+  }
+  if (context.moduleSystem) {
+    lines.push(`- Module system: ${context.moduleSystem}`);
+  }
+  if (context.testFramework) {
+    lines.push(`- Test framework: ${context.testFramework}`);
+  }
+  if (context.tempDir) {
+    lines.push(`- Temp directory: ${context.tempDir}`);
+  }
+  if (context.rules && context.rules.length > 0) {
+    lines.push("- Additional rules:");
+    for (const rule of context.rules) {
+      lines.push(`  - ${rule}`);
+    }
+  }
+  return lines.join("\n");
+}
+function composePrompt(options) {
+  const { basePrompt, config, additionalContext, repoContext } = options;
+  const sections = [];
+  const personaSection = cleanPersonaSection(basePrompt);
+  if (personaSection) {
+    sections.push(personaSection);
+  }
+  if (repoContext) {
+    sections.push(formatRepoContext(repoContext));
+  }
+  if (additionalContext) {
+    sections.push(additionalContext);
+  }
+  const scaffoldTemplate = getScaffoldTemplate(config.scaffold);
+  sections.push(scaffoldTemplate);
+  if (config.checklist !== "none") {
+    let checklistTemplate = getChecklistTemplate(config.checklist);
+    if (config.checklistOverrides) {
+      checklistTemplate = applyChecklistOverrides(config.checklist, config.checklistOverrides);
+    }
+    if (config.customChecklist && config.customChecklist.length > 0) {
+      const customSection = `
+**Custom Checks**
+${config.customChecklist.map((item) => `- [ ] ${item}`).join("\n")}
+`;
+      checklistTemplate = checklistTemplate.replace(
+        /Mark items as \[x\]/,
+        customSection + "\nMark items as [x]"
+      );
+    }
+    sections.push(checklistTemplate);
+  }
+  const contractTemplate = getContractTemplate(config.outputContract);
+  sections.push(contractTemplate);
+  const protocolTemplate = getProtocolTemplate(config.uncertaintyMode);
+  sections.push(protocolTemplate);
+  const fullText = sections.join("\n\n---\n\n");
+  return {
+    text: fullText,
+    components: {
+      persona: !!personaSection,
+      scaffold: config.scaffold,
+      checklist: config.checklist,
+      outputContract: config.outputContract,
+      uncertainty: config.uncertaintyMode
+    },
+    estimatedTokens: estimateTokens(fullText)
+  };
+}
+var AUTOMATOSX_REPO_CONTEXT = {
+  packageManager: "pnpm",
+  moduleSystem: "ESM (strict, with .js extensions)",
+  testFramework: "Vitest",
+  tempDir: "automatosx/tmp/",
+  rules: [
+    "Use explicit .js extensions in imports",
+    "Store temporary files in automatosx/tmp/",
+    "Store PRD files in automatosx/PRD/",
+    "Follow existing patterns in codebase"
+  ]
+};
+
+// src/types/cognitive.ts
+init_esm_shims();
+var DEFAULT_COGNITIVE_CONFIG = {
+  scaffold: "prover",
+  checklist: "none",
+  outputContract: "standard",
+  uncertaintyMode: "balanced"
+};
+
 // src/agents/profile-loader.ts
 var ProfileLoader = class {
   profilesDir;
@@ -17487,6 +19728,75 @@ var ProfileLoader = class {
     }
     return void 0;
   }
+  /**
+   * Compose cognitive prompt for an agent
+   * v13.0.0+: Assembles the full prompt with reasoning scaffold, checklist, etc.
+   *
+   * @param agentName - Agent name or displayName
+   * @param overrideConfig - Optional config overrides
+   * @returns Composed prompt with all cognitive framework components
+   */
+  async composeAgentPrompt(agentName, overrideConfig) {
+    const profile = await this.loadProfile(agentName);
+    let config = profile.cognitiveFramework ? { ...profile.cognitiveFramework } : this.inferCognitiveConfig(profile);
+    if (overrideConfig) {
+      config = { ...config, ...overrideConfig };
+    }
+    const composed = composePrompt({
+      basePrompt: profile.systemPrompt,
+      config,
+      repoContext: AUTOMATOSX_REPO_CONTEXT
+    });
+    logger.debug("Composed cognitive prompt", {
+      agent: agentName,
+      scaffold: config.scaffold,
+      checklist: config.checklist,
+      outputContract: config.outputContract,
+      estimatedTokens: composed.estimatedTokens
+    });
+    return composed;
+  }
+  /**
+   * Infer cognitive config from agent profile when not explicitly specified
+   * v13.0.0+: Smart defaults based on agent role and abilities
+   */
+  inferCognitiveConfig(profile) {
+    const role = profile.role.toLowerCase();
+    const name = profile.name.toLowerCase();
+    let checklist = "none";
+    if (role.includes("backend") || name === "backend" || role.includes("api")) {
+      checklist = "backend";
+    } else if (role.includes("frontend") || name === "frontend" || role.includes("ui")) {
+      checklist = "frontend";
+    } else if (role.includes("security") || name === "security") {
+      checklist = "security";
+    } else if (role.includes("qa") || role.includes("quality") || name === "quality" || role.includes("test")) {
+      checklist = "quality";
+    } else if (role.includes("architect") || name === "architecture") {
+      checklist = "architecture";
+    } else if (role.includes("devops") || name === "devops" || role.includes("infrastructure")) {
+      checklist = "devops";
+    } else if (role.includes("data") || name === "data" || role.includes("pipeline")) {
+      checklist = "data";
+    } else if (role.includes("product") || name === "product") {
+      checklist = "product";
+    }
+    return {
+      ...DEFAULT_COGNITIVE_CONFIG,
+      checklist
+    };
+  }
+  /**
+   * Get the composed system prompt for an agent
+   * v13.0.0+: Convenience method that returns just the prompt text
+   *
+   * @param agentName - Agent name or displayName
+   * @returns Full composed prompt text
+   */
+  async getComposedPrompt(agentName) {
+    const composed = await this.composeAgentPrompt(agentName);
+    return composed.text;
+  }
 };
 
 // src/agents/abilities-manager.ts
@@ -20582,6 +22892,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();
@@ -20619,16 +22947,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;
       }
     }
   }
@@ -23218,8 +25539,8 @@ var BugDetector = class {
   async loadRulesFromFile(filePath) {
     try {
       const content = await readFile(filePath, "utf-8");
-      const yaml2 = await import('js-yaml');
-      const parsed = yaml2.load(content);
+      const yaml = await import('js-yaml');
+      const parsed = yaml.load(content);
       if (parsed.rules && Array.isArray(parsed.rules)) {
         for (const rule of parsed.rules) {
           this.addRule(rule);
@@ -23651,7 +25972,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()"
@@ -23678,7 +25998,6 @@ var BugFixer = class {
       const match = currentLine.match(classPattern);
       if (match && match[1]) {
         classStartLine = i;
-        match[1];
         break;
       }
     }
@@ -23730,7 +26049,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"
@@ -24652,7 +26971,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));
@@ -24679,7 +26998,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];
@@ -24728,7 +27047,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];
@@ -24891,7 +27210,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));
@@ -25267,7 +27586,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));
@@ -25682,7 +28001,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));
@@ -26038,7 +28357,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));
@@ -26321,7 +28640,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));
@@ -26634,7 +28953,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));
@@ -26928,7 +29247,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;
@@ -31137,7 +33456,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) {
@@ -33687,6 +36006,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,