@kikkimo/claude-launcher 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -5,6 +5,47 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.0] - 2026-02-12
+
+### Added
+- **GLM-5 Model Support**: Added GLM-5 model for ZhiPu AI providers (`zhipu` and `zai`)
+- **Claude Opus 4.6 Model**: Added `claude-opus-4-6` model support with unified hyphen naming format
+- **Model Upgrade Notification**: Automatic startup notification when newer model versions are available for configured APIs
+- **Model Upgrade Settings Menu**: New submenu under API Management with:
+  - Auto Upgrade toggle (ON/OFF) - automatically use latest model versions
+  - Manual Upgrade option - review and confirm each model upgrade individually
+- **Enhanced Usage Statistics**: Added success/failure rate tracking for API calls:
+  - Overall success rate display
+  - Per-API success rate in statistics table
+  - Time-based last used display (just now, minutes ago, hours ago, days ago)
+- **Statistics Submenu**: Restructured statistics page with submenu:
+  - View Statistics Details
+  - Reset Statistics
+- **Clear All APIs**: New bulk delete option in Remove API submenu:
+  - Delete Single API
+  - Clear All APIs (with CLEAR confirmation prompt)
+
+### Changed
+- **Model Naming Convention**: Unified all model names to use hyphen format (e.g., `claude-opus-4-6` instead of mixed formats)
+- **Auto Upgrade Toggle**: Changed to radio button style for better visual feedback
+- **Statistics Display**: Enhanced table format with success rate column and relative time display
+- **Menu Structure**: Reorganized API management with logical submenu groupings
+
+### Fixed
+- **Auto Upgrade Execution**: Fixed auto upgrade to bypass cache and execute immediately when enabled
+- **Model Upgrade Notification**: Corrected menu name reference in upgrade notification hint
+- **i18n Synchronization**: Synced all 41 missing translation entries across 9 non-English locale files:
+  - Added `statistics` enhanced fields (15 entries) to all locales
+  - Added complete `model_upgrade` module (25 entries) to all locales
+  - Added missing `confirm_password_prompt` to affected locales
+
+### Documentation
+- **README Updates**: Updated both English and Chinese README files with:
+  - Model upgrade feature documentation
+  - Updated API management menu structure
+  - Success/failure rate tracking description
+  - Updated supported providers list
+
 ## [2.3.0] - 2025-12-24
 
 ### Added

package/README.md

@@ -25,11 +25,12 @@ An elegant interactive launcher for Claude Code with a beautiful Claude-style in
 - Strong password requirements and validation
 
 ### 🚀 **Third-party API Management**
-- Full support for multiple third-party API providers (OpenAI, Anthropic, DeepSeek, Kimi, MiniMax, GLM (ZhiPu AI), and more)
+- Full support for multiple third-party API providers (OpenAI, Anthropic, DeepSeek, Kimi, MiniMax, GLM/ZhiPu AI, and custom APIs)
 - Interactive API configuration with validation
-- API usage statistics and tracking
+- API usage statistics with success/failure tracking
+- Model upgrade notifications and auto-upgrade support
 - Secure configuration backup and restore
-- Easy API switching and removal
+- Easy API switching, removal, and bulk clear
 
 ### 🌍 **Enterprise-grade Features**
 - Global installation - use `claude-launcher` from anywhere
@@ -85,7 +86,11 @@ node claude-launcher
 2. **Launch Claude Code (Skip Permissions)** - Launch with `--dangerously-skip-permissions`
 3. **Launch Claude Code with Third-party API** - Use configured third-party API
 4. **Launch Claude Code with Third-party API (Skip Permissions)** - Combine third-party API with permission skipping
-5. **Third-party API Management** - Configure, switch, remove APIs, view statistics
+5. **Third-party API Management** - Full API lifecycle management:
+   - Add, switch, and remove APIs
+   - View usage statistics with success/failure rates
+   - Model upgrade settings (auto/manual upgrade)
+   - Import/export configurations
 6. **Language Settings** - Switch between 11 supported languages
 7. **Version Update Check** - Check for launcher updates
 8. **Exit** - Close the launcher
@@ -126,15 +131,23 @@ Access comprehensive API management through the dedicated menu:
 📋 Third-party API Management
 
   → Add New API
-    Remove API
+    Remove API          → Delete Single API / Clear All APIs
     Switch Active API
-    View Statistics
+    View Statistics     → View Details / Reset Statistics
+    Model Upgrade       → Auto Upgrade [ON/OFF] / Manual Upgrade
     Export Configuration
     Import Configuration
     Change Password
     Back to Main Menu
 ```
 
+### Model Upgrade Feature
+
+The launcher automatically checks for model upgrades when you start:
+- **Auto Upgrade**: Automatically use the latest model version
+- **Manual Upgrade**: Review and confirm each model upgrade
+- **Startup Notifications**: Get notified when newer model versions are available
+
 ## ⚙️ Configuration
 
 ### Modern Configuration System
@@ -158,10 +171,11 @@ Claude Launcher 2.0 uses an advanced configuration system:
 
 Configure any third-party API provider through the interactive interface:
 
-- **Supported Providers**: OpenAI, Anthropic, DeepSeek, Kimi, MiniMax (CN/Global), GLM (ZhiPu AI), and custom APIs
+- **Supported Providers**: Anthropic, OpenAI, DeepSeek, Moonshot/Kimi, MiniMax (CN/Global), GLM/ZhiPu AI (GLM-4, GLM-5), and custom Anthropic-compatible APIs
 - **Secure Storage**: All API tokens encrypted before storage
 - **Validation**: Real-time validation of URLs, tokens, and models
-- **Usage Tracking**: Monitor API usage statistics
+- **Usage Tracking**: Monitor API usage statistics with success/failure rates
+- **Model Upgrade**: Automatic detection and upgrade to latest model versions
 - **Provider-specific Features**: Optimized configuration for each provider with helpful notes and recommendations
 
 ### Configuration Import/Export

package/claude-launcher

@@ -263,9 +263,52 @@ async function addNewThirdPartyApi() {
 }
 
 /**
- * Remove third-party API
+ * Remove third-party API menu with submenu
  */
 async function removeThirdPartyApi() {
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '🗑️  ' + await i18n.t('menu.remove_api.title') + colors.reset);
+    console.log('');
+
+    const apis = apiManager.getApis();
+
+    // Show current API count
+    if (apis.length > 0) {
+        console.log(colors.cyan + '  ' + await i18n.t('messages.info.current_api_count', apis.length) + colors.reset);
+        console.log('');
+    }
+
+    const menuOptions = [
+        await i18n.t('menu.remove_api.delete_single'),
+        await i18n.t('menu.remove_api.clear_all'),
+        await i18n.t('menu.remove_api.back')
+    ];
+
+    initializeGlobalMenus();
+    globalApiManagementMenu.setOptions(menuOptions);
+    const choice = await globalApiManagementMenu.navigate();
+
+    switch (choice) {
+        case 0: // Delete Single API
+            await deleteSingleApi();
+            return;
+
+        case 1: // Clear All APIs
+            await clearAllApis();
+            return;
+
+        case 2: // Back
+        case -1:
+        default:
+            return;
+    }
+}
+
+/**
+ * Delete a single API
+ */
+async function deleteSingleApi() {
     try {
         // Get API list
         const apis = apiManager.getApis();
@@ -281,7 +324,7 @@ async function removeThirdPartyApi() {
         );
 
         if (!selectedApi) {
-            return showMenu();
+            return;
         }
 
         // Show confirmation dialog
@@ -299,23 +342,20 @@ async function removeThirdPartyApi() {
                     `${await i18n.t('api.details.provider')}: ${selectedApi.provider}`
                 ]);
 
-                // Show success message and return to main menu
+                // Show success message
                 const remainingApis = apiManager.getApis();
                 if (remainingApis.length === 0) {
                     showInfo(await i18n.t('messages.info.all_apis_removed'));
                 }
                 await waitForKey(await i18n.t('messages.prompts.press_any_key'));
-                return showMenu();
 
             } catch (removeError) {
                 showError(await i18n.t('errors.api.failed_remove', removeError.message));
                 await waitForKey(await i18n.t('messages.prompts.press_any_key'));
-                return showMenu();
             }
         } else {
             showInfo(await i18n.t('messages.info.removal_cancelled'));
             await waitForKey(await i18n.t('messages.prompts.press_any_key'));
-            return showMenu();
         }
 
     } catch (error) {
@@ -325,6 +365,42 @@ async function removeThirdPartyApi() {
     }
 }
 
+/**
+ * Clear all APIs with confirmation
+ */
+async function clearAllApis() {
+    const { simpleInput } = require('./lib/ui/prompts');
+
+    const apis = apiManager.getApis();
+    const count = apis.length;
+
+    if (count === 0) {
+        console.clear();
+        showInfo(await i18n.t('messages.info.no_apis'));
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+        return;
+    }
+
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.red + '⚠️  ' + await i18n.t('menu.remove_api.clear_all') + colors.reset);
+    console.log('');
+    console.log(colors.yellow + '  ' + await i18n.t('messages.prompts.confirm_clear_all', count) + colors.reset);
+    console.log('');
+
+    const input = await simpleInput(colors.cyan + '  ' + await i18n.t('messages.prompts.confirm_clear_all_input') + colors.reset);
+
+    if (input === 'CLEAR') {
+        const clearedCount = apiManager.clearAllApis();
+        console.clear();
+        showSuccess(await i18n.t('messages.info.all_apis_cleared', clearedCount));
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+    } else {
+        showInfo(await i18n.t('messages.info.clear_cancelled'));
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+    }
+}
+
 /**
  * Switch active third-party API
  */
@@ -357,40 +433,110 @@ async function switchThirdPartyApi() {
 /**
  * View API statistics
  */
+/**
+ * Format timestamp to relative time
+ * @param {string|null} timestamp - ISO timestamp or null
+ * @returns {string} Relative time string
+ */
+function formatRelativeTime(timestamp) {
+    if (!timestamp) return i18n.tSync('statistics.time_never');
+
+    const now = Date.now();
+    const diff = now - new Date(timestamp).getTime();
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    const days = Math.floor(diff / 86400000);
+
+    if (minutes < 1) return i18n.tSync('statistics.time_just_now');
+    if (minutes < 60) return i18n.tSync('statistics.time_minutes_ago', minutes);
+    if (hours < 24) return i18n.tSync('statistics.time_hours_ago', hours);
+    return i18n.tSync('statistics.time_days_ago', days);
+}
+
 async function viewStatistics() {
     console.clear();
     console.log('');
     console.log(colors.bright + colors.orange + '📊 ' + await i18n.t('statistics.title') + colors.reset);
     console.log('');
 
-    const stats = apiManager.getStatistics();
-    const apis = apiManager.getApis();
+    const menuOptions = [
+        await i18n.t('statistics.menu_view'),
+        await i18n.t('statistics.menu_reset'),
+        await i18n.t('statistics.menu_back')
+    ];
+
+    initializeGlobalMenus();
+    globalApiManagementMenu.setOptions(menuOptions);
+    const choice = await globalApiManagementMenu.navigate();
+
+    switch (choice) {
+        case 0: // View Statistics Details
+            await showStatisticsDetails();
+            return viewStatistics();
+
+        case 1: // Reset Statistics
+            const { simpleInput } = require('./lib/ui/prompts');
+            const confirm = await simpleInput(colors.yellow + '  ' + await i18n.t('statistics.reset_confirm') + ' ' + colors.reset);
+            if (confirm.toLowerCase() === 'y') {
+                apiManager.resetStatistics();
+                console.log(colors.green + '  ✓ ' + await i18n.t('statistics.reset_success') + colors.reset);
+                await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+            }
+            return viewStatistics();
+
+        case 2: // Back
+        case -1:
+        default:
+            return;
+    }
+}
+
+/**
+ * Show detailed statistics
+ */
+async function showStatisticsDetails() {
+    const { padStringToWidth } = require('./lib/utils/string-width');
 
-    console.log(colors.cyan + '  ' + i18n.tSync('ui.general.summary') + colors.reset);
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '📊 ' + await i18n.t('statistics.title') + colors.reset);
+    console.log('');
+
+    const stats = apiManager.getEnhancedStatistics();
+
+    // Summary section
+    console.log(colors.cyan + '  ' + i18n.tSync('ui.general.summary') + ':' + colors.reset);
     console.log(colors.gray + `    ${await i18n.t('statistics.total_apis', stats.totalApis)}` + colors.reset);
     console.log(colors.gray + `    ${await i18n.t('statistics.active_api', stats.activeApiName)}` + colors.reset);
     console.log(colors.gray + `    ${await i18n.t('statistics.most_used', stats.mostUsedApi)}` + colors.reset);
     console.log(colors.gray + `    ${await i18n.t('statistics.total_usage', stats.totalUsage)}` + colors.reset);
+    console.log(colors.gray + `    ${await i18n.t('statistics.success_rate', stats.successRate)}` + colors.reset);
     console.log('');
 
-    if (apis.length > 0) {
-        console.log(colors.cyan + '  ' + i18n.tSync('ui.general.configured_apis') + colors.reset);
-
-        // Pre-fetch translations to avoid await in forEach
-        const currentlyActiveText = await i18n.t('api.details.currently_active');
-        const providerText = await i18n.t('api.details.provider');
-        const usageText = await i18n.t('api.details.usage');
-        const timesSuffixText = await i18n.t('api.details.times_suffix');
-        const createdAtText = await i18n.t('api.details.created_at');
-
-        apis.forEach((api, index) => {
-            const isActive = apiManager.getActiveApi()?.id === api.id;
-            const activeText = isActive ? ` (${currentlyActiveText})` : '';
-            console.log(colors.gray + `    ${index + 1}. ${api.name}${activeText}` + colors.reset);
-            console.log(colors.dim + `       ${providerText}: ${api.provider}` + colors.reset);
-            console.log(colors.dim + `       ${usageText}: ${api.usageCount || 0} ${timesSuffixText}` + colors.reset);
-            console.log(colors.dim + `       ${createdAtText}: ${api.createdAt}` + colors.reset);
-        });
+    if (stats.apiStats.length > 0) {
+        console.log(colors.cyan + '  ' + i18n.tSync('ui.general.configured_apis') + ':' + colors.reset);
+        console.log('');
+
+        // Table header
+        console.log(colors.dim + '    ' +
+            padStringToWidth(await i18n.t('statistics.header_name'), 20) +
+            padStringToWidth(await i18n.t('statistics.header_usage'), 10) +
+            padStringToWidth(await i18n.t('statistics.header_success'), 10) +
+            await i18n.t('statistics.header_last_used') +
+            colors.reset);
+        console.log(colors.dim + '    ' + '─'.repeat(60) + colors.reset);
+
+        for (const api of stats.apiStats) {
+            const lastUsedText = formatRelativeTime(api.lastUsed);
+            console.log(colors.gray + '    ' +
+                padStringToWidth(api.name, 20) +
+                padStringToWidth(String(api.usageCount), 10) +
+                padStringToWidth(api.successRate, 10) +
+                lastUsedText +
+                colors.reset);
+        }
+    } else {
+        console.log(colors.gray + '  ' + await i18n.t('statistics.no_usage') + colors.reset);
     }
 
     console.log('');
@@ -568,20 +714,23 @@ async function showApiManagementMenu() {
 
     // Build menu options based on password setup status
     const menuOptions = [
-        await i18n.t('menu.api_management.add_new'),
-        await i18n.t('menu.api_management.remove'),
-        await i18n.t('menu.api_management.switch'),
-        await i18n.t('menu.api_management.statistics')
+        await i18n.t('menu.api_management.add_new'),      // 0
+        await i18n.t('menu.api_management.remove'),       // 1
+        await i18n.t('menu.api_management.switch'),       // 2
+        await i18n.t('menu.api_management.statistics')    // 3
     ];
 
     // Add import/export options only if password is set
     if (apiManager.canUseImportExport()) {
-        menuOptions.push(await i18n.t('menu.api_management.export'));
-        menuOptions.push(await i18n.t('menu.api_management.import'));
-        menuOptions.push(await i18n.t('menu.api_management.change_password'));
+        menuOptions.push(await i18n.t('menu.api_management.export'));          // 4
+        menuOptions.push(await i18n.t('menu.api_management.import'));          // 5
+        menuOptions.push(await i18n.t('menu.api_management.change_password')); // 6
     }
 
-    menuOptions.push(await i18n.t('menu.api_management.back'));
+    // Add model upgrade settings (always available)
+    menuOptions.push(await i18n.t('model_upgrade.settings_title'));  // 4 or 7 (depending on import/export)
+
+    menuOptions.push(await i18n.t('menu.api_management.back'));      // 5 or 8
 
     // Ensure global menus are initialized
     initializeGlobalMenus();
@@ -604,7 +753,7 @@ async function showApiManagementMenu() {
         await viewStatistics();
         return showMenu();
     } else if (apiManager.canUseImportExport()) {
-        // If import/export is available, handle those options
+        // With import/export enabled: indices 4-8
         if (choice === 4) { // Export Configuration
             await exportConfiguration();
             return showMenu();
@@ -614,12 +763,16 @@ async function showApiManagementMenu() {
         } else if (choice === 6) { // Change Password
             await changePassword();
             return showMenu();
-        } else if (choice === 7) { // Back to Main Menu
+        } else if (choice === 7) { // Model Upgrade Settings (NEW)
+            return await showModelUpgradeSettings();
+        } else if (choice === 8) { // Back to Main Menu
             return showMenu();
         }
     } else {
-        // If import/export is not available, only Back to Main Menu
-        if (choice === 4) { // Back to Main Menu
+        // Without import/export: indices 4-5
+        if (choice === 4) { // Model Upgrade Settings (NEW)
+            return await showModelUpgradeSettings();
+        } else if (choice === 5) { // Back to Main Menu
             return showMenu();
         }
     }
@@ -628,6 +781,144 @@ async function showApiManagementMenu() {
     return showMenu();
 }
 
+/**
+ * Show model upgrade settings menu
+ */
+async function showModelUpgradeSettings() {
+    const versionChecker = require('./lib/utils/version-checker');
+    const upgradeChecker = require('./lib/utils/model-upgrade-checker');
+
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '⚙️  ' + await i18n.t('model_upgrade.settings_title') + colors.reset);
+    console.log('');
+
+    const config = await versionChecker.loadConfig();
+    const isAutoOn = config.autoModelUpgrade === true;
+
+    console.log(colors.cyan + '  ' + await i18n.t('model_upgrade.current_config') + ':' + colors.reset);
+    console.log(colors.gray + '    ' + await i18n.t('model_upgrade.auto_upgrade_label') + ': ' +
+        (isAutoOn
+            ? colors.green + await i18n.t('model_upgrade.auto_upgrade_on')
+            : colors.dim + await i18n.t('model_upgrade.auto_upgrade_off')
+        ) + colors.reset);
+    console.log('');
+
+    const menuOptions = [
+        isAutoOn
+            ? await i18n.t('model_upgrade.menu_toggle_auto_on')
+            : await i18n.t('model_upgrade.menu_toggle_auto_off'),
+        await i18n.t('model_upgrade.menu_manual_upgrade'),
+        await i18n.t('model_upgrade.menu_back')
+    ];
+
+    initializeGlobalMenus();
+    globalApiManagementMenu.setOptions(menuOptions);
+    const choice = await globalApiManagementMenu.navigate();
+
+    switch (choice) {
+        case 0: // Toggle auto upgrade
+            await versionChecker.setAutoModelUpgrade(!isAutoOn);
+            console.log('');
+            console.log(colors.green + '✓ ' + await i18n.t('model_upgrade.auto_upgrade_label') + ': ' +
+                (!isAutoOn
+                    ? await i18n.t('model_upgrade.auto_upgrade_on')
+                    : await i18n.t('model_upgrade.auto_upgrade_off')
+                ) + colors.reset);
+            await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+            return showModelUpgradeSettings();
+
+        case 1: // Manual upgrade
+            await performManualUpgrade();
+            return showModelUpgradeSettings();
+
+        case 2: // Back
+        case -1:
+        default:
+            return showApiManagementMenu();
+    }
+}
+
+/**
+ * Perform manual upgrade for all APIs with interactive confirmation
+ */
+async function performManualUpgrade() {
+    const { getLatestModel, getProvider } = require('./lib/presets/providers');
+    const { simpleInput } = require('./lib/ui/prompts');
+
+    console.clear();
+    console.log('');
+    console.log(colors.bright + colors.orange + '🔄 ' + await i18n.t('model_upgrade.manual_title') + colors.reset);
+    console.log('');
+
+    const apis = apiManager.getApis();
+
+    if (apis.length === 0) {
+        console.log(colors.yellow + '  ' + await i18n.t('messages.info.no_apis') + colors.reset);
+        await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+        return;
+    }
+
+    console.log(colors.gray + '  ' + await i18n.t('model_upgrade.manual_checking', apis.length) + colors.reset);
+    console.log('');
+
+    let upgradedCount = 0;
+    let skippedUpToDate = 0;
+    let skippedNoInfo = 0;
+    let skippedByUser = 0;
+
+    for (let i = 0; i < apis.length; i++) {
+        const api = apis[i];
+        const latestModel = getLatestModel(api.model, api.provider);
+
+        console.log(colors.cyan + '  ─────────────────────────────────────────────────' + colors.reset);
+        console.log(colors.bright + `  ${i + 1}/${apis.length}  ${api.name}` + colors.reset);
+        console.log(colors.gray + '       ' + await i18n.t('model_upgrade.manual_api_current', api.model) + colors.reset);
+
+        if (latestModel) {
+            console.log(colors.green + '       ' + await i18n.t('model_upgrade.manual_api_latest', latestModel) + colors.reset);
+            console.log('');
+
+            // Ask for confirmation
+            const answer = await simpleInput(colors.yellow + '       ' + await i18n.t('model_upgrade.manual_confirm') + ' ' + colors.reset);
+
+            if (answer.toLowerCase() === 'y') {
+                apiManager.updateApiModel(api.id, latestModel);
+                console.log(colors.green + '       ✓ ' + await i18n.t('model_upgrade.manual_upgraded', api.model, latestModel) + colors.reset);
+                upgradedCount++;
+            } else {
+                console.log(colors.dim + '       ' + await i18n.t('model_upgrade.manual_skipped') + colors.reset);
+                skippedByUser++;
+            }
+        } else {
+            // No upgrade info available - check if model exists in provider
+            const provider = getProvider(api.provider);
+            if (provider && provider.models && provider.models.includes(api.model)) {
+                // Model exists in provider, likely already latest or no alias defined
+                console.log(colors.dim + '       ' + await i18n.t('model_upgrade.manual_api_uptodate') + colors.reset);
+                skippedUpToDate++;
+            } else {
+                console.log(colors.dim + '       ' + await i18n.t('model_upgrade.manual_api_no_info') + colors.reset);
+                skippedNoInfo++;
+            }
+        }
+
+        console.log('');
+    }
+
+    console.log(colors.cyan + '  ─────────────────────────────────────────────────' + colors.reset);
+    console.log('');
+    console.log(colors.green + '  ' + await i18n.t('model_upgrade.manual_complete') + colors.reset);
+    console.log(colors.gray + '    ' + await i18n.t('model_upgrade.manual_stats_upgraded', upgradedCount) + colors.reset);
+    console.log(colors.gray + '    ' + await i18n.t('model_upgrade.manual_stats_skipped',
+        skippedUpToDate + skippedNoInfo + skippedByUser,
+        skippedUpToDate,
+        skippedNoInfo) + colors.reset);
+    console.log('');
+
+    await waitForKey(await i18n.t('messages.prompts.press_any_key'));
+}
+
 /**
  * Handle third-party API launch
  */
@@ -646,12 +937,15 @@ async function handleThirdPartyApiLaunch(skipPermissions = false) {
             return showMenu();
         }
 
-        // Increment usage count for the active API since we're actually using it
-        apiManager.incrementActiveApiUsage();
+        // Record successful launch BEFORE launching (since process exits after)
+        apiManager.recordSuccessfulLaunch();
 
         launchClaudeWithApi(activeApi, skipPermissions);
 
     } catch (error) {
+        // Record failed launch
+        apiManager.recordFailedLaunch(error.message);
+
         showError('Failed to launch with third-party API', [error.message]);
 
         setTimeout(() => {
@@ -741,6 +1035,60 @@ async function showMenu() {
         // Silently ignore update check errors
     }
 
+    // ========================================
+    // Model upgrade check (new feature)
+    // ========================================
+    let modelUpgradeInfo = null;
+    try {
+        const upgradeChecker = require('./lib/utils/model-upgrade-checker');
+        const autoUpgrade = await upgradeChecker.isAutoUpgradeEnabled();
+
+        if (autoUpgrade) {
+            // Auto upgrade enabled: always check and upgrade (bypass cache)
+            const upgrades = upgradeChecker.checkAllApiUpgrades(apiManager);
+            if (upgrades.length > 0) {
+                const upgraded = upgradeChecker.performAutoUpgrade(apiManager, upgrades);
+                if (upgraded.length > 0) {
+                    modelUpgradeInfo = colors.green + '  ✓ ' +
+                        i18n.tSync('model_upgrade.auto_upgraded', upgraded[0].from, upgraded[0].to) + colors.reset;
+                    if (upgraded.length > 1) {
+                        modelUpgradeInfo += '\n' + colors.green + '    ' +
+                            `(+${upgraded.length - 1} more)` + colors.reset;
+                    }
+                }
+            }
+        } else {
+            // Auto upgrade disabled: use cache for notification
+            const result = await upgradeChecker.checkForModelUpgrades(apiManager);
+            if (result.needsCheck && result.upgrades.length > 0) {
+                const first = result.upgrades[0];
+                modelUpgradeInfo = colors.yellow + '  ⚠️  ' +
+                    i18n.tSync('model_upgrade.notification', first.currentModel, first.latestModel) +
+                    colors.reset + '\n' +
+                    colors.yellow + '      ' +
+                    i18n.tSync('model_upgrade.notification_api', first.apiName) +
+                    colors.reset + '\n' +
+                    colors.gray + '      ' +
+                    i18n.tSync('model_upgrade.notification_hint') +
+                    colors.reset;
+            }
+        }
+    } catch (error) {
+        // Silently ignore model upgrade check errors
+    }
+
+    // Combine version info and model upgrade info
+    let displayInfo = '';
+    if (versionInfo) {
+        displayInfo += versionInfo;
+    }
+    if (modelUpgradeInfo) {
+        if (displayInfo) {
+            displayInfo += '\n';
+        }
+        displayInfo += modelUpgradeInfo;
+    }
+
     // Populate menu options dynamically with i18n translations
     menuOptions = [
         await i18n.t('menu.main.launch_default'),
@@ -754,7 +1102,7 @@ async function showMenu() {
     ];
 
     globalMainMenu.setOptions(menuOptions);
-    const selection = await globalMainMenu.navigate(false, versionInfo); // Pass version info to display between banner and nav
+    const selection = await globalMainMenu.navigate(false, displayInfo || null); // Pass combined info to display between banner and nav
 
     if (selection === -1) {
         console.log('');