@defai.digital/automatosx 11.2.8 → 11.2.9

package/README.md

@@ -13,7 +13,7 @@
 [![Windows](https://img.shields.io/badge/Windows-10+-blue.svg)](https://www.microsoft.com/windows)
 [![Ubuntu](https://img.shields.io/badge/Ubuntu-24.04-blue.svg)](https://ubuntu.com)
 
-**Status**: ✅ **Production Ready** | v11.2.8 | Unified Event System | MCP Streaming
+**Status**: ✅ **Production Ready** | v11.2.9 | Performance Refactors | Array Optimization
 
 > 🎯 **What AutomatosX Does**: Adds 20+ specialized agents, persistent memory, workflow automation, and 80% cost savings to Claude Code/Codex - **without changing how you work**.
 

package/dist/index.js

@@ -15,6 +15,7 @@ import chalk5 from 'chalk';
 import ora8 from 'ora';
 import * as readline2 from 'readline';
 import readline2__default, { createInterface } from 'readline';
+import { Mutex } from 'async-mutex';
 import { promisify } from 'util';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -22,7 +23,6 @@ import { randomUUID, createHash } from 'crypto';
 import * as yaml4 from 'js-yaml';
 import yaml4__default, { load, dump } from 'js-yaml';
 import Table from 'cli-table3';
-import { Mutex } from 'async-mutex';
 import inquirer from 'inquirer';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
@@ -2535,6 +2535,15 @@ var init_base_provider = __esm({
         "test-provider"
         // For unit tests
       ];
+      /** Environment variables to force non-interactive CLI mode */
+      static NON_INTERACTIVE_ENV = {
+        TERM: "dumb",
+        NO_COLOR: "1",
+        FORCE_COLOR: "0",
+        CI: "true",
+        NO_UPDATE_NOTIFIER: "1",
+        DEBIAN_FRONTEND: "noninteractive"
+      };
       config;
       logger = logger;
       health;
@@ -2627,19 +2636,7 @@ var init_base_provider = __esm({
             shell: true,
             // Auto-detects: cmd.exe on Windows, /bin/sh on Unix
             timeout: this.config.timeout || 12e4,
-            env: {
-              ...process.env,
-              // Force non-interactive mode for CLIs
-              TERM: "dumb",
-              NO_COLOR: "1",
-              // Disable TTY checks for codex and other CLIs
-              FORCE_COLOR: "0",
-              CI: "true",
-              // Many CLIs disable TTY checks in CI mode
-              NO_UPDATE_NOTIFIER: "1",
-              // Disable interactive prompts
-              DEBIAN_FRONTEND: "noninteractive"
-            }
+            env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
           let stderr = "";
@@ -2789,22 +2786,14 @@ var init_base_provider = __esm({
           });
           const child = spawn(cliCommand2, commandArgs, {
             timeout: this.config.timeout || 12e4,
-            env: {
-              ...process.env,
-              // Force non-interactive mode for CLIs
-              TERM: "dumb",
-              NO_COLOR: "1",
-              FORCE_COLOR: "0",
-              CI: "true",
-              NO_UPDATE_NOTIFIER: "1",
-              DEBIAN_FRONTEND: "noninteractive"
-            }
+            env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
           let stderr = "";
           let timeoutId = null;
           let forceKillTimer = null;
           let readlineInterface = null;
+          let stderrInterface = null;
           const streamingEnabled = process.env.AUTOMATOSX_SHOW_PROVIDER_OUTPUT === "true";
           const debugMode = process.env.AUTOMATOSX_DEBUG === "true";
           const verbosity = VerbosityManager.getInstance();
@@ -2849,7 +2838,7 @@ var init_base_provider = __esm({
             });
           }
           if (child.stderr) {
-            const stderrInterface = readline2__default.createInterface({
+            stderrInterface = readline2__default.createInterface({
               input: child.stderr,
               crlfDelay: Infinity
             });
@@ -2865,6 +2854,13 @@ var init_base_provider = __esm({
                 }
               }
             });
+            stderrInterface.on("error", (error) => {
+              if (error.message !== "Readable stream already read") {
+                logger.debug("Stderr readline error (non-fatal)", {
+                  error: error.message
+                });
+              }
+            });
           }
           const cleanup = () => {
             if (timeoutId) {
@@ -2883,22 +2879,35 @@ var init_base_provider = __esm({
                 readlineInterface = null;
               }
             }
+            if (stderrInterface) {
+              try {
+                stderrInterface.close();
+              } catch (error) {
+              } finally {
+                stderrInterface = null;
+              }
+            }
           };
           child.on("close", (code, signal) => {
             cleanup();
             if (stderr) {
               logger.debug(`${cliCommand2} CLI stderr output`, { stderr: stderr.trim() });
             }
-            if (code === 0) {
+            if ((code === 0 || code === null) && !signal) {
               if (progressParser) {
                 progressParser.succeed(`${cliCommand2} completed successfully`);
               }
               resolve13({ stdout, stderr });
+            } else if (signal) {
+              if (progressParser) {
+                progressParser.fail(`${cliCommand2} killed by signal ${signal}`);
+              }
+              reject(new Error(`${cliCommand2} CLI killed by signal ${signal}. stderr: ${stderr || "none"}`));
             } else {
               if (progressParser) {
                 progressParser.fail(`${cliCommand2} failed with code ${code}`);
               }
-              reject(new Error(`${cliCommand2} CLI exited with code ${code}${signal ? ` (signal: ${signal})` : ""}. stderr: ${stderr || "none"}`));
+              reject(new Error(`${cliCommand2} CLI exited with code ${code}. stderr: ${stderr || "none"}`));
             }
           });
           child.on("error", (error) => {
@@ -3854,8 +3863,6 @@ var init_cli_wrapper = __esm({
     };
   }
 });
-
-// src/integrations/openai-codex/sdk-adapter.ts
 var CodexSdkAdapter;
 var init_sdk_adapter = __esm({
   "src/integrations/openai-codex/sdk-adapter.ts"() {
@@ -3868,6 +3875,8 @@ var init_sdk_adapter = __esm({
       sdkModule = null;
       options;
       initialized = false;
+      initMutex = new Mutex();
+      // v11.2.8: Prevent race condition in ensureInitialized
       constructor(options = {}) {
         this.options = {
           streamingEnabled: true,
@@ -3962,18 +3971,20 @@ var init_sdk_adapter = __esm({
         return this.activeThread;
       }
       async ensureInitialized() {
-        if (this.initialized) return;
-        try {
-          this.sdkModule = await import('@openai/codex-sdk');
-          this.codex = new this.sdkModule.Codex();
-          this.initialized = true;
-          logger.info("Codex SDK initialized");
-        } catch (error) {
-          throw new CodexError(
-            "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
-            "Codex SDK not available. Install with: npm install @openai/codex-sdk"
-          );
-        }
+        return this.initMutex.runExclusive(async () => {
+          if (this.initialized) return;
+          try {
+            this.sdkModule = await import('@openai/codex-sdk');
+            this.codex = new this.sdkModule.Codex();
+            this.initialized = true;
+            logger.info("Codex SDK initialized");
+          } catch (error) {
+            throw new CodexError(
+              "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
+              "Codex SDK not available. Install with: npm install @openai/codex-sdk"
+            );
+          }
+        });
       }
       async destroy() {
         this.activeThread = null;
@@ -4379,6 +4390,9 @@ var init_command_builder = __esm({
        * @returns Environment variable object
        */
       buildEnv(options) {
+        if (!options.apiKey && !options.baseUrl && !options.model) {
+          return null;
+        }
         const env = {};
         if (options.apiKey) {
           env.YOUR_API_KEY = options.apiKey;
@@ -4426,6 +4440,27 @@ var init_response_parser = __esm({
     AxCliResponseParser = class _AxCliResponseParser {
       /** Maximum number of assistant messages to prevent memory exhaustion */
       static MAX_ASSISTANT_MESSAGES = 1e3;
+      /** Pre-compiled regex patterns for error detection (avoids recompilation per call) */
+      static ERROR_WITH_COLON_REGEX = /Sorry, I encountered an error: (.+?)$/;
+      static ERROR_WITHOUT_COLON_REGEX = /Sorry, I encountered an error(.*?)$/;
+      /**
+       * Extract error message from content if present
+       * @returns Error message or null if no error
+       */
+      extractErrorFromContent(content) {
+        if (!content.includes("Sorry, I encountered an error")) {
+          return null;
+        }
+        const matchWithColon = content.match(_AxCliResponseParser.ERROR_WITH_COLON_REGEX);
+        if (matchWithColon?.[1]) {
+          return matchWithColon[1];
+        }
+        const matchWithoutColon = content.match(_AxCliResponseParser.ERROR_WITHOUT_COLON_REGEX);
+        if (matchWithoutColon) {
+          return matchWithoutColon[1] ? matchWithoutColon[1].trim() : "API error";
+        }
+        return "API error";
+      }
       /**
        * Parse JSONL output from ax-cli into ProviderResponse
        *
@@ -4450,17 +4485,9 @@ var init_response_parser = __esm({
               const parsed = JSON.parse(line);
               const validated = AxCliMessageSchema.parse(parsed);
               if (validated.role === "assistant") {
-                if (validated.content.includes("Sorry, I encountered an error")) {
-                  const matchWithColon = validated.content.match(/Sorry, I encountered an error: (.+?)$/);
-                  if (matchWithColon) {
-                    throw new Error(`ax-cli error: ${matchWithColon[1]}`);
-                  }
-                  const matchWithoutColon = validated.content.match(/Sorry, I encountered an error(.*?)$/);
-                  if (matchWithoutColon) {
-                    const errorMsg = matchWithoutColon[1] ? matchWithoutColon[1].trim() : "API error";
-                    throw new Error(`ax-cli error: ${errorMsg}`);
-                  }
-                  throw new Error("ax-cli error: API error");
+                const errorMsg = this.extractErrorFromContent(validated.content);
+                if (errorMsg) {
+                  throw new Error(`ax-cli error: ${errorMsg}`);
                 }
                 if (assistantMessages.length >= _AxCliResponseParser.MAX_ASSISTANT_MESSAGES) {
                   throw new Error(
@@ -4538,16 +4565,9 @@ var init_response_parser = __esm({
             try {
               const parsed = JSON.parse(line);
               if (parsed.role === "assistant" && parsed.content) {
-                if (parsed.content.includes("Sorry, I encountered an error")) {
-                  const matchWithColon = parsed.content.match(/Sorry, I encountered an error: (.+?)$/);
-                  if (matchWithColon) {
-                    return matchWithColon[1];
-                  }
-                  const matchWithoutColon = parsed.content.match(/Sorry, I encountered an error(.*?)$/);
-                  if (matchWithoutColon) {
-                    return matchWithoutColon[1] ? matchWithoutColon[1].trim() : "Sorry, I encountered an error";
-                  }
-                  return parsed.content;
+                const errorMsg = this.extractErrorFromContent(parsed.content);
+                if (errorMsg) {
+                  return errorMsg;
                 }
               }
             } catch {
@@ -4605,7 +4625,7 @@ var init_adapter = __esm({
             // 10MB
             env: {
               ...process.env,
-              ...this.commandBuilder.buildEnv(options)
+              ...this.commandBuilder.buildEnv(options) ?? {}
             }
           });
           if (stderr && stderr.trim().length > 0) {
@@ -4824,11 +4844,12 @@ var init_token_estimator = __esm({
 });
 
 // src/integrations/ax-cli-sdk/subagent-adapter.ts
-var SubagentAdapter;
+var TOKEN_SPLIT, SubagentAdapter;
 var init_subagent_adapter = __esm({
   "src/integrations/ax-cli-sdk/subagent-adapter.ts"() {
     init_esm_shims();
     init_logger();
+    TOKEN_SPLIT = { PROMPT: 0.3, COMPLETION: 0.7 };
     SubagentAdapter = class {
       orchestrator = null;
       subagents = /* @__PURE__ */ new Map();
@@ -5033,9 +5054,8 @@ ${task.task}` : task.task;
             success: true,
             latencyMs,
             tokensUsed: totalTokens > 0 ? {
-              prompt: Math.floor(totalTokens * 0.3),
-              // Estimated split
-              completion: Math.floor(totalTokens * 0.7),
+              prompt: Math.floor(totalTokens * TOKEN_SPLIT.PROMPT),
+              completion: Math.floor(totalTokens * TOKEN_SPLIT.COMPLETION),
               total: totalTokens
             } : void 0
           };
@@ -5198,7 +5218,10 @@ ${task.task}` : task.task;
         for (const [key, subagent] of this.subagents) {
           try {
             if (subagent.dispose) {
-              subagent.dispose();
+              const result = subagent.dispose();
+              if (result instanceof Promise) {
+                await result;
+              }
             }
             logger.debug("Subagent disposed", { key });
           } catch (error) {
@@ -6354,7 +6377,7 @@ var init_adapter2 = __esm({
     init_instructions_bridge();
     init_mcp_manager();
     init_mcp_manager();
-    AxCliSdkAdapter = class {
+    AxCliSdkAdapter = class _AxCliSdkAdapter {
       agent = null;
       // Will type as LLMAgent after import
       agentConfig = null;
@@ -6565,7 +6588,7 @@ var init_adapter2 = __esm({
           if (!await this.ensureSDKAvailable()) {
             throw new Error("ax-cli SDK not available. Install with: npm install @defai.digital/ax-cli");
           }
-          if (!this.agent || await this.hasConfigChanged(options)) {
+          if (!this.agent || this.hasConfigChanged(options)) {
             await this.initializeAgent(options);
           }
           logger.debug("Executing via SDK (streaming mode for token tracking)", {
@@ -6712,8 +6735,9 @@ var init_adapter2 = __esm({
        * Check if agent config has changed (requires new agent)
        *
        * Since SDK manages credentials via settings, we only track maxToolRounds
+       * v11.2.8: Removed unnecessary async (no async operations)
        */
-      async hasConfigChanged(options) {
+      hasConfigChanged(options) {
         if (!this.agentConfig) return true;
         const changed = this.agentConfig.maxToolRounds !== (options.maxToolRounds || 400);
         if (changed) {
@@ -6797,6 +6821,49 @@ var init_adapter2 = __esm({
           });
         }
       }
+      /**
+       * Extract token usage from various sources with priority:
+       * 1. SDK events (token_count emissions) - most accurate
+       * 2. Usage object (ChatEntry.usage or response.usage)
+       * 3. Estimation fallback
+       */
+      extractTokenUsage(prompt, content, totalTokensFromEvents, usageObject, sourceName) {
+        if (totalTokensFromEvents > 0) {
+          const estimated2 = TokenEstimator.estimateUsage(prompt, content);
+          const tokens = {
+            prompt: estimated2.prompt,
+            completion: estimated2.completion,
+            total: totalTokensFromEvents
+          };
+          logger.info(`Using token count from SDK events${sourceName ? ` (${sourceName})` : ""}`, {
+            tokens: TokenEstimator.format(tokens),
+            accuracy: "100% (total), 80-90% (split)",
+            source: "token_count events"
+          });
+          return tokens;
+        }
+        const usage = usageObject || {};
+        const actualTokens = {
+          prompt: usage.prompt_tokens || usage.prompt || usage.input || usage.promptTokens || 0,
+          completion: usage.completion_tokens || usage.completion || usage.output || usage.completionTokens || 0,
+          total: usage.total_tokens || usage.total || usage.totalTokens || 0
+        };
+        if (actualTokens.total > 0) {
+          logger.info(`Using token counts from ${sourceName || "usage object"}`, {
+            tokens: TokenEstimator.format(actualTokens),
+            accuracy: "100%",
+            source: sourceName || "usage"
+          });
+          return actualTokens;
+        }
+        const estimated = TokenEstimator.estimateUsage(prompt, content);
+        logger.warn(`SDK did not provide token counts${sourceName ? ` (${sourceName})` : ""}, using estimation`, {
+          tokens: TokenEstimator.format(estimated, true),
+          accuracy: "80-90% (estimated)",
+          source: "estimation"
+        });
+        return estimated;
+      }
       /**
        * Convert SDK response to ExecutionResponse format
        *
@@ -6827,116 +6894,47 @@ var init_adapter2 = __esm({
           }
           const lastAssistant = assistantMessages[assistantMessages.length - 1];
           const content2 = lastAssistant.content || "";
-          let finalTokens2;
-          if (totalTokensFromEvents > 0) {
-            const estimated = TokenEstimator.estimateUsage(prompt, content2);
-            finalTokens2 = {
-              prompt: estimated.prompt,
-              // Estimated split
-              completion: estimated.completion,
-              // Estimated split
-              total: totalTokensFromEvents
-              // Actual total from events
-            };
-            logger.info("Using token count from SDK events", {
-              tokens: TokenEstimator.format(finalTokens2),
-              accuracy: "100% (total), 80-90% (split)",
-              source: "token_count events"
-            });
-          } else {
-            const usage = lastAssistant.usage || lastAssistant.tokens || {};
-            const actualTokens = {
-              prompt: usage.prompt_tokens || usage.prompt || usage.input || usage.promptTokens || 0,
-              completion: usage.completion_tokens || usage.completion || usage.output || usage.completionTokens || 0,
-              total: usage.total_tokens || usage.total || usage.totalTokens || 0
-            };
-            const hasActualTokens = actualTokens.total > 0;
-            if (hasActualTokens) {
-              finalTokens2 = {
-                prompt: actualTokens.prompt,
-                completion: actualTokens.completion,
-                total: actualTokens.total
-              };
-              logger.info("Using token counts from ChatEntry.usage", {
-                tokens: TokenEstimator.format(finalTokens2),
-                accuracy: "100%",
-                source: "ChatEntry.usage"
-              });
-            } else {
-              finalTokens2 = TokenEstimator.estimateUsage(prompt, content2);
-              logger.warn("SDK did not provide token counts, using estimation", {
-                tokens: TokenEstimator.format(finalTokens2, true),
-                accuracy: "80-90% (estimated)",
-                source: "estimation"
-              });
-            }
-          }
-          const model2 = this.agent.getCurrentModel();
-          const finishReason2 = "stop";
+          const tokensUsed2 = this.extractTokenUsage(
+            prompt,
+            content2,
+            totalTokensFromEvents,
+            lastAssistant.usage || lastAssistant.tokens,
+            "ChatEntry.usage"
+          );
           return {
             content: content2,
-            model: model2,
-            tokensUsed: finalTokens2,
+            model: this.agent?.getCurrentModel() ?? "unknown",
+            tokensUsed: tokensUsed2,
             latencyMs,
-            finishReason: finishReason2,
+            finishReason: "stop",
             cached: false
-            // SDK doesn't expose cache status via ChatEntry
           };
         }
         const content = typeof result === "string" ? result : result.content || result.text || "";
-        let finalTokens;
-        if (totalTokensFromEvents > 0) {
-          const estimated = TokenEstimator.estimateUsage(prompt, content);
-          finalTokens = {
-            prompt: estimated.prompt,
-            completion: estimated.completion,
-            total: totalTokensFromEvents
-          };
-          logger.info("Using token count from SDK events (fallback path)", {
-            tokens: TokenEstimator.format(finalTokens),
-            accuracy: "100% (total), 80-90% (split)",
-            source: "token_count events"
-          });
-        } else {
-          const usage = result.usage || result.tokens || {};
-          const actualTokens = {
-            prompt: usage.prompt_tokens || usage.prompt || usage.input || usage.promptTokens || 0,
-            completion: usage.completion_tokens || usage.completion || usage.output || usage.completionTokens || 0,
-            total: usage.total_tokens || usage.total || usage.totalTokens || 0
-          };
-          const hasActualTokens = actualTokens.total > 0;
-          if (hasActualTokens) {
-            finalTokens = {
-              prompt: actualTokens.prompt,
-              completion: actualTokens.completion,
-              total: actualTokens.total
-            };
-            logger.info("Using token counts from response.usage (fallback path)", {
-              tokens: TokenEstimator.format(finalTokens),
-              accuracy: "100%",
-              source: "response.usage"
-            });
-          } else {
-            finalTokens = TokenEstimator.estimateUsage(prompt, content);
-            logger.warn("SDK did not provide token counts (fallback path), using estimation", {
-              tokens: TokenEstimator.format(finalTokens, true),
-              accuracy: "80-90% (estimated)",
-              source: "estimation"
-            });
-          }
-        }
-        const model = this.agent.getCurrentModel();
-        const finishReason = "stop";
+        const tokensUsed = this.extractTokenUsage(
+          prompt,
+          content,
+          totalTokensFromEvents,
+          result.usage || result.tokens,
+          "response.usage (fallback path)"
+        );
         return {
           content,
-          model,
-          tokensUsed: finalTokens,
+          model: this.agent?.getCurrentModel() ?? "unknown",
+          tokensUsed,
           latencyMs,
-          finishReason,
+          finishReason: "stop",
           cached: false
-          // SDK doesn't expose cache status
         };
       }
+      /** Error mapping patterns: [patterns, prefix, code] */
+      static ERROR_MAPPINGS = [
+        [["rate limit", "rate_limit"], "Rate limit exceeded", "RATE_LIMIT_EXCEEDED"],
+        [["context length", "max_tokens"], "Context length exceeded", "CONTEXT_LENGTH_EXCEEDED"],
+        [["timeout", "timed out"], "Request timeout", "TIMEOUT"],
+        [["invalid api key", "authentication"], "Authentication failed", "AUTHENTICATION_FAILED"],
+        [["network", "econnrefused"], "Network error", "NETWORK_ERROR"]
+      ];
       /**
        * Map SDK errors to AutomatosX error types
        */
@@ -6945,30 +6943,12 @@ var init_adapter2 = __esm({
           return new Error(`SDK error: ${String(error)}`);
         }
         const message = error.message.toLowerCase();
-        if (message.includes("rate limit") || message.includes("rate_limit")) {
-          const mappedError = new Error(`Rate limit exceeded: ${error.message}`);
-          mappedError.code = "RATE_LIMIT_EXCEEDED";
-          return mappedError;
-        }
-        if (message.includes("context length") || message.includes("max_tokens")) {
-          const mappedError = new Error(`Context length exceeded: ${error.message}`);
-          mappedError.code = "CONTEXT_LENGTH_EXCEEDED";
-          return mappedError;
-        }
-        if (message.includes("timeout") || message.includes("timed out")) {
-          const mappedError = new Error(`Request timeout: ${error.message}`);
-          mappedError.code = "TIMEOUT";
-          return mappedError;
-        }
-        if (message.includes("invalid api key") || message.includes("authentication")) {
-          const mappedError = new Error(`Authentication failed: ${error.message}`);
-          mappedError.code = "AUTHENTICATION_FAILED";
-          return mappedError;
-        }
-        if (message.includes("network") || message.includes("econnrefused")) {
-          const mappedError = new Error(`Network error: ${error.message}`);
-          mappedError.code = "NETWORK_ERROR";
-          return mappedError;
+        for (const [patterns, prefix, code] of _AxCliSdkAdapter.ERROR_MAPPINGS) {
+          if (patterns.some((pattern) => message.includes(pattern))) {
+            const mappedError = new Error(`${prefix}: ${error.message}`);
+            mappedError.code = code;
+            return mappedError;
+          }
         }
         return error;
       }
@@ -7003,15 +6983,10 @@ var init_adapter2 = __esm({
        * Get SDK version
        */
       async getVersion() {
-        try {
-          await import('@defai.digital/ax-cli/sdk');
+        if (await this.ensureSDKAvailable()) {
           return "3.14.5+";
-        } catch (error) {
-          logger.warn("Failed to get SDK version", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-          return "unknown";
         }
+        return "unknown";
       }
       /**
        * Get command name (for compatibility with AxCliAdapter interface)
@@ -7031,7 +7006,10 @@ var init_adapter2 = __esm({
       async destroy() {
         if (this.agent) {
           try {
-            this.agent.dispose();
+            const result = this.agent.dispose();
+            if (result instanceof Promise) {
+              await result;
+            }
             this.agent = null;
             this.agentConfig = null;
             logger.debug("SDK agent destroyed");
@@ -9285,7 +9263,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.2.8"
+  "version": "11.2.9"
 };
 
 // src/core/config/schemas.ts
@@ -15174,7 +15152,7 @@ function parseAXMD(content) {
     "Useful Links"
   ];
   for (const section of sections) {
-    const sectionName = section.split("\n")[0];
+    const sectionName = section.split("\n")[0] ?? "";
     if (sectionName && !standardSections.includes(sectionName)) {
       result.customSections.push(sectionName);
     }
@@ -16567,6 +16545,8 @@ var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
   getManualOverride() {
     if (this.manualOverride && this.manualOverride.expiresAtMs) {
       if (Date.now() >= this.manualOverride.expiresAtMs) {
+        this.manualOverride;
+        this.manualOverride = void 0;
         void this.clearManualOverride();
         return void 0;
       }
@@ -16907,19 +16887,33 @@ var ProviderMetricsTracker = class extends EventEmitter {
     const p50 = getPercentile(latencies, 50);
     const p95 = getPercentile(latencies, 95);
     const p99 = getPercentile(latencies, 99);
-    const successful = records.filter((r) => r.success);
-    const failed = records.filter((r) => !r.success);
-    const stopFinishes = successful.filter((r) => r.finishReason === "stop");
-    const lengthFinishes = successful.filter((r) => r.finishReason === "length");
-    const errorFinishes = records.filter((r) => r.finishReason === "error");
-    const successRate = successful.length / records.length;
-    const properStopRate = successful.length > 0 ? stopFinishes.length / successful.length : 0;
+    let successCount = 0;
+    let failCount = 0;
+    let stopFinishCount = 0;
+    let lengthFinishCount = 0;
+    let errorFinishCount = 0;
+    let lastSuccessTimestamp = 0;
+    let lastFailureTimestamp = 0;
+    for (const r of records) {
+      if (r.success) {
+        successCount++;
+        lastSuccessTimestamp = r.timestamp;
+        if (r.finishReason === "stop") stopFinishCount++;
+        else if (r.finishReason === "length") lengthFinishCount++;
+      } else {
+        failCount++;
+        lastFailureTimestamp = r.timestamp;
+      }
+      if (r.finishReason === "error") errorFinishCount++;
+    }
+    const successRate = successCount / records.length;
+    const properStopRate = successCount > 0 ? stopFinishCount / successCount : 0;
     const totalCost = records.reduce((sum, r) => sum + r.costUsd, 0);
     const avgCostPerRequest = totalCost / records.length;
     const totalTokens = records.reduce((sum, r) => sum + r.totalTokens, 0);
     const avgCostPer1M = totalTokens > 0 ? totalCost / totalTokens * 1e6 : 0;
-    const lastSuccess = successful.length > 0 ? successful[successful.length - 1].timestamp : 0;
-    const lastFailure = failed.length > 0 ? failed[failed.length - 1].timestamp : 0;
+    const lastSuccess = lastSuccessTimestamp;
+    const lastFailure = lastFailureTimestamp;
     let consecutiveFailures = 0;
     for (let i = records.length - 1; i >= 0; i--) {
       if (!records[i].success) {
@@ -16942,12 +16936,12 @@ var ProviderMetricsTracker = class extends EventEmitter {
       },
       quality: {
         totalRequests: records.length,
-        successfulRequests: successful.length,
-        failedRequests: failed.length,
+        successfulRequests: successCount,
+        failedRequests: failCount,
         successRate,
-        stopFinishes: stopFinishes.length,
-        lengthFinishes: lengthFinishes.length,
-        errorFinishes: errorFinishes.length,
+        stopFinishes: stopFinishCount,
+        lengthFinishes: lengthFinishCount,
+        errorFinishes: errorFinishCount,
         properStopRate
       },
       cost: {
@@ -17056,7 +17050,7 @@ var ProviderMetricsTracker = class extends EventEmitter {
    * v9.0.2: Added score caching to reduce redundant calculations
    */
   async calculateScore(provider, weights, allProviders, healthMultiplier = 1) {
-    const cacheKey = `${provider}-${JSON.stringify(weights)}-${healthMultiplier}`;
+    const cacheKey = `${provider}-${weights.cost}-${weights.latency}-${weights.quality}-${weights.availability}-${healthMultiplier}`;
     const cached = this.scoreCache.get(cacheKey);
     const currentRequestCount = this.getRequestCount(provider);
     if (cached) {
@@ -18221,8 +18215,7 @@ var Router = class {
         }
       }
       if (limitedProviders2.length === allProviders2.length && limitedProviders2.length > 0) {
-        const soonestReset = Math.min(...limitedProviders2.map((p) => p.resetAtMs));
-        throw ProviderError.allProvidersLimited(limitedProviders2, soonestReset);
+        throw ProviderError.allProvidersLimited(limitedProviders2, this.getSoonestLimitReset(limitedProviders2));
       }
       throw ProviderError.noAvailableProviders();
     }
@@ -18628,8 +18621,7 @@ var Router = class {
       }
     }
     if (limitedProviders.length === allProviders.length && limitedProviders.length > 0) {
-      const soonestReset = Math.min(...limitedProviders.map((p) => p.resetAtMs));
-      throw ProviderError.allProvidersLimited(limitedProviders, soonestReset);
+      throw ProviderError.allProvidersLimited(limitedProviders, this.getSoonestLimitReset(limitedProviders));
     }
     const errorDetails = {
       lastError: lastError?.message,
@@ -18863,6 +18855,16 @@ Run 'ax doctor' to diagnose provider setup.` : "";
       })
     };
   }
+  /**
+   * Calculate the soonest reset time from limited providers
+   * v11.2.8: Added guard against empty array (Math.min on empty array returns Infinity)
+   */
+  getSoonestLimitReset(limitedProviders) {
+    if (limitedProviders.length === 0) {
+      return Date.now() + 6e4;
+    }
+    return Math.min(...limitedProviders.map((p) => p.resetAtMs));
+  }
 };
 
 // src/core/memory/lazy-manager.ts
@@ -20698,8 +20700,6 @@ z.object({
   limit: z.number().int().positive().max(1e4).optional(),
   offset: z.number().int().nonnegative().optional()
 }).strict();
-
-// src/core/session/manager.ts
 var SessionManager = class _SessionManager {
   /** Active sessions (in-memory, keyed by session ID) */
   activeSessions = /* @__PURE__ */ new Map();
@@ -20772,8 +20772,9 @@ var SessionManager = class _SessionManager {
       try {
         SessionManagerConfigSchema.parse(config);
       } catch (error) {
+        const message = error instanceof ZodError ? error.message : String(error);
         throw new SessionError(
-          `Invalid session manager config: ${error.message}`,
+          `Invalid session manager config: ${message}`,
           void 0,
           "invalid_configuration"
         );
@@ -29880,13 +29881,23 @@ var MetricsCollector = class {
    */
   getMetricsSummary(serverMetrics) {
     const totalServers = serverMetrics.length;
-    const healthyServers = serverMetrics.filter((m) => m.memoryUsageMB > 0).length;
-    const totalCpu = serverMetrics.reduce((sum, m) => sum + m.cpuUsagePercent, 0);
-    const totalMemory = serverMetrics.reduce((sum, m) => sum + m.memoryUsageMB, 0);
-    const totalRequests = serverMetrics.reduce((sum, m) => sum + m.totalRequests, 0);
-    const totalFailed = serverMetrics.reduce((sum, m) => sum + m.failedRequests, 0);
-    const totalRestarts = serverMetrics.reduce((sum, m) => sum + m.restartCount, 0);
-    const avgResponseTime = serverMetrics.length > 0 ? serverMetrics.reduce((sum, m) => sum + m.avgResponseTimeMs, 0) / serverMetrics.length : 0;
+    let healthyServers = 0;
+    let totalCpu = 0;
+    let totalMemory = 0;
+    let totalRequests = 0;
+    let totalFailed = 0;
+    let totalRestarts = 0;
+    let totalResponseTime = 0;
+    for (const m of serverMetrics) {
+      if (m.memoryUsageMB > 0) healthyServers++;
+      totalCpu += m.cpuUsagePercent;
+      totalMemory += m.memoryUsageMB;
+      totalRequests += m.totalRequests;
+      totalFailed += m.failedRequests;
+      totalRestarts += m.restartCount;
+      totalResponseTime += m.avgResponseTimeMs;
+    }
+    const avgResponseTime = totalServers > 0 ? totalResponseTime / totalServers : 0;
     const errorRate = totalRequests > 0 ? totalFailed / totalRequests * 100 : 0;
     return {
       totalServers,
@@ -31758,7 +31769,7 @@ var addCommand = {
           throw new Error(`Invalid metadata JSON: ${error.message}`);
         }
       }
-      const embedding = new Array(1536).fill(0);
+      const embedding = Array(1536).fill(0);
       const entry = await manager.add(argv.content, embedding, metadata);
       printSuccess("\nMemory entry added successfully\n");
       console.log(`${chalk5.bold("ID:")} ${chalk5.white(entry.id)}`);
@@ -34106,47 +34117,39 @@ ${action.modifications}`;
    * @param stage - Stage to execute
    * @param context - Stage context
    * @returns Stage task prompt
+   * v11.2.8: Refactored to use array.join() for better string building performance
    */
   buildStageTask(stage, context) {
-    let prompt = `# Stage: ${stage.name}
-
-`;
-    prompt += `## Stage Description
+    const parts = [
+      `# Stage: ${stage.name}
+`,
+      `## Stage Description
 ${stage.description}
-
-`;
-    prompt += `## Original Task
+`,
+      `## Original Task
 ${context.task}
-
-`;
+`
+    ];
     if (context.previousOutputs.length > 0) {
-      prompt += `## Previous Stage Outputs
-
-`;
-      context.previousOutputs.forEach((output, index) => {
-        prompt += `### Stage ${index + 1} Output
+      parts.push(`## Previous Stage Outputs
+`);
+      parts.push(...context.previousOutputs.map(
+        (output, index) => `### Stage ${index + 1} Output
 ${output}
-
-`;
-      });
+`
+      ));
     }
     if (stage.key_questions && stage.key_questions.length > 0) {
-      prompt += `## Key Questions to Address
-`;
-      stage.key_questions.forEach((q) => prompt += `- ${q}
-`);
-      prompt += `
-`;
+      parts.push(`## Key Questions to Address`);
+      parts.push(...stage.key_questions.map((q) => `- ${q}`));
+      parts.push("");
     }
     if (stage.outputs && stage.outputs.length > 0) {
-      prompt += `## Expected Outputs
-`;
-      stage.outputs.forEach((o) => prompt += `- ${o}
-`);
-      prompt += `
-`;
+      parts.push(`## Expected Outputs`);
+      parts.push(...stage.outputs.map((o) => `- ${o}`));
+      parts.push("");
     }
-    return prompt;
+    return parts.join("\n");
   }
   /**
    * Enhance stages with index and defaults
@@ -44704,10 +44707,11 @@ function displayPlanSummary(plan) {
   console.log(chalk5.gray(`  Storage: ${plan.resourceRequirements.storage}`));
   console.log(chalk5.gray(`  Network: ${plan.resourceRequirements.network}
 `));
+  const SEVERITY_ICONS = { high: "\u{1F534}", medium: "\u{1F7E1}", low: "\u{1F7E2}" };
   if (plan.risks.length > 0) {
     console.log(chalk5.blue("Identified Risks:"));
     for (const risk of plan.risks) {
-      const icon = risk.severity === "high" ? "\u{1F534}" : risk.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+      const icon = SEVERITY_ICONS[risk.severity] ?? "\u{1F7E2}";
       console.log(`  ${icon} ${risk.severity.toUpperCase()}: ${risk.title}`);
       console.log(chalk5.gray(`    ${risk.description}`));
       console.log(chalk5.gray(`    Mitigation: ${risk.mitigation}
@@ -46833,37 +46837,38 @@ var TelemetryCollector = class {
       logger.warn("Query called on closed or uninitialized telemetry collector");
       return [];
     }
-    let sql = "SELECT * FROM telemetry_events WHERE 1=1";
+    const conditions = [];
     const params = [];
     if (filters.provider) {
-      sql += " AND provider = ?";
+      conditions.push("provider = ?");
       params.push(filters.provider);
     }
     if (filters.agentName) {
-      sql += " AND agent_name = ?";
+      conditions.push("agent_name = ?");
       params.push(filters.agentName);
     }
     if (filters.sessionId) {
-      sql += " AND session_id = ?";
+      conditions.push("session_id = ?");
       params.push(filters.sessionId);
     }
     if (filters.type) {
-      sql += " AND type = ?";
+      conditions.push("type = ?");
       params.push(filters.type);
     }
     if (filters.startDate) {
-      sql += " AND timestamp >= ?";
+      conditions.push("timestamp >= ?");
       params.push(filters.startDate);
     }
     if (filters.endDate) {
-      sql += " AND timestamp <= ?";
+      conditions.push("timestamp <= ?");
       params.push(filters.endDate);
     }
     if (filters.success !== void 0) {
-      sql += " AND success = ?";
+      conditions.push("success = ?");
       params.push(filters.success ? 1 : 0);
     }
-    sql += " ORDER BY timestamp DESC LIMIT ?";
+    const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+    const sql = `SELECT * FROM telemetry_events ${whereClause} ORDER BY timestamp DESC LIMIT ?`;
     params.push(filters.limit || 1e3);
     const rows = this.db.prepare(sql).all(...params);
     return rows.map((row) => this.mapRowToEvent(row));
@@ -46877,20 +46882,22 @@ var TelemetryCollector = class {
     if (this.closed || !this.db) {
       return 0;
     }
-    let sql = "SELECT COUNT(*) as count FROM telemetry_events WHERE 1=1";
+    const conditions = [];
     const params = [];
     if (filters.provider) {
-      sql += " AND provider = ?";
+      conditions.push("provider = ?");
       params.push(filters.provider);
     }
     if (filters.startDate) {
-      sql += " AND timestamp >= ?";
+      conditions.push("timestamp >= ?");
       params.push(filters.startDate);
     }
     if (filters.endDate) {
-      sql += " AND timestamp <= ?";
+      conditions.push("timestamp <= ?");
       params.push(filters.endDate);
     }
+    const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+    const sql = `SELECT COUNT(*) as count FROM telemetry_events ${whereClause}`;
     const result = this.db.prepare(sql).get(...params);
     return result.count;
   }
@@ -47610,9 +47617,11 @@ async function optimizeHandler(argv) {
       console.log(chalk5.green("\u2705 No optimization opportunities found. You're doing great!\n"));
       return;
     }
+    const TYPE_ICONS = { cost_saving: "\u{1F4B0}", performance: "\u26A1", security: "\u{1F512}" };
+    const SEVERITY_COLORS = { high: chalk5.red, medium: chalk5.yellow, low: chalk5.gray };
     for (const rec of recommendations) {
-      const icon = rec.type === "cost_saving" ? "\u{1F4B0}" : rec.type === "performance" ? "\u26A1" : "\u{1F512}";
-      const severityColor = rec.severity === "high" ? chalk5.red : rec.severity === "medium" ? chalk5.yellow : chalk5.gray;
+      const icon = TYPE_ICONS[rec.type] ?? "\u{1F512}";
+      const severityColor = SEVERITY_COLORS[rec.severity] ?? chalk5.gray;
       console.log(`${icon} ${severityColor(rec.severity.toUpperCase())}: ${chalk5.bold(rec.title)}`);
       console.log(`   ${rec.description}`);
       if (rec.estimatedSavings) {

package/dist/mcp/index.js

@@ -7,13 +7,13 @@ import { existsSync, readFileSync, promises, mkdirSync, createWriteStream, write
 import Database2 from 'better-sqlite3';
 import { glob } from 'glob';
 import { spawn, spawnSync } from 'child_process';
-import { z } from 'zod';
+import { z, ZodError } from 'zod';
 import chalk4 from 'chalk';
 import ora2 from 'ora';
 import readline, { createInterface } from 'readline';
+import { Mutex } from 'async-mutex';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
-import { Mutex } from 'async-mutex';
 import os2, { cpus } from 'os';
 import { load } from 'js-yaml';
 import { EventEmitter } from 'events';
@@ -2277,6 +2277,15 @@ var init_base_provider = __esm({
         "test-provider"
         // For unit tests
       ];
+      /** Environment variables to force non-interactive CLI mode */
+      static NON_INTERACTIVE_ENV = {
+        TERM: "dumb",
+        NO_COLOR: "1",
+        FORCE_COLOR: "0",
+        CI: "true",
+        NO_UPDATE_NOTIFIER: "1",
+        DEBIAN_FRONTEND: "noninteractive"
+      };
       config;
       logger = logger;
       health;
@@ -2369,19 +2378,7 @@ var init_base_provider = __esm({
             shell: true,
             // Auto-detects: cmd.exe on Windows, /bin/sh on Unix
             timeout: this.config.timeout || 12e4,
-            env: {
-              ...process.env,
-              // Force non-interactive mode for CLIs
-              TERM: "dumb",
-              NO_COLOR: "1",
-              // Disable TTY checks for codex and other CLIs
-              FORCE_COLOR: "0",
-              CI: "true",
-              // Many CLIs disable TTY checks in CI mode
-              NO_UPDATE_NOTIFIER: "1",
-              // Disable interactive prompts
-              DEBIAN_FRONTEND: "noninteractive"
-            }
+            env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
           let stderr = "";
@@ -2531,22 +2528,14 @@ var init_base_provider = __esm({
           });
           const child = spawn(cliCommand, commandArgs, {
             timeout: this.config.timeout || 12e4,
-            env: {
-              ...process.env,
-              // Force non-interactive mode for CLIs
-              TERM: "dumb",
-              NO_COLOR: "1",
-              FORCE_COLOR: "0",
-              CI: "true",
-              NO_UPDATE_NOTIFIER: "1",
-              DEBIAN_FRONTEND: "noninteractive"
-            }
+            env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
           let stderr = "";
           let timeoutId = null;
           let forceKillTimer = null;
           let readlineInterface = null;
+          let stderrInterface = null;
           const streamingEnabled = process.env.AUTOMATOSX_SHOW_PROVIDER_OUTPUT === "true";
           const debugMode = process.env.AUTOMATOSX_DEBUG === "true";
           const verbosity = VerbosityManager.getInstance();
@@ -2591,7 +2580,7 @@ var init_base_provider = __esm({
             });
           }
           if (child.stderr) {
-            const stderrInterface = readline.createInterface({
+            stderrInterface = readline.createInterface({
               input: child.stderr,
               crlfDelay: Infinity
             });
@@ -2607,6 +2596,13 @@ var init_base_provider = __esm({
                 }
               }
             });
+            stderrInterface.on("error", (error) => {
+              if (error.message !== "Readable stream already read") {
+                logger.debug("Stderr readline error (non-fatal)", {
+                  error: error.message
+                });
+              }
+            });
           }
           const cleanup = () => {
             if (timeoutId) {
@@ -2625,22 +2621,35 @@ var init_base_provider = __esm({
                 readlineInterface = null;
               }
             }
+            if (stderrInterface) {
+              try {
+                stderrInterface.close();
+              } catch (error) {
+              } finally {
+                stderrInterface = null;
+              }
+            }
           };
           child.on("close", (code, signal) => {
             cleanup();
             if (stderr) {
               logger.debug(`${cliCommand} CLI stderr output`, { stderr: stderr.trim() });
             }
-            if (code === 0) {
+            if ((code === 0 || code === null) && !signal) {
               if (progressParser) {
                 progressParser.succeed(`${cliCommand} completed successfully`);
               }
               resolve5({ stdout, stderr });
+            } else if (signal) {
+              if (progressParser) {
+                progressParser.fail(`${cliCommand} killed by signal ${signal}`);
+              }
+              reject(new Error(`${cliCommand} CLI killed by signal ${signal}. stderr: ${stderr || "none"}`));
             } else {
               if (progressParser) {
                 progressParser.fail(`${cliCommand} failed with code ${code}`);
               }
-              reject(new Error(`${cliCommand} CLI exited with code ${code}${signal ? ` (signal: ${signal})` : ""}. stderr: ${stderr || "none"}`));
+              reject(new Error(`${cliCommand} CLI exited with code ${code}. stderr: ${stderr || "none"}`));
             }
           });
           child.on("error", (error) => {
@@ -3596,8 +3605,6 @@ var init_cli_wrapper = __esm({
     };
   }
 });
-
-// src/integrations/openai-codex/sdk-adapter.ts
 var CodexSdkAdapter;
 var init_sdk_adapter = __esm({
   "src/integrations/openai-codex/sdk-adapter.ts"() {
@@ -3610,6 +3617,8 @@ var init_sdk_adapter = __esm({
       sdkModule = null;
       options;
       initialized = false;
+      initMutex = new Mutex();
+      // v11.2.8: Prevent race condition in ensureInitialized
       constructor(options = {}) {
         this.options = {
           streamingEnabled: true,
@@ -3704,18 +3713,20 @@ var init_sdk_adapter = __esm({
         return this.activeThread;
       }
       async ensureInitialized() {
-        if (this.initialized) return;
-        try {
-          this.sdkModule = await import('@openai/codex-sdk');
-          this.codex = new this.sdkModule.Codex();
-          this.initialized = true;
-          logger.info("Codex SDK initialized");
-        } catch (error) {
-          throw new CodexError(
-            "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
-            "Codex SDK not available. Install with: npm install @openai/codex-sdk"
-          );
-        }
+        return this.initMutex.runExclusive(async () => {
+          if (this.initialized) return;
+          try {
+            this.sdkModule = await import('@openai/codex-sdk');
+            this.codex = new this.sdkModule.Codex();
+            this.initialized = true;
+            logger.info("Codex SDK initialized");
+          } catch (error) {
+            throw new CodexError(
+              "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
+              "Codex SDK not available. Install with: npm install @openai/codex-sdk"
+            );
+          }
+        });
       }
       async destroy() {
         this.activeThread = null;
@@ -5229,7 +5240,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.2.8"
+  "version": "11.2.9"
 };
 
 // src/core/config/schemas.ts
@@ -6478,6 +6489,8 @@ var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
   getManualOverride() {
     if (this.manualOverride && this.manualOverride.expiresAtMs) {
       if (Date.now() >= this.manualOverride.expiresAtMs) {
+        this.manualOverride;
+        this.manualOverride = void 0;
         void this.clearManualOverride();
         return void 0;
       }
@@ -6972,19 +6985,33 @@ var ProviderMetricsTracker = class extends EventEmitter {
     const p50 = getPercentile(latencies, 50);
     const p95 = getPercentile(latencies, 95);
     const p99 = getPercentile(latencies, 99);
-    const successful = records.filter((r) => r.success);
-    const failed = records.filter((r) => !r.success);
-    const stopFinishes = successful.filter((r) => r.finishReason === "stop");
-    const lengthFinishes = successful.filter((r) => r.finishReason === "length");
-    const errorFinishes = records.filter((r) => r.finishReason === "error");
-    const successRate = successful.length / records.length;
-    const properStopRate = successful.length > 0 ? stopFinishes.length / successful.length : 0;
+    let successCount = 0;
+    let failCount = 0;
+    let stopFinishCount = 0;
+    let lengthFinishCount = 0;
+    let errorFinishCount = 0;
+    let lastSuccessTimestamp = 0;
+    let lastFailureTimestamp = 0;
+    for (const r of records) {
+      if (r.success) {
+        successCount++;
+        lastSuccessTimestamp = r.timestamp;
+        if (r.finishReason === "stop") stopFinishCount++;
+        else if (r.finishReason === "length") lengthFinishCount++;
+      } else {
+        failCount++;
+        lastFailureTimestamp = r.timestamp;
+      }
+      if (r.finishReason === "error") errorFinishCount++;
+    }
+    const successRate = successCount / records.length;
+    const properStopRate = successCount > 0 ? stopFinishCount / successCount : 0;
     const totalCost = records.reduce((sum, r) => sum + r.costUsd, 0);
     const avgCostPerRequest = totalCost / records.length;
     const totalTokens = records.reduce((sum, r) => sum + r.totalTokens, 0);
     const avgCostPer1M = totalTokens > 0 ? totalCost / totalTokens * 1e6 : 0;
-    const lastSuccess = successful.length > 0 ? successful[successful.length - 1].timestamp : 0;
-    const lastFailure = failed.length > 0 ? failed[failed.length - 1].timestamp : 0;
+    const lastSuccess = lastSuccessTimestamp;
+    const lastFailure = lastFailureTimestamp;
     let consecutiveFailures = 0;
     for (let i = records.length - 1; i >= 0; i--) {
       if (!records[i].success) {
@@ -7007,12 +7034,12 @@ var ProviderMetricsTracker = class extends EventEmitter {
       },
       quality: {
         totalRequests: records.length,
-        successfulRequests: successful.length,
-        failedRequests: failed.length,
+        successfulRequests: successCount,
+        failedRequests: failCount,
         successRate,
-        stopFinishes: stopFinishes.length,
-        lengthFinishes: lengthFinishes.length,
-        errorFinishes: errorFinishes.length,
+        stopFinishes: stopFinishCount,
+        lengthFinishes: lengthFinishCount,
+        errorFinishes: errorFinishCount,
         properStopRate
       },
       cost: {
@@ -7121,7 +7148,7 @@ var ProviderMetricsTracker = class extends EventEmitter {
    * v9.0.2: Added score caching to reduce redundant calculations
    */
   async calculateScore(provider, weights, allProviders, healthMultiplier = 1) {
-    const cacheKey = `${provider}-${JSON.stringify(weights)}-${healthMultiplier}`;
+    const cacheKey = `${provider}-${weights.cost}-${weights.latency}-${weights.quality}-${weights.availability}-${healthMultiplier}`;
     const cached = this.scoreCache.get(cacheKey);
     const currentRequestCount = this.getRequestCount(provider);
     if (cached) {
@@ -8285,8 +8312,7 @@ var Router = class {
         }
       }
       if (limitedProviders2.length === allProviders2.length && limitedProviders2.length > 0) {
-        const soonestReset = Math.min(...limitedProviders2.map((p) => p.resetAtMs));
-        throw ProviderError.allProvidersLimited(limitedProviders2, soonestReset);
+        throw ProviderError.allProvidersLimited(limitedProviders2, this.getSoonestLimitReset(limitedProviders2));
       }
       throw ProviderError.noAvailableProviders();
     }
@@ -8692,8 +8718,7 @@ var Router = class {
       }
     }
     if (limitedProviders.length === allProviders.length && limitedProviders.length > 0) {
-      const soonestReset = Math.min(...limitedProviders.map((p) => p.resetAtMs));
-      throw ProviderError.allProvidersLimited(limitedProviders, soonestReset);
+      throw ProviderError.allProvidersLimited(limitedProviders, this.getSoonestLimitReset(limitedProviders));
     }
     const errorDetails = {
       lastError: lastError?.message,
@@ -8927,6 +8952,16 @@ Run 'ax doctor' to diagnose provider setup.` : "";
       })
     };
   }
+  /**
+   * Calculate the soonest reset time from limited providers
+   * v11.2.8: Added guard against empty array (Math.min on empty array returns Infinity)
+   */
+  getSoonestLimitReset(limitedProviders) {
+    if (limitedProviders.length === 0) {
+      return Date.now() + 6e4;
+    }
+    return Math.min(...limitedProviders.map((p) => p.resetAtMs));
+  }
 };
 
 // src/core/memory/lazy-manager.ts
@@ -10760,8 +10795,6 @@ z.object({
   limit: z.number().int().positive().max(1e4).optional(),
   offset: z.number().int().nonnegative().optional()
 }).strict();
-
-// src/core/session/manager.ts
 var SessionManager = class _SessionManager {
   /** Active sessions (in-memory, keyed by session ID) */
   activeSessions = /* @__PURE__ */ new Map();
@@ -10834,8 +10867,9 @@ var SessionManager = class _SessionManager {
       try {
         SessionManagerConfigSchema.parse(config);
       } catch (error) {
+        const message = error instanceof ZodError ? error.message : String(error);
         throw new SessionError(
-          `Invalid session manager config: ${error.message}`,
+          `Invalid session manager config: ${message}`,
           void 0,
           "invalid_configuration"
         );

package/examples/abilities/our-architecture-decisions.md

@@ -25,7 +25,7 @@
 
 **Rationale:**
 
-- Node.js 20+ has first-class ESM support
+- Node.js 24+ has first-class ESM support
 - Better tree-shaking and bundle optimization
 - Modern standards compliance
 

package/examples/abilities/our-project-structure.md

@@ -137,7 +137,7 @@ import type { Provider } from '../types/provider.js';
 - `index.js.map` - Source map
 - `index.d.ts` - Type definitions
 
-**Bundle target:** ESM, Node 20+, <250KB target
+**Bundle target:** ESM, Node 24+, <250KB target
 
 ## Workspace Structure
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defai.digital/automatosx",
-  "version": "11.2.8",
+  "version": "11.2.9",
   "description": "Provider-agnostic AI orchestration platform with 20+ specialized agents, persistent memory, and multi-provider routing for Claude Code, Gemini CLI, Codex CLI, and ax-cli",
   "type": "module",
   "publishConfig": {