@xelauvas/xela-cli 0.1.0

package/src/components/Settings/Config.tsx

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