neuro-cli 5.0.0 → 5.0.1

package/dist/api/openrouter.d.ts

@@ -1,4 +1,5 @@
 import { Message, ToolCall, ToolDefinition, ToolResult } from '../core/types.js';
+import { RateLimitManager } from '../core/rate-limiter.js';
 export interface StreamCallbacks {
     onToken?: (token: string) => void;
     onToolCall?: (toolCall: ToolCall) => void;
@@ -24,11 +25,16 @@ export declare class OpenRouterClient {
     private apiKey;
     private baseUrl;
     private totalUsage;
+    private rateLimiter;
     constructor(apiKey: string, baseUrl?: string);
     get usage(): TokenUsage;
     resetUsage(): void;
     /**
-     * Main chat completion with streaming
+     * Set the rate limiter instance for this client
+     */
+    setRateLimiter(rateLimiter: RateLimitManager): void;
+    /**
+     * Main chat completion with streaming + rate limit awareness
      */
     chat(request: ChatRequest, callbacks?: StreamCallbacks): Promise<{
         content: string;

package/dist/api/openrouter.js

@@ -1,6 +1,7 @@
 // ============================================================
 // NeuroCLI - OpenRouter API Client
 // Streaming + Tool Use + Multi-model support
+// Now with RateLimitManager integration
 // ============================================================
 // @ts-ignore
 import { createParser } from 'eventsource-parser';
@@ -9,6 +10,7 @@ export class OpenRouterClient {
     apiKey;
     baseUrl;
     totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
+    rateLimiter = null;
     constructor(apiKey, baseUrl = 'https://openrouter.ai/api/v1') {
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
@@ -20,15 +22,42 @@ export class OpenRouterClient {
         this.totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
     }
     /**
-     * Main chat completion with streaming
+     * Set the rate limiter instance for this client
+     */
+    setRateLimiter(rateLimiter) {
+        this.rateLimiter = rateLimiter;
+    }
+    /**
+     * Main chat completion with streaming + rate limit awareness
      */
     async chat(request, callbacks) {
         const model = MODELS[request.model];
         if (!model) {
             throw new Error(`Unknown model: ${request.model}`);
         }
+        // --- Rate limit pre-check ---
+        let activeModel = request.model;
+        if (this.rateLimiter) {
+            const check = await this.rateLimiter.acquire(request.model);
+            if (check.suggestedModel) {
+                // Switch to the suggested alternative model
+                activeModel = check.suggestedModel;
+                callbacks?.onThinking?.(`🔄 Rate limiter rotated to ${MODELS[activeModel]?.name || activeModel}`);
+            }
+            else if (!check.allowed) {
+                // Not allowed and no alternative - wait
+                if (check.waitMs > 0) {
+                    callbacks?.onThinking?.(`⏳ Rate limited, waiting ${Math.ceil(check.waitMs / 1000)}s...`);
+                    await new Promise(resolve => setTimeout(resolve, check.waitMs));
+                }
+            }
+        }
+        const activeModelConfig = MODELS[activeModel];
+        if (!activeModelConfig) {
+            throw new Error(`Unknown model after rate limit rotation: ${activeModel}`);
+        }
         const body = {
-            model: request.model,
+            model: activeModel,
             messages: request.messages.map(m => ({
                 role: m.role,
                 content: m.content,
@@ -38,9 +67,9 @@ export class OpenRouterClient {
             })),
             stream: request.stream ?? true,
             temperature: request.temperature ?? 0.7,
-            max_tokens: request.maxTokens ?? model.maxOutput,
+            max_tokens: request.maxTokens ?? activeModelConfig.maxOutput,
         };
-        if (request.tools && request.tools.length > 0 && model.supportsTools) {
+        if (request.tools && request.tools.length > 0 && activeModelConfig.supportsTools) {
             body.tools = request.tools.map(t => ({
                 type: 'function',
                 function: {
@@ -54,47 +83,133 @@ export class OpenRouterClient {
         let lastError = null;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             if (attempt > 0) {
-                // Exponential backoff: 5s, 15s, 30s
-                const waitTime = Math.min(5000 * Math.pow(3, attempt - 1), 30000);
-                callbacks?.onThinking?.(`⏳ Rate limited, retrying in ${waitTime / 1000}s (attempt ${attempt + 1}/${maxRetries + 1})...`);
+                // Smart backoff: use rate limiter cooldown if available, otherwise exponential
+                let waitTime;
+                if (this.rateLimiter) {
+                    const state = this.rateLimiter.getStatus().find(s => s.model === activeModel);
+                    waitTime = state && state.cooldown > 0 ? state.cooldown * 1000 : Math.min(5000 * Math.pow(2, attempt - 1), 30000);
+                }
+                else {
+                    waitTime = Math.min(5000 * Math.pow(3, attempt - 1), 30000);
+                }
+                callbacks?.onThinking?.(`⏳ Retrying in ${Math.ceil(waitTime / 1000)}s (attempt ${attempt + 1}/${maxRetries + 1})...`);
                 await new Promise(resolve => setTimeout(resolve, waitTime));
             }
-            const response = await fetch(`${this.baseUrl}/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${this.apiKey}`,
-                    'Content-Type': 'application/json',
-                    'HTTP-Referer': 'https://neurocli.dev',
-                    'X-Title': 'NeuroCLI',
-                },
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorBody = await response.text();
-                // Parse retry_after from 429 errors
-                if (response.status === 429) {
-                    try {
-                        const errorData = JSON.parse(errorBody);
-                        const retryAfter = errorData?.error?.metadata?.retry_after_seconds;
-                        if (retryAfter && attempt < maxRetries) {
-                            lastError = new Error(`Rate limited, retry after ${retryAfter}s`);
+            const startTime = Date.now();
+            try {
+                const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${this.apiKey}`,
+                        'Content-Type': 'application/json',
+                        'HTTP-Referer': 'https://neurocli.dev',
+                        'X-Title': 'NeuroCLI',
+                    },
+                    body: JSON.stringify(body),
+                });
+                const responseTimeMs = Date.now() - startTime;
+                if (!response.ok) {
+                    const errorBody = await response.text();
+                    // Parse retry_after from 429 errors
+                    if (response.status === 429) {
+                        let retryAfterSeconds;
+                        try {
+                            const errorData = JSON.parse(errorBody);
+                            retryAfterSeconds = errorData?.error?.metadata?.retry_after_seconds;
+                        }
+                        catch { }
+                        // Record rate limit in manager
+                        if (this.rateLimiter) {
+                            this.rateLimiter.recordRateLimit(activeModel, retryAfterSeconds);
+                        }
+                        // Try model rotation before retrying
+                        if (this.rateLimiter && attempt < maxRetries) {
+                            const nextModel = this.rateLimiter.getNextRotationModel(activeModel);
+                            if (nextModel && nextModel !== activeModel) {
+                                const nextModelConfig = MODELS[nextModel];
+                                if (nextModelConfig) {
+                                    callbacks?.onThinking?.(`🔄 Rotating ${MODELS[activeModel]?.name || activeModel} → ${nextModelConfig.name} due to rate limit`);
+                                    activeModel = nextModel;
+                                    body.model = nextModel;
+                                    body.max_tokens = request.maxTokens ?? nextModelConfig.maxOutput;
+                                    if (request.tools && request.tools.length > 0 && nextModelConfig.supportsTools) {
+                                        // tools already set
+                                    }
+                                    else if (request.tools && !nextModelConfig.supportsTools) {
+                                        delete body.tools;
+                                    }
+                                    // Don't count this as a retry attempt for the new model
+                                    attempt--;
+                                    continue;
+                                }
+                            }
+                        }
+                        if (retryAfterSeconds && attempt < maxRetries) {
+                            lastError = new Error(`Rate limited, retry after ${retryAfterSeconds}s`);
                             continue; // Retry
                         }
+                        if (attempt < maxRetries) {
+                            lastError = new Error(`Rate limited (429): ${errorBody}`);
+                            continue;
+                        }
                     }
-                    catch { }
-                    // If we can't parse retry_after or max retries reached, throw
-                    if (attempt < maxRetries) {
-                        lastError = new Error(`Rate limited (429): ${errorBody}`);
-                        continue;
+                    // Server errors (5xx) - record and potentially rotate
+                    if (response.status >= 500) {
+                        if (this.rateLimiter) {
+                            this.rateLimiter.recordServerError(activeModel);
+                        }
+                        if (attempt < maxRetries) {
+                            lastError = new Error(`Server error (${response.status}): ${errorBody}`);
+                            // Try model rotation for server errors too
+                            if (this.rateLimiter) {
+                                const nextModel = this.rateLimiter.getNextRotationModel(activeModel);
+                                if (nextModel && nextModel !== activeModel) {
+                                    const nextModelConfig = MODELS[nextModel];
+                                    if (nextModelConfig) {
+                                        callbacks?.onThinking?.(`🔄 Rotating away from ${MODELS[activeModel]?.name || activeModel} due to server error`);
+                                        activeModel = nextModel;
+                                        body.model = nextModel;
+                                        body.max_tokens = request.maxTokens ?? nextModelConfig.maxOutput;
+                                        if (request.tools && request.tools.length > 0 && nextModelConfig.supportsTools) {
+                                            // tools already set
+                                        }
+                                        else if (request.tools && !nextModelConfig.supportsTools) {
+                                            delete body.tools;
+                                        }
+                                        attempt--;
+                                        continue;
+                                    }
+                                }
+                            }
+                            continue;
+                        }
                     }
+                    throw new Error(`OpenRouter API error (${response.status}): ${errorBody}`);
+                }
+                // Success!
+                if (this.rateLimiter) {
+                    this.rateLimiter.recordSuccess(activeModel, responseTimeMs);
+                }
+                if (request.stream && callbacks) {
+                    const result = await this.handleStreamingResponse(response, activeModel, callbacks);
+                    return result;
+                }
+                else {
+                    const result = await this.handleNonStreamingResponse(response, activeModel);
+                    return result;
                 }
-                throw new Error(`OpenRouter API error (${response.status}): ${errorBody}`);
-            }
-            if (request.stream && callbacks) {
-                return this.handleStreamingResponse(response, request.model, callbacks);
             }
-            else {
-                return this.handleNonStreamingResponse(response, request.model);
+            catch (error) {
+                // Network-level errors (fetch failed)
+                if (error instanceof TypeError && error.message.includes('fetch')) {
+                    if (this.rateLimiter) {
+                        this.rateLimiter.recordServerError(activeModel);
+                    }
+                    lastError = error;
+                    if (attempt < maxRetries)
+                        continue;
+                }
+                throw error;
             }
         }
         throw lastError || new Error('Max retries exceeded');

package/dist/commands/commands.js

@@ -297,6 +297,17 @@ export class CommandSystem {
                 description: 'Browser automation (navigate/screenshot/click)',
                 prompt: 'Use the browser to navigate, take screenshots, click elements, or extract content from web pages. {args}',
             },
+            // --- Rate Limit Commands ---
+            {
+                name: 'ratelimit',
+                description: 'Show rate limiter status for all models',
+                prompt: 'Show the current rate limiter status. Display health scores, cooldowns, 429 counts, and queue status for all tracked models. {args}',
+            },
+            {
+                name: 'ratelimit-reset',
+                description: 'Reset rate limiter state',
+                prompt: 'Reset all rate limiter cooldowns and health scores. Use this if models are stuck in cooldown. {args}',
+            },
         ];
         for (const cmd of bundled) {
             if (!this.commands.has(cmd.name)) {

package/dist/core/engine.d.ts

@@ -57,6 +57,7 @@ import { TerminalUX } from './terminal-ux.js';
 import { MultiSessionManager } from './multi-session.js';
 import { GitWorktreeManager } from './git-worktree.js';
 import { AutoUpdater } from './updater.js';
+import { RateLimitManager } from './rate-limiter.js';
 export declare class NeuroEngine {
     config: NeuroConfig;
     client: OpenRouterClient;
@@ -117,6 +118,7 @@ export declare class NeuroEngine {
     multiSession: MultiSessionManager;
     gitWorktree: GitWorktreeManager;
     updater: AutoUpdater;
+    rateLimiter: RateLimitManager;
     private autoApproveSet;
     private requireApprovalSet;
     constructor(config: NeuroConfig);

package/dist/core/engine.js

@@ -15,7 +15,8 @@
 // Spec-Driven Development, LLM Evaluator Hooks, MCP Apps,
 // Multi-Model Orchestrator, Smart Monitor, Outcome Grading,
 // Observability (OTLP), Auto-Compact, Terminal UX,
-// Multi-Session, Git Worktree, Auto-Updater
+// Multi-Session, Git Worktree, Auto-Updater,
+// Rate Limit Manager
 // ============================================================
 import { join } from 'path';
 import { homedir } from 'os';
@@ -79,6 +80,7 @@ import { TerminalUX } from './terminal-ux.js';
 import { MultiSessionManager } from './multi-session.js';
 import { GitWorktreeManager } from './git-worktree.js';
 import { AutoUpdater } from './updater.js';
+import { RateLimitManager } from './rate-limiter.js';
 export class NeuroEngine {
     config;
     client;
@@ -143,11 +145,27 @@ export class NeuroEngine {
     multiSession;
     gitWorktree;
     updater;
+    rateLimiter;
     autoApproveSet;
     requireApprovalSet;
     constructor(config) {
         this.config = config;
+        // Rate Limit Manager - initialized FIRST so it's available for all systems
+        this.rateLimiter = new RateLimitManager({
+            globalRpm: 20,
+            perModelRpm: 10,
+            baseCooldownMs: 10000,
+            maxCooldownMs: 120000,
+            backoffMultiplier: 2.0,
+            rotationPoolSize: 5,
+            enableQueue: true,
+            maxQueueSize: 50,
+            maxQueueWaitMs: 60000,
+            adaptiveLearning: true,
+            verbose: true,
+        });
         this.client = new OpenRouterClient(config.apiKey, config.baseUrl);
+        this.client.setRateLimiter(this.rateLimiter);
         this.registry = registerAllTools(new ToolRegistry());
         this.contextManager = new ContextManager(config.defaultModel, config.context.maxTokens);
         this.sessionManager = new SessionManager();
@@ -166,6 +184,7 @@ export class NeuroEngine {
             return false;
         });
         this.fallback = new FallbackChain(this.client, config.fallbackChain);
+        this.fallback.setRateLimiter(this.rateLimiter);
         // Sandbox system
         this.sandbox = new Sandbox(config.sandbox);
         // Plugin system
@@ -196,6 +215,7 @@ export class NeuroEngine {
             categoryOverrides: {},
             maxTokenBudget: config.context.maxTokens,
         }, Object.fromEntries(Object.entries(MODELS).map(([id, m]) => [id, { name: m.name, contextWindow: m.contextWindow, maxOutput: m.maxOutput }])));
+        this.modelRouter.setRateLimiter(this.rateLimiter);
         // Output styles
         this.styleManager = new StyleManager(process.cwd());
         // Extended thinking

package/dist/core/fallback.d.ts

@@ -1,5 +1,6 @@
 import { OpenRouterClient, TokenUsage } from '../api/openrouter.js';
 import { Message } from './types.js';
+import { RateLimitManager } from './rate-limiter.js';
 export interface FallbackConfig {
     models: string[];
     maxRetries: number;
@@ -27,9 +28,14 @@ export interface FallbackResult {
 export declare class FallbackChain {
     private config;
     private client;
+    private rateLimiter;
     constructor(client: OpenRouterClient, config?: Partial<FallbackConfig>);
     /**
-     * Execute a chat request with fallback chain
+     * Set the rate limiter for intelligent model rotation
+     */
+    setRateLimiter(rateLimiter: RateLimitManager): void;
+    /**
+     * Execute a chat request with fallback chain + rate limit awareness
      */
     chatWithFallback(primaryModel: string, messages: Message[], options: {
         tools?: unknown[];

package/dist/core/fallback.js

@@ -1,12 +1,14 @@
 // ============================================================
 // NeuroCLI - Fallback Model Chain
 // Automatic model fallback on failure
+// Now with RateLimitManager integration
 // ============================================================
 import { MODELS } from '../api/models.js';
 import chalk from 'chalk';
 export class FallbackChain {
     config;
     client;
+    rateLimiter = null;
     constructor(client, config) {
         this.client = client;
         this.config = {
@@ -18,13 +20,67 @@ export class FallbackChain {
         };
     }
     /**
-     * Execute a chat request with fallback chain
+     * Set the rate limiter for intelligent model rotation
+     */
+    setRateLimiter(rateLimiter) {
+        this.rateLimiter = rateLimiter;
+    }
+    /**
+     * Execute a chat request with fallback chain + rate limit awareness
      */
     async chatWithFallback(primaryModel, messages, options, onModelSwitch) {
-        const chain = [primaryModel, ...this.config.models.filter(m => m !== primaryModel)];
+        // Build the model chain: primary + configured fallbacks
+        let chain = [primaryModel, ...this.config.models.filter(m => m !== primaryModel)];
+        // If rate limiter is available, prioritize models with good health
+        if (this.rateLimiter) {
+            const availableModels = this.rateLimiter.getNextRotationModel(primaryModel);
+            // Insert rate-limiter-suggested models at the front of the chain
+            const healthyAlternatives = [];
+            const allStates = this.rateLimiter.getStatus();
+            for (const state of allStates) {
+                if (state.model !== primaryModel && state.health >= 50 && state.cooldown === 0) {
+                    healthyAlternatives.push(state.model);
+                }
+            }
+            // Remove duplicates and merge chains
+            const seen = new Set([primaryModel]);
+            const mergedChain = [primaryModel];
+            // Add healthy alternatives first (from rate limiter)
+            for (const m of healthyAlternatives) {
+                if (!seen.has(m)) {
+                    seen.add(m);
+                    mergedChain.push(m);
+                }
+            }
+            // Then add original fallback chain
+            for (const m of chain) {
+                if (!seen.has(m)) {
+                    seen.add(m);
+                    mergedChain.push(m);
+                }
+            }
+            chain = mergedChain;
+        }
         const attempts = [];
         let totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
         for (const model of chain) {
+            // Skip models that are in cooldown (if rate limiter is available)
+            if (this.rateLimiter) {
+                const check = this.rateLimiter.checkRateLimit(model);
+                if (!check.allowed && check.waitMs > 30000) {
+                    // If wait is more than 30s, skip this model entirely
+                    console.log(chalk.gray(`  ⏭️ Skipping ${MODELS[model]?.name || model} (cooldown: ${Math.ceil(check.waitMs / 1000)}s)`));
+                    attempts.push({ model, success: false, error: `In cooldown (${Math.ceil(check.waitMs / 1000)}s)` });
+                    continue;
+                }
+                if (!check.allowed && check.suggestedModel) {
+                    // Use the suggested alternative instead
+                    if (!chain.includes(check.suggestedModel)) {
+                        chain.push(check.suggestedModel);
+                    }
+                    continue;
+                }
+            }
             for (let retry = 0; retry <= this.config.maxRetries; retry++) {
                 try {
                     const modelInfo = MODELS[model];
@@ -62,7 +118,16 @@ export class FallbackChain {
                         errMsg.includes('503') ||
                         errMsg.includes('500'));
                     if (shouldFallback) {
-                        console.log(chalk.yellow(`  ⚠ ${model} failed: ${errMsg.slice(0, 80)}`));
+                        // Record the rate limit or server error
+                        if (this.rateLimiter) {
+                            if (errMsg.includes('429') || errMsg.toLowerCase().includes('rate_limit')) {
+                                this.rateLimiter.recordRateLimit(model);
+                            }
+                            else if (errMsg.includes('500') || errMsg.includes('503')) {
+                                this.rateLimiter.recordServerError(model);
+                            }
+                        }
+                        console.log(chalk.yellow(`  ⚠ ${MODELS[model]?.name || model} failed: ${errMsg.slice(0, 80)}`));
                         break; // Try next model in chain
                     }
                     // For other errors, retry on same model

package/dist/core/model-router.d.ts

@@ -29,9 +29,15 @@ export declare class ModelRouter {
     private availableModels;
     private currentEffort;
     private forcedModel;
+    private rateLimiter;
     constructor(config: RouterConfig, availableModels: Record<string, ModelInfo>);
+    /**
+     * Set the rate limiter for rate-aware routing decisions
+     */
+    setRateLimiter(rateLimiter: import('./rate-limiter.js').RateLimitManager): void;
     /**
      * Route a prompt to the best available model.
+     * Now rate-limit-aware: avoids models in cooldown and rotates to healthy alternatives.
      */
     route(prompt: string, effort?: EffortLevel): RoutingDecision;
     /**

package/dist/core/model-router.js

@@ -124,6 +124,7 @@ export class ModelRouter {
     availableModels;
     currentEffort = 'medium';
     forcedModel = null;
+    rateLimiter = null;
     // -----------------------------------------------------------------------
     // Construction
     // -----------------------------------------------------------------------
@@ -135,15 +136,53 @@ export class ModelRouter {
     // -----------------------------------------------------------------------
     // Public API
     // -----------------------------------------------------------------------
+    /**
+     * Set the rate limiter for rate-aware routing decisions
+     */
+    setRateLimiter(rateLimiter) {
+        this.rateLimiter = rateLimiter;
+    }
     /**
      * Route a prompt to the best available model.
+     * Now rate-limit-aware: avoids models in cooldown and rotates to healthy alternatives.
      */
     route(prompt, effort) {
         const effectiveEffort = effort ?? this.currentEffort;
         const analysis = this.analyzePrompt(prompt);
         const estimatedTokens = this.estimateTokens(prompt);
-        const model = this.selectModel(analysis.complexity, analysis.category, effectiveEffort);
+        let model = this.selectModel(analysis.complexity, analysis.category, effectiveEffort);
         const alternatives = this.getAlternatives(analysis.complexity, analysis.category);
+        // --- Rate-limit-aware routing ---
+        if (this.rateLimiter) {
+            const check = this.rateLimiter.checkRateLimit(model);
+            if (!check.allowed && check.suggestedModel) {
+                // Use the rate limiter's suggested alternative
+                const suggested = check.suggestedModel;
+                if (this.availableModels[suggested]) {
+                    model = suggested;
+                }
+                else {
+                    // The suggested model isn't in our available models, try alternatives
+                    for (const alt of alternatives) {
+                        const altCheck = this.rateLimiter.checkRateLimit(alt);
+                        if (altCheck.allowed) {
+                            model = alt;
+                            break;
+                        }
+                    }
+                }
+            }
+            else if (!check.allowed) {
+                // Model is rate limited and no suggested alternative, try alternatives
+                for (const alt of alternatives) {
+                    const altCheck = this.rateLimiter.checkRateLimit(alt);
+                    if (altCheck.allowed) {
+                        model = alt;
+                        break;
+                    }
+                }
+            }
+        }
         const reasoning = this.buildReasoning(analysis, effectiveEffort, model);
         return {
             model,

package/dist/core/rate-limiter.d.ts

@@ -0,0 +1,162 @@
+export interface RateLimiterConfig {
+    /** Maximum requests per minute across all models (default: 20) */
+    globalRpm: number;
+    /** Maximum requests per minute per model (default: 10) */
+    perModelRpm: number;
+    /** Base cooldown after a 429 in ms (default: 10000) */
+    baseCooldownMs: number;
+    /** Maximum cooldown in ms (default: 120000) */
+    maxCooldownMs: number;
+    /** Multiplier for consecutive 429s (default: 2.0) */
+    backoffMultiplier: number;
+    /** Number of free model rotation slots (default: 5) */
+    rotationPoolSize: number;
+    /** Enable request queuing during rate limits (default: true) */
+    enableQueue: boolean;
+    /** Maximum queue size (default: 50) */
+    maxQueueSize: number;
+    /** Maximum time a request can wait in queue in ms (default: 60000) */
+    maxQueueWaitMs: number;
+    /** Enable adaptive learning from rate limit patterns (default: true) */
+    adaptiveLearning: boolean;
+    /** Log rate limit events to console (default: true) */
+    verbose: boolean;
+}
+export interface ModelRateState {
+    /** Model ID */
+    modelId: string;
+    /** Current cooldown end time (0 = not cooling down) */
+    cooldownUntil: number;
+    /** Number of consecutive 429s */
+    consecutive429s: number;
+    /** Total 429s received */
+    total429s: number;
+    /** Total successful requests */
+    totalSuccesses: number;
+    /** Requests in current minute window */
+    requestsThisMinute: number;
+    /** Minute window start time */
+    minuteWindowStart: number;
+    /** Last request timestamp */
+    lastRequestAt: number;
+    /** Average response time in ms */
+    avgResponseMs: number;
+    /** Whether model is currently in rotation pool */
+    inRotationPool: boolean;
+    /** Health score 0-100 (100 = healthy) */
+    healthScore: number;
+}
+export interface RateLimitCheck {
+    /** Whether the request can proceed */
+    allowed: boolean;
+    /** Wait time in ms if not allowed (0 if allowed) */
+    waitMs: number;
+    /** Suggested alternative model (null if current is fine) */
+    suggestedModel: string | null;
+    /** Reason for the decision */
+    reason: string;
+}
+export interface QueuedRequest {
+    id: string;
+    model: string;
+    enqueuedAt: number;
+    resolve: (check: RateLimitCheck) => void;
+    reject: (error: Error) => void;
+}
+export declare class RateLimitManager {
+    private config;
+    private modelStates;
+    private globalRequestTimestamps;
+    private requestQueue;
+    private queueProcessTimer;
+    private rotationPool;
+    private currentRotationIndex;
+    private requestIdCounter;
+    private rateLimitPatterns;
+    constructor(config?: Partial<RateLimiterConfig>);
+    /**
+     * Check if a request can be made to a specific model.
+     * Returns a RateLimitCheck with the decision and optional alternative model.
+     */
+    checkRateLimit(modelId: string): RateLimitCheck;
+    /**
+     * Acquire permission to make a request. Resolves when the request can proceed.
+     * If queuing is enabled, waits in queue. Otherwise, rejects if rate limited.
+     */
+    acquire(modelId: string): Promise<RateLimitCheck>;
+    /**
+     * Record a successful request completion
+     */
+    recordSuccess(modelId: string, responseTimeMs: number): void;
+    /**
+     * Record a rate limit (429) response
+     */
+    recordRateLimit(modelId: string, retryAfterSeconds?: number): void;
+    /**
+     * Record a server error (5xx) - treat as potential overload
+     */
+    recordServerError(modelId: string): void;
+    /**
+     * Get the next available model from the rotation pool.
+     * Skips models that are in cooldown or have low health.
+     */
+    getNextRotationModel(excludeModel?: string): string | null;
+    /**
+     * Get the best available model for a given requested model.
+     * Tries the requested model first, then falls back through the rotation pool.
+     */
+    getBestAvailableModel(requestedModel: string): string;
+    /**
+     * Get rate limit status for all tracked models
+     */
+    getStatus(): Array<{
+        model: string;
+        name: string;
+        health: number;
+        cooldown: number;
+        consecutive429s: number;
+        total429s: number;
+        totalSuccesses: number;
+        rpm: number;
+        avgResponseMs: number;
+    }>;
+    /**
+     * Get queue status
+     */
+    getQueueStatus(): {
+        size: number;
+        oldestWaitMs: number;
+    };
+    /**
+     * Reset all rate limit state (useful for testing)
+     */
+    reset(): void;
+    /**
+     * Reset a specific model's rate limit state
+     */
+    resetModel(modelId: string): void;
+    /**
+     * Update configuration at runtime
+     */
+    updateConfig(updates: Partial<RateLimiterConfig>): void;
+    /**
+     * Print a formatted status table
+     */
+    printStatus(): void;
+    private getOrCreateState;
+    private recordRequestStart;
+    private cleanupGlobalTimestamps;
+    private cleanupModelTimestamps;
+    private findAvailableModel;
+    private initializeRotationPool;
+    private enqueueRequest;
+    private startQueueProcessor;
+    private processQueue;
+    private recordRateLimitPattern;
+    private getHealthBar;
+    /**
+     * Cleanup - call when shutting down
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/core/rate-limiter.js

@@ -0,0 +1,589 @@
+// ============================================================
+// NeuroCLI - Rate Limit Manager
+// Intelligent rate limiting with token bucket, per-model
+// cooldown tracking, model rotation, and adaptive backoff
+// ============================================================
+import chalk from 'chalk';
+import { MODELS, getFreeModelsWithTools } from '../api/models.js';
+// ---------------------------------------------------------------------------
+// RateLimitManager
+// ---------------------------------------------------------------------------
+export class RateLimitManager {
+    config;
+    modelStates = new Map();
+    globalRequestTimestamps = [];
+    requestQueue = [];
+    queueProcessTimer = null;
+    rotationPool = [];
+    currentRotationIndex = 0;
+    requestIdCounter = 0;
+    // Adaptive learning data
+    rateLimitPatterns = new Map();
+    constructor(config) {
+        this.config = {
+            globalRpm: 20,
+            perModelRpm: 10,
+            baseCooldownMs: 10000,
+            maxCooldownMs: 120000,
+            backoffMultiplier: 2.0,
+            rotationPoolSize: 5,
+            enableQueue: true,
+            maxQueueSize: 50,
+            maxQueueWaitMs: 60000,
+            adaptiveLearning: true,
+            verbose: true,
+            ...config,
+        };
+        // Initialize rotation pool with free models that support tools
+        this.initializeRotationPool();
+        // Start queue processor
+        this.startQueueProcessor();
+    }
+    // =========================================================================
+    // Pre-Request Checking
+    // =========================================================================
+    /**
+     * Check if a request can be made to a specific model.
+     * Returns a RateLimitCheck with the decision and optional alternative model.
+     */
+    checkRateLimit(modelId) {
+        const now = Date.now();
+        // 1. Check global RPM
+        this.cleanupGlobalTimestamps(now);
+        if (this.globalRequestTimestamps.length >= this.config.globalRpm) {
+            const oldestInWindow = this.globalRequestTimestamps[0];
+            const waitMs = Math.max(0, 60000 - (now - oldestInWindow));
+            const alternative = this.findAvailableModel(modelId);
+            if (alternative) {
+                return {
+                    allowed: false,
+                    waitMs: 0,
+                    suggestedModel: alternative,
+                    reason: `Global RPM limit reached (${this.config.globalRpm}/min). Suggesting alternative: ${MODELS[alternative]?.name || alternative}`,
+                };
+            }
+            return {
+                allowed: false,
+                waitMs,
+                suggestedModel: null,
+                reason: `Global RPM limit reached (${this.config.globalRpm}/min). Wait ${Math.ceil(waitMs / 1000)}s or try a different model.`,
+            };
+        }
+        // 2. Check per-model cooldown
+        const state = this.getOrCreateState(modelId);
+        if (state.cooldownUntil > now) {
+            const waitMs = state.cooldownUntil - now;
+            const alternative = this.findAvailableModel(modelId);
+            if (alternative) {
+                return {
+                    allowed: false,
+                    waitMs: 0,
+                    suggestedModel: alternative,
+                    reason: `${MODELS[modelId]?.name || modelId} is in cooldown (${Math.ceil(waitMs / 1000)}s left). Rotating to ${MODELS[alternative]?.name || alternative}`,
+                };
+            }
+            return {
+                allowed: false,
+                waitMs,
+                suggestedModel: null,
+                reason: `${MODELS[modelId]?.name || modelId} is in cooldown. Wait ${Math.ceil(waitMs / 1000)}s.`,
+            };
+        }
+        // 3. Check per-model RPM
+        this.cleanupModelTimestamps(state, now);
+        if (state.requestsThisMinute >= this.config.perModelRpm) {
+            const alternative = this.findAvailableModel(modelId);
+            if (alternative) {
+                return {
+                    allowed: false,
+                    waitMs: 0,
+                    suggestedModel: alternative,
+                    reason: `${MODELS[modelId]?.name || modelId} RPM limit (${this.config.perModelRpm}/min). Rotating to ${MODELS[alternative]?.name || alternative}`,
+                };
+            }
+            const minuteElapsed = now - state.minuteWindowStart;
+            const waitMs = Math.max(0, 60000 - minuteElapsed);
+            return {
+                allowed: false,
+                waitMs,
+                suggestedModel: null,
+                reason: `${MODELS[modelId]?.name || modelId} RPM limit reached. Wait ${Math.ceil(waitMs / 1000)}s.`,
+            };
+        }
+        // 4. Check health score - if model is unhealthy, suggest alternative
+        if (state.healthScore < 30 && state.consecutive429s > 3) {
+            const alternative = this.findAvailableModel(modelId);
+            if (alternative) {
+                return {
+                    allowed: true,
+                    waitMs: 0,
+                    suggestedModel: alternative,
+                    reason: `${MODELS[modelId]?.name || modelId} health is low (${state.healthScore}/100). Suggesting ${MODELS[alternative]?.name || alternative} for better reliability.`,
+                };
+            }
+        }
+        // All checks passed
+        return {
+            allowed: true,
+            waitMs: 0,
+            suggestedModel: null,
+            reason: 'OK',
+        };
+    }
+    /**
+     * Acquire permission to make a request. Resolves when the request can proceed.
+     * If queuing is enabled, waits in queue. Otherwise, rejects if rate limited.
+     */
+    async acquire(modelId) {
+        const check = this.checkRateLimit(modelId);
+        if (check.allowed) {
+            // If there's a suggested model due to low health, we still allow but suggest
+            this.recordRequestStart(modelId);
+            return check;
+        }
+        // If there's an alternative model suggested, switch to it
+        if (check.suggestedModel) {
+            const altCheck = this.checkRateLimit(check.suggestedModel);
+            if (altCheck.allowed) {
+                this.recordRequestStart(check.suggestedModel);
+                if (this.config.verbose) {
+                    console.log(chalk.cyan(`  🔄 Rate limiter: switching ${MODELS[modelId]?.name || modelId} → ${MODELS[check.suggestedModel]?.name || check.suggestedModel}`));
+                }
+                return { ...altCheck, suggestedModel: check.suggestedModel, reason: check.reason };
+            }
+        }
+        // If queuing is enabled, queue the request
+        if (this.config.enableQueue && check.waitMs > 0) {
+            return this.enqueueRequest(modelId);
+        }
+        // Can't proceed, return the check with wait info
+        if (this.config.verbose) {
+            console.log(chalk.yellow(`  ⏳ Rate limited: ${check.reason}`));
+        }
+        return check;
+    }
+    /**
+     * Record a successful request completion
+     */
+    recordSuccess(modelId, responseTimeMs) {
+        const state = this.getOrCreateState(modelId);
+        state.consecutive429s = 0;
+        state.totalSuccesses++;
+        state.lastRequestAt = Date.now();
+        // Update average response time (exponential moving average)
+        if (state.avgResponseMs === 0) {
+            state.avgResponseMs = responseTimeMs;
+        }
+        else {
+            state.avgResponseMs = state.avgResponseMs * 0.8 + responseTimeMs * 0.2;
+        }
+        // Recover health score
+        state.healthScore = Math.min(100, state.healthScore + 5);
+    }
+    /**
+     * Record a rate limit (429) response
+     */
+    recordRateLimit(modelId, retryAfterSeconds) {
+        const state = this.getOrCreateState(modelId);
+        const now = Date.now();
+        state.consecutive429s++;
+        state.total429s++;
+        state.lastRequestAt = now;
+        // Calculate cooldown duration
+        let cooldownMs;
+        if (retryAfterSeconds && retryAfterSeconds > 0) {
+            // Respect server-provided retry-after
+            cooldownMs = retryAfterSeconds * 1000;
+        }
+        else {
+            // Exponential backoff based on consecutive 429s
+            cooldownMs = Math.min(this.config.baseCooldownMs * Math.pow(this.config.backoffMultiplier, state.consecutive429s - 1), this.config.maxCooldownMs);
+        }
+        state.cooldownUntil = now + cooldownMs;
+        // Decrease health score
+        state.healthScore = Math.max(0, state.healthScore - (10 + state.consecutive429s * 5));
+        // Adaptive learning: record the pattern
+        if (this.config.adaptiveLearning) {
+            this.recordRateLimitPattern(modelId, cooldownMs);
+        }
+        if (this.config.verbose) {
+            console.log(chalk.yellow(`  🚫 Rate limited on ${MODELS[modelId]?.name || modelId}: ` +
+                `cooldown ${Math.ceil(cooldownMs / 1000)}s ` +
+                `(consecutive: ${state.consecutive429s}, health: ${state.healthScore}/100)`));
+        }
+    }
+    /**
+     * Record a server error (5xx) - treat as potential overload
+     */
+    recordServerError(modelId) {
+        const state = this.getOrCreateState(modelId);
+        const now = Date.now();
+        // Apply a shorter cooldown for server errors
+        state.cooldownUntil = now + this.config.baseCooldownMs / 2;
+        state.healthScore = Math.max(0, state.healthScore - 15);
+        if (this.config.verbose) {
+            console.log(chalk.yellow(`  ⚠️ Server error on ${MODELS[modelId]?.name || modelId}: ` +
+                `cooldown ${Math.ceil(this.config.baseCooldownMs / 2000)}s, health: ${state.healthScore}/100`));
+        }
+    }
+    // =========================================================================
+    // Model Rotation
+    // =========================================================================
+    /**
+     * Get the next available model from the rotation pool.
+     * Skips models that are in cooldown or have low health.
+     */
+    getNextRotationModel(excludeModel) {
+        const now = Date.now();
+        const poolSize = this.rotationPool.length;
+        if (poolSize === 0)
+            return null;
+        // Try each model in the pool, starting from current index
+        for (let i = 0; i < poolSize; i++) {
+            const idx = (this.currentRotationIndex + i) % poolSize;
+            const model = this.rotationPool[idx];
+            if (model === excludeModel)
+                continue;
+            const state = this.getOrCreateState(model);
+            // Skip if in cooldown
+            if (state.cooldownUntil > now)
+                continue;
+            // Skip if health is too low
+            if (state.healthScore < 20)
+                continue;
+            // Move rotation index forward
+            this.currentRotationIndex = (idx + 1) % poolSize;
+            return model;
+        }
+        // All models in pool are rate limited or unhealthy
+        // Find the one with the shortest wait time
+        let bestModel = null;
+        let shortestWait = Infinity;
+        for (const model of this.rotationPool) {
+            if (model === excludeModel)
+                continue;
+            const state = this.getOrCreateState(model);
+            const waitMs = Math.max(0, state.cooldownUntil - now);
+            if (waitMs < shortestWait) {
+                shortestWait = waitMs;
+                bestModel = model;
+            }
+        }
+        return bestModel;
+    }
+    /**
+     * Get the best available model for a given requested model.
+     * Tries the requested model first, then falls back through the rotation pool.
+     */
+    getBestAvailableModel(requestedModel) {
+        // Check if requested model is available
+        const check = this.checkRateLimit(requestedModel);
+        if (check.allowed)
+            return requestedModel;
+        // Try rotation pool
+        const alternative = this.findAvailableModel(requestedModel);
+        if (alternative)
+            return alternative;
+        // Last resort: return requested model (will wait)
+        return requestedModel;
+    }
+    // =========================================================================
+    // Status & Diagnostics
+    // =========================================================================
+    /**
+     * Get rate limit status for all tracked models
+     */
+    getStatus() {
+        const now = Date.now();
+        const result = [];
+        for (const [modelId, state] of this.modelStates) {
+            this.cleanupModelTimestamps(state, now);
+            result.push({
+                model: modelId,
+                name: MODELS[modelId]?.name || modelId,
+                health: state.healthScore,
+                cooldown: Math.max(0, Math.ceil((state.cooldownUntil - now) / 1000)),
+                consecutive429s: state.consecutive429s,
+                total429s: state.total429s,
+                totalSuccesses: state.totalSuccesses,
+                rpm: state.requestsThisMinute,
+                avgResponseMs: Math.round(state.avgResponseMs),
+            });
+        }
+        return result.sort((a, b) => b.health - a.health);
+    }
+    /**
+     * Get queue status
+     */
+    getQueueStatus() {
+        if (this.requestQueue.length === 0)
+            return { size: 0, oldestWaitMs: 0 };
+        return {
+            size: this.requestQueue.length,
+            oldestWaitMs: Date.now() - this.requestQueue[0].enqueuedAt,
+        };
+    }
+    /**
+     * Reset all rate limit state (useful for testing)
+     */
+    reset() {
+        for (const state of this.modelStates.values()) {
+            state.cooldownUntil = 0;
+            state.consecutive429s = 0;
+            state.healthScore = 100;
+            state.requestsThisMinute = 0;
+        }
+        this.globalRequestTimestamps = [];
+        this.requestQueue.forEach(r => r.reject(new Error('Rate limiter reset')));
+        this.requestQueue = [];
+        if (this.config.verbose) {
+            console.log(chalk.gray('  ↻ Rate limiter state reset'));
+        }
+    }
+    /**
+     * Reset a specific model's rate limit state
+     */
+    resetModel(modelId) {
+        const state = this.modelStates.get(modelId);
+        if (state) {
+            state.cooldownUntil = 0;
+            state.consecutive429s = 0;
+            state.healthScore = 100;
+            state.requestsThisMinute = 0;
+        }
+    }
+    /**
+     * Update configuration at runtime
+     */
+    updateConfig(updates) {
+        Object.assign(this.config, updates);
+        if (updates.rotationPoolSize !== undefined) {
+            this.initializeRotationPool();
+        }
+    }
+    /**
+     * Print a formatted status table
+     */
+    printStatus() {
+        const status = this.getStatus();
+        const now = Date.now();
+        console.log(chalk.bold('\n📊 Rate Limiter Status'));
+        console.log(chalk.gray('─'.repeat(80)));
+        for (const s of status) {
+            const healthBar = this.getHealthBar(s.health);
+            const cooldownStr = s.cooldown > 0 ? chalk.red(`${s.cooldown}s`) : chalk.green('✓');
+            const rpmStr = `${s.rpm}/${this.config.perModelRpm}`;
+            console.log(`  ${s.name.padEnd(35)} ${healthBar} ${cooldownStr.padEnd(8)} ` +
+                `429s: ${chalk.yellow(String(s.total429s).padEnd(4))} ` +
+                `OK: ${chalk.green(String(s.totalSuccesses).padEnd(4))} ` +
+                `RPM: ${rpmStr.padEnd(6)} ` +
+                `avg: ${s.avgResponseMs}ms`);
+        }
+        const queueStatus = this.getQueueStatus();
+        if (queueStatus.size > 0) {
+            console.log(chalk.yellow(`\n  Queue: ${queueStatus.size} requests waiting (oldest: ${Math.ceil(queueStatus.oldestWaitMs / 1000)}s)`));
+        }
+        console.log(chalk.gray('─'.repeat(80)));
+    }
+    // =========================================================================
+    // Private Methods
+    // =========================================================================
+    getOrCreateState(modelId) {
+        if (!this.modelStates.has(modelId)) {
+            this.modelStates.set(modelId, {
+                modelId,
+                cooldownUntil: 0,
+                consecutive429s: 0,
+                total429s: 0,
+                totalSuccesses: 0,
+                requestsThisMinute: 0,
+                minuteWindowStart: Date.now(),
+                lastRequestAt: 0,
+                avgResponseMs: 0,
+                inRotationPool: this.rotationPool.includes(modelId),
+                healthScore: 100,
+            });
+        }
+        return this.modelStates.get(modelId);
+    }
+    recordRequestStart(modelId) {
+        const now = Date.now();
+        const state = this.getOrCreateState(modelId);
+        // Update per-model minute window
+        this.cleanupModelTimestamps(state, now);
+        state.requestsThisMinute++;
+        state.lastRequestAt = now;
+        // Update global timestamps
+        this.cleanupGlobalTimestamps(now);
+        this.globalRequestTimestamps.push(now);
+    }
+    cleanupGlobalTimestamps(now) {
+        const oneMinuteAgo = now - 60000;
+        while (this.globalRequestTimestamps.length > 0 && this.globalRequestTimestamps[0] < oneMinuteAgo) {
+            this.globalRequestTimestamps.shift();
+        }
+    }
+    cleanupModelTimestamps(state, now) {
+        if (now - state.minuteWindowStart >= 60000) {
+            state.requestsThisMinute = 0;
+            state.minuteWindowStart = now;
+        }
+    }
+    findAvailableModel(excludeModel) {
+        const now = Date.now();
+        // First, try the rotation pool
+        for (const model of this.rotationPool) {
+            if (model === excludeModel)
+                continue;
+            const state = this.getOrCreateState(model);
+            if (state.cooldownUntil <= now && state.healthScore >= 20) {
+                this.cleanupModelTimestamps(state, now);
+                if (state.requestsThisMinute < this.config.perModelRpm) {
+                    return model;
+                }
+            }
+        }
+        // Then try any tracked model that's available
+        for (const [modelId, state] of this.modelStates) {
+            if (modelId === excludeModel)
+                continue;
+            if (state.cooldownUntil <= now && state.healthScore >= 20) {
+                this.cleanupModelTimestamps(state, now);
+                if (state.requestsThisMinute < this.config.perModelRpm) {
+                    return modelId;
+                }
+            }
+        }
+        return null;
+    }
+    initializeRotationPool() {
+        const freeModels = getFreeModelsWithTools();
+        // Sort by context window (larger is better for coding)
+        const sorted = freeModels.sort((a, b) => b.contextWindow - a.contextWindow);
+        // Take top N models for rotation
+        this.rotationPool = sorted
+            .slice(0, Math.min(this.config.rotationPoolSize, sorted.length))
+            .map(m => m.id);
+        // Mark all as in rotation pool
+        for (const modelId of this.rotationPool) {
+            const state = this.getOrCreateState(modelId);
+            state.inRotationPool = true;
+        }
+        if (this.config.verbose) {
+            console.log(chalk.gray(`  🔄 Rate limiter rotation pool: ${this.rotationPool.map(m => MODELS[m]?.name || m).join(', ')}`));
+        }
+    }
+    enqueueRequest(modelId) {
+        return new Promise((resolve, reject) => {
+            if (this.requestQueue.length >= this.config.maxQueueSize) {
+                reject(new Error(`Rate limiter queue full (${this.config.maxQueueSize}). Try again later.`));
+                return;
+            }
+            const id = `req_${++this.requestIdCounter}`;
+            const queued = {
+                id,
+                model: modelId,
+                enqueuedAt: Date.now(),
+                resolve,
+                reject,
+            };
+            this.requestQueue.push(queued);
+            if (this.config.verbose) {
+                console.log(chalk.gray(`  ⏳ Request queued for ${MODELS[modelId]?.name || modelId} (queue: ${this.requestQueue.length})`));
+            }
+            // Set a timeout to reject if waiting too long
+            setTimeout(() => {
+                const idx = this.requestQueue.findIndex(r => r.id === id);
+                if (idx !== -1) {
+                    this.requestQueue.splice(idx, 1);
+                    reject(new Error(`Request timed out waiting in rate limiter queue (${this.config.maxQueueWaitMs / 1000}s)`));
+                }
+            }, this.config.maxQueueWaitMs);
+        });
+    }
+    startQueueProcessor() {
+        // Process queue every 2 seconds
+        this.queueProcessTimer = setInterval(() => {
+            this.processQueue();
+        }, 2000);
+    }
+    processQueue() {
+        if (this.requestQueue.length === 0)
+            return;
+        const now = Date.now();
+        const toProcess = [];
+        // Find requests that can now proceed
+        for (let i = this.requestQueue.length - 1; i >= 0; i--) {
+            const req = this.requestQueue[i];
+            // Check if request has been waiting too long
+            if (now - req.enqueuedAt > this.config.maxQueueWaitMs) {
+                this.requestQueue.splice(i, 1);
+                req.reject(new Error('Request timed out in rate limiter queue'));
+                continue;
+            }
+            const check = this.checkRateLimit(req.model);
+            if (check.allowed) {
+                toProcess.push(req);
+                this.requestQueue.splice(i, 1);
+            }
+            else if (check.suggestedModel) {
+                // Try alternative model
+                const altCheck = this.checkRateLimit(check.suggestedModel);
+                if (altCheck.allowed) {
+                    this.recordRequestStart(check.suggestedModel);
+                    req.resolve({ ...altCheck, suggestedModel: check.suggestedModel, reason: check.reason });
+                    this.requestQueue.splice(i, 1);
+                }
+            }
+        }
+        // Process approved requests
+        for (const req of toProcess) {
+            this.recordRequestStart(req.model);
+            req.resolve({ allowed: true, waitMs: 0, suggestedModel: null, reason: 'Queued request approved' });
+        }
+    }
+    recordRateLimitPattern(modelId, cooldownMs) {
+        const hour = new Date().getHours();
+        let patterns = this.rateLimitPatterns.get(modelId);
+        if (!patterns) {
+            patterns = [];
+            this.rateLimitPatterns.set(modelId, patterns);
+        }
+        let existing = patterns.find(p => p.hourOfDay === hour);
+        if (!existing) {
+            existing = { hourOfDay: hour, avgCooldownMs: cooldownMs, count: 1 };
+            patterns.push(existing);
+        }
+        else {
+            existing.avgCooldownMs = (existing.avgCooldownMs * existing.count + cooldownMs) / (existing.count + 1);
+            existing.count++;
+        }
+    }
+    getHealthBar(health) {
+        const filled = Math.round(health / 10);
+        const empty = 10 - filled;
+        let color;
+        if (health >= 70)
+            color = chalk.green;
+        else if (health >= 40)
+            color = chalk.yellow;
+        else
+            color = chalk.red;
+        return color('█'.repeat(filled) + '░'.repeat(empty));
+    }
+    /**
+     * Cleanup - call when shutting down
+     */
+    dispose() {
+        if (this.queueProcessTimer) {
+            clearInterval(this.queueProcessTimer);
+            this.queueProcessTimer = null;
+        }
+        // Reject all queued requests
+        for (const req of this.requestQueue) {
+            req.reject(new Error('Rate limiter shutting down'));
+        }
+        this.requestQueue = [];
+    }
+}
+//# sourceMappingURL=rate-limiter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuro-cli",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Advanced AI-powered terminal coding assistant with multi-agent orchestration, sub-agent spawning, ACP protocol, OS-level sandboxing, spec-driven development, smart monitoring, multi-model routing, MCP Apps, auto-updater, and 23+ free models",
   "main": "dist/index.js",
   "bin": {