@defai.digital/automatosx 5.6.35 → 5.7.2

package/dist/index.js

@@ -7,6 +7,7 @@ import * as actualFS from 'fs';
 import { realpathSync as realpathSync$1, access, realpath, existsSync, readFileSync, constants, writeFileSync, readlinkSync, readdirSync, readdir as readdir$1, lstatSync, promises, mkdirSync } from 'fs';
 import os2, { homedir, cpus } from 'os';
 import { findUp } from 'find-up';
+import { EventEmitter } from 'events';
 import { exec, spawnSync } from 'child_process';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -17,7 +18,6 @@ import chalk27 from 'chalk';
 import Table from 'cli-table3';
 import * as sqliteVec from 'sqlite-vec';
 import { Mutex } from 'async-mutex';
-import { EventEmitter } from 'events';
 import ora from 'ora';
 import * as readline from 'readline';
 import { promisify } from 'util';
@@ -490,6 +490,233 @@ var init_path_utils = __esm({
   }
 });
 
+// src/utils/errors.ts
+function toBaseError(error) {
+  if (error instanceof BaseError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new BaseError(
+      error.message,
+      "E9999" /* UNKNOWN_ERROR */,
+      ["Check error details for more information"],
+      { originalError: error.name, stack: error.stack }
+    );
+  }
+  return new BaseError(
+    String(error),
+    "E9999" /* UNKNOWN_ERROR */,
+    ["An unexpected error occurred"]
+  );
+}
+var BaseError, ConfigError, ProviderError;
+var init_errors = __esm({
+  "src/utils/errors.ts"() {
+    init_esm_shims();
+    BaseError = class extends Error {
+      code;
+      suggestions;
+      context;
+      isOperational;
+      constructor(message, code, suggestions = [], context, isOperational = true) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.suggestions = suggestions;
+        this.context = context;
+        this.isOperational = isOperational;
+        Error.captureStackTrace(this, this.constructor);
+      }
+      /**
+       * Get formatted error message for display
+       */
+      getFormattedMessage() {
+        let formatted = `[${this.code}] ${this.message}`;
+        if (this.suggestions.length > 0) {
+          formatted += "\n\nSuggestions:";
+          this.suggestions.forEach((suggestion, i) => {
+            formatted += `
+  ${i + 1}. ${suggestion}`;
+          });
+        }
+        return formatted;
+      }
+      /**
+       * Get error details as object
+       */
+      toJSON() {
+        return {
+          name: this.name,
+          code: this.code,
+          message: this.message,
+          suggestions: this.suggestions,
+          context: this.context,
+          isOperational: this.isOperational,
+          stack: this.stack
+        };
+      }
+    };
+    ConfigError = class _ConfigError extends BaseError {
+      constructor(message, code = "E1001" /* CONFIG_INVALID */, suggestions = [], context) {
+        super(message, code, suggestions, context);
+      }
+      static notFound(path6) {
+        return new _ConfigError(
+          `Configuration file not found: ${path6}`,
+          "E1000" /* CONFIG_NOT_FOUND */,
+          [
+            'Run "automatosx init" to create a new configuration',
+            "Specify a custom config path with --config option",
+            "Check that you are in a valid AutomatosX project directory"
+          ],
+          { path: path6 }
+        );
+      }
+      static invalid(reason, context) {
+        return new _ConfigError(
+          `Invalid configuration: ${reason}`,
+          "E1001" /* CONFIG_INVALID */,
+          [
+            "Check your automatosx.config.json for syntax errors",
+            "Validate against the schema in documentation",
+            'Reset to default with "automatosx init --force"'
+          ],
+          context
+        );
+      }
+      static parseError(error, path6) {
+        return new _ConfigError(
+          `Failed to parse configuration: ${error.message}`,
+          "E1002" /* CONFIG_PARSE_ERROR */,
+          [
+            "Check JSON syntax in your config file",
+            "Use a JSON validator to find syntax errors",
+            'Reset to default with "automatosx init --force"'
+          ],
+          { path: path6, originalError: error.message }
+        );
+      }
+    };
+    ProviderError = class _ProviderError extends BaseError {
+      constructor(message, code = "E1301" /* PROVIDER_UNAVAILABLE */, suggestions = [], context) {
+        super(message, code, suggestions, context);
+      }
+      static notFound(providerName) {
+        return new _ProviderError(
+          `Provider "${providerName}" not found`,
+          "E1300" /* PROVIDER_NOT_FOUND */,
+          [
+            'Check available providers with "automatosx list providers"',
+            "Verify provider is enabled in automatosx.config.json",
+            "Install the provider CLI if not already installed"
+          ],
+          { providerName }
+        );
+      }
+      static unavailable(providerName, reason) {
+        const msg = reason ? `Provider "${providerName}" unavailable: ${reason}` : `Provider "${providerName}" is unavailable`;
+        return new _ProviderError(
+          msg,
+          "E1301" /* PROVIDER_UNAVAILABLE */,
+          [
+            "Check that the provider CLI is installed and in your PATH",
+            "Verify provider configuration in automatosx.config.json",
+            "Try running the provider CLI directly to diagnose issues",
+            'Check system status with "automatosx status --verbose"'
+          ],
+          { providerName, reason }
+        );
+      }
+      static timeout(providerName, timeoutMs) {
+        return new _ProviderError(
+          `Provider "${providerName}" timed out after ${timeoutMs}ms`,
+          "E1302" /* PROVIDER_TIMEOUT */,
+          [
+            "Increase timeout in automatosx.config.json",
+            "Try a simpler prompt or reduce context size",
+            "Check your network connection",
+            "Verify the provider service is responsive"
+          ],
+          { providerName, timeoutMs }
+        );
+      }
+      static noAvailableProviders() {
+        return new _ProviderError(
+          "No AI providers are available",
+          "E1306" /* PROVIDER_NO_AVAILABLE */,
+          [
+            "Install at least one provider CLI (Claude or Gemini)",
+            "Enable providers in automatosx.config.json",
+            'Check provider status with "automatosx status"',
+            "Verify provider CLIs are in your PATH"
+          ]
+        );
+      }
+      static executionError(providerName, error) {
+        return new _ProviderError(
+          `Provider "${providerName}" execution failed: ${error.message}`,
+          "E1305" /* PROVIDER_EXEC_ERROR */,
+          [
+            "Check that the provider CLI is installed correctly",
+            "Verify you have necessary API keys configured",
+            "Try running the provider CLI directly to diagnose",
+            "Check error logs with --debug flag"
+          ],
+          { providerName, originalError: error.message }
+        );
+      }
+      /**
+       * Create rate limit error with detailed context
+       * v5.7.0: Provider limit detection and rotation
+       */
+      static rateLimit(providerName, limitWindow, resetAtMs, rawMessage, retryAfterSeconds) {
+        const resetDate = new Date(resetAtMs);
+        const hoursUntilReset = Math.ceil((resetAtMs - Date.now()) / (1e3 * 60 * 60));
+        const timeDesc = hoursUntilReset < 1 ? "less than 1 hour" : hoursUntilReset === 1 ? "1 hour" : `${hoursUntilReset} hours`;
+        return new _ProviderError(
+          `Provider "${providerName}" has hit its ${limitWindow} usage limit. Resets in ${timeDesc} at ${resetDate.toISOString()}`,
+          "E1303" /* PROVIDER_RATE_LIMIT */,
+          [
+            "AutomatosX will automatically switch to the next available provider",
+            `Wait until ${resetDate.toLocaleString()} for "${providerName}" to become available again`,
+            'Check current provider status with "ax provider limits"',
+            'Use "ax provider use <name>" to manually select a different provider'
+          ],
+          {
+            providerName,
+            limitWindow,
+            resetAtMs,
+            rawMessage,
+            retryAfterSeconds
+          }
+        );
+      }
+      /**
+       * Create error for all providers exhausted
+       * v5.7.0: Provider limit detection and rotation
+       */
+      static allProvidersLimited(limitedProviders, soonestResetMs) {
+        const soonestResetDate = new Date(soonestResetMs);
+        const hoursUntilReset = Math.ceil((soonestResetMs - Date.now()) / (1e3 * 60 * 60));
+        return new _ProviderError(
+          `All providers have hit usage limits. Next provider resets in ${hoursUntilReset} hour(s) at ${soonestResetDate.toISOString()}`,
+          "E1306" /* PROVIDER_NO_AVAILABLE */,
+          [
+            `Wait until ${soonestResetDate.toLocaleString()} for providers to reset`,
+            'Check provider limits with "ax provider limits"',
+            'Use "ax provider use <name> --force" to override and try anyway',
+            "Consider spreading workload across different time periods"
+          ],
+          {
+            limitedProviders,
+            soonestResetMs
+          }
+        );
+      }
+    };
+  }
+});
+
 // src/core/cache.ts
 var TTLCache, ProviderResponseCache;
 var init_cache = __esm({
@@ -868,8 +1095,8 @@ __export(path_resolver_exports, {
   PathResolver: () => PathResolver,
   detectProjectRoot: () => detectProjectRoot
 });
-function isWindowsPath(path5) {
-  return /^[a-zA-Z]:[/\\]/.test(path5);
+function isWindowsPath(path6) {
+  return /^[a-zA-Z]:[/\\]/.test(path6);
 }
 async function detectProjectRoot(startDir = process.cwd()) {
   const gitDir = await findUp(".git", {
@@ -972,8 +1199,8 @@ var init_path_resolver = __esm({
       /**
        * 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;
@@ -983,15 +1210,15 @@ var init_path_resolver = __esm({
       /**
        * 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";
         }
@@ -1009,15 +1236,15 @@ var init_path_resolver = __esm({
       /**
        * 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));
       }
       /**
@@ -1036,11 +1263,11 @@ var init_path_resolver = __esm({
        * 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
           });
@@ -1064,6 +1291,347 @@ var init_path_resolver = __esm({
     };
   }
 });
+function getProviderLimitManager(stateDirectory) {
+  return ProviderLimitManager.getInstance(stateDirectory);
+}
+var ProviderLimitManager;
+var init_provider_limit_manager = __esm({
+  "src/core/provider-limit-manager.ts"() {
+    init_esm_shims();
+    init_logger();
+    ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
+      static instance = null;
+      stateFilePath;
+      providerStates;
+      manualOverride;
+      providerConfigs;
+      initialized = false;
+      // Performance tracking
+      metrics = {
+        checksPerformed: 0,
+        limitsRecorded: 0,
+        limitsCleared: 0,
+        cacheHits: 0
+      };
+      constructor(stateDirectory) {
+        super();
+        this.stateFilePath = path2.join(stateDirectory, "provider-limits.json");
+        this.providerStates = /* @__PURE__ */ new Map();
+        this.providerConfigs = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Get singleton instance
+       */
+      static getInstance(stateDirectory = ".automatosx/state") {
+        if (!_ProviderLimitManager.instance) {
+          _ProviderLimitManager.instance = new _ProviderLimitManager(stateDirectory);
+        }
+        return _ProviderLimitManager.instance;
+      }
+      /**
+       * Reset singleton instance (for testing)
+       */
+      static resetInstance() {
+        _ProviderLimitManager.instance = null;
+      }
+      /**
+       * Initialize manager: load state from disk
+       */
+      async initialize() {
+        if (this.initialized) {
+          return;
+        }
+        try {
+          await this.loadState();
+          this.initialized = true;
+          logger.debug("ProviderLimitManager initialized", {
+            stateFile: this.stateFilePath,
+            trackedProviders: this.providerStates.size
+          });
+        } catch (error) {
+          logger.warn("Failed to initialize ProviderLimitManager", {
+            error: error.message
+          });
+          this.initialized = true;
+        }
+      }
+      /**
+       * Register provider limit tracking configuration
+       */
+      registerProvider(providerName, config) {
+        this.providerConfigs.set(providerName, config);
+        logger.debug("Provider limit tracking registered", {
+          provider: providerName,
+          window: config.window,
+          enabled: config.enabled
+        });
+      }
+      /**
+       * Record a limit hit for a provider
+       */
+      async recordLimitHit(providerName, limitWindow, resetAtMs, metadata) {
+        this.metrics.limitsRecorded++;
+        const state = {
+          status: "limited",
+          window: limitWindow,
+          detectedAtMs: Date.now(),
+          resetAtMs,
+          reason: metadata?.reason,
+          rawMessage: metadata?.rawMessage,
+          retryAfterSeconds: metadata?.retryAfterSeconds,
+          manualHold: false
+        };
+        this.providerStates.set(providerName, state);
+        await this.saveState();
+        this.emit("limit-hit", {
+          providerName,
+          limitWindow,
+          resetAtMs,
+          reason: metadata?.reason
+        });
+        logger.warn("Provider limit hit recorded", {
+          provider: providerName,
+          window: limitWindow,
+          resetAt: new Date(resetAtMs).toISOString(),
+          reason: metadata?.reason
+        });
+      }
+      /**
+       * Check if a provider is currently limited (O(1) operation)
+       */
+      isProviderLimited(providerName, now = Date.now()) {
+        this.metrics.checksPerformed++;
+        if (this.manualOverride && this.manualOverride.provider === providerName) {
+          return { isLimited: false };
+        }
+        const state = this.providerStates.get(providerName);
+        if (!state || state.status !== "limited") {
+          this.metrics.cacheHits++;
+          return { isLimited: false };
+        }
+        if (now >= state.resetAtMs) {
+          void this.clearLimit(providerName, "expired");
+          return { isLimited: false };
+        }
+        const remainingMs = state.resetAtMs - now;
+        return {
+          isLimited: true,
+          remainingMs,
+          resetAtMs: state.resetAtMs,
+          reason: state.reason
+        };
+      }
+      /**
+       * Clear limit for a provider
+       */
+      async clearLimit(providerName, reason = "manual") {
+        const state = this.providerStates.get(providerName);
+        if (!state || state.status !== "limited") {
+          return;
+        }
+        this.metrics.limitsCleared++;
+        this.providerStates.delete(providerName);
+        await this.saveState();
+        this.emit("limit-cleared", {
+          providerName,
+          reason
+        });
+        logger.info("Provider limit cleared", {
+          provider: providerName,
+          reason
+        });
+      }
+      /**
+       * Refresh expired limits (background task)
+       */
+      async refreshExpired() {
+        const now = Date.now();
+        const expiredProviders = [];
+        for (const [providerName, state] of this.providerStates.entries()) {
+          if (state.status === "limited" && now >= state.resetAtMs) {
+            expiredProviders.push(providerName);
+            await this.clearLimit(providerName, "expired");
+          }
+        }
+        if (expiredProviders.length > 0) {
+          logger.debug("Expired provider limits refreshed", {
+            providers: expiredProviders,
+            count: expiredProviders.length
+          });
+        }
+        return expiredProviders;
+      }
+      /**
+       * Set manual override for a specific provider
+       */
+      async setManualOverride(provider, expiresAtMs) {
+        this.manualOverride = {
+          provider,
+          setAtMs: Date.now(),
+          expiresAtMs
+        };
+        await this.saveState();
+        this.emit("override-set", {
+          provider,
+          expiresAtMs
+        });
+        logger.info("Manual provider override set", {
+          provider,
+          expiresAt: expiresAtMs ? new Date(expiresAtMs).toISOString() : "never"
+        });
+      }
+      /**
+       * Clear manual override
+       */
+      async clearManualOverride() {
+        if (!this.manualOverride) {
+          return;
+        }
+        const provider = this.manualOverride.provider;
+        this.manualOverride = void 0;
+        await this.saveState();
+        this.emit("override-cleared", { provider });
+        logger.info("Manual provider override cleared", { provider });
+      }
+      /**
+       * Get current manual override
+       */
+      getManualOverride() {
+        if (this.manualOverride && this.manualOverride.expiresAtMs) {
+          if (Date.now() >= this.manualOverride.expiresAtMs) {
+            void this.clearManualOverride();
+            return void 0;
+          }
+        }
+        return this.manualOverride;
+      }
+      /**
+       * Get all provider states (for status commands)
+       */
+      getAllStates() {
+        return new Map(this.providerStates);
+      }
+      /**
+       * Get next reset time across all providers
+       */
+      getNextReset() {
+        let soonest = null;
+        for (const [providerName, state] of this.providerStates.entries()) {
+          if (state.status === "limited") {
+            if (!soonest || state.resetAtMs < soonest.resetAtMs) {
+              soonest = { providerName, resetAtMs: state.resetAtMs };
+            }
+          }
+        }
+        return soonest;
+      }
+      /**
+       * Calculate reset time for a provider based on its configuration
+       */
+      calculateResetTime(providerName, limitWindow, retryAfterSeconds) {
+        const config = this.providerConfigs.get(providerName);
+        const now = Date.now();
+        if (retryAfterSeconds) {
+          return now + retryAfterSeconds * 1e3;
+        }
+        const resetHourUtc = config?.resetHourUtc ?? 0;
+        if (limitWindow === "daily") {
+          const tomorrow = /* @__PURE__ */ new Date();
+          tomorrow.setUTCDate(tomorrow.getUTCDate() + 1);
+          tomorrow.setUTCHours(resetHourUtc, 0, 0, 0);
+          return tomorrow.getTime();
+        }
+        if (limitWindow === "weekly") {
+          const nextWeek = /* @__PURE__ */ new Date();
+          nextWeek.setUTCDate(nextWeek.getUTCDate() + 7);
+          nextWeek.setUTCHours(resetHourUtc, 0, 0, 0);
+          return nextWeek.getTime();
+        }
+        if (limitWindow === "custom" && config?.customResetMs) {
+          return now + config.customResetMs;
+        }
+        return now + 24 * 60 * 60 * 1e3;
+      }
+      /**
+       * Get performance metrics
+       */
+      getMetrics() {
+        return { ...this.metrics };
+      }
+      /**
+       * Serialize state for JSON export
+       */
+      serialize() {
+        const providers = {};
+        for (const [name, state] of this.providerStates.entries()) {
+          providers[name] = state;
+        }
+        return {
+          schemaVersion: 1,
+          providers,
+          manualOverride: this.manualOverride
+        };
+      }
+      // ========================================
+      // Private Methods: Persistence
+      // ========================================
+      /**
+       * Load state from disk
+       */
+      async loadState() {
+        try {
+          const data = await promises.readFile(this.stateFilePath, "utf-8");
+          const parsed = JSON.parse(data);
+          if (parsed.schemaVersion !== 1) {
+            logger.warn("Unsupported state schema version", {
+              version: parsed.schemaVersion
+            });
+            return;
+          }
+          for (const [name, state] of Object.entries(parsed.providers)) {
+            this.providerStates.set(name, state);
+          }
+          if (parsed.manualOverride) {
+            this.manualOverride = parsed.manualOverride;
+          }
+          logger.debug("Provider limit state loaded", {
+            providers: this.providerStates.size,
+            hasOverride: !!this.manualOverride
+          });
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            logger.debug("No existing provider limit state found (new installation)");
+          } else {
+            throw error;
+          }
+        }
+      }
+      /**
+       * Save state to disk (atomic write)
+       */
+      async saveState() {
+        try {
+          const dir = path2.dirname(this.stateFilePath);
+          await promises.mkdir(dir, { recursive: true });
+          const state = this.serialize();
+          const json = JSON.stringify(state, null, 2);
+          const tempPath = `${this.stateFilePath}.tmp`;
+          await promises.writeFile(tempPath, json, "utf-8");
+          await promises.rename(tempPath, this.stateFilePath);
+          logger.debug("Provider limit state saved", {
+            file: this.stateFilePath,
+            providers: this.providerStates.size
+          });
+        } catch (error) {
+          logger.error("Failed to save provider limit state", {
+            error: error.message,
+            file: this.stateFilePath
+          });
+        }
+      }
+    };
+  }
+});
 
 // src/providers/retry-errors.ts
 function containsErrorPattern(message, patterns) {
@@ -1189,10 +1757,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) {
@@ -1314,6 +1882,25 @@ var init_provider_cache = __esm({
         });
         return entry.available;
       }
+      /**
+       * Get cache entry with metadata (age, timestamp).
+       * v5.7.2: Added for enhanced metrics tracking.
+       */
+      getWithMetadata(providerName, ttl = 3e4) {
+        const entry = this.cache.get(providerName);
+        if (!entry) {
+          return void 0;
+        }
+        const age = Date.now() - entry.timestamp;
+        if (age >= ttl) {
+          this.cache.delete(providerName);
+          return void 0;
+        }
+        return {
+          available: entry.available,
+          age
+        };
+      }
       /**
        * Set availability status for a provider.
        *
@@ -1531,19 +2118,21 @@ var init_base_provider = __esm({
         }
         const ttl = this.calculateAdaptiveTTL();
         try {
-          const sharedCached = providerCache.get(this.config.name, ttl);
+          const sharedCached = providerCache.getWithMetadata(this.config.name, ttl);
           if (sharedCached !== void 0) {
             this.cacheMetrics.availabilityHits++;
             this.availabilityCacheMetrics.lastHit = Date.now();
+            this.availabilityCacheMetrics.totalAge += sharedCached.age;
             this.availabilityCacheMetrics.hitCount++;
             logger.debug(`Using shared cache for ${this.config.name}`, {
               provider: this.config.name,
-              available: sharedCached,
+              available: sharedCached.available,
               source: "shared-cache",
+              cacheAge: sharedCached.age,
               cacheTTL: ttl,
               cacheHits: this.cacheMetrics.availabilityHits
             });
-            return sharedCached;
+            return sharedCached.available;
           }
         } catch (error) {
           logger.warn(`Failed to read shared cache for ${this.config.name}, falling back to instance cache`, {
@@ -1712,25 +2301,25 @@ var init_base_provider = __esm({
        * @param path File path to check
        * @returns true if path exists and is valid
        */
-      checkPathExists(path5) {
+      checkPathExists(path6) {
         try {
-          if (path5.includes("..")) {
-            logger.warn("Path traversal pattern detected (..)", { path: path5 });
+          if (path6.includes("..")) {
+            logger.warn("Path traversal pattern detected (..)", { path: path6 });
             return false;
           }
-          if (path5.startsWith("~") || path5.includes("~")) {
-            logger.warn("Home directory shortcut detected (~)", { path: path5 });
+          if (path6.startsWith("~") || path6.includes("~")) {
+            logger.warn("Home directory shortcut detected (~)", { path: path6 });
             return false;
           }
           const DANGEROUS_CHARS = /[;|&$`<>{}[\]'"\\]/;
-          if (DANGEROUS_CHARS.test(path5)) {
-            logger.warn("Dangerous shell characters detected in path", { path: path5 });
+          if (DANGEROUS_CHARS.test(path6)) {
+            logger.warn("Dangerous shell characters detected in path", { path: path6 });
             return false;
           }
-          return existsSync(path5);
+          return existsSync(path6);
         } catch (error) {
           logger.debug(`Error checking path existence`, {
-            path: path5,
+            path: path6,
             error: error.message
           });
           return false;
@@ -2444,6 +3033,8 @@ var init_claude_provider = __esm({
     init_retry_errors();
     init_environment();
     init_logger();
+    init_errors();
+    init_provider_limit_manager();
     ClaudeProvider = class extends BaseProvider {
       constructor(config) {
         super(config);
@@ -2659,11 +3250,8 @@ Details: ${errorMsg}`
                     `Authentication failed: Please check your Claude API credentials.
 Details: ${errorMsg}`
                   ));
-                } else if (errorMsg.toLowerCase().includes("rate limit") || errorMsg.toLowerCase().includes("quota")) {
-                  reject(new Error(
-                    `Rate limit exceeded: Please wait a moment and try again.
-Details: ${errorMsg}`
-                  ));
+                } else if (this.isRateLimitError(errorMsg)) {
+                  reject(this.createRateLimitError(errorMsg));
                 } else {
                   reject(new Error(`Claude CLI exited with code ${code}: ${errorMsg}`));
                 }
@@ -2754,6 +3342,41 @@ Try again or use --timeout option to increase the limit.`
       supportsStreaming() {
         return false;
       }
+      /**
+       * Check if error message indicates a rate limit / usage limit error
+       * v5.7.0: Provider limit detection patterns for Claude
+       */
+      isRateLimitError(errorMsg) {
+        const lowerMsg = errorMsg.toLowerCase();
+        return lowerMsg.includes("rate limit") || lowerMsg.includes("quota") || lowerMsg.includes("limit for today") || lowerMsg.includes("limit for this week") || lowerMsg.includes("anthropicusagelimit") || lowerMsg.includes("usage limit") || lowerMsg.includes("exceeded") && (lowerMsg.includes("limit") || lowerMsg.includes("quota"));
+      }
+      /**
+       * Create detailed rate limit error with automatic recording
+       * v5.7.0: Provider limit detection and auto-rotation
+       */
+      createRateLimitError(errorMsg) {
+        const limitWindow = errorMsg.toLowerCase().includes("week") ? "weekly" : "daily";
+        const limitManager = getProviderLimitManager();
+        const resetAtMs = limitManager.calculateResetTime(
+          this.config.name,
+          limitWindow
+        );
+        void limitManager.recordLimitHit(
+          this.config.name,
+          limitWindow,
+          resetAtMs,
+          {
+            reason: "usage_limit_exceeded",
+            rawMessage: errorMsg
+          }
+        );
+        return ProviderError.rateLimit(
+          this.config.name,
+          limitWindow,
+          resetAtMs,
+          errorMsg
+        );
+      }
     };
   }
 });
@@ -2770,6 +3393,8 @@ var init_gemini_provider = __esm({
     init_base_provider();
     init_retry_errors();
     init_logger();
+    init_errors();
+    init_provider_limit_manager();
     GeminiProvider = class extends BaseProvider {
       constructor(config) {
         super(config);
@@ -2964,7 +3589,12 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
                 return;
               }
               if (code !== 0) {
-                reject(new Error(`Gemini CLI exited with code ${code}: ${stderr}`));
+                const errorMsg = stderr || "No error message";
+                if (this.isRateLimitError(errorMsg)) {
+                  reject(this.createRateLimitError(errorMsg));
+                } else {
+                  reject(new Error(`Gemini CLI exited with code ${code}: ${errorMsg}`));
+                }
               } else {
                 resolve10({ content: stdout.trim() });
               }
@@ -3028,6 +3658,44 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
       supportsStreaming() {
         return false;
       }
+      /**
+       * Check if error message indicates a rate limit / usage limit error
+       * v5.7.0: Provider limit detection patterns for Gemini
+       */
+      isRateLimitError(errorMsg) {
+        const lowerMsg = errorMsg.toLowerCase();
+        return lowerMsg.includes("resource_exhausted") || // gRPC error code
+        lowerMsg.includes("429") || // HTTP status
+        lowerMsg.includes("ratelimitexceeded") || // Gemini API error
+        lowerMsg.includes("quota exceeded") || lowerMsg.includes("quota") || lowerMsg.includes("rate limit") || lowerMsg.includes("too many requests");
+      }
+      /**
+       * Create detailed rate limit error with automatic recording
+       * v5.7.0: Provider limit detection and auto-rotation
+       */
+      createRateLimitError(errorMsg) {
+        const limitWindow = "daily";
+        const limitManager = getProviderLimitManager();
+        const resetAtMs = limitManager.calculateResetTime(
+          this.config.name,
+          limitWindow
+        );
+        void limitManager.recordLimitHit(
+          this.config.name,
+          limitWindow,
+          resetAtMs,
+          {
+            reason: "quota_exceeded",
+            rawMessage: errorMsg
+          }
+        );
+        return ProviderError.rateLimit(
+          this.config.name,
+          limitWindow,
+          resetAtMs,
+          errorMsg
+        );
+      }
     };
   }
 });
@@ -3044,6 +3712,8 @@ var init_openai_provider = __esm({
     init_base_provider();
     init_retry_errors();
     init_logger();
+    init_errors();
+    init_provider_limit_manager();
     OpenAIProvider = class extends BaseProvider {
       constructor(config) {
         super(config);
@@ -3243,7 +3913,12 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
                 return;
               }
               if (code !== 0) {
-                reject(new Error(`OpenAI CLI exited with code ${code}: ${stderr}`));
+                const errorMsg = stderr || "No error message";
+                if (this.isRateLimitError(errorMsg)) {
+                  reject(this.createRateLimitError(errorMsg));
+                } else {
+                  reject(new Error(`OpenAI CLI exited with code ${code}: ${errorMsg}`));
+                }
               } else {
                 resolve10({ content: stdout.trim() });
               }
@@ -3524,6 +4199,43 @@ This is a placeholder streaming response.`;
           });
         });
       }
+      /**
+       * Check if error message indicates a rate limit / usage limit error
+       * v5.7.0: Provider limit detection patterns for OpenAI
+       */
+      isRateLimitError(errorMsg) {
+        const lowerMsg = errorMsg.toLowerCase();
+        return lowerMsg.includes("rate_limit_exceeded") || // OpenAI API error type
+        lowerMsg.includes("429") || // HTTP status
+        lowerMsg.includes("quota exceeded") || lowerMsg.includes("insufficient_quota") || lowerMsg.includes("rate limit") || lowerMsg.includes("too many requests");
+      }
+      /**
+       * Create detailed rate limit error with automatic recording
+       * v5.7.0: Provider limit detection and auto-rotation
+       */
+      createRateLimitError(errorMsg) {
+        const limitWindow = "daily";
+        const limitManager = getProviderLimitManager();
+        const resetAtMs = limitManager.calculateResetTime(
+          this.config.name,
+          limitWindow
+        );
+        void limitManager.recordLimitHit(
+          this.config.name,
+          limitWindow,
+          resetAtMs,
+          {
+            reason: "rate_limit_exceeded",
+            rawMessage: errorMsg
+          }
+        );
+        return ProviderError.rateLimit(
+          this.config.name,
+          limitWindow,
+          resetAtMs,
+          errorMsg
+        );
+      }
     };
   }
 });
@@ -4062,6 +4774,14 @@ var GLOBAL_PROVIDER_DEFAULTS = {
     forceKillDelay: 1e3,
     // 1 second
     cacheEnabled: true
+  },
+  limitTracking: {
+    enabled: true,
+    // Enabled by default
+    window: "daily",
+    // Daily reset by default
+    resetHourUtc: 0
+    // Midnight UTC
   }
 };
 var DEFAULT_CONFIG = {
@@ -4082,7 +4802,13 @@ var DEFAULT_CONFIG = {
       // v5.6.18: Circuit breaker, process management, and version detection
       circuitBreaker: GLOBAL_PROVIDER_DEFAULTS.circuitBreaker,
       processManagement: GLOBAL_PROVIDER_DEFAULTS.processManagement,
-      versionDetection: GLOBAL_PROVIDER_DEFAULTS.versionDetection
+      versionDetection: GLOBAL_PROVIDER_DEFAULTS.versionDetection,
+      // v5.7.0: Usage limit tracking
+      limitTracking: {
+        ...GLOBAL_PROVIDER_DEFAULTS.limitTracking,
+        window: "weekly"
+        // Claude Code has weekly limits
+      }
       // v5.0.5: Removed defaults - let provider CLI use optimal defaults
       // Users can still set provider.defaults in config for specific needs
     },
@@ -4101,7 +4827,10 @@ var DEFAULT_CONFIG = {
       // v5.6.18: Circuit breaker, process management, and version detection
       circuitBreaker: GLOBAL_PROVIDER_DEFAULTS.circuitBreaker,
       processManagement: GLOBAL_PROVIDER_DEFAULTS.processManagement,
-      versionDetection: GLOBAL_PROVIDER_DEFAULTS.versionDetection
+      versionDetection: GLOBAL_PROVIDER_DEFAULTS.versionDetection,
+      // v5.7.0: Usage limit tracking
+      limitTracking: GLOBAL_PROVIDER_DEFAULTS.limitTracking
+      // Gemini: daily limits
       // v5.0.5: Removed defaults - let provider CLI use optimal defaults
     },
     "openai": {
@@ -4119,7 +4848,10 @@ var DEFAULT_CONFIG = {
       // v5.6.18: Circuit breaker, process management, and version detection
       circuitBreaker: GLOBAL_PROVIDER_DEFAULTS.circuitBreaker,
       processManagement: GLOBAL_PROVIDER_DEFAULTS.processManagement,
-      versionDetection: GLOBAL_PROVIDER_DEFAULTS.versionDetection
+      versionDetection: GLOBAL_PROVIDER_DEFAULTS.versionDetection,
+      // v5.7.0: Usage limit tracking
+      limitTracking: GLOBAL_PROVIDER_DEFAULTS.limitTracking
+      // OpenAI: daily limits
       // v5.0.5: Removed defaults - let provider CLI use optimal defaults
     }
   },
@@ -4385,181 +5117,8 @@ var DEFAULT_CONFIG = {
   }
 };
 
-// src/utils/errors.ts
-init_esm_shims();
-var BaseError = class extends Error {
-  code;
-  suggestions;
-  context;
-  isOperational;
-  constructor(message, code, suggestions = [], context, isOperational = true) {
-    super(message);
-    this.name = this.constructor.name;
-    this.code = code;
-    this.suggestions = suggestions;
-    this.context = context;
-    this.isOperational = isOperational;
-    Error.captureStackTrace(this, this.constructor);
-  }
-  /**
-   * Get formatted error message for display
-   */
-  getFormattedMessage() {
-    let formatted = `[${this.code}] ${this.message}`;
-    if (this.suggestions.length > 0) {
-      formatted += "\n\nSuggestions:";
-      this.suggestions.forEach((suggestion, i) => {
-        formatted += `
-  ${i + 1}. ${suggestion}`;
-      });
-    }
-    return formatted;
-  }
-  /**
-   * Get error details as object
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      suggestions: this.suggestions,
-      context: this.context,
-      isOperational: this.isOperational,
-      stack: this.stack
-    };
-  }
-};
-var ConfigError = class _ConfigError extends BaseError {
-  constructor(message, code = "E1001" /* CONFIG_INVALID */, suggestions = [], context) {
-    super(message, code, suggestions, context);
-  }
-  static notFound(path5) {
-    return new _ConfigError(
-      `Configuration file not found: ${path5}`,
-      "E1000" /* CONFIG_NOT_FOUND */,
-      [
-        'Run "automatosx init" 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 }
-    );
-  }
-  static invalid(reason, context) {
-    return new _ConfigError(
-      `Invalid configuration: ${reason}`,
-      "E1001" /* CONFIG_INVALID */,
-      [
-        "Check your automatosx.config.json for syntax errors",
-        "Validate against the schema in documentation",
-        'Reset to default with "automatosx init --force"'
-      ],
-      context
-    );
-  }
-  static parseError(error, path5) {
-    return new _ConfigError(
-      `Failed to parse configuration: ${error.message}`,
-      "E1002" /* CONFIG_PARSE_ERROR */,
-      [
-        "Check JSON syntax in your config file",
-        "Use a JSON validator to find syntax errors",
-        'Reset to default with "automatosx init --force"'
-      ],
-      { path: path5, originalError: error.message }
-    );
-  }
-};
-var ProviderError = class _ProviderError extends BaseError {
-  constructor(message, code = "E1301" /* PROVIDER_UNAVAILABLE */, suggestions = [], context) {
-    super(message, code, suggestions, context);
-  }
-  static notFound(providerName) {
-    return new _ProviderError(
-      `Provider "${providerName}" not found`,
-      "E1300" /* PROVIDER_NOT_FOUND */,
-      [
-        'Check available providers with "automatosx list providers"',
-        "Verify provider is enabled in automatosx.config.json",
-        "Install the provider CLI if not already installed"
-      ],
-      { providerName }
-    );
-  }
-  static unavailable(providerName, reason) {
-    const msg = reason ? `Provider "${providerName}" unavailable: ${reason}` : `Provider "${providerName}" is unavailable`;
-    return new _ProviderError(
-      msg,
-      "E1301" /* PROVIDER_UNAVAILABLE */,
-      [
-        "Check that the provider CLI is installed and in your PATH",
-        "Verify provider configuration in automatosx.config.json",
-        "Try running the provider CLI directly to diagnose issues",
-        'Check system status with "automatosx status --verbose"'
-      ],
-      { providerName, reason }
-    );
-  }
-  static timeout(providerName, timeoutMs) {
-    return new _ProviderError(
-      `Provider "${providerName}" timed out after ${timeoutMs}ms`,
-      "E1302" /* PROVIDER_TIMEOUT */,
-      [
-        "Increase timeout in automatosx.config.json",
-        "Try a simpler prompt or reduce context size",
-        "Check your network connection",
-        "Verify the provider service is responsive"
-      ],
-      { providerName, timeoutMs }
-    );
-  }
-  static noAvailableProviders() {
-    return new _ProviderError(
-      "No AI providers are available",
-      "E1306" /* PROVIDER_NO_AVAILABLE */,
-      [
-        "Install at least one provider CLI (Claude or Gemini)",
-        "Enable providers in automatosx.config.json",
-        'Check provider status with "automatosx status"',
-        "Verify provider CLIs are in your PATH"
-      ]
-    );
-  }
-  static executionError(providerName, error) {
-    return new _ProviderError(
-      `Provider "${providerName}" execution failed: ${error.message}`,
-      "E1305" /* PROVIDER_EXEC_ERROR */,
-      [
-        "Check that the provider CLI is installed correctly",
-        "Verify you have necessary API keys configured",
-        "Try running the provider CLI directly to diagnose",
-        "Check error logs with --debug flag"
-      ],
-      { providerName, originalError: error.message }
-    );
-  }
-};
-function toBaseError(error) {
-  if (error instanceof BaseError) {
-    return error;
-  }
-  if (error instanceof Error) {
-    return new BaseError(
-      error.message,
-      "E9999" /* UNKNOWN_ERROR */,
-      ["Check error details for more information"],
-      { originalError: error.name, stack: error.stack }
-    );
-  }
-  return new BaseError(
-    String(error),
-    "E9999" /* UNKNOWN_ERROR */,
-    ["An unexpected error occurred"]
-  );
-}
-
 // src/core/config.ts
+init_errors();
 init_logger();
 
 // src/utils/deep-merge.ts
@@ -4644,20 +5203,20 @@ var VALIDATION_LIMITS = {
   MAX_CONCURRENT_AGENTS: 32
   // Cap parallel agent execution to protect resources
 };
-function isValidRelativePath(path5) {
-  if (!path5 || typeof path5 !== "string") {
+function isValidRelativePath(path6) {
+  if (!path6 || typeof path6 !== "string") {
     return false;
   }
-  if (path5.startsWith("/")) {
+  if (path6.startsWith("/")) {
     return false;
   }
-  if (path5.includes("..")) {
+  if (path6.includes("..")) {
     return false;
   }
-  if (/^[a-zA-Z]:/.test(path5)) {
+  if (/^[a-zA-Z]:/.test(path6)) {
     return false;
   }
-  if (path5.startsWith("\\\\")) {
+  if (path6.startsWith("\\\\")) {
     return false;
   }
   return true;
@@ -5095,16 +5654,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 ext2 = extname(path5).toLowerCase();
+    const ext2 = extname(path6).toLowerCase();
     let userConfig;
     try {
       if (ext2 === ".yaml" || ext2 === ".yml") {
@@ -5113,7 +5672,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) {
@@ -5129,35 +5688,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: ext2 });
+    logger.info("Config loaded successfully", { path: normalizePath(path6), format: ext2 });
     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 }
     );
   }
 }
@@ -5535,16 +6094,16 @@ function validateConfig(config) {
   }
   return errors;
 }
-async function saveConfigFile(path5, config) {
+async function saveConfigFile(path6, config) {
   try {
     const validationErrors = validateConfig(config);
     if (validationErrors.length > 0) {
       throw ConfigError.invalid(
         validationErrors.join("; "),
-        { path: path5, errors: validationErrors }
+        { path: path6, errors: validationErrors }
       );
     }
-    const ext2 = extname(path5).toLowerCase();
+    const ext2 = extname(path6).toLowerCase();
     let content;
     if (ext2 === ".yaml" || ext2 === ".yml") {
       content = dump(config, {
@@ -5556,29 +6115,29 @@ async function saveConfigFile(path5, config) {
     } else {
       content = JSON.stringify(config, null, 2);
     }
-    await writeFile(path5, content, "utf-8");
-    logger.info("Config saved successfully", { path: normalizePath(path5), format: ext2 });
+    await writeFile(path6, content, "utf-8");
+    logger.info("Config saved successfully", { path: normalizePath(path6), format: ext2 });
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
     }
     if (error.code === "EACCES") {
       throw new ConfigError(
-        `Permission denied writing config: ${path5}`,
+        `Permission denied writing config: ${path6}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
         [
           "Check file permissions",
           "Run with appropriate user privileges",
           "Verify the directory is writable"
         ],
-        { path: path5, error: error.message }
+        { path: path6, error: error.message }
       );
     }
     throw new ConfigError(
       `Failed to save config: ${error.message}`,
       "E1002" /* CONFIG_PARSE_ERROR */,
       ["Check file path and permissions"],
-      { path: path5, originalError: error.message }
+      { path: path6, originalError: error.message }
     );
   }
 }
@@ -5857,6 +6416,7 @@ init_logger();
 
 // src/utils/error-formatter.ts
 init_esm_shims();
+init_errors();
 function formatError(error, options = {}) {
   const {
     verbose = false,
@@ -6314,10 +6874,10 @@ var configCommand = {
       } else {
         const projectConfig = resolve(process.cwd(), "automatosx.config.json");
         const hiddenConfig = resolve(process.cwd(), ".automatosx", "config.json");
-        const fs4 = await import('fs');
-        if (fs4.existsSync(projectConfig)) {
+        const fs5 = await import('fs');
+        if (fs5.existsSync(projectConfig)) {
           configPath = projectConfig;
-        } else if (fs4.existsSync(hiddenConfig)) {
+        } else if (fs5.existsSync(hiddenConfig)) {
           configPath = hiddenConfig;
         } else {
           configPath = projectConfig;
@@ -6364,9 +6924,9 @@ var configCommand = {
     }
   }
 };
-async function checkExists(path5) {
+async function checkExists(path6) {
   try {
-    await access$1(path5, constants.F_OK);
+    await access$1(path6, constants.F_OK);
     return true;
   } catch {
     return false;
@@ -6397,7 +6957,7 @@ async function validateConfigFile(config, verbose) {
   }
   console.log();
 }
-async function resetConfig(path5, verbose) {
+async function resetConfig(path6, verbose) {
   const { createRequire } = await import('module');
   const require2 = createRequire(import.meta.url);
   let version = "5.2.2";
@@ -6412,14 +6972,14 @@ async function resetConfig(path5, verbose) {
     // Users should rely on IDE JSON Schema plugins that fetch from npm package
     version
   };
-  await saveConfigFile(path5, config);
+  await saveConfigFile(path6, config);
   printSuccess("Configuration reset to defaults");
   if (verbose) {
     console.log(chalk27.gray(`
-Config file: ${path5}
+Config file: ${path6}
 `));
   }
-  logger.info("Configuration reset", { path: path5 });
+  logger.info("Configuration reset", { path: path6 });
 }
 async function listConfig(config, verbose) {
   console.log(chalk27.bold.cyan("\n\u{1F4CB} AutomatosX Configuration\n"));
@@ -6498,7 +7058,7 @@ async function getConfig(config, key, verbose) {
     }
   }
 }
-async function setConfig(path5, config, key, value, verbose) {
+async function setConfig(path6, config, key, value, verbose) {
   let parsedValue = value;
   try {
     parsedValue = JSON.parse(value);
@@ -6517,20 +7077,20 @@ async function setConfig(path5, config, key, value, verbose) {
     console.log();
     process.exit(1);
   }
-  await saveConfigFile(path5, config);
+  await saveConfigFile(path6, config);
   printSuccess(`Configuration updated: ${key} = ${value}`);
   if (verbose) {
     console.log(chalk27.gray(`
-Config file: ${path5}`));
+Config file: ${path6}`));
     console.log(chalk27.gray("Configuration validated successfully\n"));
   }
   logger.info("Configuration updated", { key, value });
 }
-function getNestedValue(obj, path5) {
-  return path5.split(".").reduce((current, key) => current?.[key], obj);
+function getNestedValue(obj, path6) {
+  return path6.split(".").reduce((current, key) => current?.[key], obj);
 }
-function setNestedValue(obj, path5, value) {
-  const keys = path5.split(".");
+function setNestedValue(obj, path6, value) {
+  const keys = path6.split(".");
   const lastKey = keys.pop();
   if (!lastKey) return false;
   const target = keys.reduce((current, key) => {
@@ -6581,7 +7141,7 @@ var initCommand = {
     let version = "5.1.2";
     try {
       const packageJson = JSON.parse(
-        await import('fs/promises').then((fs4) => fs4.readFile(join(packageRoot, "package.json"), "utf-8"))
+        await import('fs/promises').then((fs5) => fs5.readFile(join(packageRoot, "package.json"), "utf-8"))
       );
       version = packageJson.version;
     } catch {
@@ -6724,9 +7284,9 @@ var initCommand = {
     }
   }
 };
-async function checkExists2(path5) {
+async function checkExists2(path6) {
   try {
-    await access$1(path5, constants.F_OK);
+    await access$1(path6, constants.F_OK);
     return true;
   } catch {
     return false;
@@ -7296,6 +7856,8 @@ init_logger();
 // src/core/router.ts
 init_esm_shims();
 init_logger();
+init_errors();
+init_provider_limit_manager();
 
 // src/utils/performance-markers.ts
 init_esm_shims();
@@ -7476,6 +8038,10 @@ var Router = class {
     this.penalizedProviders = /* @__PURE__ */ new Map();
     this.providerCooldownMs = config.providerCooldownMs ?? 3e4;
     this.cache = config.cache;
+    const limitManager = getProviderLimitManager();
+    void limitManager.initialize().catch((err) => {
+      logger.warn("Failed to initialize ProviderLimitManager", { error: err.message });
+    });
     this.healthCheckIntervalMs = config.healthCheckInterval;
     if (config.healthCheckInterval) {
       this.startHealthChecks(config.healthCheckInterval);
@@ -7533,6 +8099,22 @@ var Router = class {
       cacheEnabled: this.cache?.isEnabled ?? false
     });
     if (availableProviders.length === 0) {
+      const limitManager2 = getProviderLimitManager();
+      const allProviders = this.providers;
+      const limitedProviders2 = [];
+      for (const provider of allProviders) {
+        const limitCheck = limitManager2.isProviderLimited(provider.name);
+        if (limitCheck.isLimited && limitCheck.resetAtMs) {
+          limitedProviders2.push({
+            name: provider.name,
+            resetAtMs: limitCheck.resetAtMs
+          });
+        }
+      }
+      if (limitedProviders2.length === allProviders.length && limitedProviders2.length > 0) {
+        const soonestReset = Math.min(...limitedProviders2.map((p) => p.resetAtMs));
+        throw ProviderError.allProvidersLimited(limitedProviders2, soonestReset);
+      }
       throw ProviderError.noAvailableProviders();
     }
     let lastError;
@@ -7600,20 +8182,47 @@ var Router = class {
         return response;
       } catch (error) {
         lastError = error;
-        logger.warn("\u274C Router: provider failed", {
-          provider: provider.name,
-          attempt: attemptNumber,
-          error: lastError.message,
-          willFallback: this.fallbackEnabled && attemptNumber < availableProviders.length
-        });
-        const penaltyExpiry = Date.now() + this.providerCooldownMs;
-        this.penalizedProviders.set(provider.name, penaltyExpiry);
-        logger.debug(`Provider ${provider.name} penalized until ${new Date(penaltyExpiry).toISOString()}`);
+        const isRateLimitError = error instanceof ProviderError && error.code === "E1303" /* PROVIDER_RATE_LIMIT */;
+        if (isRateLimitError) {
+          const providerError = error;
+          const limitManager2 = getProviderLimitManager();
+          const resetAtMs = providerError.context?.resetAtMs;
+          const limitWindow = providerError.context?.limitWindow;
+          if (typeof resetAtMs === "number" && typeof limitWindow === "string") {
+            await limitManager2.recordLimitHit(
+              provider.name,
+              limitWindow,
+              resetAtMs,
+              {
+                reason: providerError.context?.reason || "usage_limit_exceeded",
+                rawMessage: providerError.message
+              }
+            );
+          }
+          logger.warn("\u26A0\uFE0F  Router: provider hit usage limit, auto-rotating", {
+            provider: provider.name,
+            attempt: attemptNumber,
+            resetAtMs: providerError.context?.resetAtMs,
+            willFallback: this.fallbackEnabled && attemptNumber < availableProviders.length
+          });
+        } else {
+          logger.warn("\u274C Router: provider failed", {
+            provider: provider.name,
+            attempt: attemptNumber,
+            error: lastError.message,
+            willFallback: this.fallbackEnabled && attemptNumber < availableProviders.length
+          });
+          const penaltyExpiry = Date.now() + this.providerCooldownMs;
+          this.penalizedProviders.set(provider.name, penaltyExpiry);
+          logger.debug(`Provider ${provider.name} penalized until ${new Date(penaltyExpiry).toISOString()}`);
+        }
         if (!this.fallbackEnabled) {
           throw lastError;
         }
         if (attemptNumber < availableProviders.length) {
+          const reason = isRateLimitError ? "usage limit hit" : "error";
           logger.info("\u{1F504} Router: fallback triggered", {
+            reason,
             failedProvider: provider.name,
             nextProvider: availableProviders[attemptNumber]?.name,
             remainingProviders: availableProviders.length - attemptNumber
@@ -7626,6 +8235,21 @@ var Router = class {
       totalAttempts: attemptNumber,
       lastError: lastError?.message
     });
+    const limitManager = getProviderLimitManager();
+    const limitedProviders = [];
+    for (const provider of availableProviders) {
+      const limitCheck = limitManager.isProviderLimited(provider.name);
+      if (limitCheck.isLimited && limitCheck.resetAtMs) {
+        limitedProviders.push({
+          name: provider.name,
+          resetAtMs: limitCheck.resetAtMs
+        });
+      }
+    }
+    if (limitedProviders.length === availableProviders.length && limitedProviders.length > 0) {
+      const soonestReset = Math.min(...limitedProviders.map((p) => p.resetAtMs));
+      throw ProviderError.allProvidersLimited(limitedProviders, soonestReset);
+    }
     throw new ProviderError(
       `All providers failed. Last error: ${lastError?.message || "Unknown error"}`,
       "E1306" /* PROVIDER_NO_AVAILABLE */,
@@ -7640,10 +8264,12 @@ var Router = class {
   }
   /**
    * Get available providers sorted by priority
-   * Filters out penalized providers (those in cooldown period)
+   * v5.7.0: Enhanced with provider limit detection
+   * Filters out penalized providers (those in cooldown period) and limited providers (quota exceeded)
    */
   async getAvailableProviders() {
     const now = Date.now();
+    const limitManager = getProviderLimitManager();
     for (const [providerName, expiryTime] of this.penalizedProviders.entries()) {
       if (now >= expiryTime) {
         this.penalizedProviders.delete(providerName);
@@ -7652,6 +8278,13 @@ var Router = class {
     }
     const checks = this.providers.map(async (provider) => {
       try {
+        const limitCheck = limitManager.isProviderLimited(provider.name, now);
+        if (limitCheck.isLimited) {
+          const remainingSec = Math.ceil((limitCheck.remainingMs || 0) / 1e3);
+          const remainingHours = Math.ceil(remainingSec / 3600);
+          logger.debug(`Skipping limited provider ${provider.name} (resets in ${remainingHours}h)`);
+          return null;
+        }
         if (this.penalizedProviders.has(provider.name)) {
           const expiryTime = this.penalizedProviders.get(provider.name);
           const remainingMs = expiryTime - now;
@@ -7707,6 +8340,14 @@ var Router = class {
       const checkStartTime = Date.now();
       this.healthCheckMetrics.checksPerformed++;
       try {
+        const limitManager = getProviderLimitManager();
+        const restoredProviders = await limitManager.refreshExpired();
+        if (restoredProviders.length > 0) {
+          logger.info("\u2705 Router: provider limits auto-restored", {
+            providers: restoredProviders,
+            count: restoredProviders.length
+          });
+        }
         const availabilityResults = await Promise.allSettled(
           this.providers.map(async (provider) => {
             const startTime = Date.now();
@@ -10218,6 +10859,7 @@ var WorkspaceManager = class _WorkspaceManager {
 // src/agents/context-manager.ts
 init_esm_shims();
 init_logger();
+init_errors();
 var PROVIDER_ALIASES = {
   "claude": "claude-code",
   "gemini": "gemini-cli",
@@ -12159,6 +12801,7 @@ var TimeoutManager = class {
 
 // src/utils/timeout-validator.ts
 init_esm_shims();
+init_errors();
 var MIN_WARNING_THRESHOLD2 = 0.5;
 var MAX_WARNING_THRESHOLD2 = 0.95;
 function validateTimeoutConfig(config) {
@@ -12345,9 +12988,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;
@@ -12362,7 +13005,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);
@@ -13950,12 +14593,12 @@ var ValidationError = class extends Error {
     this.name = "ValidationError";
   }
 };
-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 }
     );
   }
   const dangerousPatterns = [
@@ -13985,51 +14628,51 @@ function validatePathParameter(path5, paramName, projectRoot = process.cwd()) {
     // Common data drive (Windows, alt format)
   ];
   for (const pattern of dangerousPatterns) {
-    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 }
     );
   }
   const suspiciousChars = /[<>:|"]/;
-  if (suspiciousChars.test(path5)) {
+  if (suspiciousChars.test(path6)) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains invalid characters`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
 }
@@ -14540,8 +15183,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,
@@ -14577,8 +15220,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,
@@ -15601,9 +16244,9 @@ var ProgressIndicator = class {
 // src/cli/commands/memory.ts
 var DEFAULT_DB_PATH = ".automatosx/memory/memory.db";
 function getMemoryManager(dbPath) {
-  const path5 = dbPath || DEFAULT_DB_PATH;
+  const path6 = dbPath || DEFAULT_DB_PATH;
   return new LazyMemoryManager({
-    dbPath: resolve(path5),
+    dbPath: resolve(path6),
     maxEntries: 1e5,
     autoCleanup: false,
     trackAccess: true
@@ -19071,6 +19714,7 @@ init_claude_provider();
 init_gemini_provider();
 init_openai_provider();
 init_logger();
+init_provider_limit_manager();
 var VERSION = getVersion();
 var statusCommand3 = {
   command: "status",
@@ -19284,6 +19928,49 @@ var statusCommand3 = {
           }
         }
         console.log();
+        console.log(chalk27.cyan("Provider Limits:"));
+        try {
+          const limitManager = getProviderLimitManager();
+          await limitManager.initialize();
+          const limitStates = limitManager.getAllStates();
+          const manualOverride = limitManager.getManualOverride();
+          const now = Date.now();
+          if (limitStates.size === 0 && !manualOverride) {
+            console.log(chalk27.gray("  No limits detected. All providers available."));
+          } else {
+            if (limitStates.size > 0) {
+              for (const [name, state] of limitStates.entries()) {
+                const remainingMs = state.resetAtMs - now;
+                const hours = Math.ceil(remainingMs / (1e3 * 60 * 60));
+                console.log(chalk27.yellow(`  \u26A0\uFE0F  ${name}: LIMITED (resets in ${hours}h)`));
+                if (argv2.verbose) {
+                  const resetDate = new Date(state.resetAtMs);
+                  console.log(chalk27.gray(`     Window: ${state.window}`));
+                  console.log(chalk27.gray(`     Resets: ${resetDate.toLocaleString()}`));
+                  if (state.reason) {
+                    console.log(chalk27.gray(`     Reason: ${state.reason}`));
+                  }
+                }
+              }
+            }
+            if (manualOverride) {
+              const expiresText = manualOverride.expiresAtMs ? `expires in ${Math.ceil((manualOverride.expiresAtMs - now) / (1e3 * 60))}m` : "no expiry";
+              console.log(chalk27.cyan(`  \u{1F527} Manual Override: ${manualOverride.provider} (${expiresText})`));
+            }
+            const availableCount = status.providers.filter((p) => {
+              const isLimited = limitStates.has(p.name);
+              const isOverridden = manualOverride && manualOverride.provider !== p.name;
+              return p.available && !isLimited && !isOverridden;
+            }).length;
+            if (availableCount > 0) {
+              console.log(chalk27.green(`  \u2705 ${availableCount} provider(s) available`));
+            }
+          }
+        } catch (error) {
+          logger.warn("Failed to get provider limits", { error: error.message });
+          console.log(chalk27.gray("  (Unable to load limit status)"));
+        }
+        console.log();
         console.log(chalk27.cyan("ENV Variable Overrides:"));
         const envVars = [
           { name: "CLAUDE_CLI", provider: "claude-code" },
@@ -19535,11 +20222,11 @@ async function getCurrentVersion() {
     return result.dependencies["@defai.digital/automatosx"]?.version || "unknown";
   } catch (error) {
     const { readFile: readFile9 } = await import('fs/promises');
-    const { dirname: dirname13, join: join26 } = await import('path');
+    const { dirname: dirname14, join: join27 } = await import('path');
     const { fileURLToPath: fileURLToPath9 } = await import('url');
     const __filename6 = fileURLToPath9(import.meta.url);
-    const __dirname7 = dirname13(__filename6);
-    const pkgPath = join26(__dirname7, "../../../package.json");
+    const __dirname7 = dirname14(__filename6);
+    const pkgPath = join27(__dirname7, "../../../package.json");
     const content = await readFile9(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version;
@@ -22263,11 +22950,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path4 = {
+var path5 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep2 = defaultPlatform === "win32" ? path4.win32.sep : path4.posix.sep;
+var sep2 = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
 minimatch.sep = sep2;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -25470,12 +26157,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path5) {
-    if (!path5) {
+  resolve(path6) {
+    if (!path6) {
       return this;
     }
-    const rootPath = this.getRootString(path5);
-    const dir = path5.substring(rootPath.length);
+    const rootPath = this.getRootString(path6);
+    const dir = path6.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -26227,8 +26914,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path5) {
-    return win32.parse(path5).root;
+  getRootString(path6) {
+    return win32.parse(path6).root;
   }
   /**
    * @internal
@@ -26274,8 +26961,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path5) {
-    return path5.startsWith("/") ? "/" : "";
+  getRootString(path6) {
+    return path6.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -26324,8 +27011,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs4 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs4);
+  constructor(cwd = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs5 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs5);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -26364,11 +27051,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path5 = this.cwd) {
-    if (typeof path5 === "string") {
-      path5 = this.cwd.resolve(path5);
+  depth(path6 = this.cwd) {
+    if (typeof path6 === "string") {
+      path6 = this.cwd.resolve(path6);
     }
-    return path5.depth();
+    return path6.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -26855,9 +27542,9 @@ var PathScurryBase = class {
     process2();
     return results;
   }
-  chdir(path5 = this.cwd) {
+  chdir(path6 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path5 === "string" ? this.cwd.resolve(path5) : path5;
+    this.cwd = typeof path6 === "string" ? this.cwd.resolve(path6) : path6;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -26883,8 +27570,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs4) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs4 });
+  newRoot(fs5) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs5 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -26912,8 +27599,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs4) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs4 });
+  newRoot(fs5) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs5 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -27219,8 +27906,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path5, n]) => [
-      path5,
+    return [...this.store.entries()].map(([path6, n]) => [
+      path6,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -27425,9 +28112,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path5, opts) {
+  constructor(patterns, path6, opts) {
     this.patterns = patterns;
-    this.path = path5;
+    this.path = path6;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -27446,11 +28133,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path5) {
-    return this.seen.has(path5) || !!this.#ignore?.ignored?.(path5);
+  #ignored(path6) {
+    return this.seen.has(path6) || !!this.#ignore?.ignored?.(path6);
   }
-  #childrenIgnored(path5) {
-    return !!this.#ignore?.childrenIgnored?.(path5);
+  #childrenIgnored(path6) {
+    return !!this.#ignore?.childrenIgnored?.(path6);
   }
   // backpressure mechanism
   pause() {
@@ -27665,8 +28352,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path5, opts) {
-    super(patterns, path5, opts);
+  constructor(patterns, path6, opts) {
+    super(patterns, path6, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -27703,8 +28390,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path5, opts) {
-    super(patterns, path5, opts);
+  constructor(patterns, path6, opts) {
+    super(patterns, path6, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -28329,8 +29016,8 @@ var ConfigManager = class {
    * @returns User configuration or empty object if not found
    */
   async readUserConfig() {
-    const path5 = getUserConfigPath();
-    return this.readConfig(path5, "user");
+    const path6 = getUserConfigPath();
+    return this.readConfig(path6, "user");
   }
   /**
    * Read project-level Gemini CLI configuration
@@ -28338,8 +29025,8 @@ var ConfigManager = class {
    * @returns Project configuration or empty object if not found
    */
   async readProjectConfig() {
-    const path5 = getProjectConfigPath();
-    return this.readConfig(path5, "project");
+    const path6 = getProjectConfigPath();
+    return this.readConfig(path6, "project");
   }
   /**
    * Read configuration from a specific path with caching
@@ -28349,7 +29036,7 @@ var ConfigManager = class {
    * @returns Configuration object
    * @private
    */
-  async readConfig(path5, scope) {
+  async readConfig(path6, scope) {
     const cached = this.cache.get(scope);
     if (cached && Date.now() - cached.timestamp < this.ttl) {
       return cached.data;
@@ -28360,13 +29047,13 @@ var ConfigManager = class {
     }
     const readOperation = (async () => {
       try {
-        const exists = await fileExists(path5);
+        const exists = await fileExists(path6);
         if (!exists) {
           const emptyConfig = {};
           this.cache.set(scope, { data: emptyConfig, timestamp: Date.now() });
           return emptyConfig;
         }
-        const config = await readJsonFile(path5);
+        const config = await readJsonFile(path6);
         this.cache.set(scope, { data: config, timestamp: Date.now() });
         return config;
       } catch (error) {
@@ -28375,8 +29062,8 @@ var ConfigManager = class {
         }
         throw new GeminiCLIError(
           "INVALID_CONFIG" /* INVALID_CONFIG */,
-          `Failed to read configuration from ${path5}`,
-          { path: path5, originalError: error }
+          `Failed to read configuration from ${path6}`,
+          { path: path6, originalError: error }
         );
       } finally {
         this.pendingReads.delete(scope);
@@ -29044,8 +29731,8 @@ var CommandTranslator = class {
         paths.push(getProjectCommandsPath());
       }
     }
-    for (const path5 of paths) {
-      const discovered = await this.scanDirectory(path5);
+    for (const path6 of paths) {
+      const discovered = await this.scanDirectory(path6);
       commands.push(...discovered);
     }
     return commands;
@@ -29086,8 +29773,8 @@ var CommandTranslator = class {
     const results = [];
     for (const name of commandNames) {
       try {
-        const path5 = await this.importCommand(name, outputDir, options);
-        results.push(path5);
+        const path6 = await this.importCommand(name, outputDir, options);
+        results.push(path6);
       } catch (error) {
         if (error instanceof GeminiCLIError) {
           console.error(`Failed to import ${name}: ${error.message}`);
@@ -29973,12 +30660,109 @@ var geminiCommand = {
   }
 };
 
+// src/cli/commands/provider-limits.ts
+init_esm_shims();
+init_provider_limit_manager();
+init_logger();
+function formatDuration(ms) {
+  const hours = Math.floor(ms / (1e3 * 60 * 60));
+  const minutes = Math.floor(ms % (1e3 * 60 * 60) / (1e3 * 60));
+  if (hours > 0) {
+    if (minutes > 0) {
+      return `${hours}h ${minutes}m`;
+    }
+    return `${hours}h`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m`;
+  }
+  return "< 1m";
+}
+var providerLimitsCommand = {
+  command: "provider-limits",
+  aliases: ["pl", "limits"],
+  describe: "Show current provider limit status",
+  builder: (yargs2) => {
+    return yargs2.option("json", {
+      describe: "Output in JSON format",
+      type: "boolean",
+      default: false
+    }).example("$0 provider-limits", "Show provider limits").example("$0 provider-limits --json", "Show limits in JSON format");
+  },
+  handler: async (argv2) => {
+    try {
+      const limitManager = getProviderLimitManager();
+      await limitManager.initialize();
+      const states = limitManager.getAllStates();
+      const manualOverride = limitManager.getManualOverride();
+      const now = Date.now();
+      if (argv2.json) {
+        const output = {
+          limits: Array.from(states.entries()).map(([name, state]) => ({
+            provider: name,
+            status: state.status,
+            window: state.window,
+            detectedAtMs: state.detectedAtMs,
+            resetAtMs: state.resetAtMs,
+            remainingMs: state.resetAtMs - now,
+            reason: state.reason,
+            manualHold: state.manualHold
+          })),
+          manualOverride: manualOverride || null,
+          timestamp: Date.now()
+        };
+        console.log(JSON.stringify(output, null, 2));
+      } else {
+        console.log();
+        console.log(chalk27.bold("\u{1F4CA} Provider Limits Status"));
+        console.log();
+        if (states.size === 0) {
+          console.log(chalk27.green("  \u2705 No limits detected. All providers available."));
+        } else {
+          for (const [name, state] of states.entries()) {
+            const resetDate = new Date(state.resetAtMs);
+            const remainingMs = state.resetAtMs - now;
+            const remainingStr = formatDuration(remainingMs);
+            console.log(chalk27.yellow(`  \u26A0\uFE0F  ${name}:`));
+            console.log(`     Status: ${state.status}`);
+            console.log(`     Window: ${state.window}`);
+            console.log(`     Resets: ${resetDate.toLocaleString()} (${remainingStr})`);
+            if (state.reason) {
+              console.log(`     Reason: ${state.reason}`);
+            }
+            console.log();
+          }
+        }
+        if (manualOverride) {
+          console.log(chalk27.cyan(`  \u{1F527} Manual Override: ${manualOverride.provider}`));
+          if (manualOverride.expiresAtMs) {
+            const expiresDate = new Date(manualOverride.expiresAtMs);
+            const expiresIn = formatDuration(manualOverride.expiresAtMs - now);
+            console.log(`     Expires: ${expiresDate.toLocaleString()} (${expiresIn})`);
+          } else {
+            console.log(`     Expires: Never`);
+          }
+          console.log();
+        }
+        console.log(chalk27.gray('  Use "ax status" for detailed provider information.'));
+        console.log();
+      }
+    } catch (error) {
+      logger.error("Failed to get provider limits", {
+        error: error.message
+      });
+      console.error(chalk27.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  }
+};
+
 // src/cli/index.ts
 installExitHandlers();
 var VERSION2 = getVersion();
 globalTracker.mark("cli_start");
 globalTracker.mark("yargs_parse_start");
-var argv = await yargs(hideBin(process.argv)).scriptName("automatosx").usage("$0 <command> [options]").usage("\nAI Agent Orchestration Platform").example("$0 init", "Initialize project").example("$0 agent create backend --template developer", "Create agent from template").example("$0 agent list", "List all agents").example('$0 run assistant "Hello"', "Run assistant agent").example('$0 run backend "task" --interactive', "Run with interactive checkpoints").example("$0 resume <run-id>", "Resume from checkpoint").example("$0 runs list", "List checkpoint runs").example('$0 session create "Build API" backend', "Create multi-agent session").example("$0 session list", "List all sessions").example("$0 workspace stats", "Show workspace statistics").example("$0 list agents", "List available agents").example('$0 memory search "topic"', "Search memory").example("$0 cache status", "View cache statistics").example("$0 config --list", "View configuration").example("$0 mcp", "Start MCP server for Claude Code").example("$0 update", "Update to latest version").example("$0 gemini status", "Show Gemini CLI integration status").option("debug", {
+var argv = await yargs(hideBin(process.argv)).scriptName("automatosx").usage("$0 <command> [options]").usage("\nAI Agent Orchestration Platform").example("$0 init", "Initialize project").example("$0 agent create backend --template developer", "Create agent from template").example("$0 agent list", "List all agents").example('$0 run assistant "Hello"', "Run assistant agent").example('$0 run backend "task" --interactive', "Run with interactive checkpoints").example("$0 resume <run-id>", "Resume from checkpoint").example("$0 runs list", "List checkpoint runs").example('$0 session create "Build API" backend', "Create multi-agent session").example("$0 session list", "List all sessions").example("$0 workspace stats", "Show workspace statistics").example("$0 list agents", "List available agents").example('$0 memory search "topic"', "Search memory").example("$0 cache status", "View cache statistics").example("$0 config --list", "View configuration").example("$0 provider-limits", "Show provider usage limits").example("$0 mcp", "Start MCP server for Claude Code").example("$0 update", "Update to latest version").example("$0 gemini status", "Show Gemini CLI integration status").option("debug", {
   alias: "D",
   type: "boolean",
   description: "Enable debug mode with verbose output",
@@ -29993,7 +30777,7 @@ var argv = await yargs(hideBin(process.argv)).scriptName("automatosx").usage("$0
   type: "string",
   description: "Path to custom config file",
   global: true
-}).command(initCommand).command(agentCommand).command(listCommand).command(runCommand).command(resumeCommand).command(runsCommand).command(sessionCommand).command(workspaceCommand).command(cacheCommand).command(configCommand).command(statusCommand3).command(memoryCommand).command(mcpCommand).command(geminiCommand).command(updateCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
+}).command(initCommand).command(agentCommand).command(listCommand).command(runCommand).command(resumeCommand).command(runsCommand).command(sessionCommand).command(workspaceCommand).command(cacheCommand).command(configCommand).command(statusCommand3).command(memoryCommand).command(mcpCommand).command(geminiCommand).command(providerLimitsCommand).command(updateCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
 globalTracker.mark("yargs_parse_end");
 globalTracker.measure("yargs_parsing", "yargs_parse_start", "yargs_parse_end");
 globalTracker.mark("options_setup_start");