components/Settings/Config.tsx

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.autoCompactEnab