@kikkimo/claude-launcher 2.5.0 → 3.1.0

package/claude-launcher

@@ -25,7 +25,7 @@ function forceStdinCleanup() {
     } catch (error) {
         // Ignore cleanup errors but log for debugging
         if (process.env.DEBUG_STDIN) {
-            console.error('[DEBUG] forceStdinCleanup error:', error.message);
+            screen.debug('[DEBUG] forceStdinCleanup error: ' + error.message);
         }
     }
 }
@@ -36,12 +36,14 @@ const Menu = require('./lib/ui/menu');
 const colors = require('./lib/ui/colors');
 const { checkForUpdates, forceCheckForUpdates } = require('./lib/utils/version-checker');
 const {
+    simpleInput,
     waitForKey,
     promptForThirdPartyApi,
     confirmAction,
     showSuccess,
     showError,
-    showInfo
+    showInfo,
+    selectProvider,
 } = require('./lib/ui/prompts');
 const {
     launchClaudeDefault,
@@ -50,10 +52,13 @@ const {
     launchClaudeWithApi
 } = require('./lib/launcher');
 const { getPasswordInput } = require('./lib/auth/password-input');
-const { verifyExportPassword, setupNewPassword, changePassword: changePasswordModule } = require('./lib/auth/password-validator');
+const { passwordGuard, verifyCurrentPassword, setupNewPassword, changePassword: changePasswordModule } = require('./lib/auth/password-validator');
 const { maskApiToken } = require('./lib/validators');
 const { showApiSelectionTable, confirmDeletion } = require('./lib/ui/interactive-table');
+const { editApi, editApiEnvVarsById, resolveProviderName } = require('./lib/ui/api-editor');
+const { i18nLabel } = require('./lib/ui/i18n-labels');
 const i18n = require('./lib/i18n');
+const screen = require('./lib/ui/screen');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -66,6 +71,7 @@ const apiManager = new ApiManager();
 let globalMainMenu = null;
 let globalConfirmMenu = null;
 let globalApiManagementMenu = null;
+let globalConfigMenu = null;
 
 /**
  * Initialize global menu objects to prevent recreation and screen flickering
@@ -80,6 +86,9 @@ function initializeGlobalMenus() {
     if (!globalApiManagementMenu) {
         globalApiManagementMenu = new Menu();
     }
+    if (!globalConfigMenu) {
+        globalConfigMenu = new Menu();
+    }
 }
 
 /**
@@ -132,7 +141,7 @@ function openFileWithDefault(filePath) {
 
     exec(command, (error) => {
         if (error) {
-            console.log(colors.yellow + `Could not open file automatically: ${error.message}` + colors.reset);
+            screen.write(colors.yellow + `Could not open file automatically: ${error.message}` + colors.reset + '\n');
         }
     });
 }
@@ -215,71 +224,653 @@ function validateImportFile(filePath) {
 // Main menu options - will be populated dynamically with i18n
 let menuOptions = [];
 
+// --- Add API flow helpers ---
+
+/**
+ * Input helper for add-api steps. Supports Esc / "back" to go back,
+ * "exit"/"quit" to cancel, empty input uses defaultValue if provided.
+ * @param {string} promptText
+ * @param {Object} opts
+ * @param {string} opts.defaultValue - fallback when input is empty
+ * @param {boolean} opts.allowEmpty - if true, empty input returns ""
+ * @param {string} opts.stepLabel - step header e.g. "Step 2/6"
+ * @param {string[]} opts.hintLines - i18n keys for hint lines (default: exit + empty_restore)
+ * @param {Function} opts.validate - (value) => { valid, error? }
+ * @returns {string|null} - input value, or null to go back
+ */
+async function inputStepValue(promptText, { defaultValue, allowEmpty, stepLabel, hintLines, validate } = {}) {
+    const lines = [''];
+    if (stepLabel) {
+        lines.push(colors.bright + stepLabel + colors.reset);
+    }
+    lines.push(colors.cyan + promptText + colors.reset);
+    lines.push('');
+    const hints = hintLines || ['prompt.exit_to_cancel', 'prompt.empty_to_restore'];
+    for (const h of hints) {
+        lines.push(colors.gray + i18n.tSync(h) + colors.reset);
+    }
+    lines.push('');
+    screen.render(lines);
+
+    while (true) {
+        const input = await simpleInput(colors.green + '> ' + colors.reset);
+        if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+            const cancelledMsg = await i18n.t('errors.general.cancelled_by_user');
+            throw new Error(cancelledMsg);
+        }
+        if (input.toLowerCase() === 'back') {
+            return null;
+        }
+        if (input === '') {
+            if (allowEmpty) return '';
+            if (defaultValue !== undefined) return defaultValue;
+        }
+        if (validate) {
+            const result = validate(input);
+            if (!result.valid) {
+                screen.write(colors.red + (result.error || 'Invalid input') + colors.reset + '\n');
+                continue;
+            }
+        }
+        return input;
+    }
+}
+
+/**
+ * Rebuild draft after user goes back and re-enters connection info.
+ * Preserves manual overrides from oldDraft for model/runtime/custom sections.
+ */
+function rebuildDraftPreservingOverrides(oldDraft, providerId, baseUrl, authToken, model, name) {
+    const draft = ApiManager.buildApiDraft(providerId, baseUrl, authToken, model, name);
+    if (!oldDraft) return draft;
+
+    // Preserve model overrides: if user set a value different from auto, keep it
+    const oldAuto = oldDraft._autoModelEnvVars || {};
+    for (const k of Object.keys(oldDraft.modelEnvVars || {})) {
+        if (oldDraft.modelEnvVars[k] !== oldAuto[k]) {
+            draft.modelEnvVars[k] = oldDraft.modelEnvVars[k];
+        }
+    }
+    // Preserve runtime manual overrides
+    const oldRtSources = oldDraft._runtimeEnvSources || {};
+    for (const k of Object.keys(oldRtSources)) {
+        if (oldRtSources[k] === 'manual') {
+            draft.runtimeEnvVars[k] = oldDraft.runtimeEnvVars[k];
+            draft._runtimeEnvSources[k] = 'manual';
+        }
+    }
+    // Preserve custom vars
+    draft.customEnvVars = { ...(oldDraft.customEnvVars || {}) };
+    return draft;
+}
+
+/**
+ * Show duplicate API branch: enter existing config or go back.
+ * @returns {'enter_existing'|'go_back'}
+ */
+async function showDuplicateBranch(existingApi) {
+    const menu = new Menu();
+    screen.render([
+        '', colors.yellow + i18n.tSync('add_api.duplicate_title') + colors.reset, '',
+        i18n.tSync('api.edit.field_name') + ': ' + existingApi.name,
+        i18n.tSync('api.details.provider') + ': ' + resolveProviderName(existingApi.provider),
+        i18n.tSync('api.details.url') + ': ' + existingApi.baseUrl,
+        i18n.tSync('api.details.model') + ': ' + existingApi.model,
+        '', colors.gray + i18n.tSync('add_api.duplicate_draft_discarded') + colors.reset, '',
+        i18n.tSync('action.please_choose'), '',
+    ]);
+    menu.setOptions([
+        i18n.tSync('add_api.duplicate_enter_config'),
+        i18n.tSync('add_api.duplicate_back'),
+    ]);
+    const choice = await menu.navigate();
+    if (choice === 0) return 'enter_existing';
+    return 'go_back';
+}
+
+// --- Draft editing sub-pages (no persistence, operate on draft object) ---
+
+async function editDraftModelConfig(draft) {
+    const menu = new Menu();
+    const { PREDEFINED_MODEL_ENV_KEYS } = require('./lib/validators');
+    const { MODEL_CONFIG_LABELS } = require('./lib/api-manager');
+    const getLabel = (key) => i18nLabel("model", key, MODEL_CONFIG_LABELS);
+
+    while (true) {
+        const rows = PREDEFINED_MODEL_ENV_KEYS.map((key) => {
+            const currentVal = draft.modelEnvVars[key] || '';
+            const autoVal = draft._autoModelEnvVars[key] || '';
+            const displayVal = currentVal || autoVal || i18n.tSync('status.not_set');
+            const isOverridden = autoVal !== '' && currentVal !== autoVal;
+            const mark = isOverridden ? '  ' + colors.cyan + i18n.tSync('status.overridden') + colors.reset : '';
+            return { label: '  ' + getLabel(key), displayVal, mark };
+        });
+        const { getStringWidth, padStringToWidth } = require('./lib/utils/string-width');
+        const maxLabelW = Math.max(...rows.map(r => getStringWidth(r.label)));
+        const maxValueW = Math.max(...rows.map(r => getStringWidth(r.displayVal)));
+        const options = rows.map(r => {
+            return colors.reset + padStringToWidth(r.label, maxLabelW + 2) + '  ' + padStringToWidth(r.displayVal, maxValueW) + r.mark;
+        });
+        options.push(i18n.tSync('api.edit.back'));
+        menu.setOptions(options);
+        const modelHintFn = (idx) => {
+            if (idx >= PREDEFINED_MODEL_ENV_KEYS.length) return null;
+            const k = PREDEFINED_MODEL_ENV_KEYS[idx];
+            const dk = {
+                ANTHROPIC_DEFAULT_SONNET_MODEL: 'hints.model.sonnet_detail',
+                ANTHROPIC_DEFAULT_OPUS_MODEL: 'hints.model.opus_detail',
+                ANTHROPIC_DEFAULT_HAIKU_MODEL: 'hints.model.haiku_detail',
+                CLAUDE_CODE_SUBAGENT_MODEL: 'hints.model.subagent_detail',
+                ANTHROPIC_CUSTOM_MODEL_OPTION: 'hints.model.custom_option_detail',
+                ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: 'hints.model.custom_name_detail',
+            };
+            return dk[k] ? i18n.tSync(dk[k]) : null;
+        };
+        const choice = await menu.navigate(null, modelHintFn, 'navigation.enter_to_edit');
+
+        if (choice === -1 || choice === PREDEFINED_MODEL_ENV_KEYS.length) return;
+
+        const key = PREDEFINED_MODEL_ENV_KEYS[choice];
+        const autoVal = draft._autoModelEnvVars[key] || '';
+        const label = getLabel(key);
+        const subMenu = new Menu();
+        let inSub = true;
+        while (inSub) {
+            const currentVal = draft.modelEnvVars[key] || '';
+            screen.render([
+                '', colors.cyan + label + colors.reset, '',
+                i18n.tSync('status.current_value') + ': ' + (currentVal || i18n.tSync('status.not_set')),
+                i18n.tSync('status.recommended_value') + ': ' + (autoVal || i18n.tSync('status.not_set')),
+                '', i18n.tSync('action.please_choose'), '',
+            ]);
+            subMenu.setOptions([
+                i18n.tSync('action.follow_recommended'),
+                i18n.tSync('action.custom_input'),
+                i18n.tSync('api.edit.back'),
+            ]);
+            const subChoice = await subMenu.navigate(null, null);
+            if (subChoice === -1 || subChoice === 2) { inSub = false; break; }
+            if (subChoice === 0) {
+                draft.modelEnvVars[key] = autoVal;
+                inSub = false;
+            } else if (subChoice === 1) {
+                const input = await inputStepValue(
+                    i18n.tSync('api.edit.current_value', currentVal),
+                    { allowEmpty: true }
+                );
+                if (input === null) continue; // "back"
+                draft.modelEnvVars[key] = (input === '') ? autoVal : input;
+                inSub = false;
+            }
+        }
+    }
+}
+
+async function editDraftRuntimeConfig(draft) {
+    const menu = new Menu();
+    const { PREDEFINED_RUNTIME_KEYS, TYPE_A_FIELDS, TYPE_B_FIELDS } = require('./lib/validators');
+    const { RUNTIME_CONFIG_LABELS } = require('./lib/api-manager');
+    const { getProvider } = require('./lib/presets/providers');
+    const getLabel = (key) => i18nLabel("runtime", key, RUNTIME_CONFIG_LABELS);
+    const providerConfig = getProvider(draft.provider);
+    const providerDefaults = providerConfig ? providerConfig.envVars || {} : {};
+
+    while (true) {
+        const runtimeKeys = [...PREDEFINED_RUNTIME_KEYS];
+        const rows = runtimeKeys.map(key => {
+            const val = draft.runtimeEnvVars[key] || '';
+            const providerVal = providerDefaults[key];
+            let display;
+            if (val === '') {
+                if (providerVal !== undefined) {
+                    if (TYPE_A_FIELDS.includes(key) && providerVal === '1') {
+                        display = i18n.tSync('status.enabled');
+                    } else {
+                        display = providerVal;
+                    }
+                } else {
+                    display = i18n.tSync('status.auto');
+                }
+            } else if (TYPE_A_FIELDS.includes(key) && val === 'off') {
+                display = i18n.tSync('status.disabled');
+            } else if (TYPE_A_FIELDS.includes(key) && val === '1') {
+                display = i18n.tSync('status.enabled');
+            } else {
+                display = val;
+            }
+            const isManual = (draft._runtimeEnvSources || {})[key] === 'manual';
+            const mark = isManual ? '  ' + colors.cyan + i18n.tSync('status.overridden') + colors.reset : '';
+            return { label: '  ' + getLabel(key), display, mark };
+        });
+        const { getStringWidth, padStringToWidth } = require('./lib/utils/string-width');
+        const maxLabelW = Math.max(...rows.map(r => getStringWidth(r.label)));
+        const maxValueW = Math.max(...rows.map(r => getStringWidth(r.display)));
+        const options = rows.map(r => {
+            return colors.reset + padStringToWidth(r.label, maxLabelW + 2) + '  ' + padStringToWidth(r.display, maxValueW) + r.mark;
+        });
+        options.push(i18n.tSync('api.edit.back'));
+        menu.setOptions(options);
+        const runtimeHintFn = (idx) => {
+            if (idx >= runtimeKeys.length) return null;
+            const k = runtimeKeys[idx];
+            const dk = {
+                API_TIMEOUT_MS: 'hints.runtime.timeout_detail',
+                CLAUDE_CODE_ATTRIBUTION_HEADER: 'hints.runtime.attribution_detail',
+                CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: 'hints.runtime.nonessential_detail',
+                CLAUDE_CODE_EFFORT_LEVEL: 'hints.runtime.effort_detail',
+                CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: 'hints.runtime.experimental_detail',
+                CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: 'hints.runtime.nonstreaming_detail',
+            };
+            if (!dk[k]) return null;
+            const val = draft.runtimeEnvVars[k] || '';
+            const isManual = (draft._runtimeEnvSources || {})[k] === 'manual';
+            let sourceText;
+            if (isManual && val !== '') {
+                sourceText = i18n.tSync('hints.runtime.source_manual');
+            } else if (providerDefaults[k] !== undefined) {
+                sourceText = i18n.tSync('hints.runtime.source_provider');
+            } else {
+                sourceText = i18n.tSync('hints.runtime.source_default');
+            }
+            return i18n.tSync(dk[k]) + '\n' + sourceText;
+        };
+        const choice = await menu.navigate(null, runtimeHintFn, 'navigation.enter_to_edit');
+
+        if (choice === -1 || choice === runtimeKeys.length) return;
+
+        const key = runtimeKeys[choice];
+        if (TYPE_A_FIELDS.includes(key) || TYPE_B_FIELDS.includes(key)) {
+            const values = TYPE_A_FIELDS.includes(key) ? ['', '1', 'off'] : ['', '1', '0'];
+            try {
+                const v = draft.runtimeEnvVars[key] || '';
+                const idx = values.indexOf(v);
+                const next = values[(idx + 1) % values.length];
+                ApiManager.applyDraftEnvChange(draft, 'runtime', key, next);
+            } catch (e) {
+                screen.write(colors.red + e.message + colors.reset + '\n');
+                await waitForKey(i18n.tSync('ui.general.press_any_key_continue'));
+            }
+        } else {
+            const isEffortLevel = (key === 'CLAUDE_CODE_EFFORT_LEVEL');
+            const extraHints = isEffortLevel ? ['hints.runtime.effort_values'] : [];
+            const draftVal = draft.runtimeEnvVars[key] || '';
+            const draftProvVal = providerDefaults[key];
+            const draftDisplayVal = draftVal || draftProvVal || i18n.tSync('status.auto');
+            const input = await inputStepValue(
+                i18n.tSync('api.edit.current_value', draftDisplayVal),
+                { allowEmpty: true, hintLines: ['prompt.exit_to_cancel', ...extraHints] }
+            );
+            if (input === null) continue; // "back"
+            try {
+                ApiManager.applyDraftEnvChange(draft, 'runtime', key, input === '' ? '' : input);
+            } catch (e) {
+                screen.write(colors.red + e.message + colors.reset + '\n');
+                await waitForKey(i18n.tSync('ui.general.press_any_key_continue'));
+            }
+        }
+    }
+}
+
+async function editDraftCustomVars(draft) {
+    const menu = new Menu();
+    while (true) {
+        const keys = Object.keys(draft.customEnvVars || {});
+        const options = keys.length > 0
+            ? keys.map(k => '  ' + k + ' = ' + draft.customEnvVars[k])
+            : [colors.gray + i18n.tSync('api.edit.no_custom_vars') + colors.reset];
+        options.push(i18n.tSync('action.add_variable'));
+        options.push(i18n.tSync('api.edit.back'));
+        menu.setOptions(options);
+        const choice = await menu.navigate(null, null, 'navigation.enter_to_edit');
+
+        if (choice === -1 || choice === options.length - 1) return;
+        if (choice === options.length - 2) {
+            const keyInput = await inputStepValue(i18n.tSync('api.edit.enter_custom_key'), { allowEmpty: false });
+            if (!keyInput || keyInput === null) continue;
+            const valInput = await inputStepValue(i18n.tSync('api.edit.enter_custom_value'), { allowEmpty: true });
+            if (valInput === null) continue;
+            try {
+                ApiManager.applyDraftEnvChange(draft, 'custom', keyInput, valInput || '');
+            } catch (e) {
+                screen.write(colors.red + e.message + colors.reset + '\n');
+                await waitForKey(i18n.tSync('ui.general.press_any_key_continue'));
+            }
+        } else if (choice < keys.length) {
+            const key = keys[choice];
+            screen.render(['', colors.yellow + i18n.tSync('confirm.delete_variable') + colors.reset]);
+            const confirm = await simpleInput('> ');
+            if (confirm.toLowerCase() === 'y') {
+                ApiManager.deleteDraftCustomEnvVar(draft, key);
+            }
+        }
+    }
+}
+
+async function editDraftSection(draft, section) {
+    if (section === 'modify_model') await editDraftModelConfig(draft);
+    else if (section === 'modify_runtime') await editDraftRuntimeConfig(draft);
+    else if (section === 'modify_custom') await editDraftCustomVars(draft);
+}
+
+/**
+ * Show config confirmation page (step 6).
+ * @returns {'finish'|'back'|'modify_model'|'modify_runtime'|'modify_custom'}
+ */
+async function showConfigConfirmation(draft) {
+    const menu = new Menu();
+    const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS } = require('./lib/validators');
+    const modelOverridden = PREDEFINED_MODEL_ENV_KEYS.filter(k => {
+        const v = draft.modelEnvVars[k] || '';
+        const a = draft._autoModelEnvVars[k];
+        return a !== undefined && v !== a;
+    }).length;
+    const runtimeOverridden = PREDEFINED_RUNTIME_KEYS.filter(k => {
+        const val = (draft.runtimeEnvVars || {})[k] || '';
+        return val !== '';
+    }).length;
+    const customCount = Object.keys(draft.customEnvVars).length;
+
+    const { getStringWidth, padStringToWidth } = require('./lib/utils/string-width');
+    const fieldLabels = [
+        i18n.tSync('api.edit.field_name'), i18n.tSync('api.details.provider'),
+        i18n.tSync('api.details.url'), i18n.tSync('api.details.model'),
+    ];
+    const labelW = Math.max(...fieldLabels.map(l => getStringWidth(l)));
+    const fieldValues = [
+        draft.name || i18n.tSync('status.not_set'), resolveProviderName(draft.provider),
+        draft.baseUrl, draft.model,
+    ];
+    function fieldLine(label, value) {
+        return '    ' + colors.gray + padStringToWidth(label, labelW) + colors.reset + '  ' + colors.cyan + value + colors.reset + '\n';
+    }
+    const overriddenMark = '  ' + colors.cyan + i18n.tSync('status.overridden') + colors.reset;
+    const versionInfo = colors.bright + colors.cyan + i18n.tSync('add_api.step_n_of_m', '6', '6') + ' · ' + i18n.tSync('add_api.confirm_config') + colors.reset + '\n'
+        + '\n'
+        + fieldLine(fieldLabels[0], fieldValues[0])
+        + fieldLine(fieldLabels[1], fieldValues[1])
+        + fieldLine(fieldLabels[2], fieldValues[2])
+        + fieldLine(fieldLabels[3], fieldValues[3])
+        + '\n'
+        + '    ' + colors.gray + i18n.tSync('add_api.confirm_page_prompt') + colors.reset + '\n'
+        + '\n'
+        + '    ' + i18n.tSync('page.model_config') + '    ' + colors.cyan + modelOverridden + '/' + PREDEFINED_MODEL_ENV_KEYS.length + colors.reset + ' ' + overriddenMark + '\n'
+        + '    ' + i18n.tSync('page.runtime_config') + '    ' + colors.cyan + runtimeOverridden + '/' + PREDEFINED_RUNTIME_KEYS.length + colors.reset + ' ' + overriddenMark + '\n'
+        + '    ' + i18n.tSync('page.custom_vars') + '    ' + colors.cyan + i18n.tSync('summary.x_items', String(customCount)) + colors.reset;
+
+    menu.setOptions([
+        i18n.tSync('action.finish_create'),
+        i18n.tSync('page.model_config'),
+        i18n.tSync('page.runtime_config'),
+        i18n.tSync('page.custom_vars'),
+        i18n.tSync('action.cancel_config'),
+    ]);
+    const hintFn = (idx) => {
+        if (idx === 0) return i18n.tSync('add_api.finish_hint');
+        if (idx === 1) return i18n.tSync('hints.model.desc');
+        if (idx === 2) return i18n.tSync('hints.runtime.desc');
+        if (idx === 3) return i18n.tSync('hints.custom.desc');
+        return null;
+    };
+    const choice = await menu.navigate(versionInfo, hintFn);
+    if (choice === -1 || choice === 4) return 'cancel';
+    if (choice === 0) return 'finish';
+    if (choice === 1) return 'modify_model';
+    if (choice === 2) return 'modify_runtime';
+    if (choice === 3) return 'modify_custom';
+}
+
 /**
- * Add new third-party API
+ * Replay draft edits onto a newly created API.
+ * @returns {{ ok: string[], failed: string[] }}
+ */
+function replayDraftToApi(apiManager, draft, newApi) {
+    const ok = [];
+    const failed = [];
+
+    // Model env vars: only write overridden values
+    for (const k of Object.keys(draft.modelEnvVars || {})) {
+        const v = draft.modelEnvVars[k];
+        const autoV = draft._autoModelEnvVars[k] || '';
+        if (v !== autoV) {
+            try {
+                apiManager.updateModelEnvVar(newApi.id, k, v);
+                ok.push('model/' + k);
+            } catch (e) {
+                failed.push('model/' + k + ': ' + e.message);
+            }
+        }
+    }
+    // Runtime env vars: only write manual values
+    for (const k of Object.keys(draft.runtimeEnvVars || {})) {
+        if ((draft._runtimeEnvSources || {})[k] === 'manual') {
+            try {
+                apiManager.updateRuntimeEnvVar(newApi.id, k, draft.runtimeEnvVars[k]);
+                ok.push('runtime/' + k);
+            } catch (e) {
+                failed.push('runtime/' + k + ': ' + e.message);
+            }
+        }
+    }
+    // Custom env vars
+    for (const [k, v] of Object.entries(draft.customEnvVars || {})) {
+        try {
+            apiManager.setCustomEnvVar(newApi.id, k, v);
+            ok.push('custom/' + k);
+        } catch (e) {
+            failed.push('custom/' + k + ': ' + e.message);
+        }
+    }
+    return { ok, failed };
+}
+
+/**
+ * Add new third-party API — 6-step wizard with state machine.
+ * Step 1: Provider → 2: Base URL → 3: Auth Token → 4: Model → 5: Name → 6: Confirm
  */
 async function addNewThirdPartyApi() {
-    try {
-        const apiData = await promptForThirdPartyApi();
-
-        // Check if this is the first API
-        const isFirstApi = apiManager.getApis().length === 0;
-        const hasExportPassword = apiManager.hasExportPassword();
-
-        const newApi = apiManager.addApi(
-            apiData.baseUrl,
-            apiData.authToken,
-            apiData.model,
-            apiData.name,
-            apiData.provider
-        );
+    const { getProvider, getSuggestedModels } = require('./lib/presets/providers');
+    let step = 1;
+    let providerId = null, providerMeta = null;
+    let baseUrl = null, authToken = null, model = null, name = '';
+    let draft = null;
 
-        showSuccess(await i18n.t('messages.success.api_added'), [
-            `Name: ${newApi.name}`,
-            `${await i18n.t('api.details.provider')}: ${newApi.provider}`,
-            `${await i18n.t('api.details.url')}: ${newApi.baseUrl}`,
-            `${await i18n.t('api.details.model')}: ${newApi.model}`
-        ]);
+    try {
+    while (step >= 1 && step <= 6) {
+        switch (step) {
+            case 1: { // Provider
+                const result = await selectProvider({
+                    title: i18n.tSync('add_api.step_n_of_m', '1', '6'),
+                    showNote: true,
+                });
+                if (!result) { step = 0; break; } // Esc = cancel
+                providerId = result.id;
+                providerMeta = getProvider(providerId);
+                baseUrl = null; authToken = null; model = null; name = '';
+                step = 2;
+                break;
+            }
+            case 2: { // Base URL
+                const defaultUrl = providerMeta ? providerMeta.baseUrl || '' : '';
+                const input = await inputStepValue(
+                    i18n.tSync('api.edit.field_base_url') + (defaultUrl ? ' [' + defaultUrl + ']' : ''),
+                    { defaultValue: defaultUrl, stepLabel: i18n.tSync('add_api.step_n_of_m', '2', '6') }
+                );
+                if (input === null) { step = 1; break; }
+                baseUrl = input;
+                step = 3;
+                break;
+            }
+            case 3: { // Auth Token
+                const input = await inputStepValue(
+                    i18n.tSync('api.details.token'),
+                    {
+                        stepLabel: i18n.tSync('add_api.step_n_of_m', '3', '6'),
+                        hintLines: ['prompt.exit_to_cancel'],
+                        validate: (v) => {
+                            if (!v || v.trim().length < 10) {
+                                return { valid: false, error: i18n.tSync('errors.api.invalid_token', 'at least 10 characters required') };
+                            }
+                            return { valid: true };
+                        },
+                    }
+                );
+                if (input === null) { step = 2; break; }
+                authToken = input;
+                step = 4;
+                break;
+            }
+            case 4: { // Model
+                const suggested = getSuggestedModels(providerId);
+                const hintLines = suggested.length > 0
+                    ? ['', colors.gray + '  ' + i18n.tSync('add_api.recommended_models') + ': ' + suggested.join(', ') + colors.reset, '']
+                    : ['', ''];
+                const fullPrompt = i18n.tSync('api.details.model');
+                const lines = [''];
+                lines.push(colors.bright + i18n.tSync('add_api.step_n_of_m', '4', '6') + colors.reset);
+                lines.push(colors.cyan + fullPrompt + colors.reset);
+                lines.push(...hintLines);
+                lines.push(colors.gray + i18n.tSync('prompt.exit_to_cancel') + colors.reset);
+                lines.push(colors.gray + i18n.tSync('prompt.empty_to_restore') + colors.reset);
+                lines.push('');
+                screen.render(lines);
+                const input = await simpleInput(colors.green + '> ' + colors.reset);
+                if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+                    throw new Error(await i18n.t('errors.general.cancelled_by_user'));
+                }
+                if (input.toLowerCase() === 'back') { step = 3; break; }
+                if (input === '' && suggested.length > 0) {
+                    model = suggested[0];
+                } else {
+                    model = input;
+                }
 
-        if (isFirstApi) {
-            showInfo(await i18n.t('messages.info.first_time_usage'));
+                // Duplicate check
+                const dup = apiManager.checkDuplicate(baseUrl, authToken, model);
+                if (dup.isDuplicate) {
+                    const action = await showDuplicateBranch(dup.existing);
+                    if (action === 'enter_existing') {
+                        await editApiEnvVarsById(apiManager, { apiId: dup.existing.id });
+                        return; // done
+                    }
+                    step = 2; break; // go back to modify connection info
+                }
+                step = 5;
+                break;
+            }
+            case 5: { // Name
+                const fullName = resolveProviderName(providerId);
+                const providerShortName = fullName.split(' (')[0].split(' -')[0];
+                // Count APIs sharing the same short-name prefix (handles moonshot / kimi_for_coding)
+                const sameNameCount = apiManager.config.apis.filter(a => {
+                    const aFull = resolveProviderName(a.provider);
+                    return aFull.split(' (')[0].split(' -')[0] === providerShortName;
+                }).length;
+                const autoName = providerShortName + ' #' + (sameNameCount + 1);
+                const input = await inputStepValue(
+                    i18n.tSync('api.edit.field_name'),
+                    { defaultValue: autoName, stepLabel: i18n.tSync('add_api.step_n_of_m', '5', '6') }
+                );
+                if (input === null) { step = 4; break; }
+                name = input;
+                // Build/rebuild draft preserving manual edits if returning from step 6
+                draft = rebuildDraftPreservingOverrides(draft, providerId, baseUrl, authToken, model, name);
+                step = 6;
+                break;
+            }
+            case 6: { // Config confirmation
+                const action = await showConfigConfirmation(draft);
+                if (action === 'finish') {
+                    try {
+                        const newApi = apiManager.addApi(baseUrl, authToken, model, name, providerId);
+                        const replayResult = replayDraftToApi(apiManager, draft, newApi);
+                        if (replayResult.failed.length > 0) {
+                            screen.write(colors.yellow + i18n.tSync('add_api.partial_failure') + colors.reset + '\n');
+                            await waitForKey(i18n.tSync('ui.general.press_any_key_continue'));
+                            await editApiEnvVarsById(apiManager, { apiId: newApi.id });
+                        } else {
+                            const isFirstApi = apiManager.getApis().length === 1;
+                            showSuccess(await i18n.t('messages.success.api_added'), [
+                                `Name: ${newApi.name}`,
+                                `${await i18n.t('api.details.provider')}: ${resolveProviderName(newApi.provider)}`,
+                                `${await i18n.t('api.details.url')}: ${newApi.baseUrl}`,
+                                `${await i18n.t('api.details.model')}: ${newApi.model}`
+                            ]);
+                            if (isFirstApi) {
+                                showInfo(await i18n.t('messages.info.first_time_usage'));
+                            }
+                        }
+                    } catch (error) {
+                        forceStdinCleanup();
+                        if (error.code === 'DUPLICATE_API') {
+                            const existing = apiManager.config.apis.find(a => a.id === error.existingApiId);
+                            if (existing) {
+                                screen.write(colors.yellow + i18n.tSync('add_api.duplicate_race_lost') + colors.reset + '\n');
+                                const action = await showDuplicateBranch(existing);
+                                if (action === 'enter_existing') {
+                                    await editApiEnvVarsById(apiManager, { apiId: existing.id });
+                                }
+                                return;
+                            }
+                        }
+                        const cancelledMessage = await i18n.t('errors.general.cancelled_by_user');
+                        if (error.message === cancelledMessage) {
+                            screen.write(colors.yellow + await i18n.t('messages.info.operation_cancelled') + colors.reset + '\n');
+                        } else {
+                            showError(await i18n.t('errors.api.failed_add', error.message));
+                        }
+                    }
+                    return; // Exit loop on all paths
+                } else if (action === 'cancel') {
+                    return; // back to main menu
+                } else {
+                    // modify_model, modify_runtime, modify_custom
+                    await editDraftSection(draft, action);
+                    // Loop back to step 6 (confirmation re-renders)
+                }
+                break;
+            }
         }
+    }
 
+    if (step === 0) {
+        screen.write(colors.yellow + i18n.tSync('messages.info.operation_cancelled') + colors.reset + '\n');
+    }
     } catch (error) {
-        // Force cleanup stdin state to prevent navigation issues
         forceStdinCleanup();
-
-        // Check if user cancelled the operation
-        const cancelledMessage = await i18n.t('errors.general.cancelled_by_user');
-        if (error.message === cancelledMessage) {
-            // User cancelled - show neutral message instead of error
-            console.log(colors.yellow + await i18n.t('messages.info.operation_cancelled') + colors.reset);
+        const cancelledMsg = i18n.tSync('errors.general.cancelled_by_user');
+        if (error.message === cancelledMsg) {
+            screen.write(colors.yellow + i18n.tSync('messages.info.operation_cancelled') + colors.reset + '\n');
+        } else if (error.code === 'DUPLICATE_API') {
+            const existing = apiManager.config.apis.find(a => a.id === error.existingApiId);
+            if (existing) {
+                screen.write(colors.yellow + i18n.tSync('add_api.duplicate_race_lost') + colors.reset + '\n');
+            }
         } else {
-            // Actual error occurred
-            showError(await i18n.t('errors.api.failed_add', error.message));
+            screen.write(colors.red + error.message + colors.reset + '\n');
         }
     }
-
-    await waitForKey(await i18n.t('messages.prompts.press_any_key'));
 }
 
 /**
  * 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();
 
+    const lines = [
+        '',
+        colors.bright + colors.orange + '🗑️  ' + await i18n.t('menu.remove_api.title') + colors.reset,
+        '',
+    ];
+
     // 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('');
+        lines.push(colors.cyan + '  ' + await i18n.t('messages.info.current_api_count', apis.length) + colors.reset);
+        lines.push('');
     }
 
+    screen.render(lines);
+
     const menuOptions = [
         await i18n.t('menu.remove_api.delete_single'),
         await i18n.t('menu.remove_api.clear_all'),
@@ -337,7 +928,6 @@ async function deleteSingleApi() {
                 const selectedIndex = apis.findIndex(api => api.id === selectedApi.id);
                 apiManager.removeApi(selectedIndex);
 
-                console.clear();
                 showSuccess(await i18n.t('messages.success.api_removed'), [
                     `${await i18n.t('api.actions.removed_info', selectedApi.name)}`,
                     `${await i18n.t('api.details.provider')}: ${selectedApi.provider}`
@@ -376,24 +966,23 @@ async function clearAllApis() {
     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('');
+    screen.render([
+        '',
+        colors.bright + colors.red + '⚠️  ' + await i18n.t('menu.remove_api.clear_all') + colors.reset,
+        '',
+        colors.yellow + '  ' + await i18n.t('messages.prompts.confirm_clear_all', count) + colors.reset,
+        '',
+    ]);
 
     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 {
@@ -455,10 +1044,11 @@ function formatRelativeTime(timestamp) {
 }
 
 async function viewStatistics() {
-    console.clear();
-    console.log('');
-    console.log(colors.bright + colors.orange + '📊 ' + await i18n.t('statistics.title') + colors.reset);
-    console.log('');
+    screen.render([
+        '',
+        colors.bright + colors.orange + '📊 ' + await i18n.t('statistics.title') + colors.reset,
+        '',
+    ]);
 
     const menuOptions = [
         await i18n.t('statistics.menu_view'),
@@ -480,7 +1070,7 @@ async function viewStatistics() {
             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);
+                screen.write(colors.green + '  ✓ ' + await i18n.t('statistics.reset_success') + colors.reset + '\n');
                 await waitForKey(await i18n.t('messages.prompts.press_any_key'));
             }
             return viewStatistics();
@@ -498,38 +1088,38 @@ async function viewStatistics() {
 async function showStatisticsDetails() {
     const { padStringToWidth } = require('./lib/utils/string-width');
 
-    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('');
+    const lines = [
+        '',
+        colors.bright + colors.orange + '📊 ' + await i18n.t('statistics.title') + colors.reset,
+        '',
+        // Summary section
+        colors.cyan + '  ' + i18n.tSync('ui.general.summary') + ':' + colors.reset,
+        colors.gray + `    ${await i18n.t('statistics.total_apis', stats.totalApis)}` + colors.reset,
+        colors.gray + `    ${await i18n.t('statistics.active_api', stats.activeApiName)}` + colors.reset,
+        colors.gray + `    ${await i18n.t('statistics.most_used', stats.mostUsedApi)}` + colors.reset,
+        colors.gray + `    ${await i18n.t('statistics.total_usage', stats.totalUsage)}` + colors.reset,
+        colors.gray + `    ${await i18n.t('statistics.success_rate', stats.successRate)}` + colors.reset,
+        '',
+    ];
 
     if (stats.apiStats.length > 0) {
-        console.log(colors.cyan + '  ' + i18n.tSync('ui.general.configured_apis') + ':' + colors.reset);
-        console.log('');
+        lines.push(colors.cyan + '  ' + i18n.tSync('ui.general.configured_apis') + ':' + colors.reset);
+        lines.push('');
 
         // Table header
-        console.log(colors.dim + '    ' +
+        lines.push(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);
+        lines.push(colors.dim + '    ' + '─'.repeat(60) + colors.reset);
 
         for (const api of stats.apiStats) {
             const lastUsedText = formatRelativeTime(api.lastUsed);
-            console.log(colors.gray + '    ' +
+            lines.push(colors.gray + '    ' +
                 padStringToWidth(api.name, 20) +
                 padStringToWidth(String(api.usageCount), 10) +
                 padStringToWidth(api.successRate, 10) +
@@ -537,10 +1127,11 @@ async function showStatisticsDetails() {
                 colors.reset);
         }
     } else {
-        console.log(colors.gray + '  ' + await i18n.t('statistics.no_usage') + colors.reset);
+        lines.push(colors.gray + '  ' + await i18n.t('statistics.no_usage') + colors.reset);
     }
 
-    console.log('');
+    lines.push('');
+    screen.render(lines);
     await waitForKey(await i18n.t('messages.prompts.press_any_key'));
 }
 
@@ -551,36 +1142,36 @@ async function showStatisticsDetails() {
 async function handleFirstTimePasswordSetup() {
     while (true) {
         // Clear screen and show header
-        console.clear();
-        console.log('');
-        console.log(colors.bright + colors.yellow + '🔐 ' + i18n.tSync('password.setup.first_time_title') + colors.reset);
-        console.log('');
-
-        // Show information
-        console.log(colors.cyan + i18n.tSync('password.setup.why_needed') + colors.reset);
+        const lines = [
+            '',
+            colors.bright + colors.yellow + '🔐 ' + i18n.tSync('password.setup.first_time_title') + colors.reset,
+            '',
+            // Show information
+            colors.cyan + i18n.tSync('password.setup.why_needed') + colors.reset,
+        ];
         const whyNeededItems = i18n.tSync('password.setup.why_needed_items');
         if (Array.isArray(whyNeededItems)) {
             whyNeededItems.forEach(item => {
-                console.log(colors.gray + '• ' + item + colors.reset);
+                lines.push(colors.gray + '• ' + item + colors.reset);
             });
         }
-        console.log('');
-        console.log(colors.cyan + '🔒 ' + i18n.tSync('password.setup.new_security_title') + colors.reset);
+        lines.push('');
+        lines.push(colors.cyan + '🔒 ' + i18n.tSync('password.setup.new_security_title') + colors.reset);
         const securityItems = i18n.tSync('password.setup.security_items');
         if (Array.isArray(securityItems)) {
             securityItems.forEach(item => {
-                console.log(colors.gray + '• ' + item + colors.reset);
+                lines.push(colors.gray + '• ' + item + colors.reset);
             });
         }
-        console.log('');
-        console.log(colors.yellow + i18n.tSync('password.setup.options_title') + colors.reset);
-        console.log(colors.gray + '• ' + i18n.tSync('password.setup.option_set') + colors.reset);
-        console.log(colors.gray + '• ' + i18n.tSync('password.setup.option_skip') + colors.reset);
-        console.log('');
-        console.log(colors.red + i18n.tSync('password.setup.warning_skip') + colors.reset);
-        console.log('');
-
-        console.log(colors.gray + '按任意键继续...' + colors.reset);
+        lines.push('');
+        lines.push(colors.yellow + i18n.tSync('password.setup.options_title') + colors.reset);
+        lines.push(colors.gray + '• ' + i18n.tSync('password.setup.option_set') + colors.reset);
+        lines.push(colors.gray + '• ' + i18n.tSync('password.setup.option_skip') + colors.reset);
+        lines.push('');
+        lines.push(colors.red + i18n.tSync('password.setup.warning_skip') + colors.reset);
+        lines.push('');
+        lines.push(colors.gray + '按任意键继续...' + colors.reset);
+        screen.render(lines);
 
         // Wait for user to read the information
         await new Promise((resolve) => {
@@ -656,14 +1247,16 @@ async function promptForPasswordSetup() {
  * Confirm skip password setup
  */
 async function confirmSkipPassword() {
-    console.log('');
-    console.log(colors.bright + colors.red + '⚠️  ' + i18n.tSync('errors.password.confirm_skip_title') + colors.reset);
-    console.log('');
-    console.log(colors.gray + i18n.tSync('ui.general.after_skipping_password_setup') + colors.reset);
-    console.log(colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[0] + colors.reset);
-    console.log(colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[1] + colors.reset);
-    console.log(colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[2] + colors.reset);
-    console.log('');
+    screen.render([
+        '',
+        colors.bright + colors.red + '⚠️  ' + i18n.tSync('errors.password.confirm_skip_title') + colors.reset,
+        '',
+        colors.gray + i18n.tSync('ui.general.after_skipping_password_setup') + colors.reset,
+        colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[0] + colors.reset,
+        colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[1] + colors.reset,
+        colors.gray + '• ' + i18n.tSync('ui.general.password_skip_consequences')[2] + colors.reset,
+        '',
+    ]);
 
     // Ensure global menus are initialized
     initializeGlobalMenus();
@@ -678,12 +1271,12 @@ async function confirmSkipPassword() {
     if (choice === 0) {
         try {
             apiManager.skipPasswordSetup();
-            console.log(colors.yellow + i18n.tSync('errors.password.setup_skipped') + colors.reset);
+            screen.write(colors.yellow + i18n.tSync('errors.password.setup_skipped') + colors.reset + '\n');
             await waitForKey(i18n.tSync('messages.prompts.press_any_key'));
             return true;
         } catch (error) {
             forceStdinCleanup();
-            console.log(colors.red + `Operation failed: ${error.message}` + colors.reset);
+            screen.write(colors.red + `Operation failed: ${error.message}` + colors.reset + '\n');
             await waitForKey(i18n.tSync('messages.prompts.press_any_key'));
             return false;
         }
@@ -699,147 +1292,114 @@ async function showApiManagementMenu() {
     // Force cleanup stdin state before showing API management menu
     forceStdinCleanup();
 
-    console.clear();
-    console.log('');
-    console.log(colors.bright + colors.orange + '📋 ' + await i18n.t('menu.api_management.title') + colors.reset);
-    console.log('');
+    screen.render([
+        '',
+        colors.bright + colors.orange + '📋 ' + await i18n.t('menu.api_management.title') + colors.reset,
+        '',
+    ]);
 
     // Check if this is first time usage and prompt for password setup
     if (apiManager.isFirstTimeUsage()) {
         const passwordChoice = await handleFirstTimePasswordSetup();
         if (!passwordChoice) {
-            // User chose to skip or canceled, return to main menu
             return showMenu();
         }
     }
 
     // Build menu options based on password setup status
     const menuOptions = [
-        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
+        await i18n.t('menu.api_management.add_new'),       // 0
+        await i18n.t('menu.api_management.edit'),           // 1
+        await i18n.t('menu.api_management.remove'),         // 2
+        await i18n.t('menu.api_management.switch'),         // 3
+        await i18n.t('menu.api_management.statistics'),     // 4
+        await i18n.t('menu.api_management.manual_upgrade')  // 5
     ];
 
     // Add import/export options only if password is set
     if (apiManager.canUseImportExport()) {
-        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.export'));          // 6
+        menuOptions.push(await i18n.t('menu.api_management.import'));          // 7
+        menuOptions.push(await i18n.t('menu.api_management.change_password')); // 8
     }
 
-    // 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
+    menuOptions.push(await i18n.t('menu.api_management.back'));      // last
 
     // Ensure global menus are initialized
     initializeGlobalMenus();
 
     globalApiManagementMenu.setOptions(menuOptions);
 
-    const choice = await globalApiManagementMenu.navigate();
+    const hintCallback = (index) => {
+        if (!apiManager.hasExportPassword()) return null;
+        const passwordHints = {};
+        passwordHints[1] = i18n.tSync('hints.edit_password_required');
+        passwordHints[2] = i18n.tSync('hints.remove_password_required');
+        if (apiManager.canUseImportExport()) {
+            passwordHints[6] = i18n.tSync('hints.export_password_required');
+            passwordHints[7] = i18n.tSync('hints.import_password_required');
+        }
+        return passwordHints[index] || null;
+    };
+
+    const choice = await globalApiManagementMenu.navigate(null, hintCallback);
 
     // Handle menu choices based on current menu options
     if (choice === 0) { // Add New API
         await addNewThirdPartyApi();
         return showMenu();
-    } else if (choice === 1) { // Remove API
-        await removeThirdPartyApi();
-        return showMenu();
-    } else if (choice === 2) { // Switch Active API
+    }
+
+    if (choice === 1) { // Edit API
+        if (await passwordGuard(apiManager, 'edit')) {
+            await editApi(apiManager);
+        }
+        return showApiManagementMenu();
+    }
+
+    if (choice === 2) { // Remove API
+        if (await passwordGuard(apiManager, 'delete')) {
+            await removeThirdPartyApi();
+        }
+        return showApiManagementMenu();
+    }
+
+    if (choice === 3) { // Switch Active API
         await switchThirdPartyApi();
         return showMenu();
-    } else if (choice === 3) { // View API Statistics
+    }
+
+    if (choice === 4) { // View API Statistics
         await viewStatistics();
         return showMenu();
-    } else if (apiManager.canUseImportExport()) {
-        // With import/export enabled: indices 4-8
-        if (choice === 4) { // Export Configuration
+    }
+
+    if (choice === 5) { // Manual Model Upgrade
+        await performManualUpgrade();
+        return showApiManagementMenu();
+    }
+
+    if (apiManager.canUseImportExport()) {
+        if (choice === 6) { // Export Configuration
             await exportConfiguration();
-            return showMenu();
-        } else if (choice === 5) { // Import Configuration
+            return showApiManagementMenu();
+        }
+
+        if (choice === 7) { // Import Configuration
             await importConfiguration();
-            return showMenu();
-        } else if (choice === 6) { // Change Password
-            await changePassword();
-            return showMenu();
-        } else if (choice === 7) { // Model Upgrade Settings (NEW)
-            return await showModelUpgradeSettings();
-        } else if (choice === 8) { // Back to Main Menu
-            return showMenu();
+            return showApiManagementMenu();
         }
-    } else {
-        // Without import/export: indices 4-5
-        if (choice === 4) { // Model Upgrade Settings (NEW)
-            return await showModelUpgradeSettings();
-        } else if (choice === 5) { // Back to Main Menu
+
+        if (choice === 8) { // Change Password
+            await changePassword();
             return showMenu();
         }
     }
 
-    // Default fallback to main menu
+    // Back to Main Menu (last item) or default fallback
     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
  */
@@ -847,21 +1407,26 @@ 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);
+        screen.render([
+            '',
+            colors.bright + colors.orange + '🔄 ' + await i18n.t('model_upgrade.manual_title') + colors.reset,
+            '',
+            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('');
+    screen.render([
+        '',
+        colors.bright + colors.orange + '🔄 ' + await i18n.t('model_upgrade.manual_title') + colors.reset,
+        '',
+        colors.gray + '  ' + await i18n.t('model_upgrade.manual_checking', apis.length) + colors.reset,
+        '',
+    ]);
 
     let upgradedCount = 0;
     let skippedUpToDate = 0;
@@ -872,87 +1437,164 @@ async function performManualUpgrade() {
         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);
+        screen.write(colors.cyan + '  ─────────────────────────────────────────────────' + colors.reset + '\n');
+        screen.write(colors.bright + `  ${i + 1}/${apis.length}  ${api.name}` + colors.reset + '\n');
+        screen.write(colors.gray + '       ' + await i18n.t('model_upgrade.manual_api_current', api.model) + colors.reset + '\n');
 
         if (latestModel) {
-            console.log(colors.green + '       ' + await i18n.t('model_upgrade.manual_api_latest', latestModel) + colors.reset);
-            console.log('');
+            screen.write(colors.green + '       ' + await i18n.t('model_upgrade.manual_api_latest', latestModel) + colors.reset + '\n');
+            screen.write('\n');
 
             // 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++;
+                try {
+                    apiManager.updateApiModel(api.id, latestModel);
+                    screen.write(colors.green + '       ✓ ' + await i18n.t('model_upgrade.manual_upgraded', api.model, latestModel) + colors.reset + '\n');
+                    upgradedCount++;
+                } catch (error) {
+                    screen.write(colors.yellow + '       ⚠️ Skipped: ' + error.message + colors.reset + '\n');
+                    skippedByUser++;
+                }
             } else {
-                console.log(colors.dim + '       ' + await i18n.t('model_upgrade.manual_skipped') + colors.reset);
+                screen.write(colors.dim + '       ' + await i18n.t('model_upgrade.manual_skipped') + colors.reset + '\n');
                 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);
+                screen.write(colors.dim + '       ' + await i18n.t('model_upgrade.manual_api_uptodate') + colors.reset + '\n');
                 skippedUpToDate++;
             } else {
-                console.log(colors.dim + '       ' + await i18n.t('model_upgrade.manual_api_no_info') + colors.reset);
+                screen.write(colors.dim + '       ' + await i18n.t('model_upgrade.manual_api_no_info') + colors.reset + '\n');
                 skippedNoInfo++;
             }
         }
 
-        console.log('');
+        screen.write('\n');
     }
 
-    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',
+    screen.write(colors.cyan + '  ─────────────────────────────────────────────────' + colors.reset + '\n');
+    screen.write('\n');
+    screen.write(colors.green + '  ' + await i18n.t('model_upgrade.manual_complete') + colors.reset + '\n');
+    screen.write(colors.gray + '    ' + await i18n.t('model_upgrade.manual_stats_upgraded', upgradedCount) + colors.reset + '\n');
+    screen.write(colors.gray + '    ' + await i18n.t('model_upgrade.manual_stats_skipped',
         skippedUpToDate + skippedNoInfo + skippedByUser,
         skippedUpToDate,
-        skippedNoInfo) + colors.reset);
-    console.log('');
+        skippedNoInfo) + colors.reset + '\n');
+    screen.write('\n');
 
     await waitForKey(await i18n.t('messages.prompts.press_any_key'));
 }
 
 /**
- * Handle third-party API launch
+ * Show API selection menu for select launch mode
  */
-async function handleThirdPartyApiLaunch(skipPermissions = false) {
-    try {
-        const activeApi = apiManager.getActiveApi();
+async function showApiSelectMenu(skipPermissions = false) {
+    const { padStringToWidth, getStringWidth } = require('./lib/utils/string-width');
+    const { getProvider } = require('./lib/presets/providers');
 
-        if (!activeApi) {
-            console.clear();
-            showInfo(i18n.tSync('launch.no_active_api'), [
-                i18n.tSync('launch.no_active_api_desc'),
-                i18n.tSync('launch.add_configure_first')
-            ]);
+    const apis = apiManager.getApis();
 
-            await waitForKey(i18n.tSync('launch.press_key_return'));
-            return showMenu();
-        }
+    if (apis.length === 0) {
+        showInfo(i18n.tSync('hints.no_api_configured'), []);
+        await waitForKey(i18n.tSync('messages.prompts.press_any_key'));
+        return showMenu();
+    }
 
-        // Record successful launch BEFORE launching (since process exits after)
-        apiManager.recordSuccessfulLaunch();
+    const activeApi = apiManager.getActiveApi();
 
-        launchClaudeWithApi(activeApi, skipPermissions);
+    // Build menu items with two-column alignment
+    // Compute max name width (including ● prefix) for consistent column alignment
+    let maxNameWidth = 0;
+    apis.forEach(api => {
+        const w = getStringWidth('● ' + api.name);
+        if (w > maxNameWidth) maxNameWidth = w;
+    });
 
-    } catch (error) {
-        // Record failed launch
-        apiManager.recordFailedLaunch(error.message);
+    const menuItems = apis.map((api) => {
+        const prefix = (activeApi && activeApi.id === api.id) ? '● ' : '  ';
+        const nameCol = prefix + api.name;
+        return padStringToWidth(nameCol, maxNameWidth + 4) + api.model;
+    });
+    menuItems.push(i18n.tSync('menu.api_select.back'));
+
+    // Hint callback for each API item
+    const hintCallback = (selectedIndex) => {
+        if (selectedIndex >= apis.length) return null; // "Back" item
+        const api = apis[selectedIndex];
+        const providerConfig = getProvider(api.provider);
+        const providerName = providerConfig ? providerConfig.name : (api.provider || 'Custom');
+        const lastUsed = formatRelativeTime(api.lastUsed || null);
+        const usageCount = api.usageCount || 0;
+        return i18n.tSync('hints.api_select.info', api.name) + '\n' +
+               i18n.tSync('hints.api_select.detail', providerName, api.model) + '\n' +
+               i18n.tSync('hints.api_select.usage', usageCount, lastUsed);
+    };
 
-        showError('Failed to launch with third-party API', [error.message]);
+    screen.render([
+        '',
+        colors.bright + colors.orange + '🔗 ' + i18n.tSync('menu.api_select.title') + colors.reset,
+        '',
+    ]);
 
-        setTimeout(() => {
-            showMenu();
-        }, 2000);
+    const selectMenu = new Menu();
+    selectMenu.setOptions(menuItems);
+    const choice = await selectMenu.navigate(null, hintCallback);
+
+    if (choice === -1 || choice === apis.length) {
+        // Back or Esc
+        return showMenu();
+    }
+
+    // User selected an API
+    const selectedApi = apis[choice];
+    apiManager.setActiveApi(choice);
+    apiManager.recordLaunchAttempt();
+    screen.exitForHandoff();
+    launchClaudeWithApi(selectedApi, skipPermissions, {
+        rollbackFn: (errorMessage) => apiManager.rollbackLaunchAttempt(errorMessage)
+    });
+}
+
+/**
+ * Handle third-party API launch
+ */
+async function handleThirdPartyApiLaunch(skipPermissions = false) {
+    const { loadConfigSync } = require('./lib/utils/version-checker');
+    const config = loadConfigSync();
+
+    if (config.apiLaunchMode === 'select') {
+        return showApiSelectMenu(skipPermissions);
+    }
+
+    // Direct mode
+    const apis = apiManager.getApis();
+
+    if (apis.length === 0) {
+        showInfo(i18n.tSync('hints.no_api_configured'), []);
+        await waitForKey(i18n.tSync('messages.prompts.press_any_key'));
+        return showMenu();
+    }
+
+    const activeApi = apiManager.getActiveApi();
+
+    if (activeApi === null) {
+        showInfo(i18n.tSync('launch.no_active_api'), [
+            i18n.tSync('launch.no_active_api_desc'),
+            i18n.tSync('launch.add_configure_first')
+        ]);
+        await waitForKey(i18n.tSync('launch.press_key_return'));
+        return showMenu();
     }
+
+    apiManager.recordLaunchAttempt();
+    screen.exitForHandoff();
+    launchClaudeWithApi(activeApi, skipPermissions, {
+        rollbackFn: (errorMessage) => apiManager.rollbackLaunchAttempt(errorMessage)
+    });
 }
 
 /**
@@ -961,14 +1603,17 @@ async function handleThirdPartyApiLaunch(skipPermissions = false) {
 async function executeSelection(selectedIndex) {
     switch (selectedIndex) {
         case 0: // Launch Claude Code
+            screen.exitForHandoff();
             launchClaudeDefault();
             break;
 
         case 1: // Launch Claude Code (Skip Permissions)
+            screen.exitForHandoff();
             launchClaudeSkipPermissions();
             break;
 
         case 2: // Launch Claude Code (Enable Auto Mode)
+            screen.exitForHandoff();
             launchClaudeAutoMode();
             break;
 
@@ -983,15 +1628,16 @@ async function executeSelection(selectedIndex) {
         case 5: // 3rd-party API Management
             return await showApiManagementMenu();
 
-        case 6: // Language Settings
-            return await showLanguageSettings();
+        case 6: // Configuration Management
+            return await showConfigManagement();
 
         case 7: // Version Update Check
             return await showVersionUpdateCheck();
 
         case 8: // Exit
-            console.log('');
-            console.log(colors.green + '👋 ' + await i18n.t('menu.main.exit') + '!' + colors.reset);
+            screen.write('\n');
+            screen.write(colors.green + '👋 ' + await i18n.t('menu.main.exit') + '!' + colors.reset + '\n');
+            screen.exit();
             process.exit(0);
             break;
 
@@ -1001,6 +1647,114 @@ async function executeSelection(selectedIndex) {
     }
 }
 
+/**
+ * Show configuration management submenu
+ */
+async function showConfigManagement(restoreIndex = 0) {
+    const versionChecker = require('./lib/utils/version-checker');
+    const { getStringWidth, padStringToWidth } = require('./lib/utils/string-width');
+
+    const config = await versionChecker.loadConfig();
+
+    // Build labels with padding to align current values
+    const labelWidth = 40;
+
+    const langName = i18n.getCurrentLanguageName();
+    const autoUpgradeVal = config.autoModelUpgrade
+        ? i18n.tSync('config.values.on')
+        : i18n.tSync('config.values.off');
+    const upgradeNotifVal = config.showModelUpgradeNotification !== false
+        ? i18n.tSync('config.values.on')
+        : i18n.tSync('config.values.off');
+    const telemetryVal = config.disableTelemetry !== false
+        ? i18n.tSync('config.values.recommended_off')
+        : i18n.tSync('config.values.on');
+    const launchModeVal = config.apiLaunchMode === 'select'
+        ? i18n.tSync('config.values.select_mode')
+        : i18n.tSync('config.values.direct_mode');
+    const noFlickerVal = config.noFlicker !== false
+        ? i18n.tSync('config.values.recommended_on')
+        : i18n.tSync('config.values.off');
+
+    const menuOptions = [
+        padStringToWidth(i18n.tSync('menu.config.language'), labelWidth) + langName,
+        padStringToWidth(i18n.tSync('menu.config.auto_model_upgrade'), labelWidth) + autoUpgradeVal,
+        padStringToWidth(i18n.tSync('menu.config.model_upgrade_notification'), labelWidth) + upgradeNotifVal,
+        padStringToWidth(i18n.tSync('menu.config.telemetry'), labelWidth) + telemetryVal,
+        padStringToWidth(i18n.tSync('menu.config.api_launch_mode'), labelWidth) + launchModeVal,
+        padStringToWidth(i18n.tSync('menu.config.no_flicker'), labelWidth) + noFlickerVal,
+        i18n.tSync('menu.config.back')
+    ];
+
+    // Synchronous hint callback for config items
+    const hintCallback = (selectedIndex) => {
+        switch (selectedIndex) {
+            case 0: return i18n.tSync('hints.config.language', langName);
+            case 1: return i18n.tSync('hints.config.auto_upgrade');
+            case 2: return i18n.tSync('hints.config.upgrade_notification');
+            case 3: return i18n.tSync('hints.config.telemetry');
+            case 4: return i18n.tSync('hints.config.launch_mode');
+            case 5: return i18n.tSync('hints.config.no_flicker');
+            default: return null;
+        }
+    };
+
+    screen.render([
+        '',
+        colors.bright + colors.orange + '⚙️  ' + i18n.tSync('menu.config.title') + colors.reset,
+        '',
+    ]);
+
+    initializeGlobalMenus();
+    globalConfigMenu.setOptions(menuOptions);
+    globalConfigMenu.selectedIndex = restoreIndex;
+    const choice = await globalConfigMenu.navigate(null, hintCallback);
+
+    switch (choice) {
+        case 0: // Language Settings
+            return await showLanguageSettings();
+
+        case 1: { // Auto Model Upgrade toggle
+            const newVal = !config.autoModelUpgrade;
+            config.autoModelUpgrade = newVal;
+            await versionChecker.saveConfig(config);
+            return showConfigManagement(1);
+        }
+
+        case 2: { // Model Upgrade Notification toggle
+            const newVal = config.showModelUpgradeNotification === false ? true : false;
+            config.showModelUpgradeNotification = newVal;
+            await versionChecker.saveConfig(config);
+            return showConfigManagement(2);
+        }
+
+        case 3: { // Telemetry toggle
+            const newVal = config.disableTelemetry === false ? true : false;
+            config.disableTelemetry = newVal;
+            await versionChecker.saveConfig(config);
+            return showConfigManagement(3);
+        }
+
+        case 4: { // API Launch Mode toggle
+            const newVal = config.apiLaunchMode === 'select' ? 'direct' : 'select';
+            config.apiLaunchMode = newVal;
+            await versionChecker.saveConfig(config);
+            return showConfigManagement(4);
+        }
+
+        case 5: { // noFlicker toggle
+            config.noFlicker = !config.noFlicker;
+            await versionChecker.saveConfig(config);
+            return showConfigManagement(5);
+        }
+
+        case 6: // Back
+        case -1:
+        default:
+            return showMenu();
+    }
+}
+
 /**
  * Show main menu
  */
@@ -1047,6 +1801,9 @@ async function showMenu() {
     try {
         const upgradeChecker = require('./lib/utils/model-upgrade-checker');
         const autoUpgrade = await upgradeChecker.isAutoUpgradeEnabled();
+        const versionChecker = require('./lib/utils/version-checker');
+        const launcherConfig = await versionChecker.loadConfig();
+        const showUpgradeNotif = launcherConfig.showModelUpgradeNotification !== false;
 
         if (autoUpgrade) {
             // Auto upgrade enabled: always check and upgrade (bypass cache)
@@ -1062,8 +1819,8 @@ async function showMenu() {
                     }
                 }
             }
-        } else {
-            // Auto upgrade disabled: use cache for notification
+        } else if (showUpgradeNotif) {
+            // Auto upgrade disabled but notification enabled: use cache for notification
             const result = await upgradeChecker.checkForModelUpgrades(apiManager);
             if (result.needsCheck && result.upgrades.length > 0) {
                 const first = result.upgrades[0];
@@ -1102,40 +1859,109 @@ async function showMenu() {
         await i18n.t('menu.main.launch_api'),
         await i18n.t('menu.main.launch_api_skip'),
         await i18n.t('menu.main.api_management'),
-        await i18n.t('menu.main.language_settings'),
+        await i18n.t('menu.main.config_management'),
         await i18n.t('menu.main.version_check'),
         await i18n.t('menu.main.exit')
     ];
 
-    // Pre-compute hint texts synchronously for menu callback
+    // Pre-compute all hint data synchronously for menu callback
     const hintAutoMode = i18n.tSync('hints.auto_mode_info');
+
     const activeApi = apiManager.getActiveApi();
-    let hintApiInfo = null;
+    const apis = apiManager.getApis();
+    const apiCount = apis.length;
+    const { getProvider } = require('./lib/presets/providers');
+
+    // Pre-compute config for hints
+    const hintConfig = require('./lib/utils/version-checker').loadConfigSync();
+    const hintApiLaunchMode = hintConfig.apiLaunchMode || 'direct';
+
+    // Pre-compute active API details
+    let activeApiName = i18n.tSync('hints.select_mode_active_none');
+    let activeProviderName = '';
+    let activeModel = '';
+    let activeLastUsed = '';
     if (activeApi) {
-        const { getProvider } = require('./lib/presets/providers');
         const providerConfig = getProvider(activeApi.provider);
-        const providerName = providerConfig ? providerConfig.name : (activeApi.provider || 'Custom');
-        hintApiInfo = i18n.tSync('hints.active_api_info', providerName, activeApi.model);
+        activeProviderName = providerConfig ? providerConfig.name : (activeApi.provider || 'Custom');
+        activeModel = activeApi.model;
+        activeApiName = activeApi.name;
+        activeLastUsed = formatRelativeTime(activeApi.lastUsed || null);
+    }
+
+    // Pre-compute API hints for indices 3, 4
+    let hintApiLines = null;
+    if (apiCount === 0) {
+        hintApiLines = i18n.tSync('hints.no_api_configured');
+    } else if (hintApiLaunchMode === 'direct') {
+        if (activeApi) {
+            hintApiLines =
+                i18n.tSync('hints.direct_mode_desc') + '\n' +
+                i18n.tSync('hints.direct_mode_api_info', activeApiName, activeProviderName) + '\n' +
+                i18n.tSync('hints.direct_mode_api_detail', activeModel, activeLastUsed) + '\n' +
+                i18n.tSync('hints.direct_mode_change');
+        } else {
+            hintApiLines =
+                i18n.tSync('hints.direct_mode_no_active') + '\n' +
+                i18n.tSync('hints.direct_mode_no_active_detail', apiCount) + '\n' +
+                '' + '\n' +
+                i18n.tSync('hints.direct_mode_change');
+        }
     } else {
-        hintApiInfo = i18n.tSync('hints.no_active_api');
+        // select mode
+        hintApiLines =
+            i18n.tSync('hints.select_mode_desc') + '\n' +
+            i18n.tSync('hints.select_mode_change') + '\n' +
+            '' + '\n' +
+            i18n.tSync('hints.select_mode_api_count', apiCount, activeApiName);
     }
 
+    // Pre-compute API management hint (index 5)
+    const hintApiMgmt = i18n.tSync('hints.api_management_info', apiCount, activeApiName);
+
+    // Pre-compute config summary hint (index 6)
+    const cfgLangName = i18n.getCurrentLanguageName();
+    const cfgLaunchMode = hintApiLaunchMode === 'select'
+        ? i18n.tSync('config.values.select_mode')
+        : i18n.tSync('config.values.direct_mode');
+    const cfgTelemetry = hintConfig.disableTelemetry !== false
+        ? i18n.tSync('config.values.off')
+        : i18n.tSync('config.values.on');
+    const cfgNoFlicker = hintConfig.noFlicker !== false
+        ? i18n.tSync('config.values.on')
+        : i18n.tSync('config.values.off');
+    const hintConfigSummary = i18n.tSync('hints.config_summary', cfgLangName, cfgLaunchMode, cfgTelemetry, cfgNoFlicker);
+
     // Synchronous hint callback — must not use await
     const hintCallback = (selectedIndex) => {
         switch (selectedIndex) {
-            case 2: return hintAutoMode;
-            case 3: return hintApiInfo;
-            case 4: return hintApiInfo;
-            default: return null;
+            case 0:
+            case 1:
+                return null;
+            case 2:
+                return hintAutoMode;
+            case 3:
+            case 4:
+                return hintApiLines;
+            case 5:
+                return hintApiMgmt;
+            case 6:
+                return hintConfigSummary;
+            case 7:
+            case 8:
+                return null;
+            default:
+                return null;
         }
     };
 
     globalMainMenu.setOptions(menuOptions);
-    const selection = await globalMainMenu.navigate(false, displayInfo || null, hintCallback);
+    const selection = await globalMainMenu.navigate(displayInfo || null, hintCallback);
 
     if (selection === -1) {
-        console.log('');
-        console.log(colors.green + '👋 ' + await i18n.t('menu.main.exit') + '!' + colors.reset);
+        screen.write('\n');
+        screen.write(colors.green + '👋 ' + await i18n.t('menu.main.exit') + '!' + colors.reset + '\n');
+        screen.exit();
         process.exit(0);
     } else {
         await executeSelection(selection);
@@ -1150,26 +1976,22 @@ async function showMenu() {
  * Export configuration with password encryption
  */
 async function exportConfiguration() {
-    console.clear();
-    console.log('');
-    console.log(colors.bright + colors.orange + '💾 ' + await i18n.t('import_export.export.title') + colors.reset);
-    console.log('');
-
-    // Add export function description
-    console.log(colors.cyan + '📄 ' + i18n.tSync('import_export.export.description_title') + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[0] + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[1] + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[2] + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[3] + colors.reset);
-    console.log('');
+    screen.render([
+        '',
+        colors.bright + colors.orange + '💾 ' + await i18n.t('import_export.export.title') + colors.reset,
+        '',
+        // Export function description
+        colors.cyan + '📄 ' + i18n.tSync('import_export.export.description_title') + colors.reset,
+        colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[0] + colors.reset,
+        colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[1] + colors.reset,
+        colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[2] + colors.reset,
+        colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[3] + colors.reset,
+        '',
+    ]);
 
     // Verify password before export
-    const verified = await verifyExportPassword(apiManager, 'export');
-    if (!verified) {
-        console.log('');
-        await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
-        return;
-    }
+    const verified = await passwordGuard(apiManager, 'export');
+    if (!verified) return;
 
     try {
         // Get export data
@@ -1183,62 +2005,59 @@ async function exportConfiguration() {
         // Write JSON file
         fs.writeFileSync(filePath, exportData, 'utf8');
 
-        console.log(colors.green + '✓ ' + i18n.tSync('import_export.export.success_title') + colors.reset);
-        console.log('');
-        console.log(colors.cyan + '📁 ' + i18n.tSync('import_export.export.details_title') + colors.reset);
-        console.log(colors.gray + `  • ` + i18n.tSync('import_export.export.details_file_saved', filePath) + colors.reset);
-        console.log(colors.gray + `  • ` + i18n.tSync('import_export.export.details_export_dir', exportDir) + colors.reset);
-        console.log(colors.gray + `  • ` + i18n.tSync('import_export.export.details_filename', filename) + colors.reset);
-        console.log('');
+        screen.write(colors.green + '✓ ' + i18n.tSync('import_export.export.success_title') + colors.reset + '\n');
+        screen.write('\n');
+        screen.write(colors.cyan + '📁 ' + i18n.tSync('import_export.export.details_title') + colors.reset + '\n');
+        screen.write(colors.gray + `  • ` + i18n.tSync('import_export.export.details_file_saved', filePath) + colors.reset + '\n');
+        screen.write(colors.gray + `  • ` + i18n.tSync('import_export.export.details_export_dir', exportDir) + colors.reset + '\n');
+        screen.write(colors.gray + `  • ` + i18n.tSync('import_export.export.details_filename', filename) + colors.reset + '\n');
+        screen.write('\n');
 
         // Open file with default application
-        console.log(colors.yellow + '🔍 ' + i18n.tSync('import_export.export.opening_file') + colors.reset);
+        screen.write(colors.yellow + '🔍 ' + i18n.tSync('import_export.export.opening_file') + colors.reset + '\n');
         openFileWithDefault(filePath);
 
-        console.log('');
-        console.log(colors.cyan + '💡 ' + i18n.tSync('import_export.export.tips_title') + colors.reset);
-        console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.tips_items')[0] + colors.reset);
-        console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.tips_items')[1] + colors.reset);
+        screen.write('\n');
+        screen.write(colors.cyan + '💡 ' + i18n.tSync('import_export.export.tips_title') + colors.reset + '\n');
+        screen.write(colors.gray + '  • ' + i18n.tSync('import_export.export.tips_items')[0] + colors.reset + '\n');
+        screen.write(colors.gray + '  • ' + i18n.tSync('import_export.export.tips_items')[1] + colors.reset + '\n');
 
     } catch (error) {
         forceStdinCleanup();
-        console.log(colors.red + `❌ Export failed: ${error.message}` + colors.reset);
+        screen.write(colors.red + `❌ Export failed: ${error.message}` + colors.reset + '\n');
     }
 
-    console.log('');
-    await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+    screen.write('\n');
+    await waitForKey(i18n.tSync('ui.general.press_any_key_continue'));
 }
 
 /**
  * Import configuration from plaintext JSON
  */
 async function importConfiguration() {
-    console.clear();
-    console.log('');
-    console.log(colors.bright + colors.orange + '📥 ' + await i18n.t('import_export.import.title') + colors.reset);
-    console.log('');
-
-    // Add import function description
-    console.log(colors.cyan + '📄 ' + i18n.tSync('ui.general.import_function_description') + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[0] + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[0] + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[1] + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[2] + colors.reset);
-    console.log('');
+    screen.render([
+        '',
+        colors.bright + colors.orange + '📥 ' + await i18n.t('import_export.import.title') + colors.reset,
+        '',
+        // Import function description
+        colors.cyan + '📄 ' + i18n.tSync('ui.general.import_function_description') + colors.reset,
+        colors.gray + '  • ' + i18n.tSync('import_export.export.description_items')[0] + colors.reset,
+        colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[0] + colors.reset,
+        colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[1] + colors.reset,
+        colors.gray + '  • ' + i18n.tSync('ui.general.import_description_items')[2] + colors.reset,
+        '',
+    ]);
 
     // Verify password identity
-    const passwordVerified = await verifyExportPassword(apiManager, 'import');
-    if (!passwordVerified) {
-        await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
-        return;
-    }
+    const passwordVerified = await passwordGuard(apiManager, 'import');
+    if (!passwordVerified) return;
 
-    console.log('');
-    console.log(colors.cyan + '📁 ' + i18n.tSync('ui.general.file_input_required') + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[0] + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[1] + colors.reset);
-    console.log(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[2] + colors.reset);
-    console.log('');
+    screen.write('\n');
+    screen.write(colors.cyan + '📁 ' + i18n.tSync('ui.general.file_input_required') + colors.reset + '\n');
+    screen.write(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[0] + colors.reset + '\n');
+    screen.write(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[1] + colors.reset + '\n');
+    screen.write(colors.gray + '  • ' + i18n.tSync('ui.general.file_input_items')[2] + colors.reset + '\n');
+    screen.write('\n');
 
     const { simpleInput } = require('./lib/ui/prompts');
 
@@ -1253,85 +2072,86 @@ async function importConfiguration() {
         const filePath = await simpleInput(colors.green + filePrompt + colors.reset);
 
         if (!filePath) {
-            console.log(colors.red + i18n.tSync('ui.general.file_path_empty') + colors.reset);
+            screen.write(colors.red + i18n.tSync('ui.general.file_path_empty') + colors.reset + '\n');
             if (attempts < maxAttempts) {
-                console.log('');
+                screen.write('\n');
                 continue;
             } else {
-                console.log(colors.red + i18n.tSync('ui.general.max_attempts_import_cancelled') + colors.reset);
+                screen.write(colors.red + i18n.tSync('ui.general.max_attempts_import_cancelled') + colors.reset + '\n');
                 await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
                 return;
             }
         }
 
         // Validate file
-        console.log('');
-        console.log(colors.yellow + i18n.tSync('ui.general.validating_file') + colors.reset);
+        screen.write('\n');
+        screen.write(colors.yellow + i18n.tSync('ui.general.validating_file') + colors.reset + '\n');
         const validation = validateImportFile(filePath);
 
         if (!validation.valid) {
-            console.log(colors.red + '❌ ' + i18n.tSync('ui.general.file_validation_failed', validation.error) + colors.reset);
+            screen.write(colors.red + '❌ ' + i18n.tSync('ui.general.file_validation_failed', validation.error) + colors.reset + '\n');
             if (attempts < maxAttempts) {
-                console.log(colors.yellow + i18n.tSync('ui.general.check_file_path_json') + colors.reset);
-                console.log('');
+                screen.write(colors.yellow + i18n.tSync('ui.general.check_file_path_json') + colors.reset + '\n');
+                screen.write('\n');
                 continue;
             } else {
-                console.log(colors.red + i18n.tSync('ui.general.max_attempts_import_cancelled') + colors.reset);
+                screen.write(colors.red + i18n.tSync('ui.general.max_attempts_import_cancelled') + colors.reset + '\n');
                 await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
                 return;
             }
         }
 
         // File is valid, proceed with import
-        console.log(colors.green + i18n.tSync('ui.general.file_validation_successful') + colors.reset);
-        console.log('');
+        screen.write(colors.green + i18n.tSync('ui.general.file_validation_successful') + colors.reset + '\n');
+        screen.write('\n');
 
         try {
             // Import the validated configuration data
             const result = apiManager.importConfigAuthenticated(validation.data);
 
-            console.log(colors.green + i18n.tSync('ui.general.import_successful') + colors.reset);
-            console.log('');
-            console.log(colors.cyan + i18n.tSync('ui.general.import_statistics') + colors.reset);
+            screen.write(colors.green + i18n.tSync('ui.general.import_successful') + colors.reset + '\n');
+            screen.write('\n');
+            screen.write(colors.cyan + i18n.tSync('ui.general.import_statistics') + colors.reset + '\n');
             const importItems = i18n.tSync('ui.general.import_stats_items');
-            console.log(colors.gray + `  • ` + importItems[0].replace('{0}', result.imported) + colors.reset);
-            console.log(colors.gray + `  • ` + importItems[1].replace('{1}', result.skipped) + colors.reset);
-            console.log(colors.gray + `  • ` + importItems[2] + colors.reset);
-            console.log(colors.gray + `  • ` + importItems[3].replace('{0}', path.resolve(filePath)) + colors.reset);
+            screen.write(colors.gray + `  • ` + importItems[0].replace('{0}', result.imported) + colors.reset + '\n');
+            screen.write(colors.gray + `  • ` + importItems[1].replace('{1}', result.skipped) + colors.reset + '\n');
+            screen.write(colors.gray + `  • ` + importItems[2] + colors.reset + '\n');
+            screen.write(colors.gray + `  • ` + importItems[3].replace('{0}', path.resolve(filePath)) + colors.reset + '\n');
 
             break; // Success, exit the loop
 
         } catch (error) {
             forceStdinCleanup();
-            console.log(colors.red + `❌ Import failed: ${error.message}` + colors.reset);
+            screen.write(colors.red + `❌ Import failed: ${error.message}` + colors.reset + '\n');
             if (attempts < maxAttempts) {
-                console.log(colors.yellow + i18n.tSync('ui.general.import_tips')[0] + colors.reset);
-                console.log('');
+                screen.write(colors.yellow + i18n.tSync('ui.general.import_tips')[0] + colors.reset + '\n');
+                screen.write('\n');
                 continue;
             } else {
-                console.log(colors.red + i18n.tSync('ui.general.max_attempts_import_failed') + colors.reset);
+                screen.write(colors.red + i18n.tSync('ui.general.max_attempts_import_failed') + colors.reset + '\n');
             }
         }
     }
 
-    console.log('');
-    await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
+    screen.write('\n');
+    await waitForKey(i18n.tSync('ui.general.press_any_key_continue'));
 }
 
 /**
  * Change password
  */
 async function changePassword() {
-    console.clear();
-    console.log('');
-    console.log(colors.bright + colors.orange + '🔑 ' + i18n.tSync('errors.password.change_password_title') + colors.reset);
-    console.log('');
+    screen.render([
+        '',
+        colors.bright + colors.orange + '🔑 ' + i18n.tSync('errors.password.change_password_title') + colors.reset,
+        '',
+    ]);
 
     // Use unified password change module
     const success = await changePasswordModule(apiManager);
 
     if (success) {
-        console.log('');
+        screen.write('\n');
     }
 
     await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
@@ -1346,16 +2166,16 @@ async function showLanguageSettings() {
         const currentLanguage = i18n.getCurrentLanguage();
         const currentLanguageName = i18n.getCurrentLanguageName();
 
-        console.clear();
-        console.log('');
-        console.log(colors.bright + colors.orange + '🌍 ' + await i18n.t('menu.language.title') + colors.reset);
-        console.log('');
-
-        // Show current language
-        console.log(colors.cyan + await i18n.t('menu.language.current', currentLanguageName) + colors.reset);
-        console.log('');
-        console.log(colors.yellow + await i18n.t('menu.language.select_prompt') + colors.reset);
-        console.log('');
+        screen.render([
+            '',
+            colors.bright + colors.orange + '🌍 ' + await i18n.t('menu.language.title') + colors.reset,
+            '',
+            // Show current language
+            colors.cyan + await i18n.t('menu.language.current', currentLanguageName) + colors.reset,
+            '',
+            colors.yellow + await i18n.t('menu.language.select_prompt') + colors.reset,
+            '',
+        ]);
 
         // Create menu options
         const languageOptions = [];
@@ -1388,14 +2208,14 @@ async function showLanguageSettings() {
         }
 
         // Switch language
-        console.clear();
-            console.log('');
-            console.log(colors.yellow + await i18n.t('status.switching_language') + colors.reset);
+        screen.render([
+            '',
+            colors.yellow + await i18n.t('status.switching_language') + colors.reset,
+        ]);
 
             try {
                 await i18n.setLanguage(selectedLangCode);
 
-                console.clear();
                 const newLanguageName = i18n.getCurrentLanguageName();
                 showSuccess(await i18n.t('messages.success.language_changed'), [
                     await i18n.t('menu.language.changed_success', newLanguageName)
@@ -1424,18 +2244,18 @@ async function showLanguageSettings() {
  */
 async function showVersionUpdateCheck() {
     try {
-        console.clear();
-        console.log('');
-        console.log(colors.bright + colors.orange + '🔄 ' + await i18n.t('version_check.title') + colors.reset);
-        console.log('');
-
-        console.log(colors.cyan + await i18n.t('version_check.checking') + colors.reset);
-        console.log(colors.gray + await i18n.t('version_check.please_wait') + colors.reset);
-        console.log('');
+        screen.render([
+            '',
+            colors.bright + colors.orange + '🔄 ' + await i18n.t('version_check.title') + colors.reset,
+            '',
+            colors.cyan + await i18n.t('version_check.checking') + colors.reset,
+            colors.gray + await i18n.t('version_check.please_wait') + colors.reset,
+            '',
+        ]);
 
         // Show progress indicator
         const progressInterval = setInterval(() => {
-            process.stdout.write('.');
+            screen.write('.');
         }, 500);
 
         try {
@@ -1444,46 +2264,46 @@ async function showVersionUpdateCheck() {
 
             // Stop progress indicator
             clearInterval(progressInterval);
-            console.log('\n');
+            screen.write('\n\n');
 
             if (result.error) {
                 // Handle errors (timeout, network, etc.)
-                console.log(colors.red + '❌ ' + await i18n.t('version_check.error') + colors.reset);
-                console.log(colors.red + '   ' + result.error + colors.reset);
-                console.log('');
-                console.log(colors.gray + await i18n.t('version_check.error_tips') + colors.reset);
+                screen.write(colors.red + '❌ ' + await i18n.t('version_check.error') + colors.reset + '\n');
+                screen.write(colors.red + '   ' + result.error + colors.reset + '\n');
+                screen.write('\n');
+                screen.write(colors.gray + await i18n.t('version_check.error_tips') + colors.reset + '\n');
             } else if (result.available) {
                 // Update available
-                console.log(colors.yellow + '🎉 ' + await i18n.t('version_check.update_available') + colors.reset);
-                console.log('');
-                console.log(colors.cyan + '   ' + await i18n.t('version_check.current_version', result.currentVersion) + colors.reset);
-                console.log(colors.green + '   ' + await i18n.t('version_check.latest_version', result.latestVersion) + colors.reset);
-                console.log('');
-                console.log(colors.yellow + '💡 ' + await i18n.t('version_check.update_command') + colors.reset);
-                console.log(colors.yellow + '   npm update -g @kikkimo/claude-launcher' + colors.reset);
+                screen.write(colors.yellow + '🎉 ' + await i18n.t('version_check.update_available') + colors.reset + '\n');
+                screen.write('\n');
+                screen.write(colors.cyan + '   ' + await i18n.t('version_check.current_version', result.currentVersion) + colors.reset + '\n');
+                screen.write(colors.green + '   ' + await i18n.t('version_check.latest_version', result.latestVersion) + colors.reset + '\n');
+                screen.write('\n');
+                screen.write(colors.yellow + '💡 ' + await i18n.t('version_check.update_command') + colors.reset + '\n');
+                screen.write(colors.yellow + '   npm update -g @kikkimo/claude-launcher' + colors.reset + '\n');
             } else {
                 // Already up to date
-                console.log(colors.green + '✅ ' + await i18n.t('version_check.up_to_date') + colors.reset);
-                console.log('');
-                console.log(colors.cyan + '   ' + await i18n.t('version_check.current_version', result.currentVersion) + colors.reset);
-                console.log(colors.cyan + '   ' + await i18n.t('version_check.latest_version', result.latestVersion) + colors.reset);
+                screen.write(colors.green + '✅ ' + await i18n.t('version_check.up_to_date') + colors.reset + '\n');
+                screen.write('\n');
+                screen.write(colors.cyan + '   ' + await i18n.t('version_check.current_version', result.currentVersion) + colors.reset + '\n');
+                screen.write(colors.cyan + '   ' + await i18n.t('version_check.latest_version', result.latestVersion) + colors.reset + '\n');
             }
 
         } catch (error) {
             // Stop progress indicator
             clearInterval(progressInterval);
-            console.log('\n');
+            screen.write('\n\n');
 
-            console.log(colors.red + '❌ ' + await i18n.t('version_check.unexpected_error') + colors.reset);
-            console.log(colors.red + '   ' + error.message + colors.reset);
+            screen.write(colors.red + '❌ ' + await i18n.t('version_check.unexpected_error') + colors.reset + '\n');
+            screen.write(colors.red + '   ' + error.message + colors.reset + '\n');
         }
 
-        console.log('');
+        screen.write('\n');
         await waitForKey(await i18n.t('messages.prompts.press_any_key'));
         return showMenu();
 
     } catch (error) {
-        console.log(colors.red + '❌ Failed to check version: ' + error.message + colors.reset);
+        screen.write(colors.red + '❌ Failed to check version: ' + error.message + colors.reset + '\n');
         await waitForKey(i18n.tSync('messages.prompts.press_any_key_menu'));
         return showMenu();
     }
@@ -1495,8 +2315,9 @@ async function showVersionUpdateCheck() {
  * Graceful shutdown handlers
  */
 process.on('SIGTERM', () => {
-    console.log('');
-    console.log(colors.green + i18n.tSync('ui.general.goodbye') + colors.reset);
+    screen.write('\n');
+    screen.write(colors.green + i18n.tSync('ui.general.goodbye') + colors.reset + '\n');
+    screen.exit();
     process.exit(0);
 });
 
@@ -1509,43 +2330,34 @@ const stdinManager = require('./lib/utils/stdin-manager');
 let exiting = false;
 
 process.on('SIGINT', () => {
-    // During Claude run, ignore in launcher so child handles it
-    // Check this BEFORE setting exiting flag to avoid breaking reentrancy protection
     if (stdinManager.isSuspended && stdinManager.isSuspended()) {
         return;
     }
-
-    // Prevent re-entrance - ensure cleanup runs only once
-    if (exiting) {
-        return;
-    }
+    if (exiting) return;
     exiting = true;
-
-    // Try to reset stdin state before handling
     try {
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(false);
             process.stdin.pause();
         }
-    } catch (_) {
-        // Ignore errors during emergency cleanup
-    }
-
-    // Use unified Ctrl+C handler from StdinManager (synchronous)
+    } catch (_) {}
     try {
-        stdinManager.handleCtrlC();
-    } catch (_) {
-        // Ignore errors during Ctrl+C handling
-    }
-
-    // Exit with standard SIGINT exit code (128 + 2 = 130)
-    // Note: If handleCtrlC() calls process.exit(0) for second Ctrl+C,
-    // this line won't be reached, which is expected behavior
+        const shouldExit = stdinManager.handleCtrlC();
+        if (shouldExit === false) {
+            exiting = false;
+            return;
+        }
+    } catch (_) {}
+    screen.exit();
     process.exit(130);
 });
 
+process.on('uncaughtException', (err) => { screen.exit(); console.error(err); process.exit(1); });
+process.on('unhandledRejection', (err) => { screen.exit(); console.error(err); process.exit(1); });
+
 // Initialize global menus and start the application
 initializeGlobalMenus();
 
 // Start the application
+screen.enter();
 showMenu();