neuro-cli 4.3.0 → 5.0.1

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/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // ============================================================
 // NeuroCLI - Advanced AI Terminal Coding Assistant
-// Main Entry Point - v4.1.3 with robust error handling
+// Main Entry Point - v5.0 (Claude Code-style Agentic Loop)
 // ============================================================
 import { Command } from 'commander';
 import { createInterface } from 'readline';
@@ -16,7 +16,7 @@ import { HeadlessMode } from './core/headless.js';
 import { ShellCompletionGenerator } from './core/shell-completion.js';
 import chalk from 'chalk';
 import { AutoUpdater } from './core/updater.js';
-const VERSION = '4.3.0';
+const VERSION = '5.0.0';
 // ---- Global Error Handlers (prevent crashes) ----
 process.on('unhandledRejection', (reason) => {
     console.error(chalk.red('\n⚠️ Unhandled promise rejection:'), reason);

package/dist/ui/renderer.d.ts

@@ -21,7 +21,7 @@ export declare class TerminalUI {
     approvalRequest(toolName: string, args: Record<string, unknown>, risk: 'low' | 'medium' | 'high'): boolean;
     tokenUsage(usage: TokenUsage, modelId: string): void;
     sessionStats(totalInput: number, totalOutput: number, totalCost: number): void;
-    agentActivity(agentName: string, status: 'starting' | 'working' | 'done' | 'error'): void;
+    agentActivity(agentName: string, status: 'starting' | 'working' | 'done' | 'error', detail?: string): void;
     error(message: string): void;
     info(message: string): void;
     success(message: string): void;

package/dist/ui/renderer.js

@@ -165,7 +165,7 @@ export class TerminalUI {
         console.log(`  ${this.theme.muted('Session:')}`, this.theme.dim(`${totalInput.toLocaleString()} in · ${totalOutput.toLocaleString()} out · $${totalCost.toFixed(4)}`));
     }
     // ── Agent Activity (subtle indicator) ───────────────────
-    agentActivity(agentName, status) {
+    agentActivity(agentName, status, detail) {
         const indicators = {
             starting: this.theme.muted('○'),
             working: this.theme.accent('◎'),
@@ -178,7 +178,8 @@ export class TerminalUI {
             done: 'done',
             error: 'failed',
         };
-        console.log(`  ${indicators[status]} ${this.theme.muted(agentName)} ${this.theme.dim(statusText[status])}`);
+        const detailStr = detail ? ` ${this.theme.dim(detail)}` : '';
+        console.log(`  ${indicators[status]} ${this.theme.muted(agentName)} ${this.theme.dim(statusText[status])}${detailStr}`);
     }
     // ── Status Messages (minimal) ───────────────────────────
     error(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuro-cli",
-  "version": "4.3.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": {