@defai.digital/automatosx 11.3.1 → 11.3.3

package/dist/mcp/index.js

@@ -3,6 +3,7 @@ import * as path4 from 'path';
 import path4__default, { dirname, join, extname as extname$1, basename, resolve, relative, isAbsolute, sep, parse, delimiter } from 'path';
 import { fileURLToPath } from 'url';
 import { mkdir, appendFile, readFile, readdir, writeFile, rename, unlink, copyFile, access, stat, realpath } from 'fs/promises';
+import * as fs3 from 'fs';
 import { existsSync, readFileSync, promises, mkdirSync, createWriteStream, writeFileSync, unlinkSync, constants } from 'fs';
 import Database2 from 'better-sqlite3';
 import { glob } from 'glob';
@@ -23,9 +24,7 @@ import { randomUUID } from 'crypto';
 import yaml from 'yaml';
 
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -39,15 +38,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var init_esm_shims = __esm({
   "node_modules/tsup/assets/esm_shims.js"() {
   }
@@ -328,16 +318,16 @@ var init_errors = __esm({
       constructor(message, code = "E1001" /* CONFIG_INVALID */, suggestions = [], context) {
         super(message, code, suggestions, context);
       }
-      static notFound(path5) {
+      static notFound(path6) {
         return new _ConfigError(
-          `Configuration file not found: ${path5}`,
+          `Configuration file not found: ${path6}`,
           "E1000" /* CONFIG_NOT_FOUND */,
           [
             'Run "automatosx setup" to create a new configuration',
             "Specify a custom config path with --config option",
             "Check that you are in a valid AutomatosX project directory"
           ],
-          { path: path5 }
+          { path: path6 }
         );
       }
       static invalid(reason, context) {
@@ -352,7 +342,7 @@ var init_errors = __esm({
           context
         );
       }
-      static parseError(error, path5) {
+      static parseError(error, path6) {
         return new _ConfigError(
           `Failed to parse configuration: ${error.message}`,
           "E1002" /* CONFIG_PARSE_ERROR */,
@@ -361,7 +351,7 @@ var init_errors = __esm({
             "Use a JSON validator to find syntax errors",
             'Reset to default with "automatosx setup --force"'
           ],
-          { path: path5, originalError: error.message }
+          { path: path6, originalError: error.message }
         );
       }
     };
@@ -1174,11 +1164,11 @@ var init_workspace_indexer = __esm({
       /**
        * Detect file type and language
        */
-      detectTypeAndLanguage(path5, ext) {
-        if (path5.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
+      detectTypeAndLanguage(path6, ext) {
+        if (path6.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
           return { type: "config", language: "json" };
         }
-        if (path5.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path5.includes("__tests__")) {
+        if (path6.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path6.includes("__tests__")) {
           const lang = LANGUAGE_MAP[ext];
           return { type: "test", language: lang };
         }
@@ -1195,15 +1185,15 @@ var init_workspace_indexer = __esm({
        *
        * Higher score = more likely to be relevant
        */
-      calculateImportance(path5, type, size) {
+      calculateImportance(path6, type, size) {
         let score = 0.5;
-        if (path5.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
-        if (path5.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
-        if (path5.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
+        if (path6.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
+        if (path6.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
+        if (path6.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
         if (type === "config") score = 0.85;
-        if (path5.includes("/core/")) score += 0.15;
-        if (path5.includes("/types/")) score += 0.1;
-        if (path5.includes("/utils/")) score += 0.05;
+        if (path6.includes("/core/")) score += 0.15;
+        if (path6.includes("/types/")) score += 0.1;
+        if (path6.includes("/utils/")) score += 0.05;
         if (type === "test") score = Math.max(0.3, score - 0.3);
         if (type === "doc") score = Math.max(0.4, score - 0.2);
         if (size > 1e4) score += 0.05;
@@ -1679,10 +1669,10 @@ function findOnPathUnix(cmdBase) {
   try {
     const which = spawnSync("which", [cmdBase], { timeout: 3e3 });
     if (which.status === 0) {
-      const path5 = which.stdout.toString().trim();
-      if (path5) {
-        logger.debug("Found via which", { cmdBase, path: path5 });
-        return { found: true, path: path5 };
+      const path6 = which.stdout.toString().trim();
+      if (path6) {
+        logger.debug("Found via which", { cmdBase, path: path6 });
+        return { found: true, path: path6 };
       }
     }
   } catch (error) {
@@ -1723,8 +1713,8 @@ var init_provider_schemas = __esm({
       completion: z.number().int().nonnegative(),
       total: z.number().int().nonnegative()
     }).refine(
-      (data) => data.total === data.prompt + data.completion,
-      "Total tokens must equal prompt + completion"
+      (data) => data.total >= data.prompt + data.completion,
+      "Total tokens must be greater than or equal to prompt + completion"
     ).describe("Token usage information");
     finishReasonSchema = z.enum([
       "stop",
@@ -1981,15 +1971,6 @@ var init_streaming_progress_parser = __esm({
 });
 
 // src/providers/error-patterns.ts
-var error_patterns_exports = {};
-__export(error_patterns_exports, {
-  GENERIC_ERROR_PATTERNS: () => GENERIC_ERROR_PATTERNS,
-  PROVIDER_ERROR_PATTERNS: () => PROVIDER_ERROR_PATTERNS,
-  getProviderErrorPatterns: () => getProviderErrorPatterns,
-  isLimitError: () => isLimitError,
-  isQuotaError: () => isQuotaError,
-  isRateLimitError: () => isRateLimitError
-});
 function isQuotaError(error, providerName) {
   const patterns = PROVIDER_ERROR_PATTERNS[providerName] || GENERIC_ERROR_PATTERNS;
   const message = (error?.message || "").toLowerCase();
@@ -2031,9 +2012,6 @@ function isRateLimitError(error, providerName) {
 function isLimitError(error, providerName) {
   return isQuotaError(error, providerName) || isRateLimitError(error, providerName);
 }
-function getProviderErrorPatterns(providerName) {
-  return PROVIDER_ERROR_PATTERNS[providerName] || GENERIC_ERROR_PATTERNS;
-}
 var PROVIDER_ERROR_PATTERNS, GENERIC_ERROR_PATTERNS;
 var init_error_patterns = __esm({
   "src/providers/error-patterns.ts"() {
@@ -2222,6 +2200,62 @@ var init_error_patterns = __esm({
           "quota_exceeded",
           "billing_hard_limit_reached"
         ]
+      },
+      /**
+       * ax-cli Provider Error Patterns (v9.2.0)
+       *
+       * ax-cli is a multi-model provider supporting GLM, xAI, OpenAI, Anthropic, Ollama, etc.
+       * BUG FIX: Added missing patterns - previously fell back to generic patterns which
+       * may miss provider-specific errors from the underlying model providers.
+       *
+       * Combines patterns from all supported backends since ax-cli proxies to them.
+       */
+      "ax-cli": {
+        quota: [
+          // GLM patterns
+          "quota exceeded",
+          "quota limit reached",
+          "insufficient quota",
+          // OpenAI patterns (via ax-cli)
+          "insufficient_quota",
+          "quota_exceeded",
+          "billing hard limit reached",
+          "usage limit exceeded",
+          "monthly quota exceeded",
+          "credit limit reached",
+          // Anthropic patterns (via ax-cli)
+          "credit limit reached",
+          // Generic patterns
+          "daily quota exceeded",
+          "api quota exceeded"
+        ],
+        rateLimit: [
+          // Common patterns
+          "rate_limit_exceeded",
+          "rate limit exceeded",
+          "too_many_requests",
+          "too many requests",
+          "requests per minute exceeded",
+          "tokens per minute exceeded",
+          "rate limit reached",
+          // Anthropic patterns (via ax-cli)
+          "rate_limit_error",
+          "overloaded_error",
+          "overloaded",
+          // xAI/Grok patterns
+          "throttled",
+          "request throttled"
+        ],
+        statusCodes: [429, 529],
+        errorCodes: [
+          "insufficient_quota",
+          "rate_limit_exceeded",
+          "quota_exceeded",
+          "rate_limit_error",
+          "overloaded_error",
+          "RATE_LIMIT_EXCEEDED",
+          "QUOTA_EXCEEDED"
+        ]
       }
     };
     GENERIC_ERROR_PATTERNS = {
@@ -2244,6 +2278,105 @@ var init_error_patterns = __esm({
     };
   }
 });
+
+// src/providers/retry-errors.ts
+function containsErrorPattern(message, patterns) {
+  const lowerMessage = message.toLowerCase();
+  return patterns.some((pattern) => lowerMessage.includes(pattern.toLowerCase()));
+}
+function getRetryableErrors(provider) {
+  const baseErrors = [
+    ...COMMON_NETWORK_ERRORS,
+    ...COMMON_RATE_LIMIT_ERRORS,
+    ...COMMON_SERVER_ERRORS
+  ];
+  switch (provider) {
+    case "claude":
+      return [...baseErrors, ...CLAUDE_RETRYABLE_ERRORS];
+    case "gemini":
+      return [...baseErrors, ...GEMINI_RETRYABLE_ERRORS];
+    case "openai":
+      return [...baseErrors, ...OPENAI_RETRYABLE_ERRORS];
+    case "ax-cli":
+      return [...baseErrors, ...AX_CLI_RETRYABLE_ERRORS];
+    case "codex":
+      return [...baseErrors, ...CODEX_RETRYABLE_ERRORS];
+    case "base":
+    default:
+      return baseErrors;
+  }
+}
+function shouldRetryError(error, provider) {
+  const message = error.message;
+  if (containsErrorPattern(message, NON_RETRYABLE_ERRORS)) {
+    return false;
+  }
+  const retryableErrors = getRetryableErrors(provider);
+  return containsErrorPattern(message, retryableErrors);
+}
+var COMMON_NETWORK_ERRORS, COMMON_RATE_LIMIT_ERRORS, COMMON_SERVER_ERRORS, CLAUDE_RETRYABLE_ERRORS, GEMINI_RETRYABLE_ERRORS, OPENAI_RETRYABLE_ERRORS, AX_CLI_RETRYABLE_ERRORS, CODEX_RETRYABLE_ERRORS, NON_RETRYABLE_ERRORS;
+var init_retry_errors = __esm({
+  "src/providers/retry-errors.ts"() {
+    init_esm_shims();
+    COMMON_NETWORK_ERRORS = [
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ENOTFOUND",
+      "ECONNREFUSED",
+      "connection_error",
+      "network connection error",
+      "timeout"
+    ];
+    COMMON_RATE_LIMIT_ERRORS = [
+      "rate_limit",
+      "rate_limit_error",
+      "too many requests"
+    ];
+    COMMON_SERVER_ERRORS = [
+      "internal_server_error",
+      "server_error",
+      "service_unavailable",
+      "unavailable"
+    ];
+    CLAUDE_RETRYABLE_ERRORS = [
+      "overloaded_error",
+      "internal_server_error"
+    ];
+    GEMINI_RETRYABLE_ERRORS = [
+      "resource_exhausted",
+      "deadline_exceeded",
+      "internal"
+    ];
+    OPENAI_RETRYABLE_ERRORS = [
+      "internal_error"
+    ];
+    AX_CLI_RETRYABLE_ERRORS = [
+      // Inherited from Anthropic (via ax-cli)
+      "overloaded_error",
+      // Inherited from OpenAI (via ax-cli)
+      "internal_error",
+      // ax-cli specific
+      "agent_error",
+      "tool_execution_error",
+      // xAI/Grok specific
+      "service_overloaded"
+    ];
+    CODEX_RETRYABLE_ERRORS = [
+      ...OPENAI_RETRYABLE_ERRORS,
+      "sandbox_error"
+      // Codex-specific sandbox issues are often transient
+    ];
+    NON_RETRYABLE_ERRORS = [
+      "authentication",
+      "unauthorized",
+      "api key",
+      "not found",
+      "permission denied",
+      "invalid_api_key",
+      "invalid_request"
+    ];
+  }
+});
 var BaseProvider;
 var init_base_provider = __esm({
   "src/providers/base-provider.ts"() {
@@ -2254,6 +2387,8 @@ var init_base_provider = __esm({
     init_provider_schemas();
     init_streaming_progress_parser();
     init_verbosity_manager();
+    init_error_patterns();
+    init_retry_errors();
     BaseProvider = class _BaseProvider {
       /**
        * Whitelist of allowed provider names for security
@@ -2286,6 +2421,10 @@ var init_base_provider = __esm({
         NO_UPDATE_NOTIFIER: "1",
         DEBIAN_FRONTEND: "noninteractive"
       };
+      /** Default CLI execution timeout in milliseconds */
+      static DEFAULT_TIMEOUT_MS = 12e4;
+      /** Time to wait after SIGTERM before escalating to SIGKILL */
+      static SIGKILL_ESCALATION_MS = 5e3;
       config;
       logger = logger;
       health;
@@ -2303,6 +2442,8 @@ var init_base_provider = __esm({
           latencyMs: 0,
           errorRate: 0,
           consecutiveFailures: 0,
+          consecutiveSuccesses: 0,
+          // BUG FIX: Track consecutive successes
           lastCheck: Date.now()
         };
       }
@@ -2343,7 +2484,7 @@ var init_base_provider = __esm({
             useStdin,
             streaming: process.env.AUTOMATOSX_SHOW_PROVIDER_OUTPUT === "true"
           });
-          const result = useStdin ? await this.executeWithStdin(cliCommand, argsString.trim(), prompt) : await this.executeWithSpawn(fullCommand, cliCommand);
+          const result = useStdin ? await this.executeWithStdin(cliCommand, cliArgs, prompt) : await this.executeWithSpawn(fullCommand, cliCommand);
           if (!result.stdout) {
             throw new Error(`${cliCommand} CLI returned empty output. stderr: ${result.stderr || "none"}`);
           }
@@ -2365,8 +2506,8 @@ var init_base_provider = __esm({
       /**
        * Execute command using spawn() with streaming support (v8.4.18)
        *
-       * Replaces execWithCleanup to support real-time line-by-line output streaming.
-       * Maintains all timeout and cleanup behaviors from execWithCleanup.
+       * Supports real-time line-by-line output streaming with proper timeout
+       * and cleanup behaviors (SIGTERM → SIGKILL escalation pattern).
        *
        * @param command - Full command string to execute
        * @param cliCommand - CLI command name (for logging)
@@ -2377,7 +2518,7 @@ var init_base_provider = __esm({
           const child = spawn(command, [], {
             shell: true,
             // Auto-detects: cmd.exe on Windows, /bin/sh on Unix
-            timeout: this.config.timeout || 12e4,
+            timeout: this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS,
             env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
@@ -2488,7 +2629,7 @@ var init_base_provider = __esm({
             });
             reject(new Error(`Failed to spawn ${cliCommand} CLI: ${error.message}`));
           });
-          const timeout = this.config.timeout || 12e4;
+          const timeout = this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS;
           timeoutId = setTimeout(() => {
             if (child.pid && !child.killed) {
               logger.warn("Killing child process due to timeout", {
@@ -2502,7 +2643,7 @@ var init_base_provider = __esm({
                   logger.warn("Force killing child process", { pid: child.pid });
                   child.kill("SIGKILL");
                 }
-              }, 5e3);
+              }, _BaseProvider.SIGKILL_ESCALATION_MS);
             }
           }, timeout);
         });
@@ -2520,14 +2661,13 @@ var init_base_provider = __esm({
        */
       async executeWithStdin(cliCommand, cliArgs, prompt) {
         return new Promise((resolve5, reject) => {
-          const commandArgs = cliArgs ? cliArgs.split(" ").filter(Boolean) : [];
           logger.debug(`Executing ${cliCommand} CLI with stdin`, {
             command: cliCommand,
-            args: commandArgs,
+            args: cliArgs,
             promptLength: prompt.length
           });
-          const child = spawn(cliCommand, commandArgs, {
-            timeout: this.config.timeout || 12e4,
+          const child = spawn(cliCommand, cliArgs, {
+            timeout: this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS,
             env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
@@ -2550,11 +2690,20 @@ var init_base_provider = __esm({
               child.stdin.write(prompt);
               child.stdin.end();
             } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
               logger.error("Failed to write to stdin", {
                 command: cliCommand,
-                error: error instanceof Error ? error.message : String(error)
+                error: errorMessage
               });
+              child.kill("SIGTERM");
+              reject(new Error(`Failed to write prompt to ${cliCommand} stdin: ${errorMessage}`));
+              return;
             }
+          } else {
+            logger.error("stdin not available for child process", { command: cliCommand });
+            child.kill("SIGTERM");
+            reject(new Error(`${cliCommand} stdin not available - cannot send prompt`));
+            return;
           }
           if (child.stdout) {
             readlineInterface = readline.createInterface({
@@ -2663,7 +2812,7 @@ var init_base_provider = __esm({
             });
             reject(new Error(`Failed to spawn ${cliCommand} CLI: ${error.message}`));
           });
-          const timeout = this.config.timeout || 12e4;
+          const timeout = this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS;
           timeoutId = setTimeout(() => {
             if (child.pid && !child.killed) {
               logger.warn("Killing child process due to timeout", {
@@ -2677,7 +2826,7 @@ var init_base_provider = __esm({
                   logger.warn("Force killing child process", { pid: child.pid });
                   child.kill("SIGKILL");
                 }
-              }, 5e3);
+              }, _BaseProvider.SIGKILL_ESCALATION_MS);
             }
           }, timeout);
         });
@@ -2743,9 +2892,7 @@ var init_base_provider = __esm({
 ${request.prompt}`;
           }
           if (process.env.AUTOMATOSX_DEBUG_PROMPT === "true") {
-            const fs3 = await import('fs');
-            const path5 = await import('path');
-            const debugPath = path5.join(process.cwd(), "automatosx/tmp/debug-prompt.txt");
+            const debugPath = path4.join(process.cwd(), "automatosx/tmp/debug-prompt.txt");
             fs3.writeFileSync(debugPath, `=== FULL PROMPT SENT TO ${this.getCLICommand()} ===
 
 ${fullPrompt}
@@ -2757,6 +2904,7 @@ ${fullPrompt}
           const result = await this.executeCLI(fullPrompt);
           const latencyMs = Date.now() - startTime;
           this.health.consecutiveFailures = 0;
+          this.health.consecutiveSuccesses++;
           this.health.available = true;
           this.health.errorRate = 0;
           this.health.latencyMs = latencyMs;
@@ -2789,6 +2937,7 @@ ${fullPrompt}
           return response;
         } catch (error) {
           this.health.consecutiveFailures++;
+          this.health.consecutiveSuccesses = 0;
           this.health.available = false;
           this.health.errorRate = 1;
           this.health.latencyMs = Date.now() - startTime;
@@ -2802,19 +2951,23 @@ ${fullPrompt}
       async isAvailable() {
         try {
           const available = await this.checkCLIAvailable();
-          this.health = {
-            available,
-            latencyMs: 0,
-            errorRate: available ? 0 : 1,
-            lastCheck: Date.now(),
-            consecutiveFailures: available ? 0 : this.health.consecutiveFailures + 1
-          };
+          this.health.available = available;
+          this.health.errorRate = available ? 0 : 1;
+          this.health.lastCheck = Date.now();
+          if (available) {
+            this.health.consecutiveFailures = 0;
+            this.health.consecutiveSuccesses++;
+          } else {
+            this.health.consecutiveFailures++;
+            this.health.consecutiveSuccesses = 0;
+          }
           return available;
         } catch (error) {
           this.health.available = false;
           this.health.errorRate = 1;
           this.health.lastCheck = Date.now();
-          this.health.consecutiveFailures = this.health.consecutiveFailures + 1;
+          this.health.consecutiveFailures++;
+          this.health.consecutiveSuccesses = 0;
           return false;
         }
       }
@@ -2869,26 +3022,16 @@ ${fullPrompt}
        * @returns true if this is a rate limit or quota error
        */
       detectRateLimitError(error) {
-        const { isLimitError: isLimitError2 } = (init_error_patterns(), __toCommonJS(error_patterns_exports));
-        try {
-          const isLimited = isLimitError2(error, this.config.name);
-          if (isLimited) {
-            this.logger.debug("Rate limit error detected", {
-              provider: this.config.name,
-              message: error?.message,
-              code: error?.code,
-              status: error?.status || error?.statusCode
-            });
-          }
-          return isLimited;
-        } catch (detectionError) {
-          this.logger.warn("Rate limit detection failed, using fallback", {
+        const isLimited = isLimitError(error, this.config.name);
+        if (isLimited) {
+          this.logger.debug("Rate limit error detected", {
             provider: this.config.name,
-            error: detectionError
+            message: error?.message,
+            code: error?.code,
+            status: error?.status || error?.statusCode
           });
-          const message = (error?.message || "").toLowerCase();
-          return message.includes("rate limit") || message.includes("quota") || message.includes("resource_exhausted") || message.includes("too many requests");
         }
+        return isLimited;
       }
       /**
        * Escape shell command arguments to prevent injection
@@ -2981,8 +3124,20 @@ ${fullPrompt}
         };
       }
       shouldRetry(error) {
-        const message = error.message.toLowerCase();
-        return message.includes("timeout") || message.includes("rate limit") || message.includes("temporarily unavailable") || message.includes("503") || message.includes("502");
+        const providerName = this.config.name.toLowerCase();
+        let retryableProvider = "base";
+        if (providerName === "claude" || providerName === "claude-code") {
+          retryableProvider = "claude";
+        } else if (providerName === "gemini" || providerName === "gemini-cli") {
+          retryableProvider = "gemini";
+        } else if (providerName === "openai") {
+          retryableProvider = "openai";
+        } else if (providerName === "codex") {
+          retryableProvider = "codex";
+        } else if (providerName === "ax-cli" || providerName === "glm") {
+          retryableProvider = "ax-cli";
+        }
+        return shouldRetryError(error, retryableProvider);
       }
       getRetryDelay(attempt) {
         return Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
@@ -3006,7 +3161,9 @@ ${fullPrompt}
           },
           health: {
             consecutiveFailures: this.health.consecutiveFailures,
-            consecutiveSuccesses: this.health.consecutiveFailures === 0 ? 1 : 0,
+            // BUG FIX: Use actual tracked value instead of incorrect derivation
+            // Previously: `consecutiveFailures === 0 ? 1 : 0` which was wrong
+            consecutiveSuccesses: this.health.consecutiveSuccesses,
             lastCheckTime: this.health.lastCheck,
             lastCheckDuration: 0,
             uptime: this.health.lastCheck > 0 ? Date.now() - this.health.lastCheck : 0
@@ -3706,7 +3863,20 @@ var init_sdk_adapter = __esm({
             }
           }
           const tokenCount = result.usage ? (result.usage.input_tokens || 0) + (result.usage.output_tokens || 0) : void 0;
-          if (!this.options.reuseThreads) {
+          if (!this.options.reuseThreads && this.activeThread) {
+            try {
+              const threadWithDispose = this.activeThread;
+              if (typeof threadWithDispose.dispose === "function") {
+                const disposeResult = threadWithDispose.dispose();
+                if (disposeResult instanceof Promise) {
+                  await disposeResult;
+                }
+              }
+            } catch (disposeError) {
+              logger.warn("Error disposing thread", {
+                error: disposeError instanceof Error ? disposeError.message : String(disposeError)
+              });
+            }
             this.activeThread = null;
           }
           return {
@@ -3885,12 +4055,38 @@ var init_hybrid_adapter = __esm({
         }
         this.activeMode = "cli";
       }
+      /**
+       * Cleanup resources
+       *
+       * BUG FIX: Use Promise.allSettled to ensure cleanup continues even if one
+       * adapter fails, and properly log any cleanup errors. Previously, a failure
+       * in SDK destroy would prevent CLI cleanup from running.
+       */
       async destroy() {
-        if (this.sdkAdapter) await this.sdkAdapter.destroy();
-        if (this.cliAdapter) await this.cliAdapter.cleanup();
+        const cleanupPromises = [];
+        if (this.sdkAdapter) {
+          cleanupPromises.push(
+            this.sdkAdapter.destroy().catch((err) => {
+              logger.warn("Error destroying SDK adapter", {
+                error: err instanceof Error ? err.message : String(err)
+              });
+            })
+          );
+        }
+        if (this.cliAdapter) {
+          cleanupPromises.push(
+            this.cliAdapter.cleanup().catch((err) => {
+              logger.warn("Error cleaning up CLI adapter", {
+                error: err instanceof Error ? err.message : String(err)
+              });
+            })
+          );
+        }
+        await Promise.allSettled(cleanupPromises);
         this.sdkAdapter = null;
         this.cliAdapter = null;
         this.activeMode = null;
+        logger.debug("HybridCodexAdapter destroyed");
       }
     };
   }
@@ -3947,7 +4143,7 @@ var init_openai_provider = __esm({
             error: error instanceof Error ? error.message : String(error),
             mode: this.hybridAdapter?.getActiveMode() || "unknown"
           });
-          throw error;
+          throw this.handleError(error);
         }
       }
       initializeHybridAdapter() {
@@ -4578,11 +4774,11 @@ var VALIDATION_LIMITS = {
   MAX_PORT: 65535
   // Maximum port number
 };
-function isValidRelativePath(path5) {
-  if (!path5 || typeof path5 !== "string") {
+function isValidRelativePath(path6) {
+  if (!path6 || typeof path6 !== "string") {
     return false;
   }
-  const normalizedPath = path5.replace(/\\/g, "/");
+  const normalizedPath = path6.replace(/\\/g, "/");
   if (normalizedPath.startsWith("/")) {
     return false;
   }
@@ -4974,7 +5170,7 @@ var PRECOMPILED_CONFIG = {
   "providers": {
     "claude-code": {
       "enabled": true,
-      "priority": 1,
+      "priority": 3,
       "timeout": 27e5,
       "command": "claude",
       "healthCheck": {
@@ -5034,7 +5230,7 @@ var PRECOMPILED_CONFIG = {
     },
     "openai": {
       "enabled": true,
-      "priority": 3,
+      "priority": 1,
       "timeout": 27e5,
       "command": "codex",
       "healthCheck": {
@@ -5272,7 +5468,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.3.1"
+  "version": "11.3.3"
 };
 
 // src/core/config/schemas.ts
@@ -5299,7 +5495,7 @@ var safeNameSchema = z.string().min(1).max(VALIDATION_LIMITS.MAX_NAME_LENGTH).re
   "Name must be alphanumeric with dash/underscore only"
 ).describe("Safe identifier name");
 var relativePathSchema = z.string().min(1).refine(
-  (path5) => !path5.includes("..") && !path5.startsWith("/"),
+  (path6) => !path6.includes("..") && !path6.startsWith("/"),
   "Path must be relative (no ../, no absolute paths)"
 ).describe("Relative path within project");
 var fileExtensionSchema = z.string().regex(
@@ -5639,16 +5835,16 @@ async function loadConfigUncached(projectDir) {
   });
   return config;
 }
-async function loadConfigFile(path5) {
+async function loadConfigFile(path6) {
   try {
-    const content = await readFile(path5, "utf-8");
+    const content = await readFile(path6, "utf-8");
     if (content.length > VALIDATION_LIMITS.MAX_CONFIG_FILE_SIZE) {
       throw ConfigError.parseError(
         new Error(`Config file too large (max ${VALIDATION_LIMITS.MAX_CONFIG_FILE_SIZE / 1024}KB, got ${Math.ceil(content.length / 1024)}KB)`),
-        path5
+        path6
       );
     }
-    const ext = extname(path5).toLowerCase();
+    const ext = extname(path6).toLowerCase();
     let userConfig;
     try {
       if (ext === ".yaml" || ext === ".yml") {
@@ -5657,7 +5853,7 @@ async function loadConfigFile(path5) {
         userConfig = JSON.parse(content);
       }
     } catch (parseError) {
-      throw ConfigError.parseError(parseError, path5);
+      throw ConfigError.parseError(parseError, path6);
     }
     const config = mergeConfig(DEFAULT_CONFIG, userConfig);
     if (config.execution && userConfig.execution?.maxConcurrentAgents === void 0) {
@@ -5673,35 +5869,35 @@ async function loadConfigFile(path5) {
     if (validationErrors.length > 0) {
       throw ConfigError.invalid(
         validationErrors.join("; "),
-        { path: path5, errors: validationErrors }
+        { path: path6, errors: validationErrors }
       );
     }
-    logger.info("Config loaded successfully", { path: normalizePath(path5), format: ext });
+    logger.info("Config loaded successfully", { path: normalizePath(path6), format: ext });
     return config;
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
     }
     if (error.code === "ENOENT") {
-      throw ConfigError.notFound(path5);
+      throw ConfigError.notFound(path6);
     }
     if (error.code === "EACCES") {
       throw new ConfigError(
-        `Permission denied reading config: ${path5}`,
+        `Permission denied reading config: ${path6}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
         [
           "Check file permissions",
           "Run with appropriate user privileges",
           "Verify the file is accessible"
         ],
-        { path: path5, error: error.message }
+        { path: path6, error: error.message }
       );
     }
     throw new ConfigError(
       `Failed to load config: ${error.message}`,
       "E1002" /* CONFIG_PARSE_ERROR */,
       ["Check file format and permissions"],
-      { path: path5, originalError: error.message }
+      { path: path6, originalError: error.message }
     );
   }
 }
@@ -5717,8 +5913,8 @@ function validateConfigWithZod(config) {
     return ["Configuration validation failed with unknown error structure"];
   }
   return result.error.issues.map((err) => {
-    const path5 = err.path.join(".");
-    return `${path5}: ${err.message}`;
+    const path6 = err.path.join(".");
+    return `${path6}: ${err.message}`;
   });
 }
 function validateConfig(config) {
@@ -6128,8 +6324,8 @@ var PathError = class extends Error {
 };
 
 // src/shared/validation/path-resolver.ts
-function isWindowsPath(path5) {
-  return /^[a-zA-Z]:[/\\]/.test(path5);
+function isWindowsPath(path6) {
+  return /^[a-zA-Z]:[/\\]/.test(path6);
 }
 async function detectProjectRoot(startDir = process.cwd()) {
   if (process.env.AUTOMATOSX_PROJECT_ROOT) {
@@ -6229,8 +6425,8 @@ var PathResolver = class {
   /**
    * Validate path is within allowed base directory
    */
-  validatePath(path5, baseDir) {
-    const normalized = normalizePath(resolvePath(path5));
+  validatePath(path6, baseDir) {
+    const normalized = normalizePath(resolvePath(path6));
     const base = normalizePath(resolvePath(baseDir));
     const separator = "/";
     const pathWithSep = normalized + separator;
@@ -6240,15 +6436,15 @@ var PathResolver = class {
   /**
    * Check if path is within allowed boundaries
    */
-  isPathAllowed(path5) {
-    const boundary = this.checkBoundaries(path5);
+  isPathAllowed(path6) {
+    const boundary = this.checkBoundaries(path6);
     return boundary === "agent_workspace" || boundary === "user_project";
   }
   /**
    * Check which boundary a path belongs to
    */
-  checkBoundaries(path5) {
-    const normalized = resolvePath(path5);
+  checkBoundaries(path6) {
+    const normalized = resolvePath(path6);
     if (this.validatePath(normalized, this.config.agentWorkspace)) {
       return "agent_workspace";
     }
@@ -6266,15 +6462,15 @@ var PathResolver = class {
   /**
    * Get relative path from project root
    */
-  getRelativeToProject(path5) {
-    const normalized = resolvePath(path5);
+  getRelativeToProject(path6) {
+    const normalized = resolvePath(path6);
     return normalizePath(getRelativePath(this.config.projectDir, normalized));
   }
   /**
    * Get relative path from working directory
    */
-  getRelativeToWorking(path5) {
-    const normalized = resolvePath(path5);
+  getRelativeToWorking(path6) {
+    const normalized = resolvePath(path6);
     return normalizePath(getRelativePath(this.config.workingDir, normalized));
   }
   /**
@@ -6293,11 +6489,11 @@ var PathResolver = class {
    * Validate path is within project boundaries
    * @throws PathError if outside project
    */
-  validateInProject(path5) {
-    const boundary = this.checkBoundaries(path5);
+  validateInProject(path6) {
+    const boundary = this.checkBoundaries(path6);
     if (boundary === "outside_boundaries" || boundary === "system_restricted") {
       throw new PathError("Path outside project directory", {
-        path: path5,
+        path: path6,
         projectDir: this.config.projectDir,
         boundary
       });
@@ -8164,18 +8360,18 @@ var ProviderSessionManager = class {
 };
 var providerSessionInstances = /* @__PURE__ */ new Map();
 async function getProviderSession(workspacePath) {
-  let path5;
+  let path6;
   {
     if (process.env.NODE_ENV === "test" || process.env.VITEST) {
-      path5 = process.cwd();
+      path6 = process.cwd();
     } else {
-      path5 = await detectProjectRoot();
+      path6 = await detectProjectRoot();
     }
   }
-  if (!providerSessionInstances.has(path5)) {
-    providerSessionInstances.set(path5, new ProviderSessionManager(path5));
+  if (!providerSessionInstances.has(path6)) {
+    providerSessionInstances.set(path6, new ProviderSessionManager(path6));
   }
-  return providerSessionInstances.get(path5);
+  return providerSessionInstances.get(path6);
 }
 
 // src/core/router/router.ts
@@ -9944,6 +10140,9 @@ var MemoryManager = class _MemoryManager {
         if (!Number.isInteger(offsetValue) || offsetValue < 0) {
           throw new Error(`Invalid offset value: ${options.offset}. Must be a non-negative integer.`);
         }
+        if (!limitClause) {
+          limitClause = "LIMIT -1";
+        }
         offsetClause = `OFFSET ${offsetValue}`;
       }
       const sql = `
@@ -10297,6 +10496,13 @@ var MemoryManager = class _MemoryManager {
       await this.initialize();
       logger.info("Database restored successfully (atomic operation)", { srcPath: normalizePath(srcPath) });
     } catch (error) {
+      try {
+        DatabaseFactory.close(this.db);
+      } finally {
+        this.initialized = false;
+        this.entryCount = 0;
+        this.statements = {};
+      }
       throw new MemoryError(
         `Failed to restore database: ${error.message}`,
         "DATABASE_ERROR",
@@ -10846,6 +11052,10 @@ var SessionManager = class _SessionManager {
   MAX_TASKS_PER_SESSION = 1e3;
   /** UUID v4 validation regex (static for performance) */
   static UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  /** Tracks whether manager has been destroyed to prevent late saves */
+  destroyed = false;
+  /** Last persistence error (reported during flush) */
+  lastSaveError;
   /**
    * Validate session ID format (must be valid UUID v4)
    *
@@ -11440,6 +11650,7 @@ var SessionManager = class _SessionManager {
    * ```
    */
   async destroy() {
+    this.destroyed = true;
     if (this.saveTimeout) {
       clearTimeout(this.saveTimeout);
       this.saveTimeout = void 0;
@@ -11450,9 +11661,12 @@ var SessionManager = class _SessionManager {
       logger.error("Error flushing save during destroy", {
         error: error.message
       });
+      this.lastSaveError = void 0;
     }
+    const sessionCount = this.activeSessions.size;
+    this.activeSessions.clear();
     logger.debug("SessionManager destroyed", {
-      sessions: this.activeSessions.size
+      sessions: sessionCount
     });
   }
   /**
@@ -11477,11 +11691,21 @@ var SessionManager = class _SessionManager {
         this.pendingSave = void 0;
       });
       await this.pendingSave;
+      if (this.lastSaveError) {
+        const err = this.lastSaveError;
+        this.lastSaveError = void 0;
+        throw err;
+      }
       return;
     }
     if (this.pendingSave) {
       try {
         await this.pendingSave;
+        if (this.lastSaveError) {
+          const err = this.lastSaveError;
+          this.lastSaveError = void 0;
+          throw err;
+        }
       } catch (err) {
         throw err;
       }
@@ -11646,7 +11870,7 @@ var SessionManager = class _SessionManager {
    * @private
    */
   saveToFile() {
-    if (!this.persistencePath) {
+    if (!this.persistencePath || this.destroyed) {
       return;
     }
     if (this.saveTimeout) {
@@ -11659,18 +11883,18 @@ var SessionManager = class _SessionManager {
       }
       this.saveNeeded = false;
       const executeNextSave = async () => {
-        await this.doSave();
+        try {
+          await this.doSave();
+          this.lastSaveError = void 0;
+        } catch (err) {
+          this.lastSaveError = err;
+        }
         if (this.saveNeeded) {
           this.saveNeeded = false;
           return executeNextSave();
         }
       };
-      this.pendingSave = executeNextSave().catch((err) => {
-        logger.error("Debounced save failed", {
-          error: err.message
-        });
-        throw err;
-      }).finally(() => {
+      this.pendingSave = executeNextSave().finally(() => {
         this.pendingSave = void 0;
       });
     }, 100);
@@ -15081,9 +15305,9 @@ var DependencyGraphBuilder = class {
   detectCycles(graph) {
     const visiting = /* @__PURE__ */ new Set();
     const visited = /* @__PURE__ */ new Set();
-    const visit = (nodeName, path5) => {
+    const visit = (nodeName, path6) => {
       if (visiting.has(nodeName)) {
-        throw new Error(`Circular dependency detected: ${[...path5, nodeName].join(" \u2192 ")}`);
+        throw new Error(`Circular dependency detected: ${[...path6, nodeName].join(" \u2192 ")}`);
       }
       if (visited.has(nodeName)) {
         return;
@@ -15098,7 +15322,7 @@ var DependencyGraphBuilder = class {
       }
       visiting.add(nodeName);
       for (const dependency of node.dependencies) {
-        visit(dependency, [...path5, nodeName]);
+        visit(dependency, [...path6, nodeName]);
       }
       visiting.delete(nodeName);
       visited.add(nodeName);
@@ -16831,59 +17055,59 @@ var DANGEROUS_PATH_PATTERNS = [
   // Common data drive (Windows, alt format)
 ];
 var SUSPICIOUS_PATH_CHARS = /[<>:|"]/;
-function validatePathParameter(path5, paramName, projectRoot = process.cwd()) {
-  if (!path5 || path5.trim() === "") {
+function validatePathParameter(path6, paramName, projectRoot = process.cwd()) {
+  if (!path6 || path6.trim() === "") {
     throw new ValidationError(
       `Invalid ${paramName}: path cannot be empty`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
   for (const pattern of DANGEROUS_PATH_PATTERNS) {
-    if (path5.includes(pattern)) {
+    if (path6.includes(pattern)) {
       throw new ValidationError(
         `Invalid ${paramName}: path contains dangerous pattern "${pattern}"`,
         -32602 /* InvalidParams */,
-        { path: path5, paramName, pattern }
+        { path: path6, paramName, pattern }
       );
     }
   }
-  if (isAbsolute(path5)) {
+  if (isAbsolute(path6)) {
     throw new ValidationError(
       `Invalid ${paramName}: absolute paths are not allowed`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
   try {
-    const resolvedPath = resolve(projectRoot, path5);
+    const resolvedPath = resolve(projectRoot, path6);
     const normalizedRoot = resolve(projectRoot);
     if (!resolvedPath.startsWith(normalizedRoot + sep) && resolvedPath !== normalizedRoot) {
       throw new ValidationError(
         `Invalid ${paramName}: path escapes project boundary`,
         -32602 /* InvalidParams */,
-        { path: path5, paramName, projectRoot, resolvedPath }
+        { path: path6, paramName, projectRoot, resolvedPath }
       );
     }
   } catch (error) {
     throw new ValidationError(
       `Invalid ${paramName}: path resolution failed`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName, error: String(error) }
+      { path: path6, paramName, error: String(error) }
     );
   }
-  if (path5.includes("\0")) {
+  if (path6.includes("\0")) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains null byte`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
-  if (SUSPICIOUS_PATH_CHARS.test(path5)) {
+  if (SUSPICIOUS_PATH_CHARS.test(path6)) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains invalid characters`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
 }
@@ -17579,8 +17803,8 @@ function createMemoryExportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_export called", { input });
     try {
-      const { path: path5 } = input;
-      const absolutePath = resolveExportPath(deps.pathResolver, path5);
+      const { path: path6 } = input;
+      const absolutePath = resolveExportPath(deps.pathResolver, path6);
       const exported = await deps.memoryManager.exportToJSON(absolutePath);
       const result = {
         success: true,
@@ -17616,8 +17840,8 @@ function createMemoryImportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_import called", { input });
     try {
-      const { path: path5 } = input;
-      const absolutePath = resolveImportPath(deps.pathResolver, path5);
+      const { path: path6 } = input;
+      const absolutePath = resolveImportPath(deps.pathResolver, path6);
       const imported = await deps.memoryManager.importFromJSON(absolutePath);
       const result = {
         success: true,
@@ -18170,7 +18394,8 @@ var McpClient = class extends EventEmitter {
    * Send JSON-RPC request and wait for response
    */
   async sendRequest(method, params, timeout) {
-    if (!this.process?.stdin) {
+    const stdin = this.process?.stdin;
+    if (!stdin) {
       throw new Error("MCP client not connected");
     }
     const id = this.nextRequestId++;
@@ -18192,7 +18417,18 @@ var McpClient = class extends EventEmitter {
         timeout: timeoutHandle
       });
       const message = JSON.stringify(request) + "\n";
-      this.process.stdin.write(message);
+      try {
+        stdin.write(message);
+      } catch (error) {
+        const pending = this.pendingRequests.get(id);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pendingRequests.delete(id);
+        }
+        const err = error instanceof Error ? error : new Error(String(error));
+        reject(err);
+        return;
+      }
       logger.debug("[MCP Client] Sent request", {
         id,
         method,
@@ -18202,6 +18438,10 @@ var McpClient = class extends EventEmitter {
   }
   /**
    * Send JSON-RPC notification (no response expected)
+   *
+   * BUG FIX: Handle write errors gracefully. If the process has exited or the
+   * pipe is broken, write() could throw an uncaught exception that would crash
+   * the application.
    */
   sendNotification(method, params) {
     if (!this.process?.stdin) {
@@ -18213,7 +18453,14 @@ var McpClient = class extends EventEmitter {
       params
     };
     const message = JSON.stringify(notification) + "\n";
-    this.process.stdin.write(message);
+    try {
+      this.process.stdin.write(message);
+    } catch (error) {
+      logger.debug("[MCP Client] Failed to send notification (pipe may be closed)", {
+        method,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
   /**
    * Handle incoming JSON-RPC message
@@ -18564,6 +18811,11 @@ var McpClientPool = class extends EventEmitter {
   }
   /**
    * Check if pool has available capacity for provider
+   *
+   * BUG FIX: Account for pendingConnections to avoid reporting capacity
+   * when concurrent connection creations are in progress. Previously,
+   * hasCapacity() could return true even when all slots were about to be
+   * filled by in-flight createConnection() calls, causing over-allocation.
    */
   hasCapacity(provider) {
     const pool = this.pools.get(provider);
@@ -18577,7 +18829,8 @@ var McpClientPool = class extends EventEmitter {
         connectedCount++;
       }
     }
-    return connectedCount < this.config.maxConnectionsPerProvider;
+    const totalAllocated = connectedCount + pool.pendingConnections;
+    return totalAllocated < this.config.maxConnectionsPerProvider;
   }
   // ============================================
   // Private Methods
@@ -18700,6 +18953,10 @@ var McpClientPool = class extends EventEmitter {
           }
         }
         for (const pooledClient of toRemove) {
+          if (pooledClient.inUse) {
+            logger.debug("[MCP Pool] Skipping idle client removal - now in use", { provider });
+            continue;
+          }
           logger.debug("[MCP Pool] Closing idle connection", {
             provider,
             idleTimeMs: now - pooledClient.lastUsed