diff --git a/apps/desktop/src-tauri/src/core/system/shortcut.rs b/apps/desktop/src-tauri/src/core/system/shortcut.rs
index 83baa11e..2f9155d0 100644
--- a/apps/desktop/src-tauri/src/core/system/shortcut.rs
+++ b/apps/desktop/src-tauri/src/core/system/shortcut.rs
@@ -49,20 +49,28 @@ pub fn register_global_shortcut<R: Runtime>(
 ) -> Result<(), String> {
     let new_shortcut = parse_shortcut(&shortcut)?;
 
-    // 注销旧快捷键
-    if let Ok(current) = CURRENT_SHORTCUT.lock() {
-        if let Some(old_shortcut) = *current {
-            let _ = app.global_shortcut().unregister(old_shortcut);
+    let old_shortcut = CURRENT_SHORTCUT.lock().ok().and_then(|current| *current);
+    if let Some(old_shortcut) = old_shortcut {
+        if let Err(error) = app.global_shortcut().unregister(old_shortcut) {
+            let message = format!("Failed to unregister previous shortcut: {}", error);
+            if let Ok(mut status) = REGISTRATION_STATUS.lock() {
+                *status = (true, Some(message.clone()));
+            }
+            return Err(message);
         }
     }
 
-    // 尝试注册新快捷键
     let result = app
         .global_shortcut()
         .register(new_shortcut)
         .map_err(|e| format!("Failed to register shortcut: {}", e));
 
-    // 更新状态
+    if result.is_err() {
+        if let Some(old_shortcut) = old_shortcut {
+            let _ = app.global_shortcut().register(old_shortcut);
+        }
+    }
+
     match result {
         Ok(_) => {
             if let Ok(mut current) = CURRENT_SHORTCUT.lock() {
diff --git a/apps/desktop/src/components/CustomSelect.vue b/apps/desktop/src/components/CustomSelect.vue
index e70bb2b5..c67047cb 100644
--- a/apps/desktop/src/components/CustomSelect.vue
+++ b/apps/desktop/src/components/CustomSelect.vue
@@ -8,7 +8,7 @@
         SelectTrigger,
         SelectValue,
     } from '@components/ui/select';
-    import type { AcceptableValue } from 'reka-ui';
+    import type { AcceptableValue, SelectTriggerProps } from 'reka-ui';
     import { computed, ref, useAttrs } from 'vue';
 
     import { type MessageKey, t, tt } from '@/i18n';
@@ -29,22 +29,48 @@
         placeholderKey?: MessageKey;
         disabled?: boolean;
         protectOptionText?: boolean;
+        open?: boolean;
+        displayLabel?: string;
+        triggerTestId?: string;
+        contentTestId?: string;
+        optionTestIdPrefix?: string;
+        disablePortal?: boolean;
+        triggerAs?: SelectTriggerProps['as'];
     }
 
     interface Emits {
         (e: 'update:modelValue', value: T): void;
+        (e: 'update:open', value: boolean): void;
+        (e: 'focus', event: FocusEvent): void;
+        (e: 'blur', event: FocusEvent): void;
     }
 
     const props = withDefaults(defineProps<Props>(), {
         placeholder: '',
         disabled: false,
         protectOptionText: false,
+        open: undefined,
+        displayLabel: '',
+        triggerTestId: '',
+        contentTestId: '',
+        optionTestIdPrefix: '',
+        disablePortal: false,
+        triggerAs: 'button',
     });
 
     const emit = defineEmits<Emits>();
+    defineSlots<{
+        trigger?(props: {
+            option: Option | undefined;
+            open: boolean;
+            displayLabel: string;
+        }): unknown;
+    }>();
     const attrs = useAttrs();
 
-    const isOpen = ref(false);
+    const localOpen = ref(false);
+
+    const isOpen = computed(() => props.open ?? localOpen.value);
 
     const selectedOption = computed(() => {
         return props.options.find((opt) => opt.value === props.modelValue);
@@ -66,6 +92,11 @@
             selectOption(value as T);
         }
     };
+
+    const updateOpen = (open: boolean) => {
+        localOpen.value = open;
+        emit('update:open', open);
+    };
 </script>
 
 <template>
@@ -74,7 +105,7 @@
         :disabled="disabled"
         :open="isOpen"
         @update:model-value="handleSelectValue"
-        @update:open="isOpen = $event"
+        @update:open="updateOpen"
     >
         <SelectTrigger
             v-bind="attrs"
@@ -86,36 +117,55 @@
             }"
             :icon-class="isOpen ? 'rotate-180' : ''"
             :disabled="disabled"
+            :as="triggerAs"
+            :data-testid="triggerTestId || undefined"
+            @focus="emit('focus', $event)"
+            @blur="emit('blur', $event)"
         >
-            <template v-if="selectedOption">
-                <div class="flex min-w-0 items-center gap-2">
-                    <img
-                        v-if="selectedOption.iconSrc"
-                        :src="selectedOption.iconSrc"
-                        :alt="selectedOption.label"
-                        class="h-4 w-4 shrink-0 rounded-sm object-contain"
-                        :data-no-i18n="protectOptionText ? 'true' : undefined"
-                        :translate="protectOptionText ? 'no' : undefined"
-                    />
-                    <span
-                        class="line-clamp-1"
-                        :data-no-i18n="protectOptionText ? 'true' : undefined"
-                        :translate="protectOptionText ? 'no' : undefined"
-                    >
-                        {{ selectedOption.label }}
-                    </span>
-                </div>
-            </template>
-            <SelectValue v-else :placeholder="resolvedPlaceholder" />
+            <slot
+                name="trigger"
+                :option="selectedOption"
+                :open="isOpen"
+                :display-label="displayLabel"
+            >
+                <template v-if="displayLabel">
+                    <span class="line-clamp-1">{{ displayLabel }}</span>
+                </template>
+                <template v-else-if="selectedOption">
+                    <div class="flex min-w-0 items-center gap-2">
+                        <img
+                            v-if="selectedOption.iconSrc"
+                            :src="selectedOption.iconSrc"
+                            :alt="selectedOption.label"
+                            class="h-4 w-4 shrink-0 rounded-sm object-contain"
+                            :data-no-i18n="protectOptionText ? 'true' : undefined"
+                            :translate="protectOptionText ? 'no' : undefined"
+                        />
+                        <span
+                            class="line-clamp-1"
+                            :data-no-i18n="protectOptionText ? 'true' : undefined"
+                            :translate="protectOptionText ? 'no' : undefined"
+                        >
+                            {{ selectedOption.label }}
+                        </span>
+                    </div>
+                </template>
+                <SelectValue v-else :placeholder="resolvedPlaceholder" />
+            </slot>
         </SelectTrigger>
 
         <SelectContent
+            :data-testid="contentTestId || undefined"
+            :disable-portal="disablePortal"
             class="w-[var(--reka-select-trigger-width)] rounded-[10px] border border-gray-200 bg-white py-1 shadow-lg"
         >
             <SelectItem
                 v-for="option in options"
                 :key="option.value"
                 :value="option.value"
+                :data-testid="
+                    optionTestIdPrefix ? `${optionTestIdPrefix}${option.value}` : undefined
+                "
                 class="flex w-full px-3 py-2 text-left text-sm transition-colors hover:bg-gray-100"
                 :class="{
                     'bg-primary-50 text-primary-600': option.value === modelValue,
diff --git a/apps/desktop/src/components/appIconMap.ts b/apps/desktop/src/components/appIconMap.ts
index 779ef1cf..26d6e286 100644
--- a/apps/desktop/src/components/appIconMap.ts
+++ b/apps/desktop/src/components/appIconMap.ts
@@ -40,6 +40,7 @@ import IconShow from '~icons/bx/show';
 import IconStop from '~icons/bx/stop';
 import IconTrash from '~icons/bx/trash';
 import IconTrashAlt from '~icons/bx/trash-alt';
+import IconUndo from '~icons/bx/undo';
 import IconWrench from '~icons/bx/wrench';
 import IconX from '~icons/bx/x';
 import IconXCircle from '~icons/bx/x-circle';
@@ -85,6 +86,7 @@ export const appIconMap = {
     stop: IconStop,
     tool: IconBriefcase,
     trash: IconTrash,
+    undo: IconUndo,
     bug: IconBug,
     wrench: IconWrench,
     x: IconX,
diff --git a/apps/desktop/src/components/ui/select/SelectContent.vue b/apps/desktop/src/components/ui/select/SelectContent.vue
index bcba5ec8..a2619532 100644
--- a/apps/desktop/src/components/ui/select/SelectContent.vue
+++ b/apps/desktop/src/components/ui/select/SelectContent.vue
@@ -8,12 +8,17 @@
         useForwardPropsEmits,
     } from 'reka-ui';
     import type { HTMLAttributes } from 'vue';
-    import { computed } from 'vue';
+    import { computed, useAttrs } from 'vue';
 
     import { cn } from '@/lib/utils';
 
+    defineOptions({
+        inheritAttrs: false,
+    });
+
     interface Props extends SelectContentProps {
         class?: HTMLAttributes['class'];
+        disablePortal?: boolean;
     }
 
     const props = withDefaults(defineProps<Props>(), {
@@ -23,23 +28,30 @@
         align: 'start',
         sideOffset: 4,
         avoidCollisions: true,
+        disablePortal: false,
     });
 
     const emits = defineEmits<SelectContentEmits>();
+    const attrs = useAttrs();
 
     const delegatedProps = computed(() => {
         const delegated = { ...props };
         Reflect.deleteProperty(delegated, 'class');
+        Reflect.deleteProperty(delegated, 'disablePortal');
         return delegated;
     });
 
     const forwarded = useForwardPropsEmits(delegatedProps, emits);
+    const contentProps = computed(() => ({
+        ...forwarded.value,
+        ...attrs,
+    }));
 </script>
 
 <template>
-    <SelectPortal>
+    <SelectPortal :disabled="disablePortal">
         <SelectContent
-            v-bind="forwarded"
+            v-bind="contentProps"
             :class="
                 cn(
                     'relative z-50 min-w-[8rem] overflow-hidden rounded-lg border border-gray-200 bg-white py-1 text-gray-900 shadow-lg',
diff --git a/apps/desktop/src/config/searchKeybindings.ts b/apps/desktop/src/config/searchKeybindings.ts
new file mode 100644
index 00000000..80662a61
--- /dev/null
+++ b/apps/desktop/src/config/searchKeybindings.ts
@@ -0,0 +1,192 @@
+import type { MessageKey } from '@/i18n';
+import {
+    hasCommandModifier,
+    isModifierlessFunctionShortcut,
+    isReservedLocalShortcut,
+    normalizeLocalShortcutString,
+} from '@/utils/shortcuts';
+
+export const SEARCH_KEYBINDING_ACTION_IDS = [
+    'search.history.open',
+    'search.input.focus',
+    'search.session.new',
+    'search.session.reopenLastClosed',
+    'search.model.toggle',
+    'search.window.pin',
+    'search.window.maximize',
+    'search.settings.open',
+] as const;
+
+export type SearchKeybindingActionId = (typeof SEARCH_KEYBINDING_ACTION_IDS)[number];
+
+export interface SearchKeybindingDefinition {
+    id: SearchKeybindingActionId;
+    labelKey: MessageKey;
+    descriptionKey: MessageKey;
+    defaultShortcut: string | null;
+    allowDisable: boolean;
+    allowModifierlessFunctionShortcut: boolean;
+}
+
+export type SearchKeybindings = Record<SearchKeybindingActionId, string | null>;
+
+export const SEARCH_KEYBINDING_DEFINITIONS: SearchKeybindingDefinition[] = [
+    {
+        id: 'search.history.open',
+        labelKey: 'settings.general.searchActions.history',
+        descriptionKey: 'settings.general.searchActionDescriptions.history',
+        defaultShortcut: 'Mod+H',
+        allowDisable: true,
+        allowModifierlessFunctionShortcut: true,
+    },
+    {
+        id: 'search.input.focus',
+        labelKey: 'settings.general.searchActions.focusInput',
+        descriptionKey: 'settings.general.searchActionDescriptions.focusInput',
+        defaultShortcut: 'Mod+L',
+        allowDisable: true,
+        allowModifierlessFunctionShortcut: true,
+    },
+    {
+        id: 'search.session.new',
+        labelKey: 'settings.general.searchActions.newSession',
+        descriptionKey: 'settings.general.searchActionDescriptions.newSession',
+        defaultShortcut: 'Mod+N',
+        allowDisable: true,
+        allowModifierlessFunctionShortcut: true,
+    },
+    {
+        id: 'search.session.reopenLastClosed',
+        labelKey: 'settings.general.searchActions.reopenLastClosedSession',
+        descriptionKey: 'settings.general.searchActionDescriptions.reopenLastClosedSession',
+        defaultShortcut: 'Mod+Shift+T',
+        allowDisable: true,
+        allowModifierlessFunctionShortcut: true,
+    },
+    {
+        id: 'search.model.toggle',
+        labelKey: 'settings.general.searchActions.modelToggle',
+        descriptionKey: 'settings.general.searchActionDescriptions.modelToggle',
+        defaultShortcut: 'Mod+M',
+        allowDisable: true,
+        allowModifierlessFunctionShortcut: true,
+    },
+    {
+        id: 'search.window.pin',
+        labelKey: 'settings.general.searchActions.windowPin',
+        descriptionKey: 'settings.general.searchActionDescriptions.windowPin',
+        defaultShortcut: 'Mod+P',
+        allowDisable: true,
+        allowModifierlessFunctionShortcut: true,
+    },
+    {
+        id: 'search.window.maximize',
+        labelKey: 'settings.general.searchActions.windowMaximize',
+        descriptionKey: 'settings.general.searchActionDescriptions.windowMaximize',
+        defaultShortcut: 'F11',
+        allowDisable: true,
+        allowModifierlessFunctionShortcut: true,
+    },
+    {
+        id: 'search.settings.open',
+        labelKey: 'settings.general.searchActions.openSettings',
+        descriptionKey: 'settings.general.searchActionDescriptions.openSettings',
+        defaultShortcut: 'Mod+,',
+        allowDisable: true,
+        allowModifierlessFunctionShortcut: false,
+    },
+];
+
+const SEARCH_KEYBINDING_DEFINITION_MAP = new Map(
+    SEARCH_KEYBINDING_DEFINITIONS.map((definition) => [definition.id, definition])
+);
+
+const SEARCH_KEYBINDING_ACTION_ID_SET = new Set<string>(SEARCH_KEYBINDING_ACTION_IDS);
+
+export function isSearchKeybindingActionId(value: string): value is SearchKeybindingActionId {
+    return SEARCH_KEYBINDING_ACTION_ID_SET.has(value);
+}
+
+export function getSearchKeybindingDefinition(
+    actionId: SearchKeybindingActionId
+): SearchKeybindingDefinition {
+    const definition = SEARCH_KEYBINDING_DEFINITION_MAP.get(actionId);
+    if (!definition) {
+        throw new Error(`Unknown search keybinding action: ${actionId}`);
+    }
+    return definition;
+}
+
+export function createDefaultSearchKeybindings(): SearchKeybindings {
+    return SEARCH_KEYBINDING_DEFINITIONS.reduce<SearchKeybindings>((accumulator, definition) => {
+        accumulator[definition.id] = definition.defaultShortcut;
+        return accumulator;
+    }, {} as SearchKeybindings);
+}
+
+export function normalizeSearchKeybindings(value: unknown): SearchKeybindings {
+    const defaults = createDefaultSearchKeybindings();
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return defaults;
+    }
+
+    const candidates = value as Record<string, unknown>;
+
+    // First pass: resolve each action's desired shortcut (validated custom value,
+    // explicit disable, or its default) without considering conflicts yet.
+    const resolved = new Map<SearchKeybindingActionId, string | null>();
+    for (const definition of SEARCH_KEYBINDING_DEFINITIONS) {
+        const candidate = candidates[definition.id];
+
+        if (candidate === null && definition.allowDisable) {
+            resolved.set(definition.id, null);
+            continue;
+        }
+
+        if (typeof candidate === 'string') {
+            const shortcut = normalizeLocalShortcutString(candidate);
+            if (shortcut) {
+                const allowsModifierlessFunction =
+                    definition.allowModifierlessFunctionShortcut &&
+                    isModifierlessFunctionShortcut(shortcut);
+                const passesModifierPolicy =
+                    hasCommandModifier(shortcut) || allowsModifierlessFunction;
+                if (passesModifierPolicy && !isReservedLocalShortcut(shortcut)) {
+                    resolved.set(definition.id, shortcut);
+                    continue;
+                }
+            }
+        }
+
+        resolved.set(definition.id, defaults[definition.id]);
+    }
+
+    // Second pass: resolve conflicts deterministically (first action in
+    // definition order keeps the shortcut). This lets clean swaps survive
+    // instead of both sides colliding with the other's default.
+    const result = createDefaultSearchKeybindings();
+    const usedShortcuts = new Set<string>();
+    for (const definition of SEARCH_KEYBINDING_DEFINITIONS) {
+        const desired = resolved.get(definition.id) ?? null;
+        if (desired === null) {
+            result[definition.id] = null;
+            continue;
+        }
+
+        if (!usedShortcuts.has(desired)) {
+            usedShortcuts.add(desired);
+            result[definition.id] = desired;
+            continue;
+        }
+
+        const fallback = normalizeLocalShortcutString(definition.defaultShortcut);
+        if (fallback && !usedShortcuts.has(fallback)) {
+            usedShortcuts.add(fallback);
+            result[definition.id] = fallback;
+        } else {
+            result[definition.id] = null;
+        }
+    }
+
+    return result;
+}
diff --git a/apps/desktop/src/i18n/messages.ts b/apps/desktop/src/i18n/messages.ts
index 1d1c41fb..2479d1ef 100644
--- a/apps/desktop/src/i18n/messages.ts
+++ b/apps/desktop/src/i18n/messages.ts
@@ -75,9 +75,9 @@ const zhCNMessages = {
     'settings.general.title': '常规设置',
     'settings.general.description': '配置应用的基本行为和外观',
     'settings.general.shortcuts': '快捷键',
-    'settings.general.shortcutsDescription': '设置桌面唤起 TouchAI 的全局入口',
     'settings.general.globalShortcut': '全局快捷键',
     'settings.general.activationShortcut': '唤起快捷键',
+    'settings.general.activationShortcutDescription': '设置呼出 TouchAI 的全局快捷键。',
     'settings.general.shortcutPlaceholder': '点击输入框设置快捷键',
     'settings.general.shortcutCapturePrompt': '请按下快捷键...',
     'settings.general.shortcutRegistrationFailed': '快捷键注册失败，可能已被其他应用占用',
@@ -87,6 +87,49 @@ const zhCNMessages = {
         '点击输入框后按下您想要设置的快捷键组合。支持的修饰键：Ctrl、Alt、Shift',
     'settings.general.winKeyUnsupported': '不支持 Win 键组合，请使用 Ctrl、Alt、Shift',
     'settings.general.shortcutSaved': '快捷键保存成功',
+    'settings.general.noShortcut': '无',
+    'settings.general.globalShortcutGroup': '全局唤起',
+    'settings.general.searchShortcutsDescription':
+        '自定义搜索窗口内的命令型快捷键，不会影响输入导航与全局唤起。',
+    'settings.general.searchShortcutGroups.session': '会话',
+    'settings.general.searchShortcutGroups.inputAndRequest': '输入与请求',
+    'settings.general.searchShortcutGroups.window': '窗口',
+    'settings.general.searchActions.history': '打开会话历史',
+    'settings.general.searchActions.focusInput': '聚焦输入框',
+    'settings.general.searchActions.newSession': '开始新会话',
+    'settings.general.searchActions.reopenLastClosedSession': '打开最近关闭的会话',
+    'settings.general.searchActions.modelToggle': '切换模型选择',
+    'settings.general.searchActions.windowPin': '切换窗口置顶',
+    'settings.general.searchActions.windowMaximize': '切换窗口最大化',
+    'settings.general.searchActions.openSettings': '打开设置',
+    'settings.general.searchActions.cancelRequest': '取消当前请求',
+    'settings.general.fixedSearchShortcuts': '固定快捷键',
+    'settings.general.fixedSearchActions.submitRequest': '发送请求',
+    'settings.general.fixedSearchActions.newLine': '换行',
+    'settings.general.fixedSearchActions.previousInputHistory': '上一条会话历史',
+    'settings.general.fixedSearchActions.nextInputHistory': '下一条会话历史',
+    'settings.general.searchActions.clearAll': '清空草稿与上下文',
+    'settings.general.searchActionDescriptions.history': '快速打开会话历史列表。',
+    'settings.general.searchActionDescriptions.focusInput': '将焦点移动到输入框。',
+    'settings.general.searchActionDescriptions.newSession': '立即开始一段新会话。',
+    'settings.general.searchActionDescriptions.reopenLastClosedSession': '重新打开最近关闭的会话。',
+    'settings.general.searchActionDescriptions.modelToggle': '展开或收起模型选择。',
+    'settings.general.searchActionDescriptions.windowPin': '切换搜索窗口置顶状态。',
+    'settings.general.searchActionDescriptions.windowMaximize': '切换搜索窗口最大化。',
+    'settings.general.searchActionDescriptions.openSettings': '快速打开设置窗口。',
+    'settings.general.searchActionDescriptions.cancelRequest': '停止当前生成或工具执行。',
+    'settings.general.searchActionDescriptions.submitRequest': '发送当前输入内容。',
+    'settings.general.searchActionDescriptions.newLine': '在输入框中插入换行。',
+    'settings.general.searchActionDescriptions.previousInputHistory': '查看上一条输入记录。',
+    'settings.general.searchActionDescriptions.nextInputHistory': '查看下一条输入记录。',
+    'settings.general.searchShortcuts.errors.modifierRequired':
+        '快捷键需要包含 Ctrl、Alt 或 Cmd，或使用允许的功能键',
+    'settings.general.searchShortcuts.errors.reserved':
+        '该快捷键保留给输入/导航行为，请选择其他组合',
+    'settings.general.searchShortcuts.errors.duplicate': '该快捷键已被“{action}”使用，请换一个组合',
+    'settings.general.searchShortcuts.errors.globalConflict':
+        '该快捷键与全局唤起快捷键冲突，请换一个组合',
+    'settings.general.searchShortcuts.fixedUnavailable': '暂不支持修改该快捷键',
     'settings.general.saveShortcutFailed': '保存快捷键到数据库失败',
     'settings.general.loadSettingsFailed': '加载设置失败',
     'settings.general.saveStartOnBootFailed': '保存开机自启动设置失败',
@@ -989,9 +1032,10 @@ const enUSMessages: Record<keyof typeof zhCNMessages, string> = {
     'settings.general.title': 'General settings',
     'settings.general.description': 'Configure basic app behavior and appearance',
     'settings.general.shortcuts': 'Shortcuts',
-    'settings.general.shortcutsDescription': 'Set the global entry point for opening TouchAI',
     'settings.general.globalShortcut': 'Global shortcut',
     'settings.general.activationShortcut': 'Activation shortcut',
+    'settings.general.activationShortcutDescription':
+        'Set the global shortcut used to open TouchAI.',
     'settings.general.shortcutPlaceholder': 'Click the field to set a shortcut',
     'settings.general.shortcutCapturePrompt': 'Press a shortcut...',
     'settings.general.shortcutRegistrationFailed':
@@ -1003,6 +1047,57 @@ const enUSMessages: Record<keyof typeof zhCNMessages, string> = {
     'settings.general.winKeyUnsupported':
         'Win key combinations are not supported. Use Ctrl, Alt, or Shift.',
     'settings.general.shortcutSaved': 'Shortcut saved',
+    'settings.general.noShortcut': 'None',
+    'settings.general.globalShortcutGroup': 'Global activation',
+    'settings.general.searchShortcutsDescription':
+        'Customize command shortcuts inside the search window without changing typing, navigation, or the global activation shortcut.',
+    'settings.general.searchShortcutGroups.session': 'Session',
+    'settings.general.searchShortcutGroups.inputAndRequest': 'Input and request',
+    'settings.general.searchShortcutGroups.window': 'Window',
+    'settings.general.searchActions.history': 'Open session history',
+    'settings.general.searchActions.focusInput': 'Focus input',
+    'settings.general.searchActions.newSession': 'Start new session',
+    'settings.general.searchActions.reopenLastClosedSession': 'Open most recently closed session',
+    'settings.general.searchActions.modelToggle': 'Toggle model picker',
+    'settings.general.searchActions.windowPin': 'Toggle window pin',
+    'settings.general.searchActions.windowMaximize': 'Toggle window maximize',
+    'settings.general.searchActions.openSettings': 'Open settings',
+    'settings.general.searchActions.cancelRequest': 'Cancel current request',
+    'settings.general.fixedSearchShortcuts': 'Fixed shortcuts',
+    'settings.general.fixedSearchActions.submitRequest': 'Submit request',
+    'settings.general.fixedSearchActions.newLine': 'Insert new line',
+    'settings.general.fixedSearchActions.previousInputHistory': 'Previous input history',
+    'settings.general.fixedSearchActions.nextInputHistory': 'Next input history',
+    'settings.general.searchActions.clearAll': 'Clear draft and context',
+    'settings.general.searchActionDescriptions.history': 'Quickly open the session history list.',
+    'settings.general.searchActionDescriptions.focusInput': 'Move focus to the input field.',
+    'settings.general.searchActionDescriptions.newSession': 'Start a new session immediately.',
+    'settings.general.searchActionDescriptions.reopenLastClosedSession':
+        'Reopen the most recently closed session.',
+    'settings.general.searchActionDescriptions.modelToggle': 'Open or close the model picker.',
+    'settings.general.searchActionDescriptions.windowPin':
+        'Toggle whether the search window stays on top.',
+    'settings.general.searchActionDescriptions.windowMaximize':
+        'Toggle the search window maximized state.',
+    'settings.general.searchActionDescriptions.openSettings': 'Quickly open the settings window.',
+    'settings.general.searchActionDescriptions.cancelRequest':
+        'Stop the current generation or tool run.',
+    'settings.general.searchActionDescriptions.submitRequest': 'Send the current input.',
+    'settings.general.searchActionDescriptions.newLine': 'Insert a new line in the input field.',
+    'settings.general.searchActionDescriptions.previousInputHistory':
+        'Show the previous input history item.',
+    'settings.general.searchActionDescriptions.nextInputHistory':
+        'Show the next input history item.',
+    'settings.general.searchShortcuts.errors.modifierRequired':
+        'A shortcut must include Ctrl, Alt, or Cmd, or use an allowed function key',
+    'settings.general.searchShortcuts.errors.reserved':
+        'This shortcut is reserved for typing or navigation. Choose another combination.',
+    'settings.general.searchShortcuts.errors.duplicate':
+        'This shortcut is already used by "{action}". Choose another combination.',
+    'settings.general.searchShortcuts.errors.globalConflict':
+        'This shortcut conflicts with the global activation shortcut. Choose another combination.',
+    'settings.general.searchShortcuts.fixedUnavailable':
+        'Changing this shortcut is not supported yet.',
     'settings.general.saveShortcutFailed': 'Failed to save shortcut to database',
     'settings.general.loadSettingsFailed': 'Failed to load settings',
     'settings.general.saveStartOnBootFailed': 'Failed to save start-on-boot setting',
diff --git a/apps/desktop/src/stores/setting/index.ts b/apps/desktop/src/stores/setting/index.ts
index 4eb1a9ef..c8adb078 100644
--- a/apps/desktop/src/stores/setting/index.ts
+++ b/apps/desktop/src/stores/setting/index.ts
@@ -1,6 +1,11 @@
 import { computed, type ComputedRef, type Ref } from 'vue';
 
 import type { AppUpdateChannel } from '@/config/appUpdate';
+import {
+    createDefaultSearchKeybindings,
+    normalizeSearchKeybindings,
+    type SearchKeybindings,
+} from '@/config/searchKeybindings';
 import type { SearchWindowDefaultSize, SearchWindowSizePreset } from '@/config/searchWindow';
 import type { AppLocale } from '@/i18n';
 import type { BrowserSettingsConfig } from '@/stores/setting/sections/browser';
@@ -23,11 +28,12 @@ import {
 } from './general';
 
 export type OutputScrollBehavior = 'follow_output' | 'stay_position' | 'jump_to_top';
-export type GeneralSettingKey = GeneralScalarSettingKey | JsonSettingsKey;
-export type GeneralSettingValue = string | number | boolean | null;
+export type GeneralSettingKey = GeneralScalarSettingKey | 'search_keybindings' | JsonSettingsKey;
+export type GeneralSettingValue = string | number | boolean | SearchKeybindings | null;
 
 export interface GeneralSettingsData {
     globalShortcut: string;
+    searchKeybindings: SearchKeybindings;
     startOnBoot: boolean;
     startMinimized: boolean;
     outputScrollBehavior: OutputScrollBehavior;
@@ -50,12 +56,13 @@ type GeneralSettingFieldValue =
     | string
     | boolean
     | null
+    | SearchKeybindings
     | BrowserSettingsConfig
     | SearchSettingsConfig;
 
 type GeneralScalarSettingStateKey = Exclude<
     keyof GeneralSettingsData,
-    'browserSettings' | 'searchSettings' | 'searchWindowDefaultSize'
+    'browserSettings' | 'searchKeybindings' | 'searchSettings' | 'searchWindowDefaultSize'
 >;
 type GeneralPersistedSettingStateKey = Exclude<
     keyof GeneralSettingsData,
@@ -80,11 +87,13 @@ export interface GeneralSettingDefinition {
     serializeValue(value: GeneralSettingFieldValue): string;
     eventValue(value: GeneralSettingFieldValue): GeneralSettingValue;
     persistBeforeApply?: boolean;
+    shouldRewritePersisted?(raw: string | null): boolean;
 }
 
 export interface GeneralSettingsComputedRefs {
     outputScrollBehavior: ComputedRef<OutputScrollBehavior>;
     globalShortcut: ComputedRef<string>;
+    searchKeybindings: ComputedRef<SearchKeybindings>;
     searchWindowSizePreset: ComputedRef<SearchWindowSizePreset>;
     searchWindowDefaultSize: ComputedRef<SearchWindowDefaultSize>;
     language: ComputedRef<AppLocale>;
@@ -97,6 +106,7 @@ export interface GeneralSettingsComputedRefs {
 
 export interface GeneralSettingUpdaters {
     updateGlobalShortcut(shortcut: string): Promise<void>;
+    updateSearchKeybindings(searchKeybindings: SearchKeybindings): Promise<void>;
     updateStartOnBoot(enabled: boolean): Promise<void>;
     updateStartMinimized(enabled: boolean): Promise<void>;
     updateOutputScrollBehavior(mode: OutputScrollBehavior): Promise<void>;
@@ -139,6 +149,7 @@ export interface GeneralSettingUpdaterBinding {
 
 const DEFAULT_GENERAL_SETTINGS: GeneralSettingsData = {
     ...GENERAL_SETTINGS_DEFAULTS,
+    searchKeybindings: createDefaultSearchKeybindings(),
 } as GeneralSettingsData;
 
 function assignGeneralSettingField(
@@ -244,22 +255,76 @@ function scalarUpdaterBindings(
     );
 }
 
+function parsePersistedSearchKeybindings(value: string | null): SearchKeybindings {
+    if (!value) {
+        return createDefaultSearchKeybindings();
+    }
+
+    try {
+        return normalizeSearchKeybindings(JSON.parse(value));
+    } catch {
+        return createDefaultSearchKeybindings();
+    }
+}
+
+function shouldRewritePersistedSearchKeybindings(value: string | null): boolean {
+    if (!value) {
+        return false;
+    }
+
+    try {
+        const parsed = JSON.parse(value);
+        return (
+            parsed &&
+            typeof parsed === 'object' &&
+            !Array.isArray(parsed) &&
+            ('search.request.cancel' in parsed || 'search.draft.clearAll' in parsed)
+        );
+    } catch {
+        return false;
+    }
+}
+
+const SEARCH_KEYBINDINGS_SETTING_DEFINITION: GeneralSettingDefinition = {
+    key: 'search_keybindings',
+    parsePersisted: parsePersistedSearchKeybindings,
+    parseUpdate: (value) => normalizeSearchKeybindings(value),
+    apply: (target, value) => {
+        target.searchKeybindings = {
+            ...(value as SearchKeybindings),
+        };
+    },
+    read: (source) => source.searchKeybindings,
+    serializeValue: (value) => JSON.stringify(normalizeSearchKeybindings(value)),
+    eventValue: (value) => ({
+        ...normalizeSearchKeybindings(value),
+    }),
+    shouldRewritePersisted: shouldRewritePersistedSearchKeybindings,
+};
+
 export const JSON_GENERAL_SETTING_DEFINITIONS: readonly GeneralSettingDefinition[] =
     JSON_SETTINGS_SECTIONS.map(jsonSettingDefinition);
 
 export const GENERAL_SETTING_DEFINITIONS: readonly GeneralSettingDefinition[] = [
     ...GENERAL_SCALAR_SETTING_SPECS.map(scalarSettingDefinition),
+    SEARCH_KEYBINDINGS_SETTING_DEFINITION,
     ...JSON_GENERAL_SETTING_DEFINITIONS,
 ];
 
 export const GENERAL_SETTING_COMPUTED_BINDINGS: readonly GeneralSettingComputedBinding[] = [
     ...scalarComputedBindings(GENERAL_SCALAR_SETTING_SPECS),
+    { exposedName: 'searchKeybindings', stateKey: 'searchKeybindings' },
     ...GENERAL_DERIVED_COMPUTED_BINDINGS,
     ...JSON_SETTINGS_SECTIONS.map(jsonComputedBinding),
 ];
 
 export const GENERAL_SETTING_UPDATER_BINDINGS: readonly GeneralSettingUpdaterBinding[] = [
     ...scalarUpdaterBindings(GENERAL_SCALAR_SETTING_SPECS),
+    {
+        exposedName: 'updateSearchKeybindings',
+        key: 'search_keybindings',
+        normalize: (value) => normalizeSearchKeybindings(value),
+    },
     ...JSON_SETTINGS_SECTIONS.map(jsonUpdaterBinding),
 ];
 
@@ -297,6 +362,7 @@ export function createGeneralSettingUpdaters(
 export function createDefaultGeneralSettings(): GeneralSettingsData {
     const defaults: GeneralSettingsData = {
         ...DEFAULT_GENERAL_SETTINGS,
+        searchKeybindings: { ...DEFAULT_GENERAL_SETTINGS.searchKeybindings },
         searchWindowDefaultSize: { ...DEFAULT_GENERAL_SETTINGS.searchWindowDefaultSize },
     };
     for (const section of JSON_SETTINGS_SECTIONS) {
@@ -308,6 +374,7 @@ export function createDefaultGeneralSettings(): GeneralSettingsData {
 export function cloneGeneralSettingsSnapshot(source: GeneralSettingsData): GeneralSettingsData {
     const snapshot: GeneralSettingsData = {
         ...source,
+        searchKeybindings: { ...source.searchKeybindings },
         searchWindowDefaultSize: { ...source.searchWindowDefaultSize },
     };
     for (const section of JSON_SETTINGS_SECTIONS) {
diff --git a/apps/desktop/src/stores/settings.ts b/apps/desktop/src/stores/settings.ts
index 4bf5cb2c..55cb8838 100644
--- a/apps/desktop/src/stores/settings.ts
+++ b/apps/desktop/src/stores/settings.ts
@@ -1,4 +1,4 @@
-// Copyright (c) 2026. 鍗冭瘹. Licensed under GPL v3
+// Copyright (c) 2026. 千诚. Licensed under GPL v3
 
 import { getSettingValue, setSetting } from '@database/queries';
 import { AppEvent, eventService } from '@services/EventService';
@@ -24,6 +24,7 @@ import {
     serializeGeneralSetting,
     serializeParsedGeneralSettingValue,
 } from './setting';
+
 export type { GeneralSettingsData, OutputScrollBehavior } from './setting';
 
 export const useSettingsStore = defineStore('settings', () => {
@@ -67,6 +68,7 @@ export const useSettingsStore = defineStore('settings', () => {
                     getSettingValue({ key: definition.key })
                 )
             );
+
             GENERAL_SETTING_DEFINITIONS.forEach((definition, index) => {
                 applyPersistedGeneralSettingValue(
                     settings.value,
@@ -75,11 +77,31 @@ export const useSettingsStore = defineStore('settings', () => {
                 );
             });
 
-            await Promise.allSettled(
-                GENERAL_SETTING_DEFINITIONS.map((definition, index) =>
-                    persistDefaultIfMissing(definition.key, settingRows[index] ?? null)
-                )
+            const persistenceResults = await Promise.allSettled(
+                GENERAL_SETTING_DEFINITIONS.map((definition, index) => {
+                    const persistedValue = settingRows[index] ?? null;
+                    if (definition.shouldRewritePersisted?.(persistedValue)) {
+                        return setSetting({
+                            key: definition.key,
+                            value: serializeSetting(definition.key),
+                        });
+                    }
+
+                    return persistDefaultIfMissing(definition.key, persistedValue);
+                })
+            );
+            const failedPersistenceKeys = persistenceResults.flatMap((result, index) =>
+                result.status === 'rejected'
+                    ? [GENERAL_SETTING_DEFINITIONS[index]?.key ?? `unknown:${index}`]
+                    : []
             );
+            if (failedPersistenceKeys.length > 0) {
+                throw new Error(
+                    `Failed to persist general setting rewrite/default value(s): ${failedPersistenceKeys.join(
+                        ', '
+                    )}`
+                );
+            }
         } finally {
             loading.value = false;
         }
diff --git a/apps/desktop/src/utils/font.ts b/apps/desktop/src/utils/font.ts
index f2fae79f..8796dc41 100644
--- a/apps/desktop/src/utils/font.ts
+++ b/apps/desktop/src/utils/font.ts
@@ -16,6 +16,7 @@ const FONT_LOAD_RETRY_DELAY_MS = 16;
 
 let fontLoadPromise: Promise<void> | null = null;
 let fontReadyListenerPromise: Promise<void> | null = null;
+let fontLoadInjectedFontFace = false;
 let fontReloadToken = 0;
 
 interface LoadFontFaceOptions {
@@ -157,6 +158,9 @@ async function injectFontFace(options: LoadFontFaceOptions = {}): Promise<boolea
     `;
     getInjectedFontFaceStyle()?.remove();
     document.head.appendChild(style);
+    if (!refresh) {
+        fontLoadInjectedFontFace = true;
+    }
 
     await verifyInjectedFontFace(fontUrl);
     return true;
@@ -170,9 +174,17 @@ function loadFontFace(options: LoadFontFaceOptions = {}): Promise<void> {
     }
 
     if (!refresh && fontLoadPromise) {
+        if (fontLoadInjectedFontFace && !hasInjectedFontFace()) {
+            return injectFontFace(options).then(() => undefined);
+        }
+
         return fontLoadPromise;
     }
 
+    if (!refresh) {
+        fontLoadInjectedFontFace = false;
+    }
+
     const loadPromise = injectFontFace(options)
         .then(() => undefined)
         .finally(() => {
diff --git a/apps/desktop/src/utils/shortcuts.ts b/apps/desktop/src/utils/shortcuts.ts
new file mode 100644
index 00000000..2bc7c34e
--- /dev/null
+++ b/apps/desktop/src/utils/shortcuts.ts
@@ -0,0 +1,383 @@
+export interface ShortcutMatchInput {
+    key: string;
+    code?: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+}
+
+export interface CapturedShortcutResult {
+    shortcut: string;
+    displayShortcut: string;
+}
+
+const MODIFIER_DISPLAY_ORDER = ['Mod', 'Ctrl', 'Alt', 'Shift'] as const;
+const SUPPORTED_CAPTURE_MODIFIERS = new Set(['Ctrl', 'Alt', 'Shift', 'Mod']);
+const RESERVED_LOCAL_SHORTCUT_KEYS = new Set([
+    'Backspace',
+    'Del',
+    'Enter',
+    'Esc',
+    'Home',
+    'End',
+    'PageUp',
+    'PageDown',
+    'Tab',
+    'Up',
+    'Down',
+    'Left',
+    'Right',
+]);
+const MODIFIER_KEYS = new Set(['Control', 'Alt', 'Shift', 'Meta', 'OS']);
+
+const KEY_DISPLAY_MAP: Record<string, string> = {
+    ' ': 'Space',
+    Spacebar: 'Space',
+    ArrowUp: 'Up',
+    ArrowDown: 'Down',
+    ArrowLeft: 'Left',
+    ArrowRight: 'Right',
+    Escape: 'Esc',
+    Esc: 'Esc',
+    Delete: 'Del',
+    Del: 'Del',
+    '.': '.',
+    ',': ',',
+};
+
+const ALIAS_MAP: Record<string, string> = {
+    cmd: 'Mod',
+    command: 'Mod',
+    meta: 'Mod',
+    win: 'Mod',
+    super: 'Mod',
+    ctrl: 'Ctrl',
+    control: 'Ctrl',
+    option: 'Alt',
+    alt: 'Alt',
+    shift: 'Shift',
+    esc: 'Esc',
+    escape: 'Esc',
+    delete: 'Del',
+    del: 'Del',
+    return: 'Enter',
+    enter: 'Enter',
+    pageup: 'PageUp',
+    pagedown: 'PageDown',
+    arrowup: 'Up',
+    up: 'Up',
+    arrowdown: 'Down',
+    down: 'Down',
+    arrowleft: 'Left',
+    left: 'Left',
+    arrowright: 'Right',
+    right: 'Right',
+    backspace: 'Backspace',
+    space: 'Space',
+};
+
+function isMacPlatform(): boolean {
+    if (typeof navigator === 'undefined') {
+        return false;
+    }
+
+    return /(Mac|iPhone|iPad|iPod)/i.test(navigator.platform);
+}
+
+function getPrimaryModifierLabel(): 'Cmd' | 'Ctrl' {
+    return isMacPlatform() ? 'Cmd' : 'Ctrl';
+}
+
+function usesPrimaryModifier(input: ShortcutMatchInput): boolean {
+    return isMacPlatform() ? Boolean(input.metaKey) : Boolean(input.ctrlKey);
+}
+
+function normalizeShortcutToken(token: string): string | null {
+    const trimmed = token.trim();
+    if (!trimmed) {
+        return null;
+    }
+
+    const alias = ALIAS_MAP[trimmed.toLowerCase()];
+    if (alias) {
+        return alias;
+    }
+
+    if (trimmed.length === 1) {
+        return trimmed.toUpperCase();
+    }
+
+    if (/^f\d{1,2}$/i.test(trimmed)) {
+        return trimmed.toUpperCase();
+    }
+
+    return trimmed;
+}
+
+function normalizeEventKey(key: string): string | null {
+    if (!key) {
+        return null;
+    }
+
+    const mappedKey = KEY_DISPLAY_MAP[key] ?? key;
+    return normalizeShortcutToken(mappedKey);
+}
+
+function normalizeFunctionKeyCode(code: string | null | undefined): string | null {
+    if (!code) {
+        return null;
+    }
+
+    const trimmedCode = code.trim();
+    if (!/^F\d{1,2}$/i.test(trimmedCode)) {
+        return null;
+    }
+
+    return trimmedCode.toUpperCase();
+}
+
+export function resolveKeyboardEventShortcutKey(
+    key: string | null | undefined,
+    code?: string | null
+): string | null {
+    const normalizedKey = normalizeEventKey(key ?? '');
+    const normalizedFunctionKeyCode = normalizeFunctionKeyCode(code);
+    if (normalizedFunctionKeyCode && (!normalizedKey || !/^F\d{1,2}$/.test(normalizedKey))) {
+        return normalizedFunctionKeyCode;
+    }
+
+    return normalizedKey;
+}
+
+function createShortcutParts(shortcut: string): { modifiers: string[]; key: string | null } {
+    const parts = shortcut
+        .split('+')
+        .map((part) => normalizeShortcutToken(part))
+        .filter((part): part is string => Boolean(part));
+
+    const modifierSet = new Set<string>();
+    let key: string | null = null;
+    for (const part of parts) {
+        if (SUPPORTED_CAPTURE_MODIFIERS.has(part)) {
+            modifierSet.add(part);
+            continue;
+        }
+
+        if (key) {
+            return { modifiers: [], key: null };
+        }
+        key = part;
+    }
+
+    if (!isMacPlatform() && modifierSet.has('Ctrl')) {
+        modifierSet.delete('Ctrl');
+        modifierSet.add('Mod');
+    }
+
+    const modifiers = MODIFIER_DISPLAY_ORDER.filter((modifier) => modifierSet.has(modifier));
+    return { modifiers, key };
+}
+
+export function normalizeLocalShortcutString(shortcut: string | null | undefined): string | null {
+    if (!shortcut) {
+        return null;
+    }
+
+    const { modifiers, key } = createShortcutParts(shortcut);
+    if (!key) {
+        return null;
+    }
+
+    return [...modifiers, key].join('+');
+}
+
+export function formatShortcutForDisplay(shortcut: string | null | undefined): string {
+    const normalized = normalizeLocalShortcutString(shortcut);
+    if (!normalized) {
+        return '—';
+    }
+
+    const { modifiers, key } = createShortcutParts(normalized);
+    const displayModifiers = modifiers.map((modifier) => {
+        if (modifier === 'Mod') {
+            return getPrimaryModifierLabel();
+        }
+        return modifier;
+    });
+
+    return [...displayModifiers, key].join('+');
+}
+
+export function toCurrentPlatformShortcut(shortcut: string | null | undefined): string | null {
+    const normalized = normalizeLocalShortcutString(shortcut);
+    if (!normalized) {
+        return null;
+    }
+
+    return formatShortcutForDisplay(normalized);
+}
+
+export function matchShortcut(
+    shortcut: string | null | undefined,
+    input: ShortcutMatchInput
+): boolean {
+    const normalized = normalizeLocalShortcutString(shortcut);
+    if (!normalized) {
+        return false;
+    }
+
+    const { modifiers, key } = createShortcutParts(normalized);
+    const eventKey = resolveKeyboardEventShortcutKey(input.key, input.code);
+    if (!eventKey || eventKey !== key) {
+        return false;
+    }
+
+    const isMac = isMacPlatform();
+    const expectsMod = modifiers.includes('Mod');
+    const expectsCtrl = modifiers.includes('Ctrl');
+    const expectsAlt = modifiers.includes('Alt');
+    const expectsShift = modifiers.includes('Shift');
+
+    if (expectsMod !== usesPrimaryModifier(input)) {
+        return false;
+    }
+
+    const effectiveCtrl = isMac
+        ? Boolean(input.ctrlKey)
+        : expectsMod
+          ? false
+          : Boolean(input.ctrlKey);
+    if (expectsCtrl !== effectiveCtrl) {
+        return false;
+    }
+
+    if (expectsAlt !== Boolean(input.altKey)) {
+        return false;
+    }
+
+    if (expectsShift !== Boolean(input.shiftKey)) {
+        return false;
+    }
+
+    if (!isMac && input.metaKey) {
+        return false;
+    }
+
+    return true;
+}
+
+export function captureShortcutFromKeyboardEvent(
+    event: KeyboardEvent
+): CapturedShortcutResult | null {
+    if (MODIFIER_KEYS.has(event.key)) {
+        return null;
+    }
+
+    if (!isMacPlatform() && event.metaKey) {
+        return null;
+    }
+
+    const key = resolveKeyboardEventShortcutKey(event.key, event.code);
+    if (!key) {
+        return null;
+    }
+
+    const modifiers: string[] = [];
+    if (usesPrimaryModifier(event)) {
+        modifiers.push('Mod');
+    }
+    if (event.ctrlKey && isMacPlatform()) {
+        modifiers.push('Ctrl');
+    }
+    if (event.altKey) {
+        modifiers.push('Alt');
+    }
+    if (event.shiftKey) {
+        modifiers.push('Shift');
+    }
+
+    const shortcut = [...modifiers, key].join('+');
+    return {
+        shortcut,
+        displayShortcut: formatShortcutForDisplay(shortcut),
+    };
+}
+
+export function isReservedLocalShortcut(shortcut: string | null | undefined): boolean {
+    const normalized = normalizeLocalShortcutString(shortcut);
+    if (!normalized) {
+        return false;
+    }
+
+    const { key } = createShortcutParts(normalized);
+    return key ? RESERVED_LOCAL_SHORTCUT_KEYS.has(key) : false;
+}
+
+export function isReservedLocalShortcutKey(
+    key: string | null | undefined,
+    code?: string | null
+): boolean {
+    const normalizedKey = resolveKeyboardEventShortcutKey(key, code);
+    return normalizedKey ? RESERVED_LOCAL_SHORTCUT_KEYS.has(normalizedKey) : false;
+}
+
+export function hasRequiredModifier(shortcut: string | null | undefined): boolean {
+    const normalized = normalizeLocalShortcutString(shortcut);
+    if (!normalized) {
+        return false;
+    }
+
+    const { modifiers } = createShortcutParts(normalized);
+    return modifiers.length > 0;
+}
+
+export function hasCommandModifier(shortcut: string | null | undefined): boolean {
+    const normalized = normalizeLocalShortcutString(shortcut);
+    if (!normalized) {
+        return false;
+    }
+
+    const { modifiers } = createShortcutParts(normalized);
+    return modifiers.some(
+        (modifier) => modifier === 'Mod' || modifier === 'Ctrl' || modifier === 'Alt'
+    );
+}
+
+export function isModifierlessFunctionShortcut(shortcut: string | null | undefined): boolean {
+    const normalized = normalizeLocalShortcutString(shortcut);
+    if (!normalized) {
+        return false;
+    }
+
+    const match = /^F(\d{1,2})$/.exec(normalized);
+    if (!match) {
+        return false;
+    }
+
+    const functionKeyNumber = Number(match[1]);
+    return functionKeyNumber >= 1 && functionKeyNumber <= 12;
+}
+
+export function findShortcutConflict<T extends string>(
+    shortcut: string | null | undefined,
+    entries: Array<{ id: T; shortcut: string | null | undefined }>,
+    excludeId?: T
+): T | null {
+    const normalized = normalizeLocalShortcutString(shortcut);
+    if (!normalized) {
+        return null;
+    }
+
+    for (const entry of entries) {
+        if (excludeId && entry.id === excludeId) {
+            continue;
+        }
+
+        if (normalizeLocalShortcutString(entry.shortcut) === normalized) {
+            return entry.id;
+        }
+    }
+
+    return null;
+}
diff --git a/apps/desktop/src/views/SearchView/composables/interaction/useSearchKeyboardRouter.ts b/apps/desktop/src/views/SearchView/composables/interaction/useSearchKeyboardRouter.ts
index 64193b17..2dd1d3e7 100644
--- a/apps/desktop/src/views/SearchView/composables/interaction/useSearchKeyboardRouter.ts
+++ b/apps/desktop/src/views/SearchView/composables/interaction/useSearchKeyboardRouter.ts
@@ -1,16 +1,20 @@
-import type { SearchPopupSurfaceType } from '../searchInteraction';
+import type { SearchKeybindingActionId, SearchKeybindings } from '@/config/searchKeybindings';
+import { matchShortcut } from '@/utils/shortcuts';
 
+export type SearchPopupSurfaceType = 'model-dropdown-surface' | 'session-history-surface';
 type SearchKeyboardSurface = 'search-surface' | SearchPopupSurfaceType;
 type SearchQuickSearchDirection = 'up' | 'down' | 'left' | 'right';
-type SearchPrimaryShortcutKey = 'h' | 'l' | 'n' | 'm' | 'p' | '.' | 'backspace';
+export type SessionInputHistoryDirection = 'older' | 'newer';
+export type SessionInputHistoryNavigationResult = 'navigated' | 'blocked' | 'ignored';
 
 interface PendingApprovalState {
     callId?: string;
     keyboardApproveAt: number;
 }
 
-interface SearchKeyboardRouteInput {
+export interface SearchKeyboardRouteInput {
     key: string;
+    code?: string;
     shiftKey?: boolean;
     ctrlKey?: boolean;
     metaKey?: boolean;
@@ -18,6 +22,7 @@ interface SearchKeyboardRouteInput {
 }
 
 interface CreateSearchKeyboardRouterOptions {
+    getSearchKeybindings: () => SearchKeybindings;
     getPendingApproval: () => PendingApprovalState | null;
     getActiveSurface: () => SearchKeyboardSurface;
     hasActivePopupWindowFocus: () => boolean;
@@ -27,6 +32,8 @@ interface CreateSearchKeyboardRouterOptions {
     hasQuickSearchHighlight: () => boolean;
     shouldTriggerQuickSearch: (query: string) => boolean;
     isMultiLineCursor: () => boolean;
+    isCursorAtTextStart: () => boolean;
+    isCursorAtEnd: () => boolean;
     hasModelOverride: () => boolean;
     getSessionHistoryCount: () => number;
     isLoading: () => boolean;
@@ -39,14 +46,21 @@ interface CreateSearchKeyboardRouterOptions {
     onMoveQuickSearchSelection: (direction: SearchQuickSearchDirection) => void;
     onOpenHighlightedQuickSearchItem: () => void | Promise<void>;
     onCloseQuickSearch: () => void;
+    onQuickSearchPageUp: () => void;
+    onQuickSearchPageDown: () => void;
+    onQuickSearchContextMenu: () => void;
+    onQuickSearchToggleView: () => void;
+    onQuickSearchCollapse: () => void;
+    onNavigateInputHistory: (
+        direction: SessionInputHistoryDirection
+    ) => SessionInputHistoryNavigationResult;
     onHideAllPopups: () => void | Promise<void>;
     onCancelRequest: () => void;
     onClearModelOverride: () => void;
     onHideWindow: () => void | Promise<void>;
     onClearSession: () => void;
     onClearDraft: () => void;
-    onClearAll: () => void;
-    onPrimaryShortcut: (key: SearchPrimaryShortcutKey) => void | Promise<void>;
+    onSearchKeybindingAction: (actionId: SearchKeybindingActionId) => void | Promise<void>;
 }
 
 /**
@@ -69,30 +83,22 @@ function isTypingAttemptDuringApproval(input: SearchKeyboardRouteInput) {
     return input.key.length === 1 || input.key === 'Backspace' || input.key === 'Delete';
 }
 
-/**
- * 判断是否命中 Ctrl/Cmd 主修饰键快捷键。
- */
-function resolvePrimaryShortcutKey(
-    input: SearchKeyboardRouteInput,
-    queryText: string,
-    isLoading: boolean
-): SearchPrimaryShortcutKey | null {
-    const hasPrimaryModifier = input.ctrlKey || input.metaKey;
-    if (!hasPrimaryModifier || input.altKey || input.shiftKey) {
-        return null;
-    }
-
-    const normalizedKey = input.key.toLowerCase();
-    if (normalizedKey === '.') {
-        return isLoading ? '.' : null;
-    }
+function hasNavigationModifier(input: SearchKeyboardRouteInput) {
+    return Boolean(input.ctrlKey || input.metaKey || input.altKey || input.shiftKey);
+}
 
-    if (normalizedKey === 'backspace') {
-        return queryText.trim() ? 'backspace' : null;
-    }
+function resolveSearchKeybindingAction(
+    input: SearchKeyboardRouteInput,
+    keybindings: SearchKeybindings
+): SearchKeybindingActionId | null {
+    for (const [actionId, shortcut] of Object.entries(keybindings) as Array<
+        [SearchKeybindingActionId, string | null]
+    >) {
+        if (!matchShortcut(shortcut, input)) {
+            continue;
+        }
 
-    if (['h', 'l', 'n', 'm', 'p'].includes(normalizedKey)) {
-        return normalizedKey as SearchPrimaryShortcutKey;
+        return actionId;
     }
 
     return null;
@@ -103,6 +109,7 @@ function resolvePrimaryShortcutKey(
  */
 export function createSearchKeyboardRouter(options: CreateSearchKeyboardRouterOptions) {
     const {
+        getSearchKeybindings,
         getPendingApproval,
         getActiveSurface,
         hasActivePopupWindowFocus,
@@ -112,6 +119,8 @@ export function createSearchKeyboardRouter(options: CreateSearchKeyboardRouterOp
         hasQuickSearchHighlight,
         shouldTriggerQuickSearch,
         isMultiLineCursor,
+        isCursorAtTextStart,
+        isCursorAtEnd,
         hasModelOverride,
         getSessionHistoryCount,
         isLoading,
@@ -124,18 +133,21 @@ export function createSearchKeyboardRouter(options: CreateSearchKeyboardRouterOp
         onMoveQuickSearchSelection,
         onOpenHighlightedQuickSearchItem,
         onCloseQuickSearch,
+        onQuickSearchPageUp,
+        onQuickSearchPageDown,
+        onQuickSearchContextMenu,
+        onQuickSearchToggleView,
+        onQuickSearchCollapse,
+        onNavigateInputHistory,
         onHideAllPopups,
         onCancelRequest,
         onClearModelOverride,
         onHideWindow,
         onClearSession,
         onClearDraft,
-        onPrimaryShortcut,
+        onSearchKeybindingAction,
     } = options;
 
-    /**
-     * 根据当前 surface 和审批状态解释一次键盘输入。
-     */
     function route(input: SearchKeyboardRouteInput) {
         const queryText = getQueryText();
         const pendingApproval = getPendingApproval();
@@ -160,17 +172,22 @@ export function createSearchKeyboardRouter(options: CreateSearchKeyboardRouterOp
             }
         }
 
-        const primaryShortcut = resolvePrimaryShortcutKey(input, queryText, isLoading());
-        if (primaryShortcut) {
-            runKeyboardEffect(() => onPrimaryShortcut(primaryShortcut));
+        if (hasActivePopupWindowFocus()) {
             return true;
         }
 
-        if (hasActivePopupWindowFocus()) {
+        const searchKeybindingAction = resolveSearchKeybindingAction(input, getSearchKeybindings());
+        if (searchKeybindingAction) {
+            runKeyboardEffect(() => onSearchKeybindingAction(searchKeybindingAction));
             return true;
         }
 
         if (input.key === 'Escape' || input.key === 'Esc') {
+            if (isQuickSearchOpen() && hasQuickSearchHighlight()) {
+                onQuickSearchCollapse();
+                return true;
+            }
+
             if (getActiveSurface() !== 'search-surface') {
                 runKeyboardEffect(onHideAllPopups);
                 return true;
@@ -181,25 +198,21 @@ export function createSearchKeyboardRouter(options: CreateSearchKeyboardRouterOp
                 return true;
             }
 
-            // Step 1: Clear input text first without exiting the current conversation
             if (queryText.trim()) {
                 onClearDraft();
                 return true;
             }
 
-            // Step 2: Clear model selection
             if (hasModelOverride()) {
                 onClearModelOverride();
                 return true;
             }
 
-            // Step 3: Exit conversation if session exists
             if (getSessionHistoryCount() > 0) {
                 onClearSession();
                 return true;
             }
 
-            // Step 4: Hide window if no session
             runKeyboardEffect(onHideWindow);
             return true;
         }
@@ -213,6 +226,26 @@ export function createSearchKeyboardRouter(options: CreateSearchKeyboardRouterOp
         }
 
         if (isQuickSearchOpen()) {
+            if (input.key === 'PageUp') {
+                onQuickSearchPageUp();
+                return true;
+            }
+
+            if (input.key === 'PageDown') {
+                onQuickSearchPageDown();
+                return true;
+            }
+
+            if (input.key === 'ContextMenu' || (input.key === 'F10' && input.shiftKey)) {
+                onQuickSearchContextMenu();
+                return true;
+            }
+
+            if (input.key.toLowerCase() === 'g' && (input.ctrlKey || input.metaKey)) {
+                onQuickSearchToggleView();
+                return true;
+            }
+
             if (hasQuickSearchHighlight()) {
                 const directionMap: Partial<Record<string, SearchQuickSearchDirection>> = {
                     ArrowUp: 'up',
@@ -247,23 +280,41 @@ export function createSearchKeyboardRouter(options: CreateSearchKeyboardRouterOp
         }
 
         if (getActiveSurface() === 'search-surface' && !isQuickSearchOpen()) {
-            if (input.key === 'ArrowDown') {
-                if (!shouldTriggerQuickSearch(queryText)) {
+            if (input.key === 'ArrowUp') {
+                if (hasNavigationModifier(input)) {
                     return false;
                 }
 
-                onOpenQuickSearch();
-                return true;
+                if (isMultiLineCursor() && !isCursorAtTextStart()) {
+                    return false;
+                }
+
+                return onNavigateInputHistory('older') !== 'ignored';
             }
 
-            if (input.key === 'ArrowUp') {
-                if (isMultiLineCursor()) {
+            if (input.key === 'ArrowDown') {
+                if (hasNavigationModifier(input)) {
+                    return false;
+                }
+
+                if (isMultiLineCursor() && !isCursorAtEnd()) {
+                    return false;
+                }
+
+                if (onNavigateInputHistory('newer') === 'navigated') {
+                    return true;
+                }
+
+                if (!shouldTriggerQuickSearch(queryText)) {
                     return false;
                 }
 
                 if (queryText.trim() || hasAttachments()) {
                     runKeyboardEffect(onSubmit);
+                    return true;
                 }
+
+                onOpenQuickSearch();
                 return true;
             }
         }
diff --git a/apps/desktop/src/views/SearchView/composables/searchInteraction.ts b/apps/desktop/src/views/SearchView/composables/searchInteraction.ts
index eaea8da4..25152aa8 100644
--- a/apps/desktop/src/views/SearchView/composables/searchInteraction.ts
+++ b/apps/desktop/src/views/SearchView/composables/searchInteraction.ts
@@ -7,6 +7,7 @@ import { AppEvent, eventService } from '@services/EventService';
 import type { PopupKeydownPayload } from '@services/PopupService';
 import { computed, type ComputedRef, reactive, type Ref, ref, watch } from 'vue';
 
+import type { SearchKeybindings } from '@/config/searchKeybindings';
 import { useAskUserStore } from '@/stores/askUser';
 import {
     cloneInputHistorySnapshot,
@@ -25,6 +26,7 @@ import type {
     SearchOverlayState,
     SearchPageController,
 } from '../types';
+import { createSearchKeyboardRouter as createConfigurableSearchKeyboardRouter } from './interaction/useSearchKeyboardRouter';
 
 export type SearchActivationSource = 'shortcut' | 'manual' | 'unknown';
 
@@ -97,70 +99,12 @@ interface SyncOverlayStateOptions {
     force?: boolean;
 }
 
-type SearchKeyboardSurface = 'search-surface' | SearchPopupSurfaceType;
-type SearchQuickSearchDirection = 'up' | 'down' | 'left' | 'right';
-type SearchPrimaryShortcutKey = 'h' | 'l' | 'n' | 'm' | 'p' | '.' | 'backspace';
 export type SessionInputHistoryDirection = 'older' | 'newer';
 export type SessionInputHistoryNavigationResult = 'navigated' | 'blocked' | 'ignored';
 
-interface PendingApprovalState {
-    callId?: string;
-    keyboardApproveAt: number;
-}
-
-interface SearchKeyboardRouteInput {
-    key: string;
-    shiftKey?: boolean;
-    ctrlKey?: boolean;
-    metaKey?: boolean;
-    altKey?: boolean;
-}
-
-interface CreateSearchKeyboardRouterOptions {
-    getPendingApproval: () => PendingApprovalState | null;
-    getActiveSurface: () => SearchKeyboardSurface;
-    hasActivePopupWindowFocus: () => boolean;
-    getQueryText: () => string;
-    hasAttachments: () => boolean;
-    isQuickSearchOpen: () => boolean;
-    hasQuickSearchHighlight: () => boolean;
-    shouldTriggerQuickSearch: (query: string) => boolean;
-    isMultiLineCursor: () => boolean;
-    isCursorAtStart: () => boolean;
-    isCursorAtTextStart: () => boolean;
-    isCursorAtEnd: () => boolean;
-    hasModelOverride: () => boolean;
-    getSessionHistoryCount: () => number;
-    isLoading: () => boolean;
-    onPromptApprovalAttention: () => void;
-    onRejectApproval: (callId?: string) => void;
-    onApproveApproval: (callId?: string) => void;
-    onForwardToPopup: (key: string) => void;
-    onSubmit: () => void | Promise<void>;
-    onOpenQuickSearch: () => void;
-    onMoveQuickSearchSelection: (direction: SearchQuickSearchDirection) => void;
-    onOpenHighlightedQuickSearchItem: () => void | Promise<void>;
-    onCloseQuickSearch: () => void;
-    onQuickSearchPageUp: () => void;
-    onQuickSearchPageDown: () => void;
-    onQuickSearchContextMenu: () => void;
-    onQuickSearchToggleView: () => void;
-    onQuickSearchCollapse: () => void;
-    onNavigateInputHistory: (
-        direction: SessionInputHistoryDirection
-    ) => SessionInputHistoryNavigationResult;
-    onHideAllPopups: () => void | Promise<void>;
-    onCancelRequest: () => void;
-    onClearModelOverride: () => void;
-    onHideWindow: () => void | Promise<void>;
-    onClearSession: () => void;
-    onClearDraft: () => void;
-    onClearAll: () => void;
-    onPrimaryShortcut: (key: SearchPrimaryShortcutKey) => void | Promise<void>;
-}
-
 export interface UseSearchKeyboardOptions {
     viewReady: Ref<boolean>;
+    searchKeybindings: Readonly<Ref<SearchKeybindings>>;
     queryText: Ref<string>;
     attachments: Ref<unknown[]>;
     cursorContext: Ref<SearchCursorContext>;
@@ -189,16 +133,15 @@ export interface UseSearchKeyboardOptions {
     toggleModelDropdown: () => Promise<void>;
     openHistoryDialog: () => Promise<void>;
     startNewSession: () => Promise<void>;
+    reopenLastClosedSession: () => Promise<void>;
     toggleWindowPin: () => Promise<void>;
     toggleWindowMaximize: () => Promise<void>;
+    openSettingsWindow: () => Promise<void>;
     handleSubmit: (query: string) => Promise<void>;
-    clearAll: () => void;
     cancelRequest: () => void;
     clearSession: () => void;
 }
 
-const DOUBLE_BACKSPACE_INTERVAL = 300;
-
 function createEmptyModelOverride(): SearchModelOverride {
     return {
         modelId: null,
@@ -697,289 +640,13 @@ export function useSearchOverlayMachine(options: UseSearchOverlayMachineOptions)
     };
 }
 
-/**
- * 在同步键盘路由中启动可能异步的副作用。
- */
-function runKeyboardEffect(effect: () => void | Promise<void>) {
-    void Promise.resolve(effect()).catch((error) => {
-        console.error('[SearchKeyboardRouter] Failed to handle keyboard effect:', error);
-    });
-}
-
-/**
- * 判断审批态下是否属于“误输入”。
- */
-function isTypingAttemptDuringApproval(input: SearchKeyboardRouteInput) {
-    if (input.ctrlKey || input.metaKey || input.altKey) {
-        return false;
-    }
-
-    return input.key.length === 1 || input.key === 'Backspace' || input.key === 'Delete';
-}
-
-/**
- * 判断是否命中 Ctrl/Cmd 主修饰键快捷键。
- */
-function resolvePrimaryShortcutKey(
-    input: SearchKeyboardRouteInput,
-    queryText: string,
-    isLoading: boolean
-): SearchPrimaryShortcutKey | null {
-    const hasPrimaryModifier = input.ctrlKey || input.metaKey;
-    if (!hasPrimaryModifier || input.altKey || input.shiftKey) {
-        return null;
-    }
-
-    const normalizedKey = input.key.toLowerCase();
-    if (normalizedKey === '.') {
-        return isLoading ? '.' : null;
-    }
-
-    if (normalizedKey === 'backspace') {
-        return queryText.trim() ? 'backspace' : null;
-    }
-
-    if (['h', 'l', 'n', 'm', 'p'].includes(normalizedKey)) {
-        return normalizedKey as SearchPrimaryShortcutKey;
-    }
-
-    return null;
-}
-
-/**
- * 纯键盘语义路由器。
- */
-export function createSearchKeyboardRouter(options: CreateSearchKeyboardRouterOptions) {
-    const {
-        getPendingApproval,
-        getActiveSurface,
-        hasActivePopupWindowFocus,
-        getQueryText,
-        hasAttachments,
-        isQuickSearchOpen,
-        hasQuickSearchHighlight,
-        shouldTriggerQuickSearch,
-        isMultiLineCursor,
-        isCursorAtTextStart,
-        isCursorAtEnd,
-        hasModelOverride,
-        getSessionHistoryCount,
-        isLoading,
-        onPromptApprovalAttention,
-        onRejectApproval,
-        onApproveApproval,
-        onForwardToPopup,
-        onSubmit,
-        onOpenQuickSearch,
-        onMoveQuickSearchSelection,
-        onOpenHighlightedQuickSearchItem,
-        onCloseQuickSearch,
-        onQuickSearchPageUp,
-        onQuickSearchPageDown,
-        onQuickSearchContextMenu,
-        onQuickSearchToggleView,
-        onQuickSearchCollapse,
-        onNavigateInputHistory,
-        onHideAllPopups,
-        onCancelRequest,
-        onClearModelOverride,
-        onHideWindow,
-        onClearSession,
-        onClearDraft,
-        onPrimaryShortcut,
-    } = options;
-
-    function route(input: SearchKeyboardRouteInput) {
-        const queryText = getQueryText();
-        const pendingApproval = getPendingApproval();
-        if (pendingApproval) {
-            if (input.key === 'Escape' || input.key === 'Esc') {
-                onRejectApproval(pendingApproval.callId);
-                return true;
-            }
-
-            if (input.key === 'Enter') {
-                if (!input.shiftKey && Date.now() >= pendingApproval.keyboardApproveAt) {
-                    onApproveApproval(pendingApproval.callId);
-                } else {
-                    onPromptApprovalAttention();
-                }
-                return true;
-            }
-
-            if (isTypingAttemptDuringApproval(input)) {
-                onPromptApprovalAttention();
-                return true;
-            }
-        }
-
-        const primaryShortcut = resolvePrimaryShortcutKey(input, queryText, isLoading());
-        if (primaryShortcut) {
-            runKeyboardEffect(() => onPrimaryShortcut(primaryShortcut));
-            return true;
-        }
-
-        if (hasActivePopupWindowFocus()) {
-            return true;
-        }
-
-        if (input.key === 'Escape' || input.key === 'Esc') {
-            // 快速搜索有高亮时，Escape 只收缩面板、清除高亮，不走清空输入链路。
-            if (isQuickSearchOpen() && hasQuickSearchHighlight()) {
-                onQuickSearchCollapse();
-                return true;
-            }
-
-            if (getActiveSurface() !== 'search-surface') {
-                runKeyboardEffect(onHideAllPopups);
-                return true;
-            }
-
-            if (isLoading()) {
-                onCancelRequest();
-                return true;
-            }
-
-            // Step 1: Clear input text first without exiting the current conversation
-            if (queryText.trim()) {
-                onClearDraft();
-                return true;
-            }
-
-            // Step 2: Clear model selection
-            if (hasModelOverride()) {
-                onClearModelOverride();
-                return true;
-            }
-
-            // Step 3: Exit conversation if session exists
-            if (getSessionHistoryCount() > 0) {
-                onClearSession();
-                return true;
-            }
-
-            // Step 4: Hide window if no session
-            runKeyboardEffect(onHideWindow);
-            return true;
-        }
-
-        if (
-            getActiveSurface() === 'model-dropdown-surface' &&
-            ['ArrowUp', 'ArrowDown', 'Enter'].includes(input.key)
-        ) {
-            onForwardToPopup(input.key);
-            return true;
-        }
-
-        if (isQuickSearchOpen()) {
-            // PageUp/PageDown 翻页
-            if (input.key === 'PageUp') {
-                onQuickSearchPageUp();
-                return true;
-            }
-            if (input.key === 'PageDown') {
-                onQuickSearchPageDown();
-                return true;
-            }
-
-            // Menu 键或 Shift+F10 打开右键菜单
-            if (input.key === 'ContextMenu' || (input.key === 'F10' && input.shiftKey)) {
-                onQuickSearchContextMenu();
-                return true;
-            }
-
-            // Ctrl+G 切换网格/列表视图
-            if (input.key === 'g' && (input.ctrlKey || input.metaKey)) {
-                onQuickSearchToggleView();
-                return true;
-            }
-
-            if (hasQuickSearchHighlight()) {
-                const directionMap: Partial<Record<string, SearchQuickSearchDirection>> = {
-                    ArrowUp: 'up',
-                    ArrowDown: 'down',
-                    ArrowLeft: 'left',
-                    ArrowRight: 'right',
-                };
-                const direction = directionMap[input.key];
-                if (direction) {
-                    onMoveQuickSearchSelection(direction);
-                    return true;
-                }
-
-                if (input.key === 'Enter') {
-                    runKeyboardEffect(onOpenHighlightedQuickSearchItem);
-                    return true;
-                }
-            } else {
-                if (input.key === 'ArrowDown') {
-                    onMoveQuickSearchSelection('down');
-                    return true;
-                }
-
-                if (input.key === 'Enter' && !input.shiftKey) {
-                    onCloseQuickSearch();
-                    if (queryText.trim()) {
-                        runKeyboardEffect(onSubmit);
-                    }
-                    return true;
-                }
-            }
-        }
-
-        if (getActiveSurface() === 'search-surface' && !isQuickSearchOpen()) {
-            if (input.key === 'ArrowUp') {
-                if (isMultiLineCursor() && !isCursorAtTextStart()) {
-                    return false;
-                }
-
-                return onNavigateInputHistory('older') !== 'ignored';
-            }
-
-            if (input.key === 'ArrowDown') {
-                if (isMultiLineCursor() && !isCursorAtEnd()) {
-                    return false;
-                }
-
-                if (onNavigateInputHistory('newer') === 'navigated') {
-                    return true;
-                }
-
-                if (!shouldTriggerQuickSearch(queryText)) {
-                    return false;
-                }
-
-                if (queryText.trim() || hasAttachments()) {
-                    runKeyboardEffect(onSubmit);
-                    return true;
-                }
-
-                onOpenQuickSearch();
-                return true;
-            }
-        }
-
-        if (getActiveSurface() === 'search-surface' && input.key === 'Enter' && !input.shiftKey) {
-            if (queryText.trim() || hasAttachments()) {
-                runKeyboardEffect(onSubmit);
-            }
-            return true;
-        }
-
-        return false;
-    }
-
-    return {
-        route,
-    };
-}
-
 /**
  * 创建 SearchView 页面级键盘处理器。
  */
 export function createSearchKeydownHandler(options: UseSearchKeyboardOptions) {
     const {
         viewReady,
+        searchKeybindings,
         queryText,
         attachments,
         cursorContext,
@@ -987,8 +654,6 @@ export function createSearchKeydownHandler(options: UseSearchKeyboardOptions) {
         modelDropdownState,
         controller,
         sessionHistory,
-        pendingRequest,
-        isWaitingForCompletion,
         isLoading,
         pendingToolApproval,
         approvePendingToolApproval,
@@ -1006,16 +671,17 @@ export function createSearchKeydownHandler(options: UseSearchKeyboardOptions) {
         toggleModelDropdown,
         openHistoryDialog,
         startNewSession,
+        reopenLastClosedSession,
         toggleWindowPin,
         toggleWindowMaximize,
+        openSettingsWindow,
         handleSubmit,
-        clearAll,
         cancelRequest,
         clearSession,
     } = options;
 
-    let lastBackspaceTime = 0;
-    const keyboardRouter = createSearchKeyboardRouter({
+    const keyboardRouter = createConfigurableSearchKeyboardRouter({
+        getSearchKeybindings: () => searchKeybindings.value,
         getPendingApproval: () =>
             pendingToolApproval.value
                 ? {
@@ -1043,7 +709,6 @@ export function createSearchKeydownHandler(options: UseSearchKeyboardOptions) {
         hasQuickSearchHighlight: () => controller.isQuickSearchItemHighlighted(),
         shouldTriggerQuickSearch,
         isMultiLineCursor: () => cursorContext.value.isMultiLine,
-        isCursorAtStart: () => cursorContext.value.cursorAtStart,
         isCursorAtTextStart: () => cursorContext.value.cursorAtTextStart,
         isCursorAtEnd: () => cursorContext.value.cursorAtEnd,
         hasModelOverride: () => Boolean(modelOverride.value.modelId),
@@ -1110,44 +775,40 @@ export function createSearchKeydownHandler(options: UseSearchKeyboardOptions) {
         onClearDraft: () => {
             queryText.value = '';
         },
-        onClearAll: () => {
-            clearAll();
-        },
-        onPrimaryShortcut: async (key) => {
-            if (key === 'h') {
-                await openHistoryDialog();
-                return;
-            }
-
-            if (key === 'l') {
-                await hideAllPopups();
-                await controller.focusSearchInput();
-                return;
-            }
-
-            if (key === 'n') {
-                if (sessionHistory.value.length > 0) {
-                    await startNewSession();
+        onSearchKeybindingAction: async (actionId) => {
+            switch (actionId) {
+                case 'search.history.open':
+                    await openHistoryDialog();
+                    return;
+                case 'search.input.focus':
+                    await hideAllPopups();
+                    await controller.focusSearchInput();
+                    return;
+                case 'search.session.new':
+                    if (sessionHistory.value.length > 0) {
+                        await startNewSession();
+                    }
+                    return;
+                case 'search.session.reopenLastClosed':
+                    await reopenLastClosedSession();
+                    return;
+                case 'search.model.toggle':
+                    await toggleModelDropdown();
+                    return;
+                case 'search.window.pin':
+                    await toggleWindowPin();
+                    return;
+                case 'search.window.maximize':
+                    await toggleWindowMaximize();
+                    return;
+                case 'search.settings.open':
+                    await openSettingsWindow();
+                    return;
+                default: {
+                    const exhaustiveActionId: never = actionId;
+                    throw new Error(`Unhandled search keybinding action: ${exhaustiveActionId}`);
                 }
-                return;
-            }
-
-            if (key === 'm') {
-                await toggleModelDropdown();
-                return;
             }
-
-            if (key === 'p') {
-                await toggleWindowPin();
-                return;
-            }
-
-            if (key === '.') {
-                cancelRequest();
-                return;
-            }
-
-            clearAll();
         },
     });
 
@@ -1178,15 +839,9 @@ export function createSearchKeydownHandler(options: UseSearchKeyboardOptions) {
             return;
         }
 
-        if (event.key === 'F11') {
-            event.preventDefault();
-            event.stopPropagation();
-            await toggleWindowMaximize();
-            return;
-        }
-
         const handledByRouter = keyboardRouter.route({
             key: event.key,
+            code: event.code,
             shiftKey: event.shiftKey,
             ctrlKey: event.ctrlKey,
             metaKey: event.metaKey,
@@ -1210,20 +865,6 @@ export function createSearchKeydownHandler(options: UseSearchKeyboardOptions) {
                 return;
             }
 
-            if (pendingRequest.value) {
-                const now = Date.now();
-                const timeSinceLastBackspace = now - lastBackspaceTime;
-                lastBackspaceTime = now;
-
-                if (timeSinceLastBackspace < DOUBLE_BACKSPACE_INTERVAL) {
-                    event.preventDefault();
-                    pendingRequest.value = null;
-                    isWaitingForCompletion.value = false;
-                    lastBackspaceTime = 0;
-                }
-                return;
-            }
-
             if (modelOverride.value.modelId && cursorContext.value.cursorAtStart) {
                 event.preventDefault();
                 modelOverride.value = createEmptyModelOverride();
diff --git a/apps/desktop/src/views/SearchView/composables/useSearchRequest.ts b/apps/desktop/src/views/SearchView/composables/useSearchRequest.ts
index 36e54f3e..82fa811d 100644
--- a/apps/desktop/src/views/SearchView/composables/useSearchRequest.ts
+++ b/apps/desktop/src/views/SearchView/composables/useSearchRequest.ts
@@ -73,6 +73,7 @@ export function useSearchRequestFlow(options: UseSearchRequestFlowOptions) {
     const sessionList = ref<SessionEntity[]>([]);
     const sessionListQuery = ref('');
     const isSessionListLoading = ref(false);
+    const lastClosedSessionId = ref<number | null>(null);
     let sessionListRequestId = 0;
     let sessionListLoadPromise: Promise<void> | null = null;
     let sessionListInFlightKey: string | null = null;
@@ -229,6 +230,9 @@ export function useSearchRequestFlow(options: UseSearchRequestFlowOptions) {
     });
 
     function clearSessionState() {
+        if (currentSessionId.value !== null) {
+            lastClosedSessionId.value = currentSessionId.value;
+        }
         clearPendingRequestState();
         clearSession();
     }
@@ -392,13 +396,49 @@ export function useSearchRequestFlow(options: UseSearchRequestFlowOptions) {
         clearDraft();
     }
 
+    function clearLastClosedSessionId() {
+        lastClosedSessionId.value = null;
+    }
+
+    function isSessionNotFoundError(error: unknown, sessionId: number): boolean {
+        return error instanceof Error && error.message === `Session ${sessionId} not found`;
+    }
+
+    async function reopenLastClosedSession(): Promise<LoadedSessionInfo | null> {
+        const sessionId = lastClosedSessionId.value;
+        if (sessionId === null || sessionId === currentSessionId.value) {
+            return null;
+        }
+
+        try {
+            const loadedSession = await openSession(sessionId);
+            if (currentSessionId.value === sessionId) {
+                clearLastClosedSessionId();
+            }
+            return loadedSession;
+        } catch (error) {
+            if (isSessionNotFoundError(error, sessionId)) {
+                clearLastClosedSessionId();
+            }
+            throw error;
+        }
+    }
+
     async function openSession(sessionId: number): Promise<LoadedSessionInfo> {
-        // 切换会话时必须丢弃当前页面暂存的排队请求，
+        if (sessionId === currentSessionId.value) {
+            return {
+                sessionId,
+                title: '',
+                modelId: modelOverride.value.modelId,
+                providerId: modelOverride.value.providerId,
+            };
+        }
+
+        const loadedSession = await openStoredSession(sessionId);
+        // 切换会话成功后必须丢弃当前页面暂存的排队请求，
         // 否则新会话会错误继承旧会话的“等待发送”锁态。
         clearPendingRequestState();
         clearDraft({ preserveModelTag: true });
-
-        const loadedSession = await openStoredSession(sessionId);
         modelOverride.value = {
             modelId: loadedSession.modelId,
             providerId: loadedSession.providerId,
@@ -461,6 +501,7 @@ export function useSearchRequestFlow(options: UseSearchRequestFlowOptions) {
         refreshSessionList,
         ensureSessionListLoaded,
         startNewSession,
+        reopenLastClosedSession,
         openSession,
         pendingToolApproval,
         pendingUserQuestion,
diff --git a/apps/desktop/src/views/SearchView/index.vue b/apps/desktop/src/views/SearchView/index.vue
index 6ee9b076..3fdc5ca9 100644
--- a/apps/desktop/src/views/SearchView/index.vue
+++ b/apps/desktop/src/views/SearchView/index.vue
@@ -116,7 +116,7 @@
     const inputHistoryRestoreVersion = ref(0);
     const mcpStore = useMcpStore();
     const settingsStore = useSettingsStore();
-    const { searchWindowDefaultSize } = storeToRefs(settingsStore);
+    const { searchWindowDefaultSize, searchKeybindings } = storeToRefs(settingsStore);
     const { sessionStatuses, refreshAllStatuses: refreshSessionStatuses } = useSessionStatus();
     const { isPinned, syncWindowPinState, setWindowPinned, toggleWindowPin } = useSearchWindowPin();
     const widgetBridgeWindow = window as Window & {
@@ -234,6 +234,7 @@
         refreshSessionList,
         ensureSessionListLoaded,
         startNewSession,
+        reopenLastClosedSession,
         openSession,
         pendingToolApproval,
         pendingUserQuestion,
@@ -241,7 +242,6 @@
         rejectPendingToolApproval,
         settleUserQuestion,
         handleSubmit,
-        clearAll,
         cancelRequest,
         handleRegenerateMessage: handleRegenerateMessageRequest,
     } = useSearchRequestFlow({
@@ -510,6 +510,7 @@
 
     useSearchKeyboard({
         viewReady,
+        searchKeybindings,
         queryText,
         attachments,
         cursorContext,
@@ -537,10 +538,11 @@
         toggleModelDropdown: handleToggleModelDropdownRequest,
         openHistoryDialog,
         startNewSession: handleStartNewSession,
+        reopenLastClosedSession: handleReopenLastClosedSession,
         toggleWindowPin: handleToggleWindowPin,
         toggleWindowMaximize: handleToggleMaximize,
+        openSettingsWindow: native.window.openSettingsWindow,
         handleSubmit,
-        clearAll,
         cancelRequest,
         clearSession: clearSessionToIdle,
     });
@@ -813,6 +815,43 @@
         await controller.focusSearchInput();
     }
 
+    async function handleReopenLastClosedSession() {
+        if (queryText.value.trim() || attachments.value.length > 0) {
+            await hideAllPopups();
+            await controller.focusSearchInput();
+            return;
+        }
+
+        controller.closeQuickSearch();
+        await hideAllPopups();
+        resetSessionInputHistoryTracking();
+
+        try {
+            const reopenedSession = await reopenLastClosedSession();
+            if (!reopenedSession) {
+                await controller.focusSearchInput();
+                return;
+            }
+
+            await syncSearchWindowState().catch((error) => {
+                console.error(
+                    '[SearchView] Failed to sync search window state after reopening session:',
+                    error
+                );
+            });
+            await remeasureTargetHeight().catch((error) => {
+                console.error(
+                    '[SearchView] Failed to remeasure window height after reopening session:',
+                    error
+                );
+            });
+            conversationPanel.value?.revealLatestContent();
+        } catch (error) {
+            console.error('[SearchView] Failed to reopen last closed session:', error);
+            await controller.focusSearchInput();
+        }
+    }
+
     async function handleToggleWindowPin() {
         try {
             await toggleWindowPin();
diff --git a/apps/desktop/src/views/SettingsView/components/General/SearchShortcutSettings.vue b/apps/desktop/src/views/SettingsView/components/General/SearchShortcutSettings.vue
new file mode 100644
index 00000000..74e0b9f3
--- /dev/null
+++ b/apps/desktop/src/views/SettingsView/components/General/SearchShortcutSettings.vue
@@ -0,0 +1,588 @@
+<script setup lang="ts">
+    import AlertMessage from '@components/AlertMessage.vue';
+    import AppIcon from '@components/AppIcon.vue';
+    import { storeToRefs } from 'pinia';
+    import { computed, onUnmounted, ref, watch } from 'vue';
+
+    import {
+        getSearchKeybindingDefinition,
+        SEARCH_KEYBINDING_DEFINITIONS,
+        type SearchKeybindingActionId,
+    } from '@/config/searchKeybindings';
+    import { type MessageKey, type MessageParams, t } from '@/i18n';
+    import { useSettingsStore } from '@/stores/settings';
+    import {
+        captureShortcutFromKeyboardEvent,
+        findShortcutConflict,
+        formatShortcutForDisplay,
+        hasCommandModifier,
+        isModifierlessFunctionShortcut,
+        isReservedLocalShortcut,
+        isReservedLocalShortcutKey,
+        normalizeLocalShortcutString,
+        toCurrentPlatformShortcut,
+    } from '@/utils/shortcuts';
+
+    defineOptions({
+        name: 'SettingsSearchShortcutSettings',
+    });
+
+    type SearchShortcutIconAction = 'clear' | 'restore';
+    type SearchShortcutGroupId = 'session' | 'inputAndRequest' | 'window';
+
+    interface SettingsSearchShortcutGroupRow {
+        kind: 'configurable' | 'fixed';
+        id: string;
+        label: string;
+        description?: string;
+        displayValue: string;
+        isCapturing?: boolean;
+        hasError?: boolean;
+        shortcutAction?: SearchShortcutIconAction;
+        shortcutActionLabel?: string;
+    }
+
+    const settingsStore = useSettingsStore();
+    const { settings } = storeToRefs(settingsStore);
+
+    const alertMessage = ref<InstanceType<typeof AlertMessage> | null>(null);
+    const isSaving = ref(false);
+    const activeSearchShortcutActionId = ref<SearchKeybindingActionId | null>(null);
+    const searchShortcutCapturedValue = ref<string | null>(null);
+    const hasCapturedSearchShortcut = ref(false);
+    const searchShortcutErrorActionId = ref<SearchKeybindingActionId | null>(null);
+    const shortcutCapturePrompt = computed(() => t('settings.general.shortcutCapturePrompt'));
+
+    function formatSearchShortcutForSettings(shortcut: string | null | undefined): string {
+        const normalizedShortcut = normalizeLocalShortcutString(shortcut);
+        return normalizedShortcut
+            ? formatShortcutForDisplay(normalizedShortcut)
+            : t('settings.general.noShortcut');
+    }
+
+    const searchShortcutDisplayMap = ref<Record<SearchKeybindingActionId, string>>(
+        SEARCH_KEYBINDING_DEFINITIONS.reduce(
+            (accumulator, definition) => {
+                accumulator[definition.id] = formatSearchShortcutForSettings(
+                    settings.value.searchKeybindings[definition.id]
+                );
+                return accumulator;
+            },
+            {} as Record<SearchKeybindingActionId, string>
+        )
+    );
+
+    const fixedSearchShortcutRows = computed<
+        Record<SearchShortcutGroupId, SettingsSearchShortcutGroupRow[]>
+    >(() => ({
+        session: [
+            {
+                kind: 'fixed',
+                id: 'search.inputHistory.older',
+                label: t('settings.general.fixedSearchActions.previousInputHistory'),
+                description: t('settings.general.searchActionDescriptions.previousInputHistory'),
+                displayValue: 'Up',
+            },
+            {
+                kind: 'fixed',
+                id: 'search.inputHistory.newer',
+                label: t('settings.general.fixedSearchActions.nextInputHistory'),
+                description: t('settings.general.searchActionDescriptions.nextInputHistory'),
+                displayValue: 'Down',
+            },
+        ],
+        inputAndRequest: [
+            {
+                kind: 'fixed',
+                id: 'search.request.cancel',
+                label: t('settings.general.searchActions.cancelRequest'),
+                description: t('settings.general.searchActionDescriptions.cancelRequest'),
+                displayValue: 'Esc',
+            },
+            {
+                kind: 'fixed',
+                id: 'search.submit',
+                label: t('settings.general.fixedSearchActions.submitRequest'),
+                description: t('settings.general.searchActionDescriptions.submitRequest'),
+                displayValue: 'Enter',
+            },
+            {
+                kind: 'fixed',
+                id: 'search.newLine',
+                label: t('settings.general.fixedSearchActions.newLine'),
+                description: t('settings.general.searchActionDescriptions.newLine'),
+                displayValue: 'Shift+Enter',
+            },
+        ],
+        window: [],
+    }));
+
+    const searchShortcutRows = computed<SettingsSearchShortcutGroupRow[]>(() =>
+        SEARCH_KEYBINDING_DEFINITIONS.map((definition) => {
+            const currentShortcut = settings.value.searchKeybindings[definition.id];
+            const isDefaultShortcut =
+                normalizeLocalShortcutString(currentShortcut) ===
+                normalizeLocalShortcutString(definition.defaultShortcut);
+            const shortcutAction: SearchShortcutIconAction = isDefaultShortcut
+                ? 'clear'
+                : 'restore';
+
+            return {
+                ...definition,
+                kind: 'configurable',
+                label: t(definition.labelKey),
+                description: t(definition.descriptionKey),
+                displayValue: searchShortcutDisplayMap.value[definition.id],
+                isCapturing: activeSearchShortcutActionId.value === definition.id,
+                hasError: searchShortcutErrorActionId.value === definition.id,
+                shortcutAction,
+                shortcutActionLabel:
+                    shortcutAction === 'clear'
+                        ? t('common.clear')
+                        : `${t('window.restore')} ${t('common.default')}`,
+            };
+        })
+    );
+
+    const searchShortcutGroups = computed(() => {
+        const rowById = new Map<string, SettingsSearchShortcutGroupRow>(
+            searchShortcutRows.value.map((row) => [row.id, row] as const)
+        );
+        const groups: Array<{
+            id: SearchShortcutGroupId;
+            title: string;
+            actionIds: SearchKeybindingActionId[];
+        }> = [
+            {
+                id: 'session',
+                title: t('settings.general.searchShortcutGroups.session'),
+                actionIds: [
+                    'search.history.open',
+                    'search.session.new',
+                    'search.session.reopenLastClosed',
+                ],
+            },
+            {
+                id: 'inputAndRequest',
+                title: t('settings.general.searchShortcutGroups.inputAndRequest'),
+                actionIds: ['search.input.focus', 'search.model.toggle'],
+            },
+            {
+                id: 'window',
+                title: t('settings.general.searchShortcutGroups.window'),
+                actionIds: ['search.window.pin', 'search.window.maximize', 'search.settings.open'],
+            },
+        ];
+
+        return groups.map((group) => ({
+            title: group.title,
+            rows: [
+                ...group.actionIds
+                    .map((actionId) => rowById.get(actionId))
+                    .filter((row): row is SettingsSearchShortcutGroupRow => Boolean(row)),
+                ...fixedSearchShortcutRows.value[group.id],
+            ],
+        }));
+    });
+
+    function updateSearchShortcutDisplay(actionId: SearchKeybindingActionId, value: string) {
+        searchShortcutDisplayMap.value = {
+            ...searchShortcutDisplayMap.value,
+            [actionId]: value,
+        };
+    }
+
+    function syncSearchShortcutDisplays() {
+        const next = { ...searchShortcutDisplayMap.value };
+        for (const definition of SEARCH_KEYBINDING_DEFINITIONS) {
+            if (activeSearchShortcutActionId.value === definition.id) {
+                continue;
+            }
+            next[definition.id] = formatSearchShortcutForSettings(
+                settings.value.searchKeybindings[definition.id]
+            );
+        }
+        searchShortcutDisplayMap.value = next;
+    }
+
+    function reportSearchShortcutError(
+        actionId: SearchKeybindingActionId,
+        messageKey: MessageKey,
+        params?: MessageParams
+    ) {
+        searchShortcutErrorActionId.value = actionId;
+        alertMessage.value?.error(t(messageKey, params), 3000);
+    }
+
+    const captureSearchShortcut = (event: KeyboardEvent) => {
+        const actionId = activeSearchShortcutActionId.value;
+        if (!actionId) {
+            return;
+        }
+
+        if (isReservedLocalShortcutKey(event.key, event.code)) {
+            return;
+        }
+
+        const captured = captureShortcutFromKeyboardEvent(event);
+        if (!captured) {
+            if (event.metaKey) {
+                alertMessage.value?.warning(t('settings.general.winKeyUnsupported'), 3000);
+            }
+            return;
+        }
+
+        event.preventDefault();
+        event.stopPropagation();
+
+        searchShortcutCapturedValue.value = captured.shortcut;
+        hasCapturedSearchShortcut.value = true;
+        searchShortcutErrorActionId.value = null;
+        updateSearchShortcutDisplay(actionId, captured.displayShortcut);
+        void confirmCapturedSearchShortcut(actionId, captured.shortcut);
+    };
+
+    async function saveSearchShortcut(
+        actionId: SearchKeybindingActionId,
+        shortcut: string | null
+    ): Promise<boolean> {
+        const normalizedShortcut =
+            shortcut === null ? null : normalizeLocalShortcutString(shortcut);
+
+        if (normalizedShortcut) {
+            const definition = getSearchKeybindingDefinition(actionId);
+            const allowsModifierlessFunctionShortcut =
+                definition.allowModifierlessFunctionShortcut &&
+                isModifierlessFunctionShortcut(normalizedShortcut);
+
+            if (!hasCommandModifier(normalizedShortcut) && !allowsModifierlessFunctionShortcut) {
+                reportSearchShortcutError(
+                    actionId,
+                    'settings.general.searchShortcuts.errors.modifierRequired'
+                );
+                updateSearchShortcutDisplay(
+                    actionId,
+                    formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+                );
+                return false;
+            }
+
+            if (isReservedLocalShortcut(normalizedShortcut)) {
+                reportSearchShortcutError(
+                    actionId,
+                    'settings.general.searchShortcuts.errors.reserved'
+                );
+                updateSearchShortcutDisplay(
+                    actionId,
+                    formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+                );
+                return false;
+            }
+
+            const conflictActionId = findShortcutConflict(
+                normalizedShortcut,
+                SEARCH_KEYBINDING_DEFINITIONS.map((definition) => ({
+                    id: definition.id,
+                    shortcut: settings.value.searchKeybindings[definition.id],
+                })),
+                actionId
+            );
+            if (conflictActionId) {
+                reportSearchShortcutError(
+                    actionId,
+                    'settings.general.searchShortcuts.errors.duplicate',
+                    {
+                        action: t(getSearchKeybindingDefinition(conflictActionId).labelKey),
+                    }
+                );
+                updateSearchShortcutDisplay(
+                    actionId,
+                    formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+                );
+                return false;
+            }
+
+            const comparableGlobalShortcut = normalizeLocalShortcutString(
+                settings.value.globalShortcut
+            );
+            const comparableLocalShortcut = normalizeLocalShortcutString(
+                toCurrentPlatformShortcut(normalizedShortcut)
+            );
+            if (
+                comparableGlobalShortcut &&
+                comparableLocalShortcut &&
+                comparableGlobalShortcut === comparableLocalShortcut
+            ) {
+                reportSearchShortcutError(
+                    actionId,
+                    'settings.general.searchShortcuts.errors.globalConflict'
+                );
+                updateSearchShortcutDisplay(
+                    actionId,
+                    formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+                );
+                return false;
+            }
+        }
+
+        isSaving.value = true;
+        searchShortcutErrorActionId.value = null;
+        try {
+            await settingsStore.updateSearchKeybindings({
+                ...settings.value.searchKeybindings,
+                [actionId]: normalizedShortcut,
+            });
+            updateSearchShortcutDisplay(
+                actionId,
+                formatSearchShortcutForSettings(normalizedShortcut)
+            );
+            alertMessage.value?.success(t('common.saved'), 2000);
+            return true;
+        } catch (error) {
+            console.error('Failed to save search shortcut:', error);
+            reportSearchShortcutError(actionId, 'settings.general.saveSettingsFailed');
+            updateSearchShortcutDisplay(
+                actionId,
+                formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+            );
+            return false;
+        } finally {
+            isSaving.value = false;
+        }
+    }
+
+    function startSearchShortcutCapture(rowOrActionId: SettingsSearchShortcutGroupRow | string) {
+        if (typeof rowOrActionId === 'string') {
+            const actionId = rowOrActionId as SearchKeybindingActionId;
+            activeSearchShortcutActionId.value = actionId;
+            hasCapturedSearchShortcut.value = false;
+            searchShortcutCapturedValue.value = null;
+            searchShortcutErrorActionId.value = null;
+            updateSearchShortcutDisplay(actionId, shortcutCapturePrompt.value);
+            return;
+        }
+
+        if (rowOrActionId.kind !== 'configurable') {
+            return;
+        }
+
+        const actionId = rowOrActionId.id as SearchKeybindingActionId;
+        activeSearchShortcutActionId.value = actionId;
+        hasCapturedSearchShortcut.value = false;
+        searchShortcutCapturedValue.value = null;
+        searchShortcutErrorActionId.value = null;
+        updateSearchShortcutDisplay(actionId, shortcutCapturePrompt.value);
+    }
+
+    async function confirmCapturedSearchShortcut(
+        actionId: SearchKeybindingActionId,
+        shortcut: string
+    ) {
+        if (activeSearchShortcutActionId.value !== actionId) {
+            return;
+        }
+
+        hasCapturedSearchShortcut.value = false;
+        searchShortcutCapturedValue.value = null;
+
+        if (
+            normalizeLocalShortcutString(shortcut) ===
+            normalizeLocalShortcutString(settings.value.searchKeybindings[actionId])
+        ) {
+            updateSearchShortcutDisplay(
+                actionId,
+                formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+            );
+            activeSearchShortcutActionId.value = null;
+            return;
+        }
+
+        const saved = await saveSearchShortcut(actionId, shortcut);
+        if (saved) {
+            activeSearchShortcutActionId.value = null;
+        }
+    }
+
+    async function stopSearchShortcutCaptureAndSave(
+        rowOrActionId: SettingsSearchShortcutGroupRow | string
+    ) {
+        const actionId =
+            typeof rowOrActionId === 'string'
+                ? (rowOrActionId as SearchKeybindingActionId)
+                : rowOrActionId.kind === 'configurable'
+                  ? (rowOrActionId.id as SearchKeybindingActionId)
+                  : null;
+        if (!actionId || activeSearchShortcutActionId.value !== actionId) {
+            return;
+        }
+
+        activeSearchShortcutActionId.value = null;
+
+        if (!hasCapturedSearchShortcut.value || !searchShortcutCapturedValue.value) {
+            updateSearchShortcutDisplay(
+                actionId,
+                formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+            );
+            return;
+        }
+
+        if (
+            normalizeLocalShortcutString(searchShortcutCapturedValue.value) ===
+            normalizeLocalShortcutString(settings.value.searchKeybindings[actionId])
+        ) {
+            updateSearchShortcutDisplay(
+                actionId,
+                formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+            );
+            return;
+        }
+
+        await saveSearchShortcut(actionId, searchShortcutCapturedValue.value);
+    }
+
+    async function resetSearchShortcut(actionId: SearchKeybindingActionId) {
+        await saveSearchShortcut(actionId, getSearchKeybindingDefinition(actionId).defaultShortcut);
+    }
+
+    async function disableSearchShortcut(actionId: SearchKeybindingActionId) {
+        await saveSearchShortcut(actionId, null);
+    }
+
+    async function handleSearchShortcutIconAction(
+        rowOrActionId: SettingsSearchShortcutGroupRow | string,
+        explicitAction?: SearchShortcutIconAction
+    ) {
+        const actionId =
+            typeof rowOrActionId === 'string'
+                ? (rowOrActionId as SearchKeybindingActionId)
+                : rowOrActionId.kind === 'configurable'
+                  ? (rowOrActionId.id as SearchKeybindingActionId)
+                  : null;
+        const action =
+            explicitAction ??
+            (typeof rowOrActionId === 'string'
+                ? undefined
+                : rowOrActionId.kind === 'configurable'
+                  ? rowOrActionId.shortcutAction
+                  : undefined);
+        if (!actionId || !action) {
+            return;
+        }
+
+        if (activeSearchShortcutActionId.value === actionId) {
+            activeSearchShortcutActionId.value = null;
+            hasCapturedSearchShortcut.value = false;
+            searchShortcutCapturedValue.value = null;
+            updateSearchShortcutDisplay(
+                actionId,
+                formatSearchShortcutForSettings(settings.value.searchKeybindings[actionId])
+            );
+        }
+
+        if (action === 'clear') {
+            await disableSearchShortcut(actionId);
+            return;
+        }
+
+        await resetSearchShortcut(actionId);
+    }
+
+    watch(activeSearchShortcutActionId, (actionId) => {
+        window.removeEventListener('keydown', captureSearchShortcut);
+        if (actionId) {
+            window.addEventListener('keydown', captureSearchShortcut);
+        }
+    });
+
+    watch(
+        () => settings.value.searchKeybindings,
+        () => {
+            syncSearchShortcutDisplays();
+        },
+        { deep: true, immediate: true }
+    );
+
+    onUnmounted(() => {
+        window.removeEventListener('keydown', captureSearchShortcut);
+    });
+</script>
+
+<template>
+    <AlertMessage ref="alertMessage" />
+
+    <div v-for="group in searchShortcutGroups" :key="group.title" class="space-y-2">
+        <div class="text-[12px] leading-5 font-medium text-neutral-500">
+            {{ group.title }}
+        </div>
+        <div class="settings-row-group divide-y divide-neutral-200/70">
+            <div
+                v-for="row in group.rows"
+                :key="row.id"
+                class="grid min-w-0 gap-4 px-5 py-4 sm:grid-cols-[minmax(0,1fr)_220px] sm:items-center"
+            >
+                <div
+                    data-testid="settings-general-row-label"
+                    class="min-w-0 text-[13px] leading-6 font-normal text-neutral-900"
+                >
+                    <div>{{ row.label }}</div>
+                    <div v-if="row.description" class="text-[12px] leading-5 text-neutral-500">
+                        {{ row.description }}
+                    </div>
+                </div>
+                <div class="min-w-0 justify-self-end">
+                    <div class="flex min-w-0 items-center justify-end">
+                        <div class="relative w-[220px] shrink-0">
+                            <input
+                                :value="row.displayValue"
+                                :data-testid="`settings-search-shortcut-input-${row.id}`"
+                                type="text"
+                                readonly
+                                :class="[
+                                    'w-full rounded-[10px] border px-9 py-2 text-center text-[12px] shadow-none [box-shadow:none] transition-colors focus:shadow-none focus:[box-shadow:none] focus:outline-none',
+                                    row.hasError
+                                        ? 'border-red-300 bg-red-50 text-red-600'
+                                        : row.isCapturing
+                                          ? 'border-primary-300 bg-white text-neutral-950'
+                                          : 'focus:border-primary-300 border-transparent bg-[#f0f0ef] text-neutral-900 hover:bg-[#ececea]',
+                                    isSaving
+                                        ? 'cursor-wait opacity-50'
+                                        : row.shortcutAction
+                                          ? 'cursor-pointer'
+                                          : 'cursor-default',
+                                ]"
+                                :disabled="isSaving"
+                                :placeholder="t('settings.general.shortcutPlaceholder')"
+                                :title="
+                                    row.kind === 'fixed'
+                                        ? t('settings.general.searchShortcuts.fixedUnavailable')
+                                        : undefined
+                                "
+                                :tabindex="row.kind === 'fixed' ? -1 : 0"
+                                @mousedown="row.kind === 'fixed' && $event.preventDefault()"
+                                @focus="startSearchShortcutCapture(row)"
+                                @blur="stopSearchShortcutCaptureAndSave(row)"
+                            />
+                            <button
+                                v-if="row.shortcutAction"
+                                type="button"
+                                class="absolute top-1/2 right-2.5 flex h-6 w-6 -translate-y-1/2 items-center justify-center rounded-md text-neutral-500 transition-colors hover:bg-neutral-200/70 hover:text-neutral-900 disabled:cursor-not-allowed disabled:opacity-50"
+                                :disabled="isSaving"
+                                :title="row.shortcutActionLabel"
+                                :aria-label="row.shortcutActionLabel"
+                                :data-testid="`settings-search-shortcut-action-${row.id}`"
+                                :data-shortcut-action="row.shortcutAction"
+                                @mousedown.prevent
+                                @click="handleSearchShortcutIconAction(row.id, row.shortcutAction)"
+                            >
+                                <AppIcon
+                                    :name="row.shortcutAction === 'clear' ? 'x' : 'undo'"
+                                    class="h-4 w-4"
+                                />
+                            </button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</template>
diff --git a/apps/desktop/src/views/SettingsView/components/General/index.vue b/apps/desktop/src/views/SettingsView/components/General/index.vue
index fe8aaed8..2ebb3fa9 100644
--- a/apps/desktop/src/views/SettingsView/components/General/index.vue
+++ b/apps/desktop/src/views/SettingsView/components/General/index.vue
@@ -1,4 +1,4 @@
-<script setup lang="ts">
+<script setup lang="ts">
     import AlertMessage from '@components/AlertMessage.vue';
     import AppIcon from '@components/AppIcon.vue';
     import CustomSelect from '@components/CustomSelect.vue';
@@ -20,7 +20,13 @@
         t,
     } from '@/i18n';
     import { type OutputScrollBehavior, useSettingsStore } from '@/stores/settings';
+    import {
+        hasCommandModifier,
+        isReservedLocalShortcutKey,
+        normalizeLocalShortcutString,
+    } from '@/utils/shortcuts';
 
+    import SearchShortcutSettings from './SearchShortcutSettings.vue';
     import { resolveShortcutCaptureCompletion } from './shortcutCapture';
     import UpdateSettingsSection from './UpdateSettingsSection.vue';
 
@@ -74,7 +80,6 @@
         label: LOCALE_LABELS[value],
     }));
 
-    const shortcutInput = ref<HTMLInputElement | null>(null);
     const isSaving = ref(false);
     const isCapturing = ref(false);
     const hasCapturedShortcut = ref(false);
@@ -83,8 +88,27 @@
     const pendingLanguage = ref<AppLocale>(settings.value.language);
     const alertMessage = ref<InstanceType<typeof AlertMessage> | null>(null);
     const shortcutRegistrationFailed = ref(false);
+    const showGlobalShortcutPresetMenu = ref(false);
+    const globalShortcutPresetShortcuts = ['Alt+Space', 'Ctrl+Space'] as const;
+    const globalShortcutPresetOptions = computed(() =>
+        globalShortcutPresetShortcuts.map((shortcut) => ({
+            label: shortcut,
+            value: shortcut,
+        }))
+    );
+
+    function findGlobalShortcutSearchConflict(shortcut: string): boolean {
+        const normalizedShortcut = normalizeLocalShortcutString(shortcut);
+        if (!normalizedShortcut) {
+            return false;
+        }
+
+        return Object.values(settings.value.searchKeybindings).some((searchShortcut) => {
+            const normalizedSearchShortcut = normalizeLocalShortcutString(searchShortcut);
+            return normalizedSearchShortcut === normalizedShortcut;
+        });
+    }
 
-    // 键名映射表
     const keyNameMap: Record<string, string> = {
         Control: 'Ctrl',
         ' ': 'Space',
@@ -96,59 +120,91 @@
         Delete: 'Del',
     };
 
-    // 捕获快捷键
     const captureShortcut = (event: KeyboardEvent) => {
-        if (!isCapturing.value) return;
+        if (!isCapturing.value) {
+            return;
+        }
 
-        event.preventDefault();
-        event.stopPropagation();
+        if (isReservedLocalShortcutKey(event.key, event.code)) {
+            return;
+        }
 
-        // 忽略单独的修饰键和 Win 键
         if (['Control', 'Alt', 'Shift', 'Meta', 'OS'].includes(event.key)) {
             return;
         }
 
-        // 不支持 Win 键组合
         if (event.metaKey) {
             alertMessage.value?.warning(t('settings.general.winKeyUnsupported'), 3000);
             return;
         }
 
         const modifiers: string[] = [];
-        if (event.ctrlKey) modifiers.push('Ctrl');
-        if (event.altKey) modifiers.push('Alt');
-        if (event.shiftKey) modifiers.push('Shift');
-
-        // 获取按键名称
-        let keyName: string = event.key;
+        if (event.ctrlKey) {
+            modifiers.push('Ctrl');
+        }
+        if (event.altKey) {
+            modifiers.push('Alt');
+        }
+        if (event.shiftKey) {
+            modifiers.push('Shift');
+        }
 
-        // 使用映射表转换键名
+        let keyName = event.key;
         const mappedKey = keyNameMap[keyName];
         if (mappedKey) {
             keyName = mappedKey;
         } else if (keyName.length === 1) {
-            // 单字符键转为大写
             keyName = keyName.toUpperCase();
         }
 
-        // 组合快捷键字符串
         const shortcut = [...modifiers, keyName].join('+');
+        if (!hasCommandModifier(shortcut)) {
+            alertMessage.value?.warning(
+                t('settings.general.searchShortcuts.errors.modifierRequired'),
+                3000
+            );
+            return;
+        }
+
+        event.preventDefault();
+        event.stopPropagation();
+
         displayShortcut.value = shortcut;
         hasCapturedShortcut.value = true;
+        showGlobalShortcutPresetMenu.value = false;
+        void confirmCapturedShortcut(shortcut);
     };
 
-    // 开始捕获（输入框获得焦点）
     const startCapture = () => {
         isCapturing.value = true;
         hasCapturedShortcut.value = false;
         displayShortcut.value = shortcutCapturePrompt.value;
+        showGlobalShortcutPresetMenu.value = true;
+    };
+
+    const confirmCapturedShortcut = async (shortcut: string) => {
+        if (!isCapturing.value) {
+            return;
+        }
+
+        isCapturing.value = false;
+        showGlobalShortcutPresetMenu.value = false;
+
+        if (shortcut === settings.value.globalShortcut) {
+            displayShortcut.value = settings.value.globalShortcut;
+            return;
+        }
+
+        await saveNewShortcut(shortcut);
     };
 
-    // 停止捕获并保存（输入框失去焦点）
     const stopCaptureAndSave = async () => {
-        if (!isCapturing.value) return;
+        if (!isCapturing.value) {
+            return;
+        }
 
         isCapturing.value = false;
+        showGlobalShortcutPresetMenu.value = false;
 
         const completion = resolveShortcutCaptureCompletion({
             currentShortcut: settings.value.globalShortcut,
@@ -161,17 +217,37 @@
             return;
         }
 
-        // 保存新快捷键
         await saveNewShortcut(completion.shortcut);
     };
 
-    // 保存新快捷键的通用函数
+    const handleGlobalShortcutPresetOpenChange = (open: boolean) => {
+        if (isSaving.value) {
+            return;
+        }
+
+        if (open) {
+            startCapture();
+            return;
+        }
+
+        void stopCaptureAndSave();
+    };
+
     const saveNewShortcut = async (newShortcut: string) => {
+        if (findGlobalShortcutSearchConflict(newShortcut)) {
+            shortcutRegistrationFailed.value = false;
+            displayShortcut.value = settings.value.globalShortcut;
+            alertMessage.value?.error(
+                t('settings.general.searchShortcuts.errors.globalConflict'),
+                3000
+            );
+            return;
+        }
+
         isSaving.value = true;
         shortcutRegistrationFailed.value = false;
 
         try {
-            // 先注册到 Rust 端
             const registered = await registerShortcut(newShortcut);
             if (!registered) {
                 shortcutRegistrationFailed.value = true;
@@ -179,17 +255,13 @@
                 return;
             }
 
-            // 注册成功后保存到数据库
             await saveShortcutToDatabase(newShortcut);
-
-            // 更新本地状态
             settings.value.globalShortcut = newShortcut;
             displayShortcut.value = newShortcut;
             alertMessage.value?.success(t('settings.general.shortcutSaved'), 3000);
         } catch (error) {
             console.error('Failed to save shortcut:', error);
             alertMessage.value?.error(t('settings.general.saveShortcutFailed'), 3000);
-            // 恢复原值
             displayShortcut.value = settings.value.globalShortcut;
             shortcutRegistrationFailed.value = false;
         } finally {
@@ -197,27 +269,24 @@
         }
     };
 
-    // 使用建议的快捷键
     const useSuggestedShortcut = async (shortcut: string) => {
-        // 如果正在捕获，先取消捕获
-        if (isCapturing.value) {
-            isCapturing.value = false;
+        if (isSaving.value) {
+            return;
         }
 
-        // 如果输入框有焦点，先失焦
-        if (shortcutInput.value) {
-            shortcutInput.value.blur();
+        showGlobalShortcutPresetMenu.value = false;
+        if (isCapturing.value) {
+            isCapturing.value = false;
         }
 
         await saveNewShortcut(shortcut);
     };
 
-    // 监听 isCapturing 状态，添加/移除全局键盘监听
     watch(isCapturing, (newValue) => {
         if (newValue) {
-            window.addEventListener('keydown', captureShortcut);
+            window.addEventListener('keydown', captureShortcut, { capture: true });
         } else {
-            window.removeEventListener('keydown', captureShortcut);
+            window.removeEventListener('keydown', captureShortcut, { capture: true });
         }
     });
 
@@ -238,13 +307,11 @@
         { immediate: true }
     );
 
-    // 从 store 加载设置
     const loadSettings = async () => {
         try {
             await settingsStore.initialize();
             displayShortcut.value = settings.value.globalShortcut;
 
-            // 检查快捷键注册状态
             const [failed, error] = await native.shortcut.getShortcutStatus();
             if (failed) {
                 shortcutRegistrationFailed.value = true;
@@ -256,7 +323,6 @@
         }
     };
 
-    // 注册快捷键到 Rust 端
     const registerShortcut = async (shortcut: string): Promise<boolean> => {
         try {
             await native.shortcut.registerGlobalShortcut(shortcut);
@@ -313,7 +379,6 @@
                 };
             })();
 
-            // 发送系统通知
             notify({
                 title: t('notification.shortcutRegistrationFailed.title'),
                 body: t(shortcutErrorMessage.notificationBodyKey, shortcutErrorMessage.params),
@@ -327,7 +392,6 @@
         }
     };
 
-    // 保存快捷键到数据库并注册
     const saveShortcutToDatabase = async (shortcut: string) => {
         try {
             await settingsStore.updateGlobalShortcut(shortcut);
@@ -400,7 +464,6 @@
     onMounted(async () => {
         await loadSettings();
 
-        // 同步开机自启动状态
         try {
             const isEnabled = await native.autostart.isAutostartEnabled();
             if (isEnabled !== settings.value.startOnBoot) {
@@ -412,9 +475,8 @@
         }
     });
 
-    // 组件卸载时清理事件监听
     onUnmounted(() => {
-        window.removeEventListener('keydown', captureShortcut);
+        window.removeEventListener('keydown', captureShortcut, { capture: true });
     });
 </script>
 
@@ -432,14 +494,15 @@
                     <h2 class="settings-section-title">
                         {{ t('settings.general.shortcuts') }}
                     </h2>
-                    <p class="settings-section-description">
-                        {{ t('settings.general.shortcutsDescription') }}
-                    </p>
+                </div>
+
+                <div class="text-[12px] leading-5 font-medium text-neutral-500">
+                    {{ t('settings.general.globalShortcutGroup') }}
                 </div>
 
                 <div
                     data-testid="settings-general-card-shortcut"
-                    class="settings-row-group divide-y divide-neutral-200/70"
+                    class="settings-row-group divide-y divide-neutral-200/70 overflow-visible"
                 >
                     <div
                         class="grid min-w-0 gap-4 px-5 py-4 sm:grid-cols-[minmax(0,1fr)_360px] sm:items-center"
@@ -448,67 +511,57 @@
                             data-testid="settings-general-row-label"
                             class="text-[13px] leading-6 font-normal text-neutral-900"
                         >
-                            {{ t('settings.general.activationShortcut') }}
+                            <div>{{ t('settings.general.activationShortcut') }}</div>
+                            <div class="text-[12px] leading-5 text-neutral-500">
+                                {{ t('settings.general.activationShortcutDescription') }}
+                            </div>
                         </label>
                         <div class="min-w-0 justify-self-end">
                             <div
                                 data-testid="settings-shortcut-control-row"
-                                class="flex min-w-0 items-center justify-end gap-3 text-[11px]"
+                                class="flex min-w-0 items-center justify-end text-[11px]"
                             >
-                                <div
-                                    data-testid="settings-shortcut-suggestions"
-                                    class="shrink-0 text-left whitespace-nowrap"
-                                >
-                                    <span class="text-[11px] text-neutral-400">
-                                        {{ t('settings.general.suggestionsShort') }}
-                                    </span>
-                                    <button
-                                        class="text-primary-700 decoration-primary-300 hover:text-primary-600 ml-2 font-mono text-[11px] underline underline-offset-2 transition-colors disabled:cursor-not-allowed disabled:opacity-50"
-                                        :disabled="isSaving"
-                                        @click="useSuggestedShortcut('Alt+Space')"
-                                    >
-                                        Alt+Space
-                                    </button>
-                                    <span class="mx-1.5 text-neutral-300">|</span>
-                                    <button
-                                        class="text-primary-700 decoration-primary-300 hover:text-primary-600 font-mono text-[11px] underline underline-offset-2 transition-colors disabled:cursor-not-allowed disabled:opacity-50"
-                                        :disabled="isSaving"
-                                        @click="useSuggestedShortcut('Ctrl+Space')"
-                                    >
-                                        Ctrl+Space
-                                    </button>
-                                </div>
-                                <div data-testid="settings-general-control" class="w-[180px]">
+                                <div data-testid="settings-general-control" class="w-[220px]">
                                     <div
                                         data-testid="settings-general-shortcut-input-wrap"
-                                        class="relative ml-auto w-[180px] shrink-0"
+                                        class="relative ml-auto w-[220px] shrink-0"
                                     >
-                                        <input
-                                            ref="shortcutInput"
-                                            v-model="displayShortcut"
-                                            data-testid="settings-global-shortcut-input"
-                                            type="text"
-                                            readonly
-                                            :class="[
-                                                'w-full rounded-[10px] border px-3 py-2 text-center font-mono text-[12px] shadow-none [box-shadow:none] transition-colors focus:shadow-none focus:[box-shadow:none] focus:outline-none',
-                                                shortcutRegistrationFailed
-                                                    ? 'border-red-300 bg-red-50 text-red-600'
-                                                    : isCapturing
-                                                      ? 'border-primary-300 bg-white text-neutral-950'
-                                                      : 'focus:border-primary-300 border-transparent bg-[#f0f0ef] text-neutral-900 hover:bg-[#ececea]',
-                                                isSaving
-                                                    ? 'cursor-wait opacity-50'
-                                                    : 'cursor-pointer',
-                                            ]"
+                                        <CustomSelect
+                                            :model-value="displayShortcut"
+                                            :options="globalShortcutPresetOptions"
+                                            :open="showGlobalShortcutPresetMenu"
+                                            :display-label="displayShortcut"
                                             :disabled="isSaving"
-                                            :placeholder="t('settings.general.shortcutPlaceholder')"
-                                            @focus="startCapture"
-                                            @blur="stopCaptureAndSave"
-                                        />
+                                            trigger-as="div"
+                                            content-test-id="settings-global-shortcut-preset-menu"
+                                            option-test-id-prefix="settings-global-shortcut-preset-"
+                                            disable-portal
+                                            protect-option-text
+                                            @update:open="handleGlobalShortcutPresetOpenChange"
+                                            @update:model-value="useSuggestedShortcut"
+                                        >
+                                            <template #trigger>
+                                                <input
+                                                    v-model="displayShortcut"
+                                                    data-testid="settings-global-shortcut-input"
+                                                    type="text"
+                                                    readonly
+                                                    class="min-w-0 flex-1 bg-transparent text-center text-[12px] outline-none"
+                                                    :disabled="isSaving"
+                                                    :placeholder="
+                                                        t('settings.general.shortcutPlaceholder')
+                                                    "
+                                                    @pointerdown.stop
+                                                    @keydown.capture="captureShortcut"
+                                                    @click.stop
+                                                    @focus="startCapture"
+                                                />
+                                            </template>
+                                        </CustomSelect>
                                         <span
                                             v-if="shortcutRegistrationFailed"
                                             data-testid="settings-shortcut-occupied-indicator"
-                                            class="absolute top-1/2 right-2.5 flex h-4 w-4 -translate-y-1/2 items-center justify-center text-red-500"
+                                            class="absolute top-1/2 right-8 flex h-4 w-4 -translate-y-1/2 items-center justify-center text-red-500"
                                             :title="
                                                 t('settings.general.shortcutRegistrationFailed')
                                             "
@@ -524,6 +577,8 @@
                         </div>
                     </div>
                 </div>
+
+                <SearchShortcutSettings />
             </section>
 
             <section class="space-y-4">
diff --git a/apps/desktop/tests/SettingsView/general-language.test.ts b/apps/desktop/tests/SettingsView/general-language.test.ts
index 07da4c83..a61594f9 100644
--- a/apps/desktop/tests/SettingsView/general-language.test.ts
+++ b/apps/desktop/tests/SettingsView/general-language.test.ts
@@ -166,7 +166,9 @@ describe('Settings General shortcut capture i18n', () => {
 
         expect(wrapper.text()).toContain('General');
         expect(wrapper.text()).toContain('Shortcuts');
-        expect(wrapper.text()).toContain('Set the global entry point for opening TouchAI');
+        expect(wrapper.text()).toContain('Set the global shortcut used to open TouchAI.');
+        expect(wrapper.text()).toContain('Toggle window maximize');
+        expect(wrapper.text()).toContain('Toggle the search window maximized state.');
         expect(wrapper.text()).toContain('Activation shortcut');
         expect(wrapper.text()).toContain('Startup and window');
         expect(wrapper.text()).toContain(
diff --git a/apps/desktop/tests/composables/SearchView/searchInteraction.test.ts b/apps/desktop/tests/composables/SearchView/searchInteraction.test.ts
index 5f357024..cf3aad95 100644
--- a/apps/desktop/tests/composables/SearchView/searchInteraction.test.ts
+++ b/apps/desktop/tests/composables/SearchView/searchInteraction.test.ts
@@ -1,13 +1,15 @@
 import { mountComposable } from '@tests/utils/composables';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createPinia, setActivePinia } from 'pinia';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { computed, nextTick, ref } from 'vue';
 
+import { createDefaultSearchKeybindings } from '@/config/searchKeybindings';
 import { createInputHistorySnapshot, type SessionMessage } from '@/types/session';
 import {
     createPopupSurfaceCoordinator,
     createSearchEntryPolicy,
     createSearchInteractionContext,
-    createSearchKeyboardRouter,
+    createSearchKeydownHandler,
     createSessionInputHistoryBrowseState,
     extractSessionInputHistoryEntries,
     navigateSessionInputHistory,
@@ -31,6 +33,10 @@ function createUserMessage(id: string, overrides: Partial<SessionMessage> = {}):
     };
 }
 
+beforeEach(() => {
+    setActivePinia(createPinia());
+});
+
 function createControllerStub() {
     return {
         focusConversation: vi.fn(),
@@ -66,11 +72,6 @@ function createControllerStub() {
     } satisfies SearchPageController;
 }
 
-async function flushMicrotasks() {
-    await Promise.resolve();
-    await Promise.resolve();
-}
-
 describe('extractSessionInputHistoryEntries', () => {
     it('returns only user prompts that still have visible input history content', () => {
         const entries = extractSessionInputHistoryEntries([
@@ -293,6 +294,192 @@ describe('useQuickSearchCoordinator', () => {
     });
 });
 
+describe('createSearchKeydownHandler', () => {
+    it('routes the default F11 maximize shortcut to the maximize callback', async () => {
+        const controller = createControllerStub();
+        const toggleWindowMaximize = vi.fn().mockResolvedValue(undefined);
+        const handleKeyDown = createSearchKeydownHandler({
+            viewReady: ref(true),
+            searchKeybindings: ref(createDefaultSearchKeybindings()),
+            queryText: ref(''),
+            attachments: ref([]),
+            cursorContext: ref<SearchCursorContext>({
+                isMultiLine: false,
+                cursorAtStart: true,
+                cursorAtTextStart: true,
+                cursorAtEnd: true,
+            }),
+            modelOverride: ref<SearchModelOverride>({
+                modelId: null,
+                providerId: null,
+            }),
+            modelDropdownState: ref({ isOpen: false }),
+            controller,
+            sessionHistory: ref([]),
+            pendingRequest: ref(null),
+            isWaitingForCompletion: ref(false),
+            isLoading: ref(false),
+            pendingToolApproval: ref(null),
+            approvePendingToolApproval: vi.fn(() => false),
+            rejectPendingToolApproval: vi.fn(() => false),
+            promptPendingToolApprovalAttention: vi.fn(),
+            getActivePopupType: () => null,
+            hasActivePopupWindowFocus: () => false,
+            isQuickSearchOpen: computed(() => false),
+            shouldTriggerQuickSearch: () => false,
+            sessionHistoryPopupOpen: ref(false),
+            hideAllPopups: vi.fn().mockResolvedValue(undefined),
+            hideSearchWindow: vi.fn().mockResolvedValue(undefined),
+            navigateInputHistory: vi.fn(() => 'ignored' as const),
+            closeModelDropdown: vi.fn().mockResolvedValue(undefined),
+            toggleModelDropdown: vi.fn().mockResolvedValue(undefined),
+            openHistoryDialog: vi.fn().mockResolvedValue(undefined),
+            startNewSession: vi.fn().mockResolvedValue(undefined),
+            reopenLastClosedSession: vi.fn().mockResolvedValue(undefined),
+            toggleWindowPin: vi.fn().mockResolvedValue(undefined),
+            toggleWindowMaximize,
+            openSettingsWindow: vi.fn().mockResolvedValue(undefined),
+            handleSubmit: vi.fn().mockResolvedValue(undefined),
+            cancelRequest: vi.fn(),
+            clearSession: vi.fn(),
+        });
+
+        const event = new KeyboardEvent('keydown', { key: 'F11', cancelable: true });
+        await handleKeyDown(event);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(toggleWindowMaximize).toHaveBeenCalledTimes(1);
+        expect(event.defaultPrevented).toBe(true);
+    });
+
+    it('cancels a pending request with Escape and ignores Backspace', async () => {
+        const controller = createControllerStub();
+        const cancelRequest = vi.fn();
+        const handleKeyDown = createSearchKeydownHandler({
+            viewReady: ref(true),
+            searchKeybindings: ref(createDefaultSearchKeybindings()),
+            queryText: ref(''),
+            attachments: ref([]),
+            cursorContext: ref<SearchCursorContext>({
+                isMultiLine: false,
+                cursorAtStart: true,
+                cursorAtTextStart: true,
+                cursorAtEnd: true,
+            }),
+            modelOverride: ref<SearchModelOverride>({
+                modelId: null,
+                providerId: null,
+            }),
+            modelDropdownState: ref({ isOpen: false }),
+            controller,
+            sessionHistory: ref([]),
+            pendingRequest: ref({ query: 'q', attachments: [] }),
+            isWaitingForCompletion: ref(true),
+            isLoading: ref(true),
+            pendingToolApproval: ref(null),
+            approvePendingToolApproval: vi.fn(() => false),
+            rejectPendingToolApproval: vi.fn(() => false),
+            promptPendingToolApprovalAttention: vi.fn(),
+            getActivePopupType: () => null,
+            hasActivePopupWindowFocus: () => false,
+            isQuickSearchOpen: computed(() => false),
+            shouldTriggerQuickSearch: () => false,
+            sessionHistoryPopupOpen: ref(false),
+            hideAllPopups: vi.fn().mockResolvedValue(undefined),
+            hideSearchWindow: vi.fn().mockResolvedValue(undefined),
+            navigateInputHistory: vi.fn(() => 'ignored' as const),
+            closeModelDropdown: vi.fn().mockResolvedValue(undefined),
+            toggleModelDropdown: vi.fn().mockResolvedValue(undefined),
+            openHistoryDialog: vi.fn().mockResolvedValue(undefined),
+            startNewSession: vi.fn().mockResolvedValue(undefined),
+            reopenLastClosedSession: vi.fn().mockResolvedValue(undefined),
+            toggleWindowPin: vi.fn().mockResolvedValue(undefined),
+            toggleWindowMaximize: vi.fn().mockResolvedValue(undefined),
+            openSettingsWindow: vi.fn().mockResolvedValue(undefined),
+            handleSubmit: vi.fn().mockResolvedValue(undefined),
+            cancelRequest,
+            clearSession: vi.fn(),
+        });
+
+        const backspaceEvent = new KeyboardEvent('keydown', { key: 'Backspace', cancelable: true });
+        await handleKeyDown(backspaceEvent);
+        expect(cancelRequest).not.toHaveBeenCalled();
+        expect(backspaceEvent.defaultPrevented).toBe(false);
+
+        const escapeEvent = new KeyboardEvent('keydown', { key: 'Escape', cancelable: true });
+        await handleKeyDown(escapeEvent);
+        expect(cancelRequest).toHaveBeenCalledTimes(1);
+        expect(escapeEvent.defaultPrevented).toBe(true);
+    });
+
+    it('routes a configured command shortcut to reopen the most recently closed session', async () => {
+        const controller = createControllerStub();
+        const reopenLastClosedSession = vi.fn().mockResolvedValue(undefined);
+        const handleKeyDown = createSearchKeydownHandler({
+            viewReady: ref(true),
+            searchKeybindings: ref({
+                ...createDefaultSearchKeybindings(),
+                'search.session.reopenLastClosed': 'Mod+Shift+Y',
+            }),
+            queryText: ref(''),
+            attachments: ref([]),
+            cursorContext: ref<SearchCursorContext>({
+                isMultiLine: false,
+                cursorAtStart: true,
+                cursorAtTextStart: true,
+                cursorAtEnd: true,
+            }),
+            modelOverride: ref<SearchModelOverride>({
+                modelId: null,
+                providerId: null,
+            }),
+            modelDropdownState: ref({ isOpen: false }),
+            controller,
+            sessionHistory: ref([]),
+            pendingRequest: ref(null),
+            isWaitingForCompletion: ref(false),
+            isLoading: ref(false),
+            pendingToolApproval: ref(null),
+            approvePendingToolApproval: vi.fn(() => false),
+            rejectPendingToolApproval: vi.fn(() => false),
+            promptPendingToolApprovalAttention: vi.fn(),
+            getActivePopupType: () => null,
+            hasActivePopupWindowFocus: () => false,
+            isQuickSearchOpen: computed(() => false),
+            shouldTriggerQuickSearch: () => false,
+            sessionHistoryPopupOpen: ref(false),
+            hideAllPopups: vi.fn().mockResolvedValue(undefined),
+            hideSearchWindow: vi.fn().mockResolvedValue(undefined),
+            navigateInputHistory: vi.fn(() => 'ignored' as const),
+            closeModelDropdown: vi.fn().mockResolvedValue(undefined),
+            toggleModelDropdown: vi.fn().mockResolvedValue(undefined),
+            openHistoryDialog: vi.fn().mockResolvedValue(undefined),
+            startNewSession: vi.fn().mockResolvedValue(undefined),
+            reopenLastClosedSession,
+            toggleWindowPin: vi.fn().mockResolvedValue(undefined),
+            toggleWindowMaximize: vi.fn().mockResolvedValue(undefined),
+            openSettingsWindow: vi.fn().mockResolvedValue(undefined),
+            handleSubmit: vi.fn().mockResolvedValue(undefined),
+            cancelRequest: vi.fn(),
+            clearSession: vi.fn(),
+        });
+
+        const event = new KeyboardEvent('keydown', {
+            key: 'y',
+            ctrlKey: true,
+            shiftKey: true,
+            cancelable: true,
+        });
+        await handleKeyDown(event);
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(reopenLastClosedSession).toHaveBeenCalledTimes(1);
+        expect(event.defaultPrevented).toBe(true);
+    });
+});
+
 describe('useSearchOverlayMachine', () => {
     afterEach(() => {
         document.body.innerHTML = '';
@@ -329,150 +516,3 @@ describe('useSearchOverlayMachine', () => {
         mounted.unmount();
     });
 });
-
-describe('createSearchKeyboardRouter', () => {
-    function createKeyboardRouter(
-        overrides: Partial<Parameters<typeof createSearchKeyboardRouter>[0]> = {}
-    ) {
-        const callbacks = {
-            onPromptApprovalAttention: vi.fn(),
-            onRejectApproval: vi.fn(),
-            onApproveApproval: vi.fn(),
-            onForwardToPopup: vi.fn(),
-            onSubmit: vi.fn(),
-            onOpenQuickSearch: vi.fn(),
-            onMoveQuickSearchSelection: vi.fn(),
-            onOpenHighlightedQuickSearchItem: vi.fn(),
-            onCloseQuickSearch: vi.fn(),
-            onQuickSearchPageUp: vi.fn(),
-            onQuickSearchPageDown: vi.fn(),
-            onQuickSearchContextMenu: vi.fn(),
-            onQuickSearchToggleView: vi.fn(),
-            onQuickSearchCollapse: vi.fn(),
-            onNavigateInputHistory: vi.fn(() => 'ignored' as const),
-            onHideAllPopups: vi.fn(),
-            onCancelRequest: vi.fn(),
-            onClearModelOverride: vi.fn(),
-            onHideWindow: vi.fn(),
-            onClearSession: vi.fn(),
-            onClearDraft: vi.fn(),
-            onClearAll: vi.fn(),
-            onPrimaryShortcut: vi.fn(),
-        };
-
-        return {
-            callbacks,
-            router: createSearchKeyboardRouter({
-                getPendingApproval: () => null,
-                getActiveSurface: () => 'search-surface',
-                hasActivePopupWindowFocus: () => false,
-                getQueryText: () => '',
-                hasAttachments: () => false,
-                isQuickSearchOpen: () => false,
-                hasQuickSearchHighlight: () => false,
-                shouldTriggerQuickSearch: () => false,
-                isMultiLineCursor: () => false,
-                isCursorAtStart: () => true,
-                isCursorAtTextStart: () => true,
-                isCursorAtEnd: () => true,
-                hasModelOverride: () => false,
-                getSessionHistoryCount: () => 0,
-                isLoading: () => false,
-                ...callbacks,
-                ...overrides,
-            }),
-        };
-    }
-
-    it('rejects pending approval with escape before normal surface handling', () => {
-        const { router, callbacks } = createKeyboardRouter({
-            getPendingApproval: () => ({
-                callId: 'approval-1',
-                keyboardApproveAt: Date.now() + 1_000,
-            }),
-        });
-
-        const handled = router.route({ key: 'Escape' });
-
-        expect(handled).toBe(true);
-        expect(callbacks.onRejectApproval).toHaveBeenCalledWith('approval-1');
-    });
-
-    it('submits when ArrowDown cannot navigate newer history and query text is present', () => {
-        const { router, callbacks } = createKeyboardRouter({
-            getQueryText: () => 'touch',
-            shouldTriggerQuickSearch: () => true,
-            onNavigateInputHistory: vi.fn(() => 'ignored' as const),
-        });
-
-        const handled = router.route({ key: 'ArrowDown' });
-
-        expect(handled).toBe(true);
-        expect(callbacks.onSubmit).toHaveBeenCalledTimes(1);
-        expect(callbacks.onOpenQuickSearch).not.toHaveBeenCalled();
-    });
-
-    it('opens quick search when ArrowDown cannot navigate newer history and query is empty with eligible trigger', () => {
-        const { router, callbacks } = createKeyboardRouter({
-            getQueryText: () => '',
-            shouldTriggerQuickSearch: () => true,
-            hasAttachments: () => false,
-            onNavigateInputHistory: vi.fn(() => 'ignored' as const),
-        });
-
-        const handled = router.route({ key: 'ArrowDown' });
-
-        expect(handled).toBe(true);
-        expect(callbacks.onOpenQuickSearch).toHaveBeenCalledTimes(1);
-    });
-
-    it('does not navigate input history when multiline cursor is not at the text start', () => {
-        const { router, callbacks } = createKeyboardRouter({
-            isMultiLineCursor: () => true,
-            isCursorAtTextStart: () => false,
-        });
-
-        const handled = router.route({ key: 'ArrowUp' });
-
-        expect(handled).toBe(false);
-        expect(callbacks.onNavigateInputHistory).not.toHaveBeenCalled();
-    });
-
-    it('forwards model-dropdown arrow keys to the popup surface contract', () => {
-        const { router, callbacks } = createKeyboardRouter({
-            getActiveSurface: () => 'model-dropdown-surface',
-        });
-
-        const handled = router.route({ key: 'ArrowDown' });
-
-        expect(handled).toBe(true);
-        expect(callbacks.onForwardToPopup).toHaveBeenCalledWith('ArrowDown');
-    });
-
-    it('clears the draft before model/session/window dismissal on escape', () => {
-        const { router, callbacks } = createKeyboardRouter({
-            getQueryText: () => 'hello',
-        });
-
-        const handled = router.route({ key: 'Escape' });
-
-        expect(handled).toBe(true);
-        expect(callbacks.onClearDraft).toHaveBeenCalledTimes(1);
-        expect(callbacks.onClearModelOverride).not.toHaveBeenCalled();
-        expect(callbacks.onClearSession).not.toHaveBeenCalled();
-        expect(callbacks.onHideWindow).not.toHaveBeenCalled();
-    });
-
-    it('fires the stop-request primary shortcut only while the request is still loading', async () => {
-        const { router, callbacks } = createKeyboardRouter({
-            getQueryText: () => '',
-            isLoading: () => true,
-        });
-
-        const handled = router.route({ key: '.', ctrlKey: true });
-        await flushMicrotasks();
-
-        expect(handled).toBe(true);
-        expect(callbacks.onPrimaryShortcut).toHaveBeenCalledWith('.');
-    });
-});
diff --git a/apps/desktop/tests/composables/SearchView/useSearchKeyboardRouter.test.ts b/apps/desktop/tests/composables/SearchView/useSearchKeyboardRouter.test.ts
index e186d6ae..d22edb35 100644
--- a/apps/desktop/tests/composables/SearchView/useSearchKeyboardRouter.test.ts
+++ b/apps/desktop/tests/composables/SearchView/useSearchKeyboardRouter.test.ts
@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
+import { createDefaultSearchKeybindings } from '@/config/searchKeybindings';
 import { createSearchKeyboardRouter } from '@/views/SearchView/composables/interaction/useSearchKeyboardRouter';
 
 async function flushAsyncWork() {
@@ -10,7 +11,7 @@ async function flushAsyncWork() {
 function createKeyboardRouter(
     overrides: Partial<Parameters<typeof createSearchKeyboardRouter>[0]> = {}
 ) {
-    const callbacks = {
+    const defaultCallbacks = {
         onPromptApprovalAttention: vi.fn(),
         onRejectApproval: vi.fn(),
         onApproveApproval: vi.fn(),
@@ -20,6 +21,12 @@ function createKeyboardRouter(
         onMoveQuickSearchSelection: vi.fn(),
         onOpenHighlightedQuickSearchItem: vi.fn(),
         onCloseQuickSearch: vi.fn(),
+        onQuickSearchPageUp: vi.fn(),
+        onQuickSearchPageDown: vi.fn(),
+        onQuickSearchContextMenu: vi.fn(),
+        onQuickSearchToggleView: vi.fn(),
+        onQuickSearchCollapse: vi.fn(),
+        onNavigateInputHistory: vi.fn(() => 'ignored' as const),
         onHideAllPopups: vi.fn(),
         onCancelRequest: vi.fn(),
         onClearModelOverride: vi.fn(),
@@ -27,27 +34,31 @@ function createKeyboardRouter(
         onClearSession: vi.fn(),
         onClearDraft: vi.fn(),
         onClearAll: vi.fn(),
-        onPrimaryShortcut: vi.fn(),
+        onSearchKeybindingAction: vi.fn(),
+    };
+    const routerOptions = {
+        getSearchKeybindings: () => createDefaultSearchKeybindings(),
+        getPendingApproval: () => null,
+        getActiveSurface: () => 'search-surface' as const,
+        hasActivePopupWindowFocus: () => false,
+        getQueryText: () => '',
+        hasAttachments: () => false,
+        isQuickSearchOpen: () => false,
+        hasQuickSearchHighlight: () => false,
+        shouldTriggerQuickSearch: () => false,
+        isMultiLineCursor: () => false,
+        isCursorAtTextStart: () => true,
+        isCursorAtEnd: () => true,
+        hasModelOverride: () => false,
+        getSessionHistoryCount: () => 0,
+        isLoading: () => false,
+        ...defaultCallbacks,
+        ...overrides,
     };
 
     return {
-        callbacks,
-        router: createSearchKeyboardRouter({
-            getPendingApproval: () => null,
-            getActiveSurface: () => 'search-surface',
-            hasActivePopupWindowFocus: () => false,
-            getQueryText: () => '',
-            hasAttachments: () => false,
-            isQuickSearchOpen: () => false,
-            hasQuickSearchHighlight: () => false,
-            shouldTriggerQuickSearch: () => false,
-            isMultiLineCursor: () => false,
-            hasModelOverride: () => false,
-            getSessionHistoryCount: () => 0,
-            isLoading: () => false,
-            ...callbacks,
-            ...overrides,
-        }),
+        callbacks: routerOptions,
+        router: createSearchKeyboardRouter(routerOptions),
     };
 }
 
@@ -89,22 +100,198 @@ describe('createSearchKeyboardRouter', () => {
         expect(callbacks.onApproveApproval).toHaveBeenCalledWith('approval-2');
     });
 
-    it('runs primary shortcuts only when their guard conditions are satisfied', async () => {
+    it('lets modified typing attempts bypass pending approval attention', () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getPendingApproval: () => ({
+                callId: 'approval-3',
+                keyboardApproveAt: Date.now() + 5_000,
+            }),
+            getSearchKeybindings: () => ({
+                ...createDefaultSearchKeybindings(),
+                'search.history.open': 'Alt+X',
+            }),
+        });
+
+        expect(router.route({ key: 'x', altKey: true })).toBe(true);
+
+        expect(callbacks.onPromptApprovalAttention).not.toHaveBeenCalled();
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledWith('search.history.open');
+    });
+
+    it('treats Backspace and Delete as typing attempts during pending approval', () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getPendingApproval: () => ({
+                callId: 'approval-4',
+                keyboardApproveAt: Date.now() + 5_000,
+            }),
+        });
+
+        expect(router.route({ key: 'Backspace' })).toBe(true);
+        expect(router.route({ key: 'Delete' })).toBe(true);
+        expect(router.route({ key: 'Enter', shiftKey: true })).toBe(true);
+
+        expect(callbacks.onPromptApprovalAttention).toHaveBeenCalledTimes(3);
+        expect(callbacks.onApproveApproval).not.toHaveBeenCalled();
+    });
+
+    it('routes configurable command shortcuts through the action callback', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => ({
+                ...createDefaultSearchKeybindings(),
+                'search.history.open': 'Mod+Y',
+            }),
+        });
+
+        expect(router.route({ key: 'y', ctrlKey: true })).toBe(true);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledWith('search.history.open');
+    });
+
+    it('routes function-row search shortcuts by keyboard code when the key value is remapped', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => ({
+                ...createDefaultSearchKeybindings(),
+                'search.history.open': 'F2',
+            }),
+        });
+
+        expect(router.route({ key: 'BrightnessUp', code: 'F2' })).toBe(true);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledWith('search.history.open');
+    });
+
+    it('does not route Ctrl+Up through default search shortcuts or input history', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => createDefaultSearchKeybindings(),
+        });
+
+        expect(router.route({ key: 'ArrowUp', ctrlKey: true })).toBe(false);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).not.toHaveBeenCalled();
+        expect(callbacks.onNavigateInputHistory).not.toHaveBeenCalled();
+    });
+
+    it('routes the default maximize shortcut through the action callback', async () => {
         const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => createDefaultSearchKeybindings(),
+        });
+
+        expect(router.route({ key: 'F11' })).toBe(true);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledWith('search.window.maximize');
+    });
+
+    it('routes the default settings shortcut through the action callback', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => createDefaultSearchKeybindings(),
+        });
+
+        expect(router.route({ key: ',', ctrlKey: true })).toBe(true);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledWith('search.settings.open');
+    });
+
+    it('routes the default reopen-last-closed-session shortcut through the action callback', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => createDefaultSearchKeybindings(),
+        });
+
+        expect(router.route({ key: 't', ctrlKey: true, shiftKey: true })).toBe(true);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledWith(
+            'search.session.reopenLastClosed'
+        );
+    });
+
+    it('stops routing raw F11 after the maximize shortcut is remapped', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => ({
+                ...createDefaultSearchKeybindings(),
+                'search.window.maximize': 'F12',
+            }),
+        });
+
+        expect(router.route({ key: 'F11' })).toBe(false);
+        expect(router.route({ key: 'F12' })).toBe(true);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledTimes(1);
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledWith('search.window.maximize');
+    });
+
+    it('does not route removed Ctrl+. and Ctrl+Backspace shortcuts', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => createDefaultSearchKeybindings(),
             getQueryText: () => 'touchai',
             isLoading: () => true,
         });
 
-        expect(router.route({ key: 'Backspace', ctrlKey: true })).toBe(true);
-        expect(router.route({ key: '.', ctrlKey: true })).toBe(true);
+        expect(router.route({ key: 'Backspace', ctrlKey: true })).toBe(false);
+        expect(router.route({ key: '.', ctrlKey: true })).toBe(false);
         expect(router.route({ key: '.', ctrlKey: true, shiftKey: true })).toBe(false);
         await flushAsyncWork();
 
-        expect(callbacks.onPrimaryShortcut).toHaveBeenNthCalledWith(1, 'backspace');
-        expect(callbacks.onPrimaryShortcut).toHaveBeenNthCalledWith(2, '.');
+        expect(callbacks.onSearchKeybindingAction).not.toHaveBeenCalled();
+    });
+
+    it('swallows keyboard effects that reject after routing a shortcut', async () => {
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const rejection = new Error('shortcut side effect failed');
+        const { router, callbacks } = createKeyboardRouter({
+            getSearchKeybindings: () => ({
+                ...createDefaultSearchKeybindings(),
+                'search.history.open': 'Mod+Y',
+            }),
+            onSearchKeybindingAction: vi.fn().mockRejectedValue(rejection),
+        });
+
+        expect(router.route({ key: 'y', ctrlKey: true })).toBe(true);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).toHaveBeenCalledWith('search.history.open');
+        expect(errorSpy).toHaveBeenCalledWith(
+            '[SearchKeyboardRouter] Failed to handle keyboard effect:',
+            rejection
+        );
+    });
+
+    it('consumes keys while a popup window owns focus', () => {
+        const { router, callbacks } = createKeyboardRouter({
+            hasActivePopupWindowFocus: () => true,
+        });
+
+        expect(router.route({ key: 'A' })).toBe(true);
+
+        expect(callbacks.onSubmit).not.toHaveBeenCalled();
+        expect(callbacks.onOpenQuickSearch).not.toHaveBeenCalled();
+    });
+
+    it('does not route search shortcuts while a popup window owns focus', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            hasActivePopupWindowFocus: () => true,
+        });
+
+        expect(router.route({ key: 'F11' })).toBe(true);
+        expect(router.route({ key: 'h', ctrlKey: true })).toBe(true);
+        await flushAsyncWork();
+
+        expect(callbacks.onSearchKeybindingAction).not.toHaveBeenCalled();
     });
 
     it('applies the escape fallback order on the search surface', async () => {
+        const loadingRouter = createKeyboardRouter({
+            isLoading: () => true,
+        });
+        expect(loadingRouter.router.route({ key: 'Escape' })).toBe(true);
+        expect(loadingRouter.callbacks.onCancelRequest).toHaveBeenCalledTimes(1);
+        expect(loadingRouter.callbacks.onClearDraft).not.toHaveBeenCalled();
+
         const draftRouter = createKeyboardRouter({
             getQueryText: () => 'current draft',
         });
@@ -132,6 +319,18 @@ describe('createSearchKeyboardRouter', () => {
         expect(emptyRouter.callbacks.onHideWindow).toHaveBeenCalledTimes(1);
     });
 
+    it('collapses highlighted quick search on escape before closing surfaces', () => {
+        const { router, callbacks } = createKeyboardRouter({
+            isQuickSearchOpen: () => true,
+            hasQuickSearchHighlight: () => true,
+        });
+
+        expect(router.route({ key: 'Esc' })).toBe(true);
+
+        expect(callbacks.onQuickSearchCollapse).toHaveBeenCalledTimes(1);
+        expect(callbacks.onHideWindow).not.toHaveBeenCalled();
+    });
+
     it('hides popup surfaces with escape and forwards model dropdown navigation keys', async () => {
         const popupRouter = createKeyboardRouter({
             getActiveSurface: () => 'model-dropdown-surface',
@@ -151,16 +350,41 @@ describe('createSearchKeyboardRouter', () => {
         expect(dropdownRouter.callbacks.onForwardToPopup).toHaveBeenNthCalledWith(2, 'Enter');
     });
 
+    it('routes quick-search page, menu, and view-toggle keys', () => {
+        const { router, callbacks } = createKeyboardRouter({
+            isQuickSearchOpen: () => true,
+            hasQuickSearchHighlight: () => false,
+        });
+
+        expect(router.route({ key: 'PageUp' })).toBe(true);
+        expect(router.route({ key: 'PageDown' })).toBe(true);
+        expect(router.route({ key: 'ContextMenu' })).toBe(true);
+        expect(router.route({ key: 'F10', shiftKey: true })).toBe(true);
+        expect(router.route({ key: 'g', ctrlKey: true })).toBe(true);
+        expect(router.route({ key: 'G', metaKey: true })).toBe(true);
+
+        expect(callbacks.onQuickSearchPageUp).toHaveBeenCalledTimes(1);
+        expect(callbacks.onQuickSearchPageDown).toHaveBeenCalledTimes(1);
+        expect(callbacks.onQuickSearchContextMenu).toHaveBeenCalledTimes(2);
+        expect(callbacks.onQuickSearchToggleView).toHaveBeenCalledTimes(2);
+    });
+
     it('routes highlighted quick-search navigation and opening through the quick-search contract', async () => {
         const { router, callbacks } = createKeyboardRouter({
             isQuickSearchOpen: () => true,
             hasQuickSearchHighlight: () => true,
         });
 
+        expect(router.route({ key: 'ArrowUp' })).toBe(true);
+        expect(router.route({ key: 'ArrowDown' })).toBe(true);
+        expect(router.route({ key: 'ArrowLeft' })).toBe(true);
         expect(router.route({ key: 'ArrowRight' })).toBe(true);
         expect(router.route({ key: 'Enter' })).toBe(true);
         await flushAsyncWork();
 
+        expect(callbacks.onMoveQuickSearchSelection).toHaveBeenNthCalledWith(1, 'up');
+        expect(callbacks.onMoveQuickSearchSelection).toHaveBeenNthCalledWith(2, 'down');
+        expect(callbacks.onMoveQuickSearchSelection).toHaveBeenNthCalledWith(3, 'left');
         expect(callbacks.onMoveQuickSearchSelection).toHaveBeenCalledWith('right');
         expect(callbacks.onOpenHighlightedQuickSearchItem).toHaveBeenCalledTimes(1);
     });
@@ -181,27 +405,115 @@ describe('createSearchKeyboardRouter', () => {
         expect(quickSearchRouter.callbacks.onSubmit).toHaveBeenCalledTimes(1);
 
         const openRouter = createKeyboardRouter({
-            getQueryText: () => 'touch',
+            getQueryText: () => '',
             shouldTriggerQuickSearch: () => true,
         });
         expect(openRouter.router.route({ key: 'ArrowDown' })).toBe(true);
         expect(openRouter.callbacks.onOpenQuickSearch).toHaveBeenCalledTimes(1);
     });
 
-    it('submits ArrowUp on a single-line cursor and leaves multiline editing alone', async () => {
+    it('closes unhighlighted quick search on enter without submitting empty text', async () => {
+        const { router, callbacks } = createKeyboardRouter({
+            getQueryText: () => '   ',
+            isQuickSearchOpen: () => true,
+            hasQuickSearchHighlight: () => false,
+        });
+
+        expect(router.route({ key: 'Enter' })).toBe(true);
+        expect(router.route({ key: 'Enter', shiftKey: true })).toBe(false);
+        await flushAsyncWork();
+
+        expect(callbacks.onCloseQuickSearch).toHaveBeenCalledTimes(1);
+        expect(callbacks.onSubmit).not.toHaveBeenCalled();
+    });
+
+    it('uses input-history navigation for ArrowUp and leaves multiline editing alone', async () => {
         const singleLineRouter = createKeyboardRouter({
             getQueryText: () => 'submit me',
             isMultiLineCursor: () => false,
+            isCursorAtTextStart: () => true,
+            onNavigateInputHistory: vi.fn(() => 'navigated' as const),
         });
         expect(singleLineRouter.router.route({ key: 'ArrowUp' })).toBe(true);
-        await flushAsyncWork();
-        expect(singleLineRouter.callbacks.onSubmit).toHaveBeenCalledTimes(1);
+        expect(singleLineRouter.callbacks.onNavigateInputHistory).toHaveBeenCalledWith('older');
 
         const multiLineRouter = createKeyboardRouter({
             getQueryText: () => 'keep editing',
             isMultiLineCursor: () => true,
+            isCursorAtTextStart: () => false,
         });
         expect(multiLineRouter.router.route({ key: 'ArrowUp' })).toBe(false);
-        expect(multiLineRouter.callbacks.onSubmit).not.toHaveBeenCalled();
+        expect(multiLineRouter.callbacks.onNavigateInputHistory).not.toHaveBeenCalled();
+        await flushAsyncWork();
+    });
+
+    it('uses newer input-history navigation before quick-search fallback on ArrowDown', async () => {
+        const historyRouter = createKeyboardRouter({
+            onNavigateInputHistory: vi.fn(() => 'navigated' as const),
+            shouldTriggerQuickSearch: vi.fn(() => true),
+        });
+        expect(historyRouter.router.route({ key: 'ArrowDown' })).toBe(true);
+        expect(historyRouter.callbacks.onNavigateInputHistory).toHaveBeenCalledWith('newer');
+        expect(historyRouter.callbacks.onOpenQuickSearch).not.toHaveBeenCalled();
+
+        const multilineRouter = createKeyboardRouter({
+            isMultiLineCursor: () => true,
+            isCursorAtEnd: () => false,
+        });
+        expect(multilineRouter.router.route({ key: 'ArrowDown' })).toBe(false);
+        expect(multilineRouter.callbacks.onNavigateInputHistory).not.toHaveBeenCalled();
+
+        const noTriggerRouter = createKeyboardRouter({
+            shouldTriggerQuickSearch: vi.fn(() => false),
+        });
+        expect(noTriggerRouter.router.route({ key: 'ArrowDown' })).toBe(false);
+        expect(noTriggerRouter.callbacks.onOpenQuickSearch).not.toHaveBeenCalled();
+        await flushAsyncWork();
+    });
+
+    it('submits query text or attachments from ArrowDown quick-search fallback', async () => {
+        const queryRouter = createKeyboardRouter({
+            getQueryText: () => 'touch',
+            shouldTriggerQuickSearch: () => true,
+        });
+        expect(queryRouter.router.route({ key: 'ArrowDown' })).toBe(true);
+        await flushAsyncWork();
+        expect(queryRouter.callbacks.onSubmit).toHaveBeenCalledTimes(1);
+
+        const attachmentRouter = createKeyboardRouter({
+            hasAttachments: () => true,
+            shouldTriggerQuickSearch: () => true,
+        });
+        expect(attachmentRouter.router.route({ key: 'ArrowDown' })).toBe(true);
+        await flushAsyncWork();
+        expect(attachmentRouter.callbacks.onSubmit).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles Enter on the search surface for text, attachments, and empty drafts', async () => {
+        const queryRouter = createKeyboardRouter({
+            getQueryText: () => 'touch',
+        });
+        expect(queryRouter.router.route({ key: 'Enter' })).toBe(true);
+        await flushAsyncWork();
+        expect(queryRouter.callbacks.onSubmit).toHaveBeenCalledTimes(1);
+
+        const attachmentRouter = createKeyboardRouter({
+            hasAttachments: () => true,
+        });
+        expect(attachmentRouter.router.route({ key: 'Enter' })).toBe(true);
+        await flushAsyncWork();
+        expect(attachmentRouter.callbacks.onSubmit).toHaveBeenCalledTimes(1);
+
+        const emptyRouter = createKeyboardRouter();
+        expect(emptyRouter.router.route({ key: 'Enter' })).toBe(true);
+        await flushAsyncWork();
+        expect(emptyRouter.callbacks.onSubmit).not.toHaveBeenCalled();
+
+        const shiftedRouter = createKeyboardRouter({
+            getQueryText: () => 'touch',
+        });
+        expect(shiftedRouter.router.route({ key: 'Enter', shiftKey: true })).toBe(false);
+        await flushAsyncWork();
+        expect(shiftedRouter.callbacks.onSubmit).not.toHaveBeenCalled();
     });
 });
diff --git a/apps/desktop/tests/composables/SearchView/useSearchRequest.test.ts b/apps/desktop/tests/composables/SearchView/useSearchRequest.test.ts
index 27ec1ba1..f05a2d49 100644
--- a/apps/desktop/tests/composables/SearchView/useSearchRequest.test.ts
+++ b/apps/desktop/tests/composables/SearchView/useSearchRequest.test.ts
@@ -32,7 +32,6 @@ const {
         approvePendingToolApproval: vi.fn(() => true),
         rejectPendingToolApproval: vi.fn(() => true),
     };
-
     return {
         agentCallbacks: callbacksHolder,
         agentState: agent,
@@ -130,7 +129,6 @@ describe('useSearchRequestFlow', () => {
         agentState.currentSessionId.value = null;
         agentState.sessionHistory.value = [];
         agentState.pendingToolApproval.value = null;
-
         listSessionsMock.mockResolvedValue([]);
         dismissSessionTerminalStatusMock.mockResolvedValue(undefined);
         agentState.sendRequest.mockResolvedValue(undefined);
@@ -333,6 +331,277 @@ describe('useSearchRequestFlow', () => {
         mounted.unmount();
     });
 
+    it('keeps draft and queue state when opening a stored session fails', async () => {
+        const queuedAttachment = createAttachment('queued-failed-open');
+        const modelOverride = ref({
+            modelId: 'stale-model',
+            providerId: 2,
+        });
+        const clearDraft = vi.fn();
+        const openError = new Error('session not found');
+
+        agentState.isLoading.value = true;
+        agentState.openSession.mockRejectedValueOnce(openError);
+
+        const mounted = await mountComposable(() =>
+            useSearchRequestFlow({
+                modelOverride,
+                clearDraft,
+                getSupportedAttachments: () => [queuedAttachment],
+                getUnsupportedAttachmentMessage: () => null,
+                getCurrentInputSnapshot: (query) =>
+                    createInputHistorySnapshot({
+                        text: query,
+                        attachments: [queuedAttachment],
+                    }),
+            })
+        );
+
+        await mounted.result.handleSubmit('queued before failed open');
+
+        await expect(mounted.result.openSession(7)).rejects.toThrow(openError);
+
+        expect(clearDraft).not.toHaveBeenCalledWith({
+            preserveModelTag: true,
+        });
+        expect(mounted.result.pendingRequest.value?.query).toBe('queued before failed open');
+        expect(mounted.result.isWaitingForCompletion.value).toBe(true);
+        expect(modelOverride.value).toEqual({
+            modelId: 'stale-model',
+            providerId: 2,
+        });
+        mounted.unmount();
+    });
+
+    it('does not clear draft or reopen when opening the current session', async () => {
+        const modelOverride = ref({
+            modelId: 'current-model',
+            providerId: 12,
+        });
+        const clearDraft = vi.fn();
+        agentState.currentSessionId.value = 7;
+
+        const mounted = await mountComposable(() =>
+            useSearchRequestFlow({
+                modelOverride,
+                clearDraft,
+                getSupportedAttachments: () => [],
+                getUnsupportedAttachmentMessage: () => null,
+                getCurrentInputSnapshot: (query) =>
+                    createInputHistorySnapshot({
+                        text: query,
+                        attachments: [],
+                    }),
+            })
+        );
+
+        const loadedSession = await mounted.result.openSession(7);
+
+        expect(agentState.openSession).not.toHaveBeenCalled();
+        expect(clearDraft).not.toHaveBeenCalled();
+        expect(dismissSessionTerminalStatusMock).not.toHaveBeenCalledWith(7);
+        expect(loadedSession).toEqual({
+            sessionId: 7,
+            title: '',
+            modelId: 'current-model',
+            providerId: 12,
+        });
+
+        mounted.unmount();
+    });
+
+    it('reopens the most recently closed session', async () => {
+        const modelOverride = ref({
+            modelId: null,
+            providerId: null,
+        });
+        const mounted = await mountComposable(() =>
+            useSearchRequestFlow({
+                modelOverride,
+                clearDraft: vi.fn(),
+                getSupportedAttachments: () => [],
+                getUnsupportedAttachmentMessage: () => null,
+                getCurrentInputSnapshot: (query) =>
+                    createInputHistorySnapshot({
+                        text: query,
+                        attachments: [],
+                    }),
+            })
+        );
+
+        agentState.currentSessionId.value = 23;
+        mounted.result.clearSession();
+
+        expect(agentState.clearSession).toHaveBeenCalledTimes(1);
+
+        agentState.currentSessionId.value = null;
+        agentState.openSession.mockImplementationOnce(async () => {
+            agentState.currentSessionId.value = 23;
+            return {
+                sessionId: 23,
+                title: 'Reopened Session',
+                modelId: 'gpt-5',
+                providerId: 9,
+            };
+        });
+
+        const reopenedSession = await mounted.result.reopenLastClosedSession();
+
+        expect(agentState.openSession).toHaveBeenCalledWith(23);
+        expect(reopenedSession).toEqual({
+            sessionId: 23,
+            title: 'Reopened Session',
+            modelId: 'gpt-5',
+            providerId: 9,
+        });
+
+        const secondReopenAttempt = await mounted.result.reopenLastClosedSession();
+        expect(secondReopenAttempt).toBeNull();
+        expect(agentState.openSession).toHaveBeenCalledTimes(1);
+
+        mounted.unmount();
+    });
+
+    it('does not reopen when no closed session is recorded', async () => {
+        const modelOverride = ref({
+            modelId: null,
+            providerId: null,
+        });
+        const clearDraft = vi.fn();
+
+        const mounted = await mountComposable(() =>
+            useSearchRequestFlow({
+                modelOverride,
+                clearDraft,
+                getSupportedAttachments: () => [],
+                getUnsupportedAttachmentMessage: () => null,
+                getCurrentInputSnapshot: (query) =>
+                    createInputHistorySnapshot({
+                        text: query,
+                        attachments: [],
+                    }),
+            })
+        );
+
+        const reopenedSession = await mounted.result.reopenLastClosedSession();
+
+        expect(agentState.openSession).not.toHaveBeenCalled();
+        expect(clearDraft).not.toHaveBeenCalled();
+        expect(reopenedSession).toBeNull();
+
+        mounted.unmount();
+    });
+
+    it('keeps the last closed session id when reopening fails with a generic error', async () => {
+        const modelOverride = ref({
+            modelId: null,
+            providerId: null,
+        });
+        const openError = new Error('database unavailable');
+
+        const mounted = await mountComposable(() =>
+            useSearchRequestFlow({
+                modelOverride,
+                clearDraft: vi.fn(),
+                getSupportedAttachments: () => [],
+                getUnsupportedAttachmentMessage: () => null,
+                getCurrentInputSnapshot: (query) =>
+                    createInputHistorySnapshot({
+                        text: query,
+                        attachments: [],
+                    }),
+            })
+        );
+
+        agentState.currentSessionId.value = 23;
+        mounted.result.clearSession();
+        agentState.currentSessionId.value = null;
+        agentState.openSession.mockRejectedValueOnce(openError);
+
+        await expect(mounted.result.reopenLastClosedSession()).rejects.toThrow(openError);
+
+        agentState.openSession.mockResolvedValueOnce({
+            sessionId: 23,
+            title: 'Reopened Session',
+            modelId: 'gpt-5',
+            providerId: 9,
+        });
+
+        await mounted.result.reopenLastClosedSession();
+
+        expect(agentState.openSession).toHaveBeenCalledTimes(2);
+        expect(agentState.openSession).toHaveBeenLastCalledWith(23);
+
+        mounted.unmount();
+    });
+
+    it('clears the last closed session id when the stored session no longer exists', async () => {
+        const modelOverride = ref({
+            modelId: null,
+            providerId: null,
+        });
+        const openError = new Error('Session 23 not found');
+
+        const mounted = await mountComposable(() =>
+            useSearchRequestFlow({
+                modelOverride,
+                clearDraft: vi.fn(),
+                getSupportedAttachments: () => [],
+                getUnsupportedAttachmentMessage: () => null,
+                getCurrentInputSnapshot: (query) =>
+                    createInputHistorySnapshot({
+                        text: query,
+                        attachments: [],
+                    }),
+            })
+        );
+
+        agentState.currentSessionId.value = 23;
+        mounted.result.clearSession();
+        agentState.currentSessionId.value = null;
+        agentState.openSession.mockRejectedValueOnce(openError);
+
+        await expect(mounted.result.reopenLastClosedSession()).rejects.toThrow(openError);
+
+        const secondReopenAttempt = await mounted.result.reopenLastClosedSession();
+        expect(secondReopenAttempt).toBeNull();
+        expect(agentState.openSession).toHaveBeenCalledTimes(1);
+
+        mounted.unmount();
+    });
+
+    it('does not reopen or clear draft when the last closed session is already current', async () => {
+        const modelOverride = ref({
+            modelId: null,
+            providerId: null,
+        });
+        const clearDraft = vi.fn();
+        agentState.currentSessionId.value = 23;
+
+        const mounted = await mountComposable(() =>
+            useSearchRequestFlow({
+                modelOverride,
+                clearDraft,
+                getSupportedAttachments: () => [],
+                getUnsupportedAttachmentMessage: () => null,
+                getCurrentInputSnapshot: (query) =>
+                    createInputHistorySnapshot({
+                        text: query,
+                        attachments: [],
+                    }),
+            })
+        );
+
+        mounted.result.clearSession();
+        const reopenedSession = await mounted.result.reopenLastClosedSession();
+
+        expect(agentState.openSession).not.toHaveBeenCalled();
+        expect(clearDraft).not.toHaveBeenCalled();
+        expect(reopenedSession).toBeNull();
+
+        mounted.unmount();
+    });
+
     it('regenerates from the nearest preceding user message and drops unsupported attachments', async () => {
         const supportedAttachment = createAttachment('supported-1');
         const unsupportedAttachment = createAttachment('unsupported-1', {
diff --git a/apps/desktop/tests/config/searchKeybindings.test.ts b/apps/desktop/tests/config/searchKeybindings.test.ts
new file mode 100644
index 00000000..451dbc6f
--- /dev/null
+++ b/apps/desktop/tests/config/searchKeybindings.test.ts
@@ -0,0 +1,116 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+    createDefaultSearchKeybindings,
+    getSearchKeybindingDefinition,
+    isSearchKeybindingActionId,
+    normalizeSearchKeybindings,
+    SEARCH_KEYBINDING_ACTION_IDS,
+    SEARCH_KEYBINDING_DEFINITIONS,
+    type SearchKeybindingActionId,
+} from '@/config/searchKeybindings';
+
+describe('search keybinding configuration', () => {
+    it('keeps action ids and definitions in sync', () => {
+        expect(SEARCH_KEYBINDING_DEFINITIONS.map((definition) => definition.id)).toEqual(
+            SEARCH_KEYBINDING_ACTION_IDS
+        );
+        expect(isSearchKeybindingActionId('search.history.open')).toBe(true);
+        expect(isSearchKeybindingActionId('search.request.cancel')).toBe(false);
+    });
+
+    it('returns definitions for known actions and rejects unknown actions', () => {
+        expect(getSearchKeybindingDefinition('search.window.maximize')).toMatchObject({
+            id: 'search.window.maximize',
+            defaultShortcut: 'F11',
+            allowDisable: true,
+            allowModifierlessFunctionShortcut: true,
+        });
+
+        expect(() =>
+            getSearchKeybindingDefinition('search.request.cancel' as SearchKeybindingActionId)
+        ).toThrow('Unknown search keybinding action: search.request.cancel');
+    });
+
+    it('creates the default keybinding map from definitions', () => {
+        const defaults = createDefaultSearchKeybindings();
+
+        expect(defaults).toEqual({
+            'search.history.open': 'Mod+H',
+            'search.input.focus': 'Mod+L',
+            'search.session.new': 'Mod+N',
+            'search.session.reopenLastClosed': 'Mod+Shift+T',
+            'search.model.toggle': 'Mod+M',
+            'search.window.pin': 'Mod+P',
+            'search.window.maximize': 'F11',
+            'search.settings.open': 'Mod+,',
+        });
+    });
+
+    it('normalizes persisted shortcuts and preserves disabled actions', () => {
+        expect(
+            normalizeSearchKeybindings({
+                'search.history.open': ' ctrl + shift + h ',
+                'search.input.focus': null,
+                'search.session.new': '   ',
+                'search.session.reopenLastClosed': 'Mod+Up',
+                'search.model.toggle': 'Ctrl+Backspace',
+                'search.window.maximize': 'f2',
+                'search.settings.open': 'ctrl + ,',
+                unknown: 'Alt+U',
+            })
+        ).toEqual({
+            ...createDefaultSearchKeybindings(),
+            'search.history.open': 'Mod+Shift+H',
+            'search.input.focus': null,
+            'search.window.maximize': 'F2',
+            'search.settings.open': 'Mod+,',
+        });
+    });
+
+    it('rejects persisted shortcuts that bypass capture policy', () => {
+        expect(
+            normalizeSearchKeybindings({
+                'search.history.open': 'H',
+                'search.input.focus': 'Ctrl+L',
+                'search.model.toggle': 'Shift+M',
+                'search.window.maximize': 'F12',
+            })
+        ).toEqual({
+            ...createDefaultSearchKeybindings(),
+            'search.input.focus': 'Mod+L',
+            'search.window.maximize': 'F12',
+        });
+    });
+
+    it('rejects persisted shortcut duplicates while preserving disabled actions', () => {
+        expect(
+            normalizeSearchKeybindings({
+                'search.history.open': 'Ctrl+Y',
+                'search.input.focus': 'Ctrl+Y',
+                'search.session.new': null,
+                'search.model.toggle': 'Ctrl+N',
+            })
+        ).toEqual({
+            ...createDefaultSearchKeybindings(),
+            'search.history.open': 'Mod+Y',
+            'search.session.new': null,
+            'search.model.toggle': 'Mod+N',
+        });
+    });
+
+    it('falls back to defaults for invalid persisted payloads', () => {
+        const defaults = createDefaultSearchKeybindings();
+
+        expect(normalizeSearchKeybindings(null)).toEqual(defaults);
+        expect(normalizeSearchKeybindings(undefined)).toEqual(defaults);
+        expect(normalizeSearchKeybindings('Mod+H')).toEqual(defaults);
+        expect(normalizeSearchKeybindings(['Mod+H'])).toEqual(defaults);
+        expect(
+            normalizeSearchKeybindings({
+                'search.history.open': 42,
+                'search.input.focus': false,
+            })
+        ).toEqual(defaults);
+    });
+});
diff --git a/apps/desktop/tests/stores/setting.test.ts b/apps/desktop/tests/stores/setting.test.ts
index dfc96da4..3052be82 100644
--- a/apps/desktop/tests/stores/setting.test.ts
+++ b/apps/desktop/tests/stores/setting.test.ts
@@ -32,6 +32,7 @@ const EXPECTED_GENERAL_SETTING_KEYS: GeneralSettingKey[] = [
     'app_update_channel',
     'app_update_auto_check',
     'app_update_last_checked_at',
+    'search_keybindings',
     'browser_settings',
     'search_settings',
 ];
@@ -121,6 +122,7 @@ describe('setting registry', () => {
             'appUpdateChannel',
             'appUpdateAutoCheck',
             'appUpdateLastCheckedAt',
+            'searchKeybindings',
             'searchWindowDefaultSize',
             'browserSettings',
             'searchSettings',
@@ -136,6 +138,7 @@ describe('setting registry', () => {
             'updateAppUpdateChannel',
             'updateAppUpdateAutoCheck',
             'updateAppUpdateLastCheckedAt',
+            'updateSearchKeybindings',
             'updateBrowserSettings',
             'updateSearchSettings',
         ]);
diff --git a/apps/desktop/tests/stores/settings-keybindings.test.ts b/apps/desktop/tests/stores/settings-keybindings.test.ts
new file mode 100644
index 00000000..ce10f499
--- /dev/null
+++ b/apps/desktop/tests/stores/settings-keybindings.test.ts
@@ -0,0 +1,140 @@
+import { AppEvent } from '@services/EventService';
+import { createPinia, setActivePinia } from 'pinia';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { createDefaultSearchKeybindings } from '@/config/searchKeybindings';
+
+const { eventHandlers, eventServiceMock, getSettingValueMock, setSettingMock, windowMock } =
+    vi.hoisted(() => ({
+        eventHandlers: new Map<string, (payload: unknown) => void>(),
+        eventServiceMock: {
+            emit: vi.fn(),
+            on: vi.fn(async (event: string, handler: (payload: unknown) => void) => {
+                eventHandlers.set(event, handler);
+                return () => {
+                    eventHandlers.delete(event);
+                };
+            }),
+        },
+        getSettingValueMock: vi.fn(),
+        setSettingMock: vi.fn(),
+        windowMock: {
+            label: 'settings',
+        },
+    }));
+
+vi.mock('@database/queries', () => ({
+    getSettingValue: getSettingValueMock,
+    setSetting: setSettingMock,
+}));
+
+vi.mock('@services/EventService', async () => {
+    const actual =
+        await vi.importActual<typeof import('@services/EventService')>('@services/EventService');
+    return {
+        ...actual,
+        eventService: eventServiceMock,
+    };
+});
+
+vi.mock('@tauri-apps/api/window', () => ({
+    getCurrentWindow: () => windowMock,
+}));
+
+function mockSettings(values: Record<string, string | null>) {
+    getSettingValueMock.mockImplementation(async ({ key }: { key: string }) => values[key] ?? null);
+    setSettingMock.mockImplementation(async ({ key, value }: { key: string; value: string }) => ({
+        id: 1,
+        key,
+        value,
+        created_at: '2026-06-03 00:00:00',
+        updated_at: '2026-06-03 00:00:00',
+    }));
+}
+
+describe('settings search keybindings state', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        eventHandlers.clear();
+        setActivePinia(createPinia());
+        windowMock.label = 'settings';
+    });
+
+    it('persists default search keybindings when the row is missing', async () => {
+        mockSettings({});
+
+        const { useSettingsStore } = await import('@/stores/settings');
+        const store = useSettingsStore();
+
+        await store.initialize();
+
+        expect(store.settings.searchKeybindings).toEqual(createDefaultSearchKeybindings());
+        expect(store.settings.searchKeybindings['search.window.maximize']).toBe('F11');
+        expect(store.settings.searchKeybindings['search.settings.open']).toBe('Mod+,');
+        expect(setSettingMock).toHaveBeenCalledWith({
+            key: 'search_keybindings',
+            value: JSON.stringify(createDefaultSearchKeybindings()),
+        });
+    });
+
+    it('loads persisted search keybindings and merges missing defaults', async () => {
+        mockSettings({
+            search_keybindings: JSON.stringify({
+                'search.history.open': 'Mod+Y',
+                'search.request.cancel': null,
+                'search.draft.clearAll': 'Mod+Backspace',
+            }),
+        });
+
+        const { useSettingsStore } = await import('@/stores/settings');
+        const store = useSettingsStore();
+
+        await store.initialize();
+
+        expect(store.settings.searchKeybindings['search.history.open']).toBe('Mod+Y');
+        expect(store.settings.searchKeybindings).toEqual({
+            ...createDefaultSearchKeybindings(),
+            'search.history.open': 'Mod+Y',
+        });
+        expect(store.settings.searchKeybindings['search.window.maximize']).toBe(
+            createDefaultSearchKeybindings()['search.window.maximize']
+        );
+        expect(setSettingMock).toHaveBeenCalledWith({
+            key: 'search_keybindings',
+            value: JSON.stringify({
+                ...createDefaultSearchKeybindings(),
+                'search.history.open': 'Mod+Y',
+            }),
+        });
+        expect(store.settings.searchKeybindings['search.input.focus']).toBe(
+            createDefaultSearchKeybindings()['search.input.focus']
+        );
+    });
+
+    it('updates search keybindings, persists them, and broadcasts the change', async () => {
+        mockSettings({});
+
+        const { useSettingsStore } = await import('@/stores/settings');
+        const store = useSettingsStore();
+        await store.initialize();
+
+        const nextKeybindings = {
+            ...createDefaultSearchKeybindings(),
+            'search.input.focus': 'Mod+K',
+        };
+
+        await store.updateSearchKeybindings(nextKeybindings);
+
+        expect(store.settings.searchKeybindings).toEqual(nextKeybindings);
+        expect(setSettingMock).toHaveBeenLastCalledWith({
+            key: 'search_keybindings',
+            value: JSON.stringify(nextKeybindings),
+        });
+        expect(eventServiceMock.emit).toHaveBeenLastCalledWith(AppEvent.SETTINGS_GENERAL_UPDATED, {
+            sourceId: expect.any(String),
+            windowLabel: 'settings',
+            key: 'search_keybindings',
+            value: nextKeybindings,
+        });
+    });
+});
diff --git a/apps/desktop/tests/utils/shortcuts.test.ts b/apps/desktop/tests/utils/shortcuts.test.ts
new file mode 100644
index 00000000..58210d5b
--- /dev/null
+++ b/apps/desktop/tests/utils/shortcuts.test.ts
@@ -0,0 +1,174 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+    captureShortcutFromKeyboardEvent,
+    findShortcutConflict,
+    formatShortcutForDisplay,
+    hasCommandModifier,
+    hasRequiredModifier,
+    isModifierlessFunctionShortcut,
+    isReservedLocalShortcut,
+    isReservedLocalShortcutKey,
+    matchShortcut,
+    normalizeLocalShortcutString,
+    resolveKeyboardEventShortcutKey,
+    toCurrentPlatformShortcut,
+} from '@/utils/shortcuts';
+
+const originalPlatform = navigator.platform;
+
+function setPlatform(platform: string) {
+    Object.defineProperty(window.navigator, 'platform', {
+        configurable: true,
+        value: platform,
+    });
+}
+
+describe('shortcut utilities', () => {
+    beforeEach(() => {
+        setPlatform('Win32');
+    });
+
+    afterEach(() => {
+        setPlatform(originalPlatform);
+    });
+
+    it('normalizes shortcut strings with aliases and stable modifier ordering', () => {
+        expect(normalizeLocalShortcutString(' shift + cmd + option + k ')).toBe('Mod+Alt+Shift+K');
+        expect(normalizeLocalShortcutString('control+delete')).toBe('Mod+Del');
+        expect(normalizeLocalShortcutString('return')).toBe('Enter');
+        expect(normalizeLocalShortcutString('f12')).toBe('F12');
+        expect(normalizeLocalShortcutString(null)).toBeNull();
+        expect(normalizeLocalShortcutString('Ctrl+Alt')).toBeNull();
+        expect(normalizeLocalShortcutString('Ctrl+A+B')).toBeNull();
+        expect(normalizeLocalShortcutString('   ')).toBeNull();
+
+        setPlatform('MacIntel');
+
+        expect(normalizeLocalShortcutString('control+delete')).toBe('Ctrl+Del');
+    });
+
+    it('formats display shortcuts for the current platform', () => {
+        expect(formatShortcutForDisplay('Mod+Shift+H')).toBe('Ctrl+Shift+H');
+        expect(toCurrentPlatformShortcut('Mod+H')).toBe('Ctrl+H');
+        expect(toCurrentPlatformShortcut('')).toBeNull();
+        expect(formatShortcutForDisplay(null)).toBeTruthy();
+
+        setPlatform('MacIntel');
+
+        expect(formatShortcutForDisplay('Mod+Ctrl+Alt+Shift+H')).toBe('Cmd+Ctrl+Alt+Shift+H');
+        expect(toCurrentPlatformShortcut('Mod+H')).toBe('Cmd+H');
+    });
+
+    it('resolves keyboard event keys from display key aliases and function-row codes', () => {
+        expect(resolveKeyboardEventShortcutKey('ArrowUp')).toBe('Up');
+        expect(resolveKeyboardEventShortcutKey(' ', null)).toBe('Space');
+        expect(resolveKeyboardEventShortcutKey('BrightnessUp', 'F2')).toBe('F2');
+        expect(resolveKeyboardEventShortcutKey('F2', 'F3')).toBe('F2');
+        expect(resolveKeyboardEventShortcutKey('', 'KeyA')).toBeNull();
+        expect(resolveKeyboardEventShortcutKey(undefined, undefined)).toBeNull();
+    });
+
+    it('matches shortcuts using platform-specific Mod behavior', () => {
+        expect(matchShortcut('Mod+H', { key: 'h', ctrlKey: true })).toBe(true);
+        expect(matchShortcut('Mod+H', { key: 'h', metaKey: true })).toBe(false);
+        expect(matchShortcut('Ctrl+H', { key: 'h', ctrlKey: true })).toBe(true);
+        expect(matchShortcut('Ctrl+H', { key: 'h' })).toBe(false);
+        expect(
+            matchShortcut('Alt+Shift+Del', { key: 'Delete', altKey: true, shiftKey: true })
+        ).toBe(true);
+        expect(matchShortcut('Alt+Shift+Del', { key: 'Delete', altKey: true })).toBe(false);
+        expect(matchShortcut(null, { key: 'h' })).toBe(false);
+        expect(matchShortcut('Mod+H', { key: 'x', ctrlKey: true })).toBe(false);
+
+        setPlatform('MacIntel');
+
+        expect(matchShortcut('Mod+H', { key: 'h', metaKey: true })).toBe(true);
+        expect(matchShortcut('Mod+H', { key: 'h', ctrlKey: true })).toBe(false);
+        expect(matchShortcut('Mod+Ctrl+H', { key: 'h', metaKey: true, ctrlKey: true })).toBe(true);
+    });
+
+    it('captures shortcuts from keyboard events and ignores unsupported key presses', () => {
+        expect(
+            captureShortcutFromKeyboardEvent(new KeyboardEvent('keydown', { key: 'Control' }))
+        ).toBeNull();
+        expect(
+            captureShortcutFromKeyboardEvent(
+                new KeyboardEvent('keydown', { key: 'k', metaKey: true })
+            )
+        ).toBeNull();
+
+        expect(
+            captureShortcutFromKeyboardEvent(
+                new KeyboardEvent('keydown', {
+                    key: 'BrightnessUp',
+                    code: 'F2',
+                    ctrlKey: true,
+                    altKey: true,
+                    shiftKey: true,
+                })
+            )
+        ).toEqual({
+            shortcut: 'Mod+Alt+Shift+F2',
+            displayShortcut: 'Ctrl+Alt+Shift+F2',
+        });
+
+        setPlatform('MacIntel');
+
+        expect(
+            captureShortcutFromKeyboardEvent(
+                new KeyboardEvent('keydown', {
+                    key: 'k',
+                    metaKey: true,
+                    ctrlKey: true,
+                    altKey: true,
+                    shiftKey: true,
+                })
+            )
+        ).toEqual({
+            shortcut: 'Mod+Ctrl+Alt+Shift+K',
+            displayShortcut: 'Cmd+Ctrl+Alt+Shift+K',
+        });
+    });
+
+    it('classifies reserved, modifierless, and conflicting shortcuts', () => {
+        expect(isReservedLocalShortcut('Enter')).toBe(true);
+        expect(isReservedLocalShortcut('Mod+Backspace')).toBe(true);
+        expect(isReservedLocalShortcut('Ctrl+Delete')).toBe(true);
+        expect(isReservedLocalShortcut('Alt+Home')).toBe(true);
+        expect(isReservedLocalShortcut('Shift+End')).toBe(true);
+        expect(isReservedLocalShortcut('Mod+PageUp')).toBe(true);
+        expect(isReservedLocalShortcut('Mod+PageDown')).toBe(true);
+        expect(isReservedLocalShortcut('Mod+K')).toBe(false);
+        expect(isReservedLocalShortcut(null)).toBe(false);
+        expect(isReservedLocalShortcutKey('ArrowDown')).toBe(true);
+        expect(isReservedLocalShortcutKey('BrightnessUp', 'F2')).toBe(false);
+
+        expect(hasRequiredModifier('Mod+K')).toBe(true);
+        expect(hasRequiredModifier('Shift+K')).toBe(true);
+        expect(hasRequiredModifier('F11')).toBe(false);
+        expect(hasRequiredModifier('')).toBe(false);
+
+        expect(hasCommandModifier('Mod+K')).toBe(true);
+        expect(hasCommandModifier('Alt+Shift+K')).toBe(true);
+        expect(hasCommandModifier('Shift+K')).toBe(false);
+        expect(hasCommandModifier('F11')).toBe(false);
+
+        expect(isModifierlessFunctionShortcut('F1')).toBe(true);
+        expect(isModifierlessFunctionShortcut('F12')).toBe(true);
+        expect(isModifierlessFunctionShortcut('F13')).toBe(false);
+        expect(isModifierlessFunctionShortcut('Mod+F1')).toBe(false);
+        expect(isModifierlessFunctionShortcut(null)).toBe(false);
+
+        const entries = [
+            { id: 'history', shortcut: 'Mod+H' },
+            { id: 'new-session', shortcut: 'Mod+N' },
+            { id: 'disabled', shortcut: null },
+        ];
+
+        expect(findShortcutConflict('cmd+h', entries)).toBe('history');
+        expect(findShortcutConflict('Mod+H', entries, 'history')).toBeNull();
+        expect(findShortcutConflict('Mod+P', entries)).toBeNull();
+        expect(findShortcutConflict('', entries)).toBeNull();
+    });
+});
diff --git a/apps/desktop/tests/views/SettingsView/settingsGeneralComponent.test.ts b/apps/desktop/tests/views/SettingsView/settingsGeneralComponent.test.ts
index 05b0bd40..99577991 100644
--- a/apps/desktop/tests/views/SettingsView/settingsGeneralComponent.test.ts
+++ b/apps/desktop/tests/views/SettingsView/settingsGeneralComponent.test.ts
@@ -2,34 +2,45 @@ import type { AppUpdateState } from '@services/AppUpdateService/types';
 import { flushPromises, mount } from '@vue/test-utils';
 import { vi } from 'vitest';
 
+import { createDefaultSearchKeybindings } from '@/config/searchKeybindings';
+import { setLocale } from '@/i18n';
 import GeneralSection from '@/views/SettingsView/components/General/index.vue';
 
-const settingsStoreMock = vi.hoisted(() => ({
-    settings: {
-        value: {
-            globalShortcut: 'Alt+Space',
-            startOnBoot: false,
-            startMinimized: true,
-            language: 'zh-CN',
-            outputScrollBehavior: 'follow_output',
-            searchWindowSizePreset: 'normal',
-            searchWindowDefaultSize: { width: 720, height: 520 },
-            appUpdateChannel: 'stable',
-            appUpdateAutoCheck: true,
-            appUpdateLastCheckedAt: null,
+const settingsStoreMock = vi.hoisted(() => {
+    const createGeneralSettingsMock = (searchKeybindings: Record<string, string | null>) => ({
+        globalShortcut: 'Alt+Space',
+        searchKeybindings: {
+            ...searchKeybindings,
         },
-    },
-    initialize: vi.fn().mockResolvedValue(undefined),
-    updateGlobalShortcut: vi.fn().mockResolvedValue(undefined),
-    updateStartOnBoot: vi.fn().mockResolvedValue(undefined),
-    updateStartMinimized: vi.fn().mockResolvedValue(undefined),
-    updateOutputScrollBehavior: vi.fn().mockResolvedValue(undefined),
-    updateSearchWindowSizePreset: vi.fn().mockResolvedValue(undefined),
-    updateLanguage: vi.fn().mockResolvedValue(undefined),
-    updateAppUpdateChannel: vi.fn().mockResolvedValue(undefined),
-    updateAppUpdateAutoCheck: vi.fn().mockResolvedValue(undefined),
-    updateAppUpdateLastCheckedAt: vi.fn().mockResolvedValue(undefined),
-}));
+        startOnBoot: false,
+        startMinimized: true,
+        language: 'zh-CN',
+        outputScrollBehavior: 'follow_output',
+        searchWindowSizePreset: 'normal',
+        searchWindowDefaultSize: { width: 720, height: 520 },
+        appUpdateChannel: 'stable',
+        appUpdateAutoCheck: true,
+        appUpdateLastCheckedAt: null,
+    });
+
+    return {
+        createGeneralSettingsMock,
+        settings: {
+            value: createGeneralSettingsMock({}),
+        },
+        initialize: vi.fn().mockResolvedValue(undefined),
+        updateGlobalShortcut: vi.fn().mockResolvedValue(undefined),
+        updateSearchKeybindings: vi.fn().mockResolvedValue(undefined),
+        updateStartOnBoot: vi.fn().mockResolvedValue(undefined),
+        updateStartMinimized: vi.fn().mockResolvedValue(undefined),
+        updateOutputScrollBehavior: vi.fn().mockResolvedValue(undefined),
+        updateSearchWindowSizePreset: vi.fn().mockResolvedValue(undefined),
+        updateLanguage: vi.fn().mockResolvedValue(undefined),
+        updateAppUpdateChannel: vi.fn().mockResolvedValue(undefined),
+        updateAppUpdateAutoCheck: vi.fn().mockResolvedValue(undefined),
+        updateAppUpdateLastCheckedAt: vi.fn().mockResolvedValue(undefined),
+    };
+});
 
 const nativeMock = vi.hoisted(() => ({
     shortcut: {
@@ -87,9 +98,27 @@ vi.mock('@components/AppIcon.vue', () => ({
 vi.mock('@components/CustomSelect.vue', () => ({
     default: {
         name: 'CustomSelectStub',
-        props: ['modelValue', 'options'],
-        emits: ['update:modelValue'],
-        template: '<select data-testid="custom-select"><option>{{ modelValue }}</option></select>',
+        props: ['modelValue', 'options', 'open', 'contentTestId', 'optionTestIdPrefix'],
+        emits: ['update:modelValue', 'update:open'],
+        template: `
+            <div data-testid="custom-select">
+                <slot name="trigger" />
+                <select v-if="!$slots.trigger" data-testid="custom-select-native">
+                    <option>{{ modelValue }}</option>
+                </select>
+                <div v-if="open" :data-testid="contentTestId">
+                    <button
+                        v-for="option in options"
+                        :key="option.value"
+                        type="button"
+                        :data-testid="optionTestIdPrefix ? optionTestIdPrefix + option.value : undefined"
+                        @click="$emit('update:modelValue', option.value)"
+                    >
+                        {{ option.label }}
+                    </button>
+                </div>
+            </div>
+        `,
     },
 }));
 
@@ -149,19 +178,69 @@ vi.mock('@services/AppUpdateService', () => ({
 describe('SettingsGeneralSection', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        setLocale('zh-CN');
         appUpdateServiceMock.state = appUpdateServiceMock.createState();
         nativeMock.shortcut.getShortcutStatus.mockResolvedValue([false, null]);
         nativeMock.autostart.isAutostartEnabled.mockResolvedValue(false);
+        settingsStoreMock.settings.value = settingsStoreMock.createGeneralSettingsMock(
+            createDefaultSearchKeybindings()
+        );
     });
 
-    it('renders the general settings groups and row controls', () => {
+    it('renders the general settings groups and row controls', async () => {
         const wrapper = mount(GeneralSection);
 
+        await flushPromises();
+
         expect(wrapper.get('h1').text()).toBe('通用');
         expect(wrapper.text()).toContain('快捷键');
         expect(wrapper.text()).toContain('唤起快捷键');
-        expect(wrapper.text()).toContain('Alt+Space');
-        expect(wrapper.text()).toContain('Ctrl+Space');
+        expect(
+            (
+                wrapper.get('[data-testid="settings-global-shortcut-input"]')
+                    .element as HTMLInputElement
+            ).value
+        ).toBe('Alt+Space');
+        expect(wrapper.text()).toContain('设置呼出 TouchAI 的全局快捷键。');
+        expect(wrapper.text()).not.toContain('Ctrl+Space');
+        expect(wrapper.find('[data-testid="settings-shortcut-suggestions"]').exists()).toBe(false);
+        expect(wrapper.find('[data-testid="settings-global-shortcut-preset-menu"]').exists()).toBe(
+            false
+        );
+        expect(wrapper.text()).not.toContain('搜索页快捷键');
+        expect(wrapper.text()).toContain('会话');
+        expect(wrapper.text()).toContain('输入与请求');
+        expect(wrapper.text()).toContain('窗口');
+        expect(wrapper.text()).toContain('打开会话历史');
+        expect(wrapper.text()).toContain('快速打开会话历史列表。');
+        expect(wrapper.text()).toContain('开始新会话');
+        expect(wrapper.text()).toContain('切换窗口最大化');
+        expect(wrapper.text()).toContain('切换搜索窗口最大化。');
+        expect(wrapper.text()).toContain('打开设置');
+        expect(wrapper.text()).toContain('快速打开设置窗口。');
+        expect(
+            (
+                wrapper.get('[data-testid="settings-search-shortcut-input-search.window.maximize"]')
+                    .element as HTMLInputElement
+            ).value
+        ).toBe('F11');
+        expect(
+            (
+                wrapper.get('[data-testid="settings-search-shortcut-input-search.settings.open"]')
+                    .element as HTMLInputElement
+            ).value
+        ).toBe('Ctrl+,');
+        expect(
+            (
+                wrapper.get('[data-testid="settings-search-shortcut-input-search.request.cancel"]')
+                    .element as HTMLInputElement
+            ).value
+        ).toBe('Esc');
+        expect(
+            wrapper
+                .get('[data-testid="settings-search-shortcut-input-search.history.open"]')
+                .classes()
+        ).not.toContain('font-mono');
         expect(wrapper.text()).toContain('启动与窗口');
         expect(wrapper.text()).toContain('开机自启动');
         expect(wrapper.text()).toContain('启动时最小化');
@@ -187,7 +266,336 @@ describe('SettingsGeneralSection', () => {
         expect(controls.length).toBeGreaterThanOrEqual(3);
 
         const rowLabels = wrapper.findAll('[data-testid="settings-general-row-label"]');
-        expect(rowLabels).toHaveLength(8);
+        expect(rowLabels.length).toBeGreaterThanOrEqual(13);
+    });
+
+    it('opens global shortcut presets from the shortcut field and saves a preset', async () => {
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get('[data-testid="settings-global-shortcut-input"]');
+        await input.trigger('focus');
+        await flushPromises();
+
+        expect(wrapper.find('[data-testid="settings-global-shortcut-preset-menu"]').exists()).toBe(
+            true
+        );
+        expect(
+            wrapper.get('[data-testid="settings-global-shortcut-preset-Alt+Space"]').text()
+        ).toBe('Alt+Space');
+        expect(
+            wrapper.get('[data-testid="settings-global-shortcut-preset-Ctrl+Space"]').text()
+        ).toBe('Ctrl+Space');
+
+        await wrapper
+            .get('[data-testid="settings-global-shortcut-preset-Ctrl+Space"]')
+            .trigger('click');
+        await flushPromises();
+
+        expect(nativeMock.shortcut.registerGlobalShortcut).toHaveBeenCalledWith('Ctrl+Space');
+        expect(settingsStoreMock.updateGlobalShortcut).toHaveBeenCalledWith('Ctrl+Space');
+        expect((input.element as HTMLInputElement).value).toBe('Ctrl+Space');
+        expect(settingsStoreMock.settings.value.globalShortcut).toBe('Ctrl+Space');
+        expect(wrapper.find('[data-testid="settings-global-shortcut-preset-menu"]').exists()).toBe(
+            false
+        );
+    });
+
+    it('saves the global shortcut immediately after a shortcut is pressed', async () => {
+        settingsStoreMock.settings.value.searchKeybindings['search.session.new'] = 'Mod+Shift+N';
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get('[data-testid="settings-global-shortcut-input"]');
+        await input.trigger('focus');
+        await flushPromises();
+
+        window.dispatchEvent(new KeyboardEvent('keydown', { key: 'n', ctrlKey: true }));
+        await flushPromises();
+
+        expect(nativeMock.shortcut.registerGlobalShortcut).toHaveBeenCalledWith('Ctrl+N');
+        expect(settingsStoreMock.updateGlobalShortcut).toHaveBeenCalledWith('Ctrl+N');
+        expect(wrapper.find('[data-testid="settings-global-shortcut-preset-menu"]').exists()).toBe(
+            false
+        );
+    });
+
+    it('captures Ctrl+Space from the global shortcut input before the preset menu handles Space', async () => {
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get('[data-testid="settings-global-shortcut-input"]');
+        await input.trigger('focus');
+        await flushPromises();
+
+        await input.trigger('keydown', {
+            key: ' ',
+            code: 'Space',
+            ctrlKey: true,
+        });
+        await flushPromises();
+
+        expect(nativeMock.shortcut.registerGlobalShortcut).toHaveBeenCalledWith('Ctrl+Space');
+        expect(settingsStoreMock.updateGlobalShortcut).toHaveBeenCalledWith('Ctrl+Space');
+        expect((input.element as HTMLInputElement).value).toBe('Ctrl+Space');
+        expect(settingsStoreMock.settings.value.globalShortcut).toBe('Ctrl+Space');
+    });
+
+    it('does not capture navigation keys while global shortcut presets are open', async () => {
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get('[data-testid="settings-global-shortcut-input"]');
+        await input.trigger('focus');
+        await flushPromises();
+
+        const event = new KeyboardEvent('keydown', { key: 'ArrowDown', cancelable: true });
+        window.dispatchEvent(event);
+        await flushPromises();
+
+        expect(event.defaultPrevented).toBe(false);
+        expect(nativeMock.shortcut.registerGlobalShortcut).not.toHaveBeenCalled();
+        expect(settingsStoreMock.updateGlobalShortcut).not.toHaveBeenCalled();
+        expect(wrapper.find('[data-testid="settings-global-shortcut-preset-menu"]').exists()).toBe(
+            true
+        );
+
+        wrapper.unmount();
+    });
+
+    it('does not save a global shortcut that duplicates a search shortcut', async () => {
+        settingsStoreMock.settings.value.searchKeybindings['search.history.open'] = 'Mod+A';
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get('[data-testid="settings-global-shortcut-input"]');
+        await input.trigger('focus');
+        await flushPromises();
+
+        window.dispatchEvent(new KeyboardEvent('keydown', { key: 'a', ctrlKey: true }));
+        await flushPromises();
+
+        expect(nativeMock.shortcut.registerGlobalShortcut).not.toHaveBeenCalled();
+        expect(settingsStoreMock.updateGlobalShortcut).not.toHaveBeenCalled();
+        expect((input.element as HTMLInputElement).value).toBe('Alt+Space');
+    });
+    it('accepts modifierless function keys for configurable search shortcuts', async () => {
+        settingsStoreMock.settings.value.searchKeybindings['search.history.open'] = 'Mod+Shift+H';
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get(
+            '[data-testid="settings-search-shortcut-input-search.history.open"]'
+        );
+        await input.trigger('focus');
+        await flushPromises();
+        window.dispatchEvent(new KeyboardEvent('keydown', { key: 'F1' }));
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).toHaveBeenCalledWith({
+            ...settingsStoreMock.settings.value.searchKeybindings,
+            'search.history.open': 'F1',
+        });
+    });
+
+    it('captures a function-row key by keyboard code when the key value is not an F-key', async () => {
+        settingsStoreMock.settings.value.searchKeybindings['search.history.open'] = 'Mod+Shift+H';
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get(
+            '[data-testid="settings-search-shortcut-input-search.history.open"]'
+        );
+        await input.trigger('focus');
+        await flushPromises();
+        window.dispatchEvent(new KeyboardEvent('keydown', { key: 'BrightnessUp', code: 'F2' }));
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).toHaveBeenCalledWith({
+            ...settingsStoreMock.settings.value.searchKeybindings,
+            'search.history.open': 'F2',
+        });
+    });
+
+    it('does not capture navigation keys while editing a search shortcut', async () => {
+        settingsStoreMock.settings.value.searchKeybindings['search.history.open'] = 'Mod+Shift+H';
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get(
+            '[data-testid="settings-search-shortcut-input-search.history.open"]'
+        );
+        await input.trigger('focus');
+        await flushPromises();
+
+        const event = new KeyboardEvent('keydown', { key: 'ArrowDown', cancelable: true });
+        window.dispatchEvent(event);
+        await flushPromises();
+
+        expect(event.defaultPrevented).toBe(false);
+        expect(settingsStoreMock.updateSearchKeybindings).not.toHaveBeenCalled();
+
+        window.dispatchEvent(new KeyboardEvent('keydown', { key: 'F1' }));
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).toHaveBeenCalledWith({
+            ...settingsStoreMock.settings.value.searchKeybindings,
+            'search.history.open': 'F1',
+        });
+    });
+
+    it('keeps search shortcut capture active after a validation failure', async () => {
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get(
+            '[data-testid="settings-search-shortcut-input-search.history.open"]'
+        );
+        await input.trigger('focus');
+        await flushPromises();
+        window.dispatchEvent(new KeyboardEvent('keydown', { key: 'a', shiftKey: true }));
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).not.toHaveBeenCalled();
+
+        window.dispatchEvent(new KeyboardEvent('keydown', { key: 'F1' }));
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).toHaveBeenCalledWith({
+            ...settingsStoreMock.settings.value.searchKeybindings,
+            'search.history.open': 'F1',
+        });
+    });
+
+    it('shows fixed search shortcuts as unsupported for editing', async () => {
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const input = wrapper.get('[data-testid="settings-search-shortcut-input-search.submit"]');
+        expect(input.attributes('title')).toBe('暂不支持修改该快捷键');
+        expect(input.attributes('tabindex')).toBe('-1');
+
+        await input.trigger('focus');
+        await flushPromises();
+        window.dispatchEvent(new KeyboardEvent('keydown', { key: 'F2' }));
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).not.toHaveBeenCalled();
+        expect((input.element as HTMLInputElement).value).toBe('Enter');
+    });
+
+    it('uses an inline x icon to clear a default search shortcut', async () => {
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        expect(
+            wrapper
+                .find('[data-testid="settings-search-shortcut-reset-search.history.open"]')
+                .exists()
+        ).toBe(false);
+        expect(
+            wrapper
+                .find('[data-testid="settings-search-shortcut-disable-search.history.open"]')
+                .exists()
+        ).toBe(false);
+
+        const action = wrapper.get(
+            '[data-testid="settings-search-shortcut-action-search.history.open"]'
+        );
+        expect(action.attributes('data-shortcut-action')).toBe('clear');
+        expect(action.get('[data-testid="app-icon"]').attributes('data-name')).toBe('x');
+
+        await action.trigger('click');
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).toHaveBeenCalledWith({
+            ...settingsStoreMock.settings.value.searchKeybindings,
+            'search.history.open': null,
+        });
+    });
+
+    it('uses an inline undo icon to restore non-default search shortcuts', async () => {
+        settingsStoreMock.settings.value.searchKeybindings['search.history.open'] = 'Mod+Shift+H';
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        const action = wrapper.get(
+            '[data-testid="settings-search-shortcut-action-search.history.open"]'
+        );
+        expect(action.attributes('data-shortcut-action')).toBe('restore');
+        expect(action.get('[data-testid="app-icon"]').attributes('data-name')).toBe('undo');
+
+        await action.trigger('click');
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).toHaveBeenCalledWith({
+            ...settingsStoreMock.settings.value.searchKeybindings,
+            'search.history.open': 'Mod+H',
+        });
+    });
+
+    it('restores the default search shortcut from the cleared state', async () => {
+        const clearedSearchKeybindings = {
+            ...settingsStoreMock.settings.value.searchKeybindings,
+            'search.history.open': null,
+        };
+        settingsStoreMock.settings.value.searchKeybindings = clearedSearchKeybindings;
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        expect(
+            (
+                wrapper.get('[data-testid="settings-search-shortcut-input-search.history.open"]')
+                    .element as HTMLInputElement
+            ).value
+        ).toBe('无');
+
+        const action = wrapper.get(
+            '[data-testid="settings-search-shortcut-action-search.history.open"]'
+        );
+        expect(action.attributes('data-shortcut-action')).toBe('restore');
+        expect(action.get('[data-testid="app-icon"]').attributes('data-name')).toBe('undo');
+
+        await action.trigger('click');
+        await flushPromises();
+
+        expect(settingsStoreMock.updateSearchKeybindings).toHaveBeenCalledWith({
+            ...clearedSearchKeybindings,
+            'search.history.open': 'Mod+H',
+        });
+    });
+
+    it('localizes the cleared search shortcut fallback', async () => {
+        setLocale('en-US');
+        settingsStoreMock.settings.value.language = 'en-US';
+        settingsStoreMock.settings.value.searchKeybindings = {
+            ...settingsStoreMock.settings.value.searchKeybindings,
+            'search.history.open': null,
+        };
+
+        const wrapper = mount(GeneralSection);
+
+        await flushPromises();
+
+        expect(
+            (
+                wrapper.get('[data-testid="settings-search-shortcut-input-search.history.open"]')
+                    .element as HTMLInputElement
+            ).value
+        ).toBe('None');
     });
 
     it('shows the current version in the latest update details', async () => {
diff --git a/eslint.config.js b/eslint.config.js
index 4c733c6c..26dd29c0 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -66,6 +66,10 @@ export default defineConfig([
         '.coverage/**',
         '**/.coverage',
         '**/.coverage/**',
+        '.vite-cache',
+        '.vite-cache/**',
+        '**/.vite-cache',
+        '**/.vite-cache/**',
         'src-tauri',
         'src-tauri/**',
         '**/src-tauri',