@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/components/Settings/Config.js

@@ -0,0 +1,1628 @@
+import { MACRO, feature } from '../../recovery/bunBundleShim.js';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+import { c as _c } from "react/compiler-runtime";
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { Box, Text, useTheme, useThemeSetting, useTerminalFocus } from '../../ink.js';
+import * as React from 'react';
+import { useState, useCallback } from 'react';
+import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js';
+import figures from 'figures';
+import { saveGlobalConfig, getCurrentProjectConfig } from '../../utils/config.js';
+import { normalizeApiKeyForConfig } from '../../utils/authPortable.js';
+import { getGlobalConfig, getAutoUpdaterDisabledReason, formatAutoUpdaterDisabledReason, getRemoteControlAtStartup } from '../../utils/config.js';
+import chalk from 'chalk';
+import { permissionModeTitle, permissionModeFromString, toExternalPermissionMode, isExternalPermissionMode, EXTERNAL_PERMISSION_MODES, PERMISSION_MODES } from '../../utils/permissions/PermissionMode.js';
+import { getAutoModeEnabledState, hasAutoModeOptInAnySource, transitionPlanAutoMode } from '../../utils/permissions/permissionSetup.js';
+import { logError } from '../../utils/log.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { isBridgeEnabled } from '../../bridge/bridgeEnabled.js';
+import { ThemePicker } from '../ThemePicker.js';
+import { useAppState, useSetAppState, useAppStateStore } from '../../state/AppState.js';
+import { ModelPicker } from '../ModelPicker.js';
+import { modelDisplayString, isOpus1mMergeEnabled } from '../../utils/model/model.js';
+import { isBilledAsExtraUsage } from '../../utils/extraUsage.js';
+import { ClaudeMdExternalIncludesDialog } from '../ClaudeMdExternalIncludesDialog.js';
+import { ChannelDowngradeDialog } from '../ChannelDowngradeDialog.js';
+import { Dialog } from '../design-system/Dialog.js';
+import { Select } from '../CustomSelect/index.js';
+import { OutputStylePicker } from '../OutputStylePicker.js';
+import { LanguagePicker } from '../LanguagePicker.js';
+import { getExternalClaudeMdIncludes, getMemoryFiles, hasExternalClaudeMdIncludes } from '../../utils/claudemd.js';
+import { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js';
+import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js';
+import { Byline } from '../design-system/Byline.js';
+import { useTabHeaderFocus } from '../design-system/Tabs.js';
+import { useIsInsideModal } from '../../context/modalContext.js';
+import { SearchBox } from '../SearchBox.js';
+import { isSupportedTerminal, hasAccessToIDEExtensionDiffFeature } from '../../utils/ide.js';
+import { getInitialSettings, getSettingsForSource, updateSettingsForSource } from '../../utils/settings/settings.js';
+import { getUserMsgOptIn, setUserMsgOptIn } from '../../bootstrap/state.js';
+import { DEFAULT_OUTPUT_STYLE_NAME } from '../../constants/outputStyles.js';
+import { isEnvTruthy, isRunningOnHomespace } from '../../utils/envUtils.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js';
+import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js';
+import { getCliTeammateModeOverride, clearCliTeammateModeOverride } from '../../utils/swarm/backends/teammateModeSnapshot.js';
+import { getHardcodedTeammateModelFallback } from '../../utils/swarm/teammateModel.js';
+import { useSearchInput } from '../../hooks/useSearchInput.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import { clearFastModeCooldown, FAST_MODE_MODEL_DISPLAY, isFastModeAvailable, isFastModeEnabled, getFastModeModel, isFastModeSupportedByModel } from '../../utils/fastMode.js';
+import { isFullscreenEnvEnabled } from '../../utils/fullscreen.js';
+export function Config({ onClose, context, setTabsHidden, onIsSearchModeChange, contentHeight }) {
+    const { headerFocused, focusHeader } = useTabHeaderFocus();
+    const insideModal = useIsInsideModal();
+    const [, setTheme] = useTheme();
+    const themeSetting = useThemeSetting();
+    const [globalConfig, setGlobalConfig] = useState(getGlobalConfig());
+    const initialConfig = React.useRef(getGlobalConfig());
+    const [settingsData, setSettingsData] = useState(getInitialSettings());
+    const initialSettingsData = React.useRef(getInitialSettings());
+    const [currentOutputStyle, setCurrentOutputStyle] = useState(settingsData?.outputStyle || DEFAULT_OUTPUT_STYLE_NAME);
+    const initialOutputStyle = React.useRef(currentOutputStyle);
+    const [currentLanguage, setCurrentLanguage] = useState(settingsData?.language);
+    const initialLanguage = React.useRef(currentLanguage);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [isSearchMode, setIsSearchMode] = useState(true);
+    const isTerminalFocused = useTerminalFocus();
+    const { rows } = useTerminalSize();
+    // contentHeight is set by Settings.tsx (same value passed to Tabs to fix
+    // pane height across all tabs — prevents layout jank when switching).
+    // Reserve ~10 rows for chrome (search box, gaps, footer, scroll hints).
+    // Fallback calc for standalone rendering (tests).
+    const paneCap = contentHeight ?? Math.min(Math.floor(rows * 0.8), 30);
+    const maxVisible = Math.max(5, paneCap - 10);
+    const mainLoopModel = useAppState(s => s.mainLoopModel);
+    const verbose = useAppState(s_0 => s_0.verbose);
+    const thinkingEnabled = useAppState(s_1 => s_1.thinkingEnabled);
+    const isFastMode = useAppState(s_2 => isFastModeEnabled() ? s_2.fastMode : false);
+    const promptSuggestionEnabled = useAppState(s_3 => s_3.promptSuggestionEnabled);
+    // Show auto in the default-mode dropdown when the user has opted in OR the
+    // config is fully 'enabled' — even if currently circuit-broken ('disabled'),
+    // an opted-in user should still see it in settings (it's a temporary state).
+    const showAutoInDefaultModePicker = feature('TRANSCRIPT_CLASSIFIER') ? hasAutoModeOptInAnySource() || getAutoModeEnabledState() === 'enabled' : false;
+    // Chat/Transcript view picker is visible to entitled users (pass the GB
+    // gate) even if they haven't opted in this session — it IS the persistent
+    // opt-in. 'chat' written here is read at next startup by main.tsx which
+    // sets userMsgOptIn if still entitled.
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const showDefaultViewPicker = feature('KAIROS') || feature('KAIROS_BRIEF') ? require('../../tools/BriefTool/BriefTool.js').isBriefEntitled() : false;
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    const setAppState = useSetAppState();
+    const [changes, setChanges] = useState({});
+    const initialThinkingEnabled = React.useRef(thinkingEnabled);
+    // Per-source settings snapshots for revert-on-escape. getInitialSettings()
+    // returns merged-across-sources which can't tell us what to delete vs
+    // restore; per-source snapshots + updateSettingsForSource's
+    // undefined-deletes-key semantics can. Lazy-init via useState (no setter) to
+    // avoid reading settings files on every render — useRef evaluates its arg
+    // eagerly even though only the first result is kept.
+    const [initialLocalSettings] = useState(() => getSettingsForSource('localSettings'));
+    const [initialUserSettings] = useState(() => getSettingsForSource('userSettings'));
+    const initialThemeSetting = React.useRef(themeSetting);
+    // AppState fields Config may modify — snapshot once at mount.
+    const store = useAppStateStore();
+    const [initialAppState] = useState(() => {
+        const s_4 = store.getState();
+        return {
+            mainLoopModel: s_4.mainLoopModel,
+            mainLoopModelForSession: s_4.mainLoopModelForSession,
+            verbose: s_4.verbose,
+            thinkingEnabled: s_4.thinkingEnabled,
+            fastMode: s_4.fastMode,
+            promptSuggestionEnabled: s_4.promptSuggestionEnabled,
+            isBriefOnly: s_4.isBriefOnly,
+            replBridgeEnabled: s_4.replBridgeEnabled,
+            replBridgeOutboundOnly: s_4.replBridgeOutboundOnly,
+            settings: s_4.settings
+        };
+    });
+    // Bootstrap state snapshot — userMsgOptIn is outside AppState, so
+    // revertChanges needs to restore it separately. Without this, cycling
+    // defaultView to 'chat' then Escape leaves the tool active while the
+    // display filter reverts — the exact ambient-activation behavior this
+    // PR's entitlement/opt-in split is meant to prevent.
+    const [initialUserMsgOptIn] = useState(() => getUserMsgOptIn());
+    // Set on first user-visible change; gates revertChanges() on Escape so
+    // opening-then-closing doesn't trigger redundant disk writes.
+    const isDirty = React.useRef(false);
+    const [showThinkingWarning, setShowThinkingWarning] = useState(false);
+    const [showSubmenu, setShowSubmenu] = useState(null);
+    const { query: searchQuery, setQuery: setSearchQuery, cursorOffset: searchCursorOffset } = useSearchInput({
+        isActive: isSearchMode && showSubmenu === null && !headerFocused,
+        onExit: () => setIsSearchMode(false),
+        onExitUp: focusHeader,
+        // Ctrl+C/D must reach Settings' useExitOnCtrlCD; 'd' also avoids
+        // double-action (delete-char + exit-pending).
+        passthroughCtrlKeys: ['c', 'd']
+    });
+    // Tell the parent when Config's own Esc handler is active so Settings cedes
+    // confirm:no. Only true when search mode owns the keyboard — not when the
+    // tab header is focused (then Settings must handle Esc-to-close).
+    const ownsEsc = isSearchMode && !headerFocused;
+    React.useEffect(() => {
+        onIsSearchModeChange?.(ownsEsc);
+    }, [ownsEsc, onIsSearchModeChange]);
+    const isConnectedToIde = hasAccessToIDEExtensionDiffFeature(context.options.mcpClients);
+    const isFileCheckpointingAvailable = !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING);
+    const memoryFiles = React.use(getMemoryFiles(true));
+    const shouldShowExternalIncludesToggle = hasExternalClaudeMdIncludes(memoryFiles);
+    const autoUpdaterDisabledReason = getAutoUpdaterDisabledReason();
+    function onChangeMainModelConfig(value) {
+        const previousModel = mainLoopModel;
+        logEvent('tengu_config_model_changed', {
+            from_model: previousModel,
+            to_model: value
+        });
+        setAppState(prev => ({
+            ...prev,
+            mainLoopModel: value,
+            mainLoopModelForSession: null
+        }));
+        setChanges(prev_0 => {
+            const valStr = modelDisplayString(value) + (isBilledAsExtraUsage(value, false, isOpus1mMergeEnabled()) ? ' · Billed as extra usage' : '');
+            if ('model' in prev_0) {
+                const { model, ...rest } = prev_0;
+                return {
+                    ...rest,
+                    model: valStr
+                };
+            }
+            return {
+                ...prev_0,
+                model: valStr
+            };
+        });
+    }
+    function onChangeVerbose(value_0) {
+        // Update the global config to persist the setting
+        saveGlobalConfig(current => ({
+            ...current,
+            verbose: value_0
+        }));
+        setGlobalConfig({
+            ...getGlobalConfig(),
+            verbose: value_0
+        });
+        // Update the app state for immediate UI feedback
+        setAppState(prev_1 => ({
+            ...prev_1,
+            verbose: value_0
+        }));
+        setChanges(prev_2 => {
+            if ('verbose' in prev_2) {
+                const { verbose: verbose_0, ...rest_0 } = prev_2;
+                return rest_0;
+            }
+            return {
+                ...prev_2,
+                verbose: value_0
+            };
+        });
+    }
+    // TODO: Add MCP servers
+    const settingsItems = [
+        // Global settings
+        {
+            id: 'autoCompactEnabled',
+            label: 'Auto-compact',
+            value: globalConfig.autoCompactEnabled,
+            type: 'boolean',
+            onChange(autoCompactEnabled) {
+                saveGlobalConfig(current_0 => ({
+                    ...current_0,
+                    autoCompactEnabled
+                }));
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    autoCompactEnabled
+                });
+                logEvent('tengu_auto_compact_setting_changed', {
+                    enabled: autoCompactEnabled
+                });
+            }
+        }, {
+            id: 'spinnerTipsEnabled',
+            label: 'Show tips',
+            value: settingsData?.spinnerTipsEnabled ?? true,
+            type: 'boolean',
+            onChange(spinnerTipsEnabled) {
+                updateSettingsForSource('localSettings', {
+                    spinnerTipsEnabled
+                });
+                // Update local state to reflect the change immediately
+                setSettingsData(prev_3 => ({
+                    ...prev_3,
+                    spinnerTipsEnabled
+                }));
+                logEvent('tengu_tips_setting_changed', {
+                    enabled: spinnerTipsEnabled
+                });
+            }
+        }, {
+            id: 'prefersReducedMotion',
+            label: 'Reduce motion',
+            value: settingsData?.prefersReducedMotion ?? false,
+            type: 'boolean',
+            onChange(prefersReducedMotion) {
+                updateSettingsForSource('localSettings', {
+                    prefersReducedMotion
+                });
+                setSettingsData(prev_4 => ({
+                    ...prev_4,
+                    prefersReducedMotion
+                }));
+                // Sync to AppState so components react immediately
+                setAppState(prev_5 => ({
+                    ...prev_5,
+                    settings: {
+                        ...prev_5.settings,
+                        prefersReducedMotion
+                    }
+                }));
+                logEvent('tengu_reduce_motion_setting_changed', {
+                    enabled: prefersReducedMotion
+                });
+            }
+        }, {
+            id: 'thinkingEnabled',
+            label: 'Thinking mode',
+            value: thinkingEnabled ?? true,
+            type: 'boolean',
+            onChange(enabled) {
+                setAppState(prev_6 => ({
+                    ...prev_6,
+                    thinkingEnabled: enabled
+                }));
+                updateSettingsForSource('userSettings', {
+                    alwaysThinkingEnabled: enabled ? undefined : false
+                });
+                logEvent('tengu_thinking_toggled', {
+                    enabled
+                });
+            }
+        },
+        // Fast mode toggle (ant-only, eliminated from external builds)
+        ...(isFastModeEnabled() && isFastModeAvailable() ? [{
+                id: 'fastMode',
+                label: `Fast mode (${FAST_MODE_MODEL_DISPLAY} only)`,
+                value: !!isFastMode,
+                type: 'boolean',
+                onChange(enabled_0) {
+                    clearFastModeCooldown();
+                    updateSettingsForSource('userSettings', {
+                        fastMode: enabled_0 ? true : undefined
+                    });
+                    if (enabled_0) {
+                        setAppState(prev_7 => ({
+                            ...prev_7,
+                            mainLoopModel: getFastModeModel(),
+                            mainLoopModelForSession: null,
+                            fastMode: true
+                        }));
+                        setChanges(prev_8 => ({
+                            ...prev_8,
+                            model: getFastModeModel(),
+                            'Fast mode': 'ON'
+                        }));
+                    }
+                    else {
+                        setAppState(prev_9 => ({
+                            ...prev_9,
+                            fastMode: false
+                        }));
+                        setChanges(prev_10 => ({
+                            ...prev_10,
+                            'Fast mode': 'OFF'
+                        }));
+                    }
+                }
+            }] : []), ...(getFeatureValue_CACHED_MAY_BE_STALE('tengu_chomp_inflection', false) ? [{
+                id: 'promptSuggestionEnabled',
+                label: 'Prompt suggestions',
+                value: promptSuggestionEnabled,
+                type: 'boolean',
+                onChange(enabled_1) {
+                    setAppState(prev_11 => ({
+                        ...prev_11,
+                        promptSuggestionEnabled: enabled_1
+                    }));
+                    updateSettingsForSource('userSettings', {
+                        promptSuggestionEnabled: enabled_1 ? undefined : false
+                    });
+                }
+            }] : []),
+        // Speculation toggle (ant-only)
+        ...("external" === 'ant' ? [{
+                id: 'speculationEnabled',
+                label: 'Speculative execution',
+                value: globalConfig.speculationEnabled ?? true,
+                type: 'boolean',
+                onChange(enabled_2) {
+                    saveGlobalConfig(current_1 => {
+                        if (current_1.speculationEnabled === enabled_2)
+                            return current_1;
+                        return {
+                            ...current_1,
+                            speculationEnabled: enabled_2
+                        };
+                    });
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        speculationEnabled: enabled_2
+                    });
+                    logEvent('tengu_speculation_setting_changed', {
+                        enabled: enabled_2
+                    });
+                }
+            }] : []), ...(isFileCheckpointingAvailable ? [{
+                id: 'fileCheckpointingEnabled',
+                label: 'Rewind code (checkpoints)',
+                value: globalConfig.fileCheckpointingEnabled,
+                type: 'boolean',
+                onChange(enabled_3) {
+                    saveGlobalConfig(current_2 => ({
+                        ...current_2,
+                        fileCheckpointingEnabled: enabled_3
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        fileCheckpointingEnabled: enabled_3
+                    });
+                    logEvent('tengu_file_history_snapshots_setting_changed', {
+                        enabled: enabled_3
+                    });
+                }
+            }] : []), {
+            id: 'verbose',
+            label: 'Verbose output',
+            value: verbose,
+            type: 'boolean',
+            onChange: onChangeVerbose
+        }, {
+            id: 'terminalProgressBarEnabled',
+            label: 'Terminal progress bar',
+            value: globalConfig.terminalProgressBarEnabled,
+            type: 'boolean',
+            onChange(terminalProgressBarEnabled) {
+                saveGlobalConfig(current_3 => ({
+                    ...current_3,
+                    terminalProgressBarEnabled
+                }));
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    terminalProgressBarEnabled
+                });
+                logEvent('tengu_terminal_progress_bar_setting_changed', {
+                    enabled: terminalProgressBarEnabled
+                });
+            }
+        }, ...(getFeatureValue_CACHED_MAY_BE_STALE('tengu_terminal_sidebar', false) ? [{
+                id: 'showStatusInTerminalTab',
+                label: 'Show status in terminal tab',
+                value: globalConfig.showStatusInTerminalTab ?? false,
+                type: 'boolean',
+                onChange(showStatusInTerminalTab) {
+                    saveGlobalConfig(current_4 => ({
+                        ...current_4,
+                        showStatusInTerminalTab
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        showStatusInTerminalTab
+                    });
+                    logEvent('tengu_terminal_tab_status_setting_changed', {
+                        enabled: showStatusInTerminalTab
+                    });
+                }
+            }] : []), {
+            id: 'showTurnDuration',
+            label: 'Show turn duration',
+            value: globalConfig.showTurnDuration,
+            type: 'boolean',
+            onChange(showTurnDuration) {
+                saveGlobalConfig(current_5 => ({
+                    ...current_5,
+                    showTurnDuration
+                }));
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    showTurnDuration
+                });
+                logEvent('tengu_show_turn_duration_setting_changed', {
+                    enabled: showTurnDuration
+                });
+            }
+        }, {
+            id: 'defaultPermissionMode',
+            label: 'Default permission mode',
+            value: settingsData?.permissions?.defaultMode || 'default',
+            options: (() => {
+                const priorityOrder = ['default', 'plan'];
+                const allModes = feature('TRANSCRIPT_CLASSIFIER') ? PERMISSION_MODES : EXTERNAL_PERMISSION_MODES;
+                const excluded = ['bypassPermissions'];
+                if (feature('TRANSCRIPT_CLASSIFIER') && !showAutoInDefaultModePicker) {
+                    excluded.push('auto');
+                }
+                return [...priorityOrder, ...allModes.filter(m => !priorityOrder.includes(m) && !excluded.includes(m))];
+            })(),
+            type: 'enum',
+            onChange(mode) {
+                const parsedMode = permissionModeFromString(mode);
+                // Internal modes (e.g. auto) are stored directly
+                const validatedMode = isExternalPermissionMode(parsedMode) ? toExternalPermissionMode(parsedMode) : parsedMode;
+                const result = updateSettingsForSource('userSettings', {
+                    permissions: {
+                        ...settingsData?.permissions,
+                        defaultMode: validatedMode
+                    }
+                });
+                if (result.error) {
+                    logError(result.error);
+                    return;
+                }
+                // Update local state to reflect the change immediately.
+                // validatedMode is typed as the wide PermissionMode union but at
+                // runtime is always a PERMISSION_MODES member (the options dropdown
+                // is built from that array above), so this narrowing is sound.
+                setSettingsData(prev_12 => ({
+                    ...prev_12,
+                    permissions: {
+                        ...prev_12?.permissions,
+                        defaultMode: validatedMode
+                    }
+                }));
+                // Track changes
+                setChanges(prev_13 => ({
+                    ...prev_13,
+                    defaultPermissionMode: mode
+                }));
+                logEvent('tengu_config_changed', {
+                    setting: 'defaultPermissionMode',
+                    value: mode
+                });
+            }
+        }, ...(feature('TRANSCRIPT_CLASSIFIER') && showAutoInDefaultModePicker ? [{
+                id: 'useAutoModeDuringPlan',
+                label: 'Use auto mode during plan',
+                value: settingsData?.useAutoModeDuringPlan ?? true,
+                type: 'boolean',
+                onChange(useAutoModeDuringPlan) {
+                    updateSettingsForSource('userSettings', {
+                        useAutoModeDuringPlan
+                    });
+                    setSettingsData(prev_14 => ({
+                        ...prev_14,
+                        useAutoModeDuringPlan
+                    }));
+                    // Internal writes suppress the file watcher, so
+                    // applySettingsChange won't fire. Reconcile directly so
+                    // mid-plan toggles take effect immediately.
+                    setAppState(prev_15 => {
+                        const next = transitionPlanAutoMode(prev_15.toolPermissionContext);
+                        if (next === prev_15.toolPermissionContext)
+                            return prev_15;
+                        return {
+                            ...prev_15,
+                            toolPermissionContext: next
+                        };
+                    });
+                    setChanges(prev_16 => ({
+                        ...prev_16,
+                        'Use auto mode during plan': useAutoModeDuringPlan
+                    }));
+                }
+            }] : []), {
+            id: 'respectGitignore',
+            label: 'Respect .gitignore in file picker',
+            value: globalConfig.respectGitignore,
+            type: 'boolean',
+            onChange(respectGitignore) {
+                saveGlobalConfig(current_6 => ({
+                    ...current_6,
+                    respectGitignore
+                }));
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    respectGitignore
+                });
+                logEvent('tengu_respect_gitignore_setting_changed', {
+                    enabled: respectGitignore
+                });
+            }
+        }, {
+            id: 'copyFullResponse',
+            label: 'Always copy full response (skip /copy picker)',
+            value: globalConfig.copyFullResponse,
+            type: 'boolean',
+            onChange(copyFullResponse) {
+                saveGlobalConfig(current_7 => ({
+                    ...current_7,
+                    copyFullResponse
+                }));
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    copyFullResponse
+                });
+                logEvent('tengu_config_changed', {
+                    setting: 'copyFullResponse',
+                    value: String(copyFullResponse)
+                });
+            }
+        },
+        // Copy-on-select is only meaningful with in-app selection (fullscreen
+        // alt-screen mode). In inline mode the terminal emulator owns selection.
+        ...(isFullscreenEnvEnabled() ? [{
+                id: 'copyOnSelect',
+                label: 'Copy on select',
+                value: globalConfig.copyOnSelect ?? true,
+                type: 'boolean',
+                onChange(copyOnSelect) {
+                    saveGlobalConfig(current_8 => ({
+                        ...current_8,
+                        copyOnSelect
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        copyOnSelect
+                    });
+                    logEvent('tengu_config_changed', {
+                        setting: 'copyOnSelect',
+                        value: String(copyOnSelect)
+                    });
+                }
+            }] : []),
+        // autoUpdates setting is hidden - use DISABLE_AUTOUPDATER env var to control
+        autoUpdaterDisabledReason ? {
+            id: 'autoUpdatesChannel',
+            label: 'Auto-update channel',
+            value: 'disabled',
+            type: 'managedEnum',
+            onChange() { }
+        } : {
+            id: 'autoUpdatesChannel',
+            label: 'Auto-update channel',
+            value: settingsData?.autoUpdatesChannel ?? 'latest',
+            type: 'managedEnum',
+            onChange() {
+                // Handled via toggleSetting -> 'ChannelDowngrade'
+            }
+        }, {
+            id: 'theme',
+            label: 'Theme',
+            value: themeSetting,
+            type: 'managedEnum',
+            onChange: setTheme
+        }, {
+            id: 'notifChannel',
+            label: feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION') ? 'Local notifications' : 'Notifications',
+            value: globalConfig.preferredNotifChannel,
+            options: ['auto', 'iterm2', 'terminal_bell', 'iterm2_with_bell', 'kitty', 'ghostty', 'notifications_disabled'],
+            type: 'enum',
+            onChange(notifChannel) {
+                saveGlobalConfig(current_9 => ({
+                    ...current_9,
+                    preferredNotifChannel: notifChannel
+                }));
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    preferredNotifChannel: notifChannel
+                });
+            }
+        }, ...(feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION') ? [{
+                id: 'taskCompleteNotifEnabled',
+                label: 'Push when idle',
+                value: globalConfig.taskCompleteNotifEnabled ?? false,
+                type: 'boolean',
+                onChange(taskCompleteNotifEnabled) {
+                    saveGlobalConfig(current_10 => ({
+                        ...current_10,
+                        taskCompleteNotifEnabled
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        taskCompleteNotifEnabled
+                    });
+                }
+            }, {
+                id: 'inputNeededNotifEnabled',
+                label: 'Push when input needed',
+                value: globalConfig.inputNeededNotifEnabled ?? false,
+                type: 'boolean',
+                onChange(inputNeededNotifEnabled) {
+                    saveGlobalConfig(current_11 => ({
+                        ...current_11,
+                        inputNeededNotifEnabled
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        inputNeededNotifEnabled
+                    });
+                }
+            }, {
+                id: 'agentPushNotifEnabled',
+                label: 'Push when Claude decides',
+                value: globalConfig.agentPushNotifEnabled ?? false,
+                type: 'boolean',
+                onChange(agentPushNotifEnabled) {
+                    saveGlobalConfig(current_12 => ({
+                        ...current_12,
+                        agentPushNotifEnabled
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        agentPushNotifEnabled
+                    });
+                }
+            }] : []), {
+            id: 'outputStyle',
+            label: 'Output style',
+            value: currentOutputStyle,
+            type: 'managedEnum',
+            onChange: () => { } // handled by OutputStylePicker submenu
+        }, ...(showDefaultViewPicker ? [{
+                id: 'defaultView',
+                label: 'What you see by default',
+                // 'default' means the setting is unset — currently resolves to
+                // transcript (main.tsx falls through when defaultView !== 'chat').
+                // String() narrows the conditional-schema-spread union to string.
+                value: settingsData?.defaultView === undefined ? 'default' : String(settingsData.defaultView),
+                options: ['transcript', 'chat', 'default'],
+                type: 'enum',
+                onChange(selected) {
+                    const defaultView = selected === 'default' ? undefined : selected;
+                    updateSettingsForSource('localSettings', {
+                        defaultView
+                    });
+                    setSettingsData(prev_17 => ({
+                        ...prev_17,
+                        defaultView
+                    }));
+                    const nextBrief = defaultView === 'chat';
+                    setAppState(prev_18 => {
+                        if (prev_18.isBriefOnly === nextBrief)
+                            return prev_18;
+                        return {
+                            ...prev_18,
+                            isBriefOnly: nextBrief
+                        };
+                    });
+                    // Keep userMsgOptIn in sync so the tool list follows the view.
+                    // Two-way now (same as /brief) — accepting a cache invalidation
+                    // is better than leaving the tool on after switching away.
+                    // Reverted on Escape via initialUserMsgOptIn snapshot.
+                    setUserMsgOptIn(nextBrief);
+                    setChanges(prev_19 => ({
+                        ...prev_19,
+                        'Default view': selected
+                    }));
+                    logEvent('tengu_default_view_setting_changed', {
+                        value: (defaultView ?? 'unset')
+                    });
+                }
+            }] : []), {
+            id: 'language',
+            label: 'Language',
+            value: currentLanguage ?? 'Default (English)',
+            type: 'managedEnum',
+            onChange: () => { } // handled by LanguagePicker submenu
+        }, {
+            id: 'editorMode',
+            label: 'Editor mode',
+            // Convert 'emacs' to 'normal' for backward compatibility
+            value: globalConfig.editorMode === 'emacs' ? 'normal' : globalConfig.editorMode || 'normal',
+            options: ['normal', 'vim'],
+            type: 'enum',
+            onChange(value_1) {
+                saveGlobalConfig(current_13 => ({
+                    ...current_13,
+                    editorMode: value_1
+                }));
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    editorMode: value_1
+                });
+                logEvent('tengu_editor_mode_changed', {
+                    mode: value_1,
+                    source: 'config_panel'
+                });
+            }
+        }, {
+            id: 'prStatusFooterEnabled',
+            label: 'Show PR status footer',
+            value: globalConfig.prStatusFooterEnabled ?? true,
+            type: 'boolean',
+            onChange(enabled_4) {
+                saveGlobalConfig(current_14 => {
+                    if (current_14.prStatusFooterEnabled === enabled_4)
+                        return current_14;
+                    return {
+                        ...current_14,
+                        prStatusFooterEnabled: enabled_4
+                    };
+                });
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    prStatusFooterEnabled: enabled_4
+                });
+                logEvent('tengu_pr_status_footer_setting_changed', {
+                    enabled: enabled_4
+                });
+            }
+        }, {
+            id: 'model',
+            label: 'Model',
+            value: mainLoopModel === null ? 'Default (recommended)' : mainLoopModel,
+            type: 'managedEnum',
+            onChange: onChangeMainModelConfig
+        }, ...(isConnectedToIde ? [{
+                id: 'diffTool',
+                label: 'Diff tool',
+                value: globalConfig.diffTool ?? 'auto',
+                options: ['terminal', 'auto'],
+                type: 'enum',
+                onChange(diffTool) {
+                    saveGlobalConfig(current_15 => ({
+                        ...current_15,
+                        diffTool: diffTool
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        diffTool: diffTool
+                    });
+                    logEvent('tengu_diff_tool_changed', {
+                        tool: diffTool,
+                        source: 'config_panel'
+                    });
+                }
+            }] : []), ...(!isSupportedTerminal() ? [{
+                id: 'autoConnectIde',
+                label: 'Auto-connect to IDE (external terminal)',
+                value: globalConfig.autoConnectIde ?? false,
+                type: 'boolean',
+                onChange(autoConnectIde) {
+                    saveGlobalConfig(current_16 => ({
+                        ...current_16,
+                        autoConnectIde
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        autoConnectIde
+                    });
+                    logEvent('tengu_auto_connect_ide_changed', {
+                        enabled: autoConnectIde,
+                        source: 'config_panel'
+                    });
+                }
+            }] : []), ...(isSupportedTerminal() ? [{
+                id: 'autoInstallIdeExtension',
+                label: 'Auto-install IDE extension',
+                value: globalConfig.autoInstallIdeExtension ?? true,
+                type: 'boolean',
+                onChange(autoInstallIdeExtension) {
+                    saveGlobalConfig(current_17 => ({
+                        ...current_17,
+                        autoInstallIdeExtension
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        autoInstallIdeExtension
+                    });
+                    logEvent('tengu_auto_install_ide_extension_changed', {
+                        enabled: autoInstallIdeExtension,
+                        source: 'config_panel'
+                    });
+                }
+            }] : []), {
+            id: 'claudeInChromeDefaultEnabled',
+            label: 'Claude in Chrome enabled by default',
+            value: globalConfig.claudeInChromeDefaultEnabled ?? true,
+            type: 'boolean',
+            onChange(enabled_5) {
+                saveGlobalConfig(current_18 => ({
+                    ...current_18,
+                    claudeInChromeDefaultEnabled: enabled_5
+                }));
+                setGlobalConfig({
+                    ...getGlobalConfig(),
+                    claudeInChromeDefaultEnabled: enabled_5
+                });
+                logEvent('tengu_claude_in_chrome_setting_changed', {
+                    enabled: enabled_5
+                });
+            }
+        },
+        // Teammate mode (only shown when agent swarms are enabled)
+        ...(isAgentSwarmsEnabled() ? (() => {
+            const cliOverride = getCliTeammateModeOverride();
+            const label = cliOverride ? `Teammate mode [overridden: ${cliOverride}]` : 'Teammate mode';
+            return [{
+                    id: 'teammateMode',
+                    label,
+                    value: globalConfig.teammateMode ?? 'auto',
+                    options: ['auto', 'tmux', 'in-process'],
+                    type: 'enum',
+                    onChange(mode_0) {
+                        if (mode_0 !== 'auto' && mode_0 !== 'tmux' && mode_0 !== 'in-process') {
+                            return;
+                        }
+                        // Clear CLI override and set new mode (pass mode to avoid race condition)
+                        clearCliTeammateModeOverride(mode_0);
+                        saveGlobalConfig(current_19 => ({
+                            ...current_19,
+                            teammateMode: mode_0
+                        }));
+                        setGlobalConfig({
+                            ...getGlobalConfig(),
+                            teammateMode: mode_0
+                        });
+                        logEvent('tengu_teammate_mode_changed', {
+                            mode: mode_0
+                        });
+                    }
+                }, {
+                    id: 'teammateDefaultModel',
+                    label: 'Default teammate model',
+                    value: teammateModelDisplayString(globalConfig.teammateDefaultModel),
+                    type: 'managedEnum',
+                    onChange() { }
+                }];
+        })() : []),
+        // Remote at startup toggle — gated on build flag + GrowthBook + policy
+        ...(feature('BRIDGE_MODE') && isBridgeEnabled() ? [{
+                id: 'remoteControlAtStartup',
+                label: 'Enable Remote Control for all sessions',
+                value: globalConfig.remoteControlAtStartup === undefined ? 'default' : String(globalConfig.remoteControlAtStartup),
+                options: ['true', 'false', 'default'],
+                type: 'enum',
+                onChange(selected_0) {
+                    if (selected_0 === 'default') {
+                        // Unset the config key so it falls back to the platform default
+                        saveGlobalConfig(current_20 => {
+                            if (current_20.remoteControlAtStartup === undefined)
+                                return current_20;
+                            const next_0 = {
+                                ...current_20
+                            };
+                            delete next_0.remoteControlAtStartup;
+                            return next_0;
+                        });
+                        setGlobalConfig({
+                            ...getGlobalConfig(),
+                            remoteControlAtStartup: undefined
+                        });
+                    }
+                    else {
+                        const enabled_6 = selected_0 === 'true';
+                        saveGlobalConfig(current_21 => {
+                            if (current_21.remoteControlAtStartup === enabled_6)
+                                return current_21;
+                            return {
+                                ...current_21,
+                                remoteControlAtStartup: enabled_6
+                            };
+                        });
+                        setGlobalConfig({
+                            ...getGlobalConfig(),
+                            remoteControlAtStartup: enabled_6
+                        });
+                    }
+                    // Sync to AppState so useReplBridge reacts immediately
+                    const resolved = getRemoteControlAtStartup();
+                    setAppState(prev_20 => {
+                        if (prev_20.replBridgeEnabled === resolved && !prev_20.replBridgeOutboundOnly)
+                            return prev_20;
+                        return {
+                            ...prev_20,
+                            replBridgeEnabled: resolved,
+                            replBridgeOutboundOnly: false
+                        };
+                    });
+                }
+            }] : []), ...(shouldShowExternalIncludesToggle ? [{
+                id: 'showExternalIncludesDialog',
+                label: 'External CLAUDE.md includes',
+                value: (() => {
+                    const projectConfig = getCurrentProjectConfig();
+                    if (projectConfig.hasClaudeMdExternalIncludesApproved) {
+                        return 'true';
+                    }
+                    else {
+                        return 'false';
+                    }
+                })(),
+                type: 'managedEnum',
+                onChange() {
+                    // Will be handled by toggleSetting function
+                }
+            }] : []), ...(process.env.ANTHROPIC_API_KEY && !isRunningOnHomespace() ? [{
+                id: 'apiKey',
+                label: _jsxs(Text, { children: ["Use custom API key:", ' ', _jsx(Text, { bold: true, children: normalizeApiKeyForConfig(process.env.ANTHROPIC_API_KEY) })] }),
+                searchText: 'Use custom API key',
+                value: Boolean(process.env.ANTHROPIC_API_KEY && globalConfig.customApiKeyResponses?.approved?.includes(normalizeApiKeyForConfig(process.env.ANTHROPIC_API_KEY))),
+                type: 'boolean',
+                onChange(useCustomKey) {
+                    saveGlobalConfig(current_22 => {
+                        const updated = {
+                            ...current_22
+                        };
+                        if (!updated.customApiKeyResponses) {
+                            updated.customApiKeyResponses = {
+                                approved: [],
+                                rejected: []
+                            };
+                        }
+                        if (!updated.customApiKeyResponses.approved) {
+                            updated.customApiKeyResponses = {
+                                ...updated.customApiKeyResponses,
+                                approved: []
+                            };
+                        }
+                        if (!updated.customApiKeyResponses.rejected) {
+                            updated.customApiKeyResponses = {
+                                ...updated.customApiKeyResponses,
+                                rejected: []
+                            };
+                        }
+                        if (process.env.ANTHROPIC_API_KEY) {
+                            const truncatedKey = normalizeApiKeyForConfig(process.env.ANTHROPIC_API_KEY);
+                            if (useCustomKey) {
+                                updated.customApiKeyResponses = {
+                                    ...updated.customApiKeyResponses,
+                                    approved: [...(updated.customApiKeyResponses.approved ?? []).filter(k => k !== truncatedKey), truncatedKey],
+                                    rejected: (updated.customApiKeyResponses.rejected ?? []).filter(k_0 => k_0 !== truncatedKey)
+                                };
+                            }
+                            else {
+                                updated.customApiKeyResponses = {
+                                    ...updated.customApiKeyResponses,
+                                    approved: (updated.customApiKeyResponses.approved ?? []).filter(k_1 => k_1 !== truncatedKey),
+                                    rejected: [...(updated.customApiKeyResponses.rejected ?? []).filter(k_2 => k_2 !== truncatedKey), truncatedKey]
+                                };
+                            }
+                        }
+                        return updated;
+                    });
+                    setGlobalConfig(getGlobalConfig());
+                }
+            }] : [])
+    ];
+    // Filter settings based on search query
+    const filteredSettingsItems = React.useMemo(() => {
+        if (!searchQuery)
+            return settingsItems;
+        const lowerQuery = searchQuery.toLowerCase();
+        return settingsItems.filter(setting => {
+            if (setting.id.toLowerCase().includes(lowerQuery))
+                return true;
+            const searchableText = 'searchText' in setting ? setting.searchText : setting.label;
+            return searchableText.toLowerCase().includes(lowerQuery);
+        });
+    }, [settingsItems, searchQuery]);
+    // Adjust selected index when filtered list shrinks, and keep the selected
+    // item visible when maxVisible changes (e.g., terminal resize).
+    React.useEffect(() => {
+        if (selectedIndex >= filteredSettingsItems.length) {
+            const newIndex = Math.max(0, filteredSettingsItems.length - 1);
+            setSelectedIndex(newIndex);
+            setScrollOffset(Math.max(0, newIndex - maxVisible + 1));
+            return;
+        }
+        setScrollOffset(prev_21 => {
+            if (selectedIndex < prev_21)
+                return selectedIndex;
+            if (selectedIndex >= prev_21 + maxVisible)
+                return selectedIndex - maxVisible + 1;
+            return prev_21;
+        });
+    }, [filteredSettingsItems.length, selectedIndex, maxVisible]);
+    // Keep the selected item visible within the scroll window.
+    // Called synchronously from navigation handlers to avoid a render frame
+    // where the selected item falls outside the visible window.
+    const adjustScrollOffset = useCallback((newIndex_0) => {
+        setScrollOffset(prev_22 => {
+            if (newIndex_0 < prev_22)
+                return newIndex_0;
+            if (newIndex_0 >= prev_22 + maxVisible)
+                return newIndex_0 - maxVisible + 1;
+            return prev_22;
+        });
+    }, [maxVisible]);
+    // Enter: keep all changes (already persisted by onChange handlers), close
+    // with a summary of what changed.
+    const handleSaveAndClose = useCallback(() => {
+        // Submenu handling: each submenu has its own Enter/Esc — don't close
+        // the whole panel while one is open.
+        if (showSubmenu !== null) {
+            return;
+        }
+        // Log any changes that were made
+        // TODO: Make these proper messages
+        const formattedChanges = Object.entries(changes).map(([key, value_2]) => {
+            logEvent('tengu_config_changed', {
+                key: key,
+                value: value_2
+            });
+            return `Set ${key} to ${chalk.bold(value_2)}`;
+        });
+        // Check for API key changes
+        // On homespace, ANTHROPIC_API_KEY is preserved in process.env for child
+        // processes but ignored by Context Code itself (see auth.ts).
+        const effectiveApiKey = isRunningOnHomespace() ? undefined : process.env.ANTHROPIC_API_KEY;
+        const initialUsingCustomKey = Boolean(effectiveApiKey && initialConfig.current.customApiKeyResponses?.approved?.includes(normalizeApiKeyForConfig(effectiveApiKey)));
+        const currentUsingCustomKey = Boolean(effectiveApiKey && globalConfig.customApiKeyResponses?.approved?.includes(normalizeApiKeyForConfig(effectiveApiKey)));
+        if (initialUsingCustomKey !== currentUsingCustomKey) {
+            formattedChanges.push(`${currentUsingCustomKey ? 'Enabled' : 'Disabled'} custom API key`);
+            logEvent('tengu_config_changed', {
+                key: 'env.ANTHROPIC_API_KEY',
+                value: currentUsingCustomKey
+            });
+        }
+        if (globalConfig.theme !== initialConfig.current.theme) {
+            formattedChanges.push(`Set theme to ${chalk.bold(globalConfig.theme)}`);
+        }
+        if (globalConfig.preferredNotifChannel !== initialConfig.current.preferredNotifChannel) {
+            formattedChanges.push(`Set notifications to ${chalk.bold(globalConfig.preferredNotifChannel)}`);
+        }
+        if (currentOutputStyle !== initialOutputStyle.current) {
+            formattedChanges.push(`Set output style to ${chalk.bold(currentOutputStyle)}`);
+        }
+        if (currentLanguage !== initialLanguage.current) {
+            formattedChanges.push(`Set response language to ${chalk.bold(currentLanguage ?? 'Default (English)')}`);
+        }
+        if (globalConfig.editorMode !== initialConfig.current.editorMode) {
+            formattedChanges.push(`Set editor mode to ${chalk.bold(globalConfig.editorMode || 'emacs')}`);
+        }
+        if (globalConfig.diffTool !== initialConfig.current.diffTool) {
+            formattedChanges.push(`Set diff tool to ${chalk.bold(globalConfig.diffTool)}`);
+        }
+        if (globalConfig.autoConnectIde !== initialConfig.current.autoConnectIde) {
+            formattedChanges.push(`${globalConfig.autoConnectIde ? 'Enabled' : 'Disabled'} auto-connect to IDE`);
+        }
+        if (globalConfig.autoInstallIdeExtension !== initialConfig.current.autoInstallIdeExtension) {
+            formattedChanges.push(`${globalConfig.autoInstallIdeExtension ? 'Enabled' : 'Disabled'} auto-install IDE extension`);
+        }
+        if (globalConfig.autoCompactEnabled !== initialConfig.current.autoCompactEnabled) {
+            formattedChanges.push(`${globalConfig.autoCompactEnabled ? 'Enabled' : 'Disabled'} auto-compact`);
+        }
+        if (globalConfig.respectGitignore !== initialConfig.current.respectGitignore) {
+            formattedChanges.push(`${globalConfig.respectGitignore ? 'Enabled' : 'Disabled'} respect .gitignore in file picker`);
+        }
+        if (globalConfig.copyFullResponse !== initialConfig.current.copyFullResponse) {
+            formattedChanges.push(`${globalConfig.copyFullResponse ? 'Enabled' : 'Disabled'} always copy full response`);
+        }
+        if (globalConfig.copyOnSelect !== initialConfig.current.copyOnSelect) {
+            formattedChanges.push(`${globalConfig.copyOnSelect ? 'Enabled' : 'Disabled'} copy on select`);
+        }
+        if (globalConfig.terminalProgressBarEnabled !== initialConfig.current.terminalProgressBarEnabled) {
+            formattedChanges.push(`${globalConfig.terminalProgressBarEnabled ? 'Enabled' : 'Disabled'} terminal progress bar`);
+        }
+        if (globalConfig.showStatusInTerminalTab !== initialConfig.current.showStatusInTerminalTab) {
+            formattedChanges.push(`${globalConfig.showStatusInTerminalTab ? 'Enabled' : 'Disabled'} terminal tab status`);
+        }
+        if (globalConfig.showTurnDuration !== initialConfig.current.showTurnDuration) {
+            formattedChanges.push(`${globalConfig.showTurnDuration ? 'Enabled' : 'Disabled'} turn duration`);
+        }
+        if (globalConfig.remoteControlAtStartup !== initialConfig.current.remoteControlAtStartup) {
+            const remoteLabel = globalConfig.remoteControlAtStartup === undefined ? 'Reset Remote Control to default' : `${globalConfig.remoteControlAtStartup ? 'Enabled' : 'Disabled'} Remote Control for all sessions`;
+            formattedChanges.push(remoteLabel);
+        }
+        if (settingsData?.autoUpdatesChannel !== initialSettingsData.current?.autoUpdatesChannel) {
+            formattedChanges.push(`Set auto-update channel to ${chalk.bold(settingsData?.autoUpdatesChannel ?? 'latest')}`);
+        }
+        if (formattedChanges.length > 0) {
+            onClose(formattedChanges.join('\n'));
+        }
+        else {
+            onClose('Config dialog dismissed', {
+                display: 'system'
+            });
+        }
+    }, [showSubmenu, changes, globalConfig, mainLoopModel, currentOutputStyle, currentLanguage, settingsData?.autoUpdatesChannel, isFastModeEnabled() ? settingsData?.fastMode : undefined, onClose]);
+    // Restore all state stores to their mount-time snapshots. Changes are
+    // applied to disk/AppState immediately on toggle, so "cancel" means
+    // actively writing the old values back.
+    const revertChanges = useCallback(() => {
+        // Theme: restores ThemeProvider React state. Must run before the global
+        // config overwrite since setTheme internally calls saveGlobalConfig with
+        // a partial update — we want the full snapshot to be the last write.
+        if (themeSetting !== initialThemeSetting.current) {
+            setTheme(initialThemeSetting.current);
+        }
+        // Global config: full overwrite from snapshot. saveGlobalConfig skips if
+        // the returned ref equals current (test mode checks ref; prod writes to
+        // disk but content is identical).
+        saveGlobalConfig(() => initialConfig.current);
+        // Settings files: restore each key Config may have touched. undefined
+        // deletes the key (updateSettingsForSource customizer at settings.ts:368).
+        const il = initialLocalSettings;
+        updateSettingsForSource('localSettings', {
+            spinnerTipsEnabled: il?.spinnerTipsEnabled,
+            prefersReducedMotion: il?.prefersReducedMotion,
+            defaultView: il?.defaultView,
+            outputStyle: il?.outputStyle
+        });
+        const iu = initialUserSettings;
+        updateSettingsForSource('userSettings', {
+            alwaysThinkingEnabled: iu?.alwaysThinkingEnabled,
+            fastMode: iu?.fastMode,
+            promptSuggestionEnabled: iu?.promptSuggestionEnabled,
+            autoUpdatesChannel: iu?.autoUpdatesChannel,
+            minimumVersion: iu?.minimumVersion,
+            language: iu?.language,
+            ...(feature('TRANSCRIPT_CLASSIFIER') ? {
+                useAutoModeDuringPlan: iu?.useAutoModeDuringPlan
+            } : {}),
+            // ThemePicker's Ctrl+T writes this key directly — include it so the
+            // disk state reverts along with the in-memory AppState.settings restore.
+            syntaxHighlightingDisabled: iu?.syntaxHighlightingDisabled,
+            // permissions: the defaultMode onChange (above) spreads the MERGED
+            // settingsData.permissions into userSettings — project/policy allow/deny
+            // arrays can leak to disk. Spread the full initial snapshot so the
+            // mergeWith array-customizer (settings.ts:375) replaces leaked arrays.
+            // Explicitly include defaultMode so undefined triggers the customizer's
+            // delete path even when iu.permissions lacks that key.
+            permissions: iu?.permissions === undefined ? undefined : {
+                ...iu.permissions,
+                defaultMode: iu.permissions.defaultMode
+            }
+        });
+        // AppState: batch-restore all possibly-touched fields.
+        const ia = initialAppState;
+        setAppState(prev_23 => ({
+            ...prev_23,
+            mainLoopModel: ia.mainLoopModel,
+            mainLoopModelForSession: ia.mainLoopModelForSession,
+            verbose: ia.verbose,
+            thinkingEnabled: ia.thinkingEnabled,
+            fastMode: ia.fastMode,
+            promptSuggestionEnabled: ia.promptSuggestionEnabled,
+            isBriefOnly: ia.isBriefOnly,
+            replBridgeEnabled: ia.replBridgeEnabled,
+            replBridgeOutboundOnly: ia.replBridgeOutboundOnly,
+            settings: ia.settings,
+            // Reconcile auto-mode state after useAutoModeDuringPlan revert above —
+            // the onChange handler may have activated/deactivated auto mid-plan.
+            toolPermissionContext: transitionPlanAutoMode(prev_23.toolPermissionContext)
+        }));
+        // Bootstrap state: restore userMsgOptIn. Only touched by the defaultView
+        // onChange above, so no feature() guard needed here (that path only
+        // exists when showDefaultViewPicker is true).
+        if (getUserMsgOptIn() !== initialUserMsgOptIn) {
+            setUserMsgOptIn(initialUserMsgOptIn);
+        }
+    }, [themeSetting, setTheme, initialLocalSettings, initialUserSettings, initialAppState, initialUserMsgOptIn, setAppState]);
+    // Escape: revert all changes (if any) and close.
+    const handleEscape = useCallback(() => {
+        if (showSubmenu !== null) {
+            return;
+        }
+        if (isDirty.current) {
+            revertChanges();
+        }
+        onClose('Config dialog dismissed', {
+            display: 'system'
+        });
+    }, [showSubmenu, revertChanges, onClose]);
+    // Disable when submenu is open so the submenu's Dialog handles ESC, and in
+    // search mode so the onKeyDown handler (which clears-then-exits search)
+    // wins — otherwise Escape in search would jump straight to revert+close.
+    useKeybinding('confirm:no', handleEscape, {
+        context: 'Settings',
+        isActive: showSubmenu === null && !isSearchMode && !headerFocused
+    });
+    // Save-and-close fires on Enter only when not in search mode (Enter there
+    // exits search to the list — see the isSearchMode branch in handleKeyDown).
+    useKeybinding('settings:close', handleSaveAndClose, {
+        context: 'Settings',
+        isActive: showSubmenu === null && !isSearchMode && !headerFocused
+    });
+    // Settings navigation and toggle actions via configurable keybindings.
+    // Only active when not in search mode and no submenu is open.
+    const toggleSetting = useCallback(() => {
+        const setting_0 = filteredSettingsItems[selectedIndex];
+        if (!setting_0 || !setting_0.onChange) {
+            return;
+        }
+        if (setting_0.type === 'boolean') {
+            isDirty.current = true;
+            setting_0.onChange(!setting_0.value);
+            if (setting_0.id === 'thinkingEnabled') {
+                const newValue = !setting_0.value;
+                const backToInitial = newValue === initialThinkingEnabled.current;
+                if (backToInitial) {
+                    setShowThinkingWarning(false);
+                }
+                else if (context.messages.some(m_0 => m_0.type === 'assistant')) {
+                    setShowThinkingWarning(true);
+                }
+            }
+            return;
+        }
+        if (setting_0.id === 'theme' || setting_0.id === 'model' || setting_0.id === 'teammateDefaultModel' || setting_0.id === 'showExternalIncludesDialog' || setting_0.id === 'outputStyle' || setting_0.id === 'language') {
+            // managedEnum items open a submenu — isDirty is set by the submenu's
+            // completion callback, not here (submenu may be cancelled).
+            switch (setting_0.id) {
+                case 'theme':
+                    setShowSubmenu('Theme');
+                    setTabsHidden(true);
+                    return;
+                case 'model':
+                    setShowSubmenu('Model');
+                    setTabsHidden(true);
+                    return;
+                case 'teammateDefaultModel':
+                    setShowSubmenu('TeammateModel');
+                    setTabsHidden(true);
+                    return;
+                case 'showExternalIncludesDialog':
+                    setShowSubmenu('ExternalIncludes');
+                    setTabsHidden(true);
+                    return;
+                case 'outputStyle':
+                    setShowSubmenu('OutputStyle');
+                    setTabsHidden(true);
+                    return;
+                case 'language':
+                    setShowSubmenu('Language');
+                    setTabsHidden(true);
+                    return;
+            }
+        }
+        if (setting_0.id === 'autoUpdatesChannel') {
+            if (autoUpdaterDisabledReason) {
+                // Auto-updates are disabled - show enable dialog instead
+                setShowSubmenu('EnableAutoUpdates');
+                setTabsHidden(true);
+                return;
+            }
+            const currentChannel = settingsData?.autoUpdatesChannel ?? 'latest';
+            if (currentChannel === 'latest') {
+                // Switching to stable - show downgrade dialog
+                setShowSubmenu('ChannelDowngrade');
+                setTabsHidden(true);
+            }
+            else {
+                // Switching to latest - just do it and clear minimumVersion
+                isDirty.current = true;
+                updateSettingsForSource('userSettings', {
+                    autoUpdatesChannel: 'latest',
+                    minimumVersion: undefined
+                });
+                setSettingsData(prev_24 => ({
+                    ...prev_24,
+                    autoUpdatesChannel: 'latest',
+                    minimumVersion: undefined
+                }));
+                logEvent('tengu_autoupdate_channel_changed', {
+                    channel: 'latest'
+                });
+            }
+            return;
+        }
+        if (setting_0.type === 'enum') {
+            isDirty.current = true;
+            const currentIndex = setting_0.options.indexOf(setting_0.value);
+            const nextIndex = (currentIndex + 1) % setting_0.options.length;
+            setting_0.onChange(setting_0.options[nextIndex]);
+            return;
+        }
+    }, [autoUpdaterDisabledReason, filteredSettingsItems, selectedIndex, settingsData?.autoUpdatesChannel, setTabsHidden]);
+    const moveSelection = (delta) => {
+        setShowThinkingWarning(false);
+        const newIndex_1 = Math.max(0, Math.min(filteredSettingsItems.length - 1, selectedIndex + delta));
+        setSelectedIndex(newIndex_1);
+        adjustScrollOffset(newIndex_1);
+    };
+    useKeybindings({
+        'select:previous': () => {
+            if (selectedIndex === 0) {
+                // ↑ at top enters search mode so users can type-to-filter after
+                // reaching the list boundary. Wheel-up (scroll:lineUp) clamps
+                // instead — overshoot shouldn't move focus away from the list.
+                setShowThinkingWarning(false);
+                setIsSearchMode(true);
+                setScrollOffset(0);
+            }
+            else {
+                moveSelection(-1);
+            }
+        },
+        'select:next': () => moveSelection(1),
+        // Wheel. ScrollKeybindingHandler's scroll:line* returns false (not
+        // consumed) when the ScrollBox content fits — which it always does
+        // here because the list is paginated (slice). The event falls through
+        // to this handler which navigates the list, clamping at boundaries.
+        'scroll:lineUp': () => moveSelection(-1),
+        'scroll:lineDown': () => moveSelection(1),
+        'select:accept': toggleSetting,
+        'settings:search': () => {
+            setIsSearchMode(true);
+            setSearchQuery('');
+        }
+    }, {
+        context: 'Settings',
+        isActive: showSubmenu === null && !isSearchMode && !headerFocused
+    });
+    // Combined key handling across search/list modes. Branch order mirrors
+    // the original useInput gate priority: submenu and header short-circuit
+    // first (their own handlers own input), then search vs. list.
+    const handleKeyDown = useCallback((e) => {
+        if (showSubmenu !== null)
+            return;
+        if (headerFocused)
+            return;
+        // Search mode: Esc clears then exits, Enter/↓ moves to the list.
+        if (isSearchMode) {
+            if (e.key === 'escape') {
+                e.preventDefault();
+                if (searchQuery.length > 0) {
+                    setSearchQuery('');
+                }
+                else {
+                    setIsSearchMode(false);
+                }
+                return;
+            }
+            if (e.key === 'return' || e.key === 'down' || e.key === 'wheeldown') {
+                e.preventDefault();
+                setIsSearchMode(false);
+                setSelectedIndex(0);
+                setScrollOffset(0);
+            }
+            return;
+        }
+        // List mode: left/right/tab cycle the selected option's value. These
+        // keys used to switch tabs; now they only do so when the tab row is
+        // explicitly focused (see headerFocused in Settings.tsx).
+        if (e.key === 'left' || e.key === 'right' || e.key === 'tab') {
+            e.preventDefault();
+            toggleSetting();
+            return;
+        }
+        // Fallback: printable characters (other than those bound to actions)
+        // enter search mode. Carve out j/k// — useKeybindings (still on the
+        // useInput path) consumes these via stopImmediatePropagation, but
+        // onKeyDown dispatches independently so we must skip them explicitly.
+        if (e.ctrl || e.meta)
+            return;
+        if (e.key === 'j' || e.key === 'k' || e.key === '/')
+            return;
+        if (e.key.length === 1 && e.key !== ' ') {
+            e.preventDefault();
+            setIsSearchMode(true);
+            setSearchQuery(e.key);
+        }
+    }, [showSubmenu, headerFocused, isSearchMode, searchQuery, setSearchQuery, toggleSetting]);
+    return _jsx(Box, { flexDirection: "column", width: "100%", tabIndex: 0, autoFocus: true, onKeyDown: handleKeyDown, children: showSubmenu === 'Theme' ? _jsxs(_Fragment, { children: [_jsx(ThemePicker, { onThemeSelect: setting_1 => {
+                        isDirty.current = true;
+                        setTheme(setting_1);
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                    }, onCancel: () => {
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                    }, hideEscToCancel: true, skipExitHandling: true }), _jsx(Box, { children: _jsx(Text, { dimColor: true, italic: true, children: _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "Enter", action: "seleccionar" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Confirmation", fallback: "Esc", description: "cancelar" })] }) }) })] }) : showSubmenu === 'Model' ? _jsxs(_Fragment, { children: [_jsx(ModelPicker, { initial: mainLoopModel, onSelect: (model_0, _effort) => {
+                        isDirty.current = true;
+                        onChangeMainModelConfig(model_0);
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                    }, onCancel: () => {
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                    }, showFastModeNotice: isFastModeEnabled() ? isFastMode && isFastModeSupportedByModel(mainLoopModel) && isFastModeAvailable() : false }), _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "Enter", action: "confirmar" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Confirmation", fallback: "Esc", description: "cancelar" })] }) })] }) : showSubmenu === 'TeammateModel' ? _jsxs(_Fragment, { children: [_jsx(ModelPicker, { initial: globalConfig.teammateDefaultModel ?? null, skipSettingsWrite: true, headerText: "Default model for newly spawned teammates. The leader can override via the tool call's model parameter.", onSelect: (model_1, _effort_0) => {
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                        // First-open-then-Enter from unset: picker highlights "Default"
+                        // (initial=null) and confirming would write null, silently
+                        // switching Opus-fallback → follow-leader. Treat as no-op.
+                        if (globalConfig.teammateDefaultModel === undefined && model_1 === null) {
+                            return;
+                        }
+                        isDirty.current = true;
+                        saveGlobalConfig(current_23 => current_23.teammateDefaultModel === model_1 ? current_23 : {
+                            ...current_23,
+                            teammateDefaultModel: model_1
+                        });
+                        setGlobalConfig({
+                            ...getGlobalConfig(),
+                            teammateDefaultModel: model_1
+                        });
+                        setChanges(prev_25 => ({
+                            ...prev_25,
+                            teammateDefaultModel: teammateModelDisplayString(model_1)
+                        }));
+                        logEvent('tengu_teammate_default_model_changed', {
+                            model: model_1
+                        });
+                    }, onCancel: () => {
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                    } }), _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "Enter", action: "confirmar" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Confirmation", fallback: "Esc", description: "cancelar" })] }) })] }) : showSubmenu === 'ExternalIncludes' ? _jsxs(_Fragment, { children: [_jsx(ClaudeMdExternalIncludesDialog, { onDone: () => {
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                    }, externalIncludes: getExternalClaudeMdIncludes(memoryFiles) }), _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "Enter", action: "confirmar" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Confirmation", fallback: "Esc", description: "disable external includes" })] }) })] }) : showSubmenu === 'OutputStyle' ? _jsxs(_Fragment, { children: [_jsx(OutputStylePicker, { initialStyle: currentOutputStyle, onComplete: style => {
+                        isDirty.current = true;
+                        setCurrentOutputStyle(style ?? DEFAULT_OUTPUT_STYLE_NAME);
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                        // Save to local settings
+                        updateSettingsForSource('localSettings', {
+                            outputStyle: style
+                        });
+                        void logEvent('tengu_output_style_changed', {
+                            style: (style ?? DEFAULT_OUTPUT_STYLE_NAME),
+                            source: 'config_panel',
+                            settings_source: 'localSettings'
+                        });
+                    }, onCancel: () => {
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                    } }), _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "Enter", action: "confirmar" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Confirmation", fallback: "Esc", description: "cancelar" })] }) })] }) : showSubmenu === 'Language' ? _jsxs(_Fragment, { children: [_jsx(LanguagePicker, { initialLanguage: currentLanguage, onComplete: language => {
+                        isDirty.current = true;
+                        setCurrentLanguage(language);
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                        // Save to user settings
+                        updateSettingsForSource('userSettings', {
+                            language
+                        });
+                        void logEvent('tengu_language_changed', {
+                            language: (language ?? 'default'),
+                            source: 'config_panel'
+                        });
+                    }, onCancel: () => {
+                        setShowSubmenu(null);
+                        setTabsHidden(false);
+                    } }), _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "Enter", action: "confirmar" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Settings", fallback: "Esc", description: "cancelar" })] }) })] }) : showSubmenu === 'EnableAutoUpdates' ? _jsx(Dialog, { title: "Enable Auto-Updates", onCancel: () => {
+                setShowSubmenu(null);
+                setTabsHidden(false);
+            }, hideBorder: true, hideInputGuide: true, children: autoUpdaterDisabledReason?.type !== 'config' ? _jsxs(_Fragment, { children: [_jsx(Text, { children: autoUpdaterDisabledReason?.type === 'env' ? 'Auto-updates are controlled by an environment variable and cannot be changed here.' : 'Auto-updates are disabled in development builds.' }), autoUpdaterDisabledReason?.type === 'env' && _jsxs(Text, { dimColor: true, children: ["Unset ", autoUpdaterDisabledReason.envVar, " to re-enable auto-updates."] })] }) : _jsx(Select, { options: [{
+                        label: 'Enable with latest channel',
+                        value: 'latest'
+                    }, {
+                        label: 'Enable with stable channel',
+                        value: 'stable'
+                    }], onChange: (channel) => {
+                    isDirty.current = true;
+                    setShowSubmenu(null);
+                    setTabsHidden(false);
+                    saveGlobalConfig(current_24 => ({
+                        ...current_24,
+                        autoUpdates: true
+                    }));
+                    setGlobalConfig({
+                        ...getGlobalConfig(),
+                        autoUpdates: true
+                    });
+                    updateSettingsForSource('userSettings', {
+                        autoUpdatesChannel: channel,
+                        minimumVersion: undefined
+                    });
+                    setSettingsData(prev_26 => ({
+                        ...prev_26,
+                        autoUpdatesChannel: channel,
+                        minimumVersion: undefined
+                    }));
+                    logEvent('tengu_autoupdate_enabled', {
+                        channel: channel
+                    });
+                } }) }) : showSubmenu === 'ChannelDowngrade' ? _jsx(ChannelDowngradeDialog, { currentVersion: MACRO.VERSION, onChoice: (choice) => {
+                setShowSubmenu(null);
+                setTabsHidden(false);
+                if (choice === 'cancel') {
+                    // User cancelled - don't change anything
+                    return;
+                }
+                isDirty.current = true;
+                // Switch to stable channel
+                const newSettings = {
+                    autoUpdatesChannel: 'stable'
+                };
+                if (choice === 'stay') {
+                    // User wants to stay on current version until stable catches up
+                    newSettings.minimumVersion = MACRO.VERSION;
+                }
+                updateSettingsForSource('userSettings', newSettings);
+                setSettingsData(prev_27 => ({
+                    ...prev_27,
+                    ...newSettings
+                }));
+                logEvent('tengu_autoupdate_channel_changed', {
+                    channel: 'stable',
+                    minimum_version_set: choice === 'stay'
+                });
+            } }) : _jsxs(Box, { flexDirection: "column", gap: 1, marginY: insideModal ? undefined : 1, children: [_jsx(SearchBox, { query: searchQuery, isFocused: isSearchMode && !headerFocused, isTerminalFocused: isTerminalFocused, cursorOffset: searchCursorOffset, placeholder: "Search settings\u2026" }), _jsx(Box, { flexDirection: "column", children: filteredSettingsItems.length === 0 ? _jsxs(Text, { dimColor: true, italic: true, children: ["No settings match \"", searchQuery, "\""] }) : _jsxs(_Fragment, { children: [scrollOffset > 0 && _jsxs(Text, { dimColor: true, children: [figures.arrowUp, " ", scrollOffset, " more above"] }), filteredSettingsItems.slice(scrollOffset, scrollOffset + maxVisible).map((setting_2, i) => {
+                                const actualIndex = scrollOffset + i;
+                                const isSelected = actualIndex === selectedIndex && !headerFocused && !isSearchMode;
+                                return _jsx(React.Fragment, { children: _jsxs(Box, { children: [_jsx(Box, { width: 44, children: _jsxs(Text, { color: isSelected ? 'suggestion' : undefined, children: [isSelected ? figures.pointer : ' ', ' ', setting_2.label] }) }), _jsx(Box, { children: setting_2.type === 'boolean' ? _jsxs(_Fragment, { children: [_jsx(Text, { color: isSelected ? 'suggestion' : undefined, children: setting_2.value.toString() }), showThinkingWarning && setting_2.id === 'thinkingEnabled' && _jsxs(Text, { color: "warning", children: [' ', "Changing thinking mode mid-conversation will increase latency and may reduce quality."] })] }) : setting_2.id === 'theme' ? _jsx(Text, { color: isSelected ? 'suggestion' : undefined, children: THEME_LABELS[setting_2.value.toString()] ?? setting_2.value.toString() }) : setting_2.id === 'notifChannel' ? _jsx(Text, { color: isSelected ? 'suggestion' : undefined, children: _jsx(NotifChannelLabel, { value: setting_2.value.toString() }) }) : setting_2.id === 'defaultPermissionMode' ? _jsx(Text, { color: isSelected ? 'suggestion' : undefined, children: permissionModeTitle(setting_2.value) }) : setting_2.id === 'autoUpdatesChannel' && autoUpdaterDisabledReason ? _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: isSelected ? 'suggestion' : undefined, children: "disabled" }), _jsxs(Text, { dimColor: true, children: ["(", formatAutoUpdaterDisabledReason(autoUpdaterDisabledReason), ")"] })] }) : _jsx(Text, { color: isSelected ? 'suggestion' : undefined, children: setting_2.value.toString() }) }, isSelected ? 'selected' : 'unselected')] }) }, setting_2.id);
+                            }), scrollOffset + maxVisible < filteredSettingsItems.length && _jsxs(Text, { dimColor: true, children: [figures.arrowDown, ' ', filteredSettingsItems.length - scrollOffset - maxVisible, ' ', "more below"] })] }) }), headerFocused ? _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "\u2190/\u2192 tab", action: "switch" }), _jsx(KeyboardShortcutHint, { shortcut: "\u2193", action: "return" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Settings", fallback: "Esc", description: "cerrar" })] }) }) : isSearchMode ? _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(Text, { children: "Type to filter" }), _jsx(KeyboardShortcutHint, { shortcut: "Enter/\u2193", action: "seleccionar" }), _jsx(KeyboardShortcutHint, { shortcut: "\u2191", action: "tabs" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Settings", fallback: "Esc", description: "clear" })] }) }) : _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(ConfigurableShortcutHint, { action: "select:accept", context: "Settings", fallback: "Space", description: "change" }), _jsx(ConfigurableShortcutHint, { action: "settings:close", context: "Settings", fallback: "Enter", description: "save" }), _jsx(ConfigurableShortcutHint, { action: "settings:search", context: "Settings", fallback: "/", description: "search" }), _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Settings", fallback: "Esc", description: "cancelar" })] }) })] }) });
+}
+function teammateModelDisplayString(value) {
+    if (value === undefined) {
+        return modelDisplayString(getHardcodedTeammateModelFallback());
+    }
+    if (value === null)
+        return "Default (leader's model)";
+    return modelDisplayString(value);
+}
+const THEME_LABELS = {
+    auto: 'Auto (match terminal)',
+    dark: 'Dark mode',
+    light: 'Light mode',
+    'dark-daltonized': 'Dark mode (colorblind-friendly)',
+    'light-daltonized': 'Light mode (colorblind-friendly)',
+    'dark-ansi': 'Dark mode (ANSI colors only)',
+    'light-ansi': 'Light mode (ANSI colors only)'
+};
+function NotifChannelLabel(t0) {
+    const $ = _c(4);
+    const { value } = t0;
+    switch (value) {
+        case "auto":
+            {
+                return "Auto";
+            }
+        case "iterm2":
+            {
+                let t1;
+                if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+                    t1 = _jsxs(Text, { children: ["iTerm2 ", _jsx(Text, { dimColor: true, children: "(OSC 9)" })] });
+                    $[0] = t1;
+                }
+                else {
+                    t1 = $[0];
+                }
+                return t1;
+            }
+        case "terminal_bell":
+            {
+                let t1;
+                if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+                    t1 = _jsxs(Text, { children: ["Terminal Bell ", _jsx(Text, { dimColor: true, children: "(\\a)" })] });
+                    $[1] = t1;
+                }
+                else {
+                    t1 = $[1];
+                }
+                return t1;
+            }
+        case "kitty":
+            {
+                let t1;
+                if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+                    t1 = _jsxs(Text, { children: ["Kitty ", _jsx(Text, { dimColor: true, children: "(OSC 99)" })] });
+                    $[2] = t1;
+                }
+                else {
+                    t1 = $[2];
+                }
+                return t1;
+            }
+        case "ghostty":
+            {
+                let t1;
+                if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+                    t1 = _jsxs(Text, { children: ["Ghostty ", _jsx(Text, { dimColor: true, children: "(OSC 777)" })] });
+                    $[3] = t1;
+                }
+                else {
+                    t1 = $[3];
+                }
+                return t1;
+            }
+        case "iterm2_with_bell":
+            {
+                return "iTerm2 w/ Bell";
+            }
+        case "notifications_disabled":
+            {
+                return "Disabled";
+            }
+        default:
+            {
+                return value;
+            }
+    }
+}