diff --git a/frontend/src/App.css b/frontend/src/App.css
index ae1fdfc..94e5679 100644
--- a/frontend/src/App.css
+++ b/frontend/src/App.css
@@ -2356,6 +2356,11 @@ body.image-preview-open {
   overflow: hidden;
 }
 
+.composer-card:focus-visible {
+  outline: 2px solid rgba(77, 168, 255, 0.78);
+  outline-offset: -2px;
+}
+
 .composer-shell {
   display: flex;
   flex-direction: column;
@@ -3185,3 +3190,102 @@ body[data-route='/'] .social-link-button:focus-visible::before {
 .browser-assist-form {
   max-width: 620px;
 }
+
+.keyboard-shortcuts-settings {
+  max-width: 780px;
+}
+
+.keyboard-shortcuts-heading h4 {
+  margin: 24px 0 4px;
+}
+
+.keyboard-shortcuts-heading .ant-typography {
+  margin-bottom: 16px;
+}
+
+.keyboard-shortcut-list {
+  overflow: hidden;
+  border: 1px solid var(--app-border);
+  border-radius: 10px;
+  background: var(--app-bg-panel-strong);
+}
+
+.keyboard-shortcut-row {
+  display: grid;
+  grid-template-columns: minmax(220px, 1fr) minmax(120px, auto) auto;
+  align-items: center;
+  gap: 16px;
+  padding: 14px 16px;
+  border-bottom: 1px solid var(--app-border-soft);
+}
+
+.keyboard-shortcut-row:last-child {
+  border-bottom: 0;
+}
+
+.keyboard-shortcut-copy {
+  min-width: 0;
+  display: grid;
+  gap: 3px;
+}
+
+.keyboard-shortcut-key {
+  min-width: 108px;
+  padding: 5px 9px;
+  border: 1px solid var(--app-border);
+  border-bottom-color: var(--app-border-strong);
+  border-radius: 6px;
+  background: var(--app-bg-muted);
+  color: var(--app-text);
+  font-family: ui-monospace, SFMono-Regular, Consolas, "Liberation Mono", monospace;
+  font-size: 12px;
+  font-weight: 700;
+  line-height: 1.4;
+  text-align: center;
+  white-space: nowrap;
+}
+
+.keyboard-shortcut-key.is-empty {
+  color: var(--app-text-muted);
+  font-weight: 500;
+}
+
+.keyboard-shortcut-actions {
+  justify-self: end;
+}
+
+.keyboard-shortcuts-error {
+  margin-top: 12px;
+}
+
+.keyboard-shortcuts-footer {
+  margin-top: 16px;
+}
+
+.keyboard-shortcut-live {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+@media (max-width: 720px) {
+  .keyboard-shortcut-row {
+    grid-template-columns: minmax(0, 1fr) auto;
+    gap: 10px;
+  }
+
+  .keyboard-shortcut-key {
+    min-width: 96px;
+  }
+
+  .keyboard-shortcut-actions {
+    grid-column: 1 / -1;
+    justify-self: start;
+  }
+}
diff --git a/frontend/src/components/ChatPane.tsx b/frontend/src/components/ChatPane.tsx
index 2fce863..6067246 100644
--- a/frontend/src/components/ChatPane.tsx
+++ b/frontend/src/components/ChatPane.tsx
@@ -38,6 +38,8 @@ import { ToolField } from './ToolField'
 import { ChatMessageList } from './ChatMessageList'
 import { ToolCallAssistPopover } from '../features/tool-call-assist/ToolCallAssistPopover'
 import { normalizeChatText } from '../lib/chat-format'
+import { formatKeyboardShortcutBinding, type KeyboardShortcutConfig } from '../features/keyboard-shortcuts/shortcuts'
+import type { ComposerKeyboardAction } from '../hooks/chatWorkspace/composerKeyboard'
 import type {
   ComposerMode,
   BuiltinToolOption,
@@ -65,10 +67,11 @@ type ChatPaneProps = {
   composer: string
   composerMode: ComposerMode
   draftBuffer: string
-  handleComposerKeyDown: (event: KeyboardEvent<HTMLTextAreaElement>) => void
+  handleComposerKeyDown: (event: KeyboardEvent<HTMLElement>) => ComposerKeyboardAction['type']
   isMobile: boolean
   isWaitingForUser: boolean
   keyboardOffset: number
+  keyboardShortcuts: KeyboardShortcutConfig
   messagesLoading: boolean
   onDraft: () => void | Promise<void>
   onAutomationRecording: (action: 'start' | 'stop' | 'cancel') => void | Promise<void>
@@ -119,6 +122,7 @@ export function ChatPane(props: ChatPaneProps) {
     isMobile,
     isWaitingForUser,
     keyboardOffset,
+    keyboardShortcuts,
     messagesLoading,
     onDraft,
     onAutomationRecording,
@@ -264,6 +268,38 @@ export function ChatPane(props: ChatPaneProps) {
     { label: 'summery 模式', value: 'summery' },
     { label: 'reasoning 模式', value: 'reasoning' },
   ]
+  const shortcutCopy = (action: keyof KeyboardShortcutConfig['bindings'], label: string) => {
+    const binding = keyboardShortcuts.bindings[action]
+    return binding ? `${formatKeyboardShortcutBinding(binding)} ${label}` : ''
+  }
+  const modeCycleShortcut = shortcutCopy('cycle_mode', '切换类型')
+  const answerShortcutHint = [
+    shortcutCopy('stream', '流式输出'),
+    shortcutCopy('newline', '换行'),
+    shortcutCopy('complete', '结束输出'),
+    shortcutCopy('restore_draft', '继续编辑'),
+    modeCycleShortcut,
+  ].filter(Boolean).join('，')
+  const thinkingShortcutHint = [
+    shortcutCopy('stream', '流式输出'),
+    shortcutCopy('newline', '换行'),
+    modeCycleShortcut,
+  ].filter(Boolean).join('，')
+
+  function handleComposerAreaKeyDown(event: KeyboardEvent<HTMLElement>) {
+    const action = handleComposerKeyDown(event)
+    if (action !== 'cycle_mode') return
+    window.requestAnimationFrame(() => {
+      const editor = composerCardRef.current?.querySelector<HTMLTextAreaElement>(
+        'textarea[data-composer-editor="true"]:not(:disabled)',
+      )
+      if (editor) {
+        editor.focus()
+      } else {
+        composerCardRef.current?.focus()
+      }
+    })
+  }
 
   return (
     <div className="chat-pane" style={paneStyle}>
@@ -299,7 +335,15 @@ export function ChatPane(props: ChatPaneProps) {
         />
       </div>
 
-      <Card ref={composerCardRef} className="composer-card" style={composerStyle}>
+      <Card
+        ref={composerCardRef}
+        className="composer-card"
+        style={composerStyle}
+        role="group"
+        aria-label="回复编辑区快捷键区域"
+        tabIndex={-1}
+        onKeyDown={handleComposerAreaKeyDown}
+      >
         <div className="composer-shell">
           <Space direction="vertical" size={12} className="composer-stack">
             {draftBuffer && (
@@ -539,16 +583,16 @@ export function ChatPane(props: ChatPaneProps) {
                   <Typography.Text className="thinking-panel-hint">
                     当前会以{' '}
                     {reasoningStreamMode === 'reasoning' ? 'reasoning' : 'summery'}
-                    输出给调用方 · Enter 流式输出，Shift+Enter 换行
+                    输出给调用方{thinkingShortcutHint ? ` · ${thinkingShortcutHint}` : ''}
                   </Typography.Text>
                 </div>
                 <TextArea
                   value={thinkingText}
                   onChange={(event) => setThinkingText(event.target.value)}
-                  onKeyDown={handleComposerKeyDown}
+                  data-composer-editor="true"
                   placeholder={
                     isWaitingForUser
-                      ? '输入思考过程。按 Enter 会立刻流式输出给调用方（和正文一样），Shift+Enter 换行。'
+                      ? `输入思考过程。${thinkingShortcutHint || '可使用下方按钮输出。'}`
                       : '当前没有等待中的 user 请求。'
                   }
                   autoSize={{ minRows: 4, maxRows: 10 }}
@@ -562,10 +606,10 @@ export function ChatPane(props: ChatPaneProps) {
                 <TextArea
                   value={composer}
                   onChange={(event) => setComposer(event.target.value)}
-                  onKeyDown={handleComposerKeyDown}
+                  data-composer-editor="true"
                   placeholder={
                     isWaitingForUser
-                      ? '输入你作为 assistant 的回复。Enter 流式输出，Shift+Enter 换行，Ctrl/⌘+Enter 结束输出。'
+                      ? `输入你作为 assistant 的回复。${answerShortcutHint || '可使用下方按钮输出。'}`
                       : '当前没有等待中的 user 请求。'
                   }
                   autoSize={{ minRows: 4, maxRows: 10 }}
@@ -581,16 +625,16 @@ export function ChatPane(props: ChatPaneProps) {
                 ? '正在发送并等待服务端同步草稿…'
                 : isWaitingForUser
                 ? composerMode === 'assistant_message'
-                  ? 'Enter 流式输出，Shift+Enter 换行，Ctrl/⌘+Enter 结束。片段会保留在本轮回复里。'
+                  ? `${answerShortcutHint || '可使用右侧按钮输出'}。片段会保留在本轮回复里。`
                 : composerMode === 'thinking'
-                    ? `Enter 流式输出思考（${
+                    ? `${thinkingShortcutHint || '可使用左侧按钮输出思考'}（${
                         isResponsesConversation && reasoningStreamMode === 'reasoning'
                           ? 'reasoning'
                           : 'summery'
-                      }），Shift+Enter 换行。思考不会结束这一轮。`
+                      }）。思考不会结束这一轮。`
                     : composerMode === 'builtin_tool'
-                      ? '内置工具会输出 Responses 官方内置工具事件，不会结束这一轮。'
-                    : 'Tool Call 模式会根据 schema 组装参数 JSON，点击左侧按钮会直接输出一个 function_call item。'
+                      ? `内置工具会输出 Responses 官方内置工具事件，不会结束这一轮${modeCycleShortcut ? ` · ${modeCycleShortcut}` : ''}。`
+                    : `Tool Call 模式会根据 schema 组装参数 JSON，点击左侧按钮会直接输出一个 function_call item${modeCycleShortcut ? ` · ${modeCycleShortcut}` : ''}。`
                 : '没有新的 user 请求时不能输出回复。'}
             </Typography.Text>
             <Space>
diff --git a/frontend/src/components/WorkspaceRoute.tsx b/frontend/src/components/WorkspaceRoute.tsx
index 53a58fa..0c8de37 100644
--- a/frontend/src/components/WorkspaceRoute.tsx
+++ b/frontend/src/components/WorkspaceRoute.tsx
@@ -191,6 +191,7 @@ export function WorkspaceRoute() {
             isMobile={isMobile}
             isWaitingForUser={workspace.isWaitingForUser}
             keyboardOffset={workspace.keyboardOffset}
+            keyboardShortcuts={workspace.keyboardShortcuts}
             messagesLoading={workspace.messagesLoading}
             onDraft={workspace.handleDraft}
             onAutomationRecording={workspace.handleAutomationRecording}
diff --git a/frontend/src/components/settings/AutomationRulesPanel.tsx b/frontend/src/components/settings/AutomationRulesPanel.tsx
index f008682..6ac480b 100644
--- a/frontend/src/components/settings/AutomationRulesPanel.tsx
+++ b/frontend/src/components/settings/AutomationRulesPanel.tsx
@@ -3,7 +3,7 @@ import { DeleteOutlined, EditOutlined, PlusOutlined } from '@ant-design/icons'
 
 import type { AutomationRule } from '../../types/chat'
 
-type AutomationRulesPanelProps = {
+export type AutomationRulesPanelProps = {
   automationRules: AutomationRule[]
   onCreateAutomationRule: () => void | Promise<void>
   onDeleteAutomationRule: (ruleId: string) => void | Promise<void>
diff --git a/frontend/src/components/settings/KeyboardShortcutsSettingsPanel.tsx b/frontend/src/components/settings/KeyboardShortcutsSettingsPanel.tsx
new file mode 100644
index 0000000..1185e30
--- /dev/null
+++ b/frontend/src/components/settings/KeyboardShortcutsSettingsPanel.tsx
@@ -0,0 +1,274 @@
+import { useMemo, useState, type KeyboardEvent } from 'react'
+import { Alert, Button, Space, Typography } from 'antd'
+import { EditOutlined, SaveOutlined, UndoOutlined } from '@ant-design/icons'
+
+import { appMessage } from '../../lib/antdMessage'
+import {
+  KEYBOARD_SHORTCUT_ACTIONS,
+  createDefaultKeyboardShortcutConfig,
+  formatKeyboardShortcutBinding,
+  getKeyboardShortcutValidationIssues,
+  isAltGraphModifierActive,
+  isKeyboardShortcutBindingSafe,
+  keyboardShortcutBindingsEqual,
+  keyboardShortcutConfigsEqual,
+  normalizeKeyboardShortcutEvent,
+  type KeyboardShortcutAction,
+  type KeyboardShortcutConfig,
+} from '../../features/keyboard-shortcuts/shortcuts'
+import {
+  saveKeyboardShortcutConfig,
+  setKeyboardShortcutBinding,
+} from '../../features/keyboard-shortcuts/storage'
+import { useKeyboardShortcuts } from '../../features/keyboard-shortcuts/useKeyboardShortcuts'
+
+const ACTION_COPY: Record<KeyboardShortcutAction, { label: string; description: string }> = {
+  stream: {
+    label: '流式输出',
+    description: '发送当前助手消息或思考片段，但不结束本轮输出。',
+  },
+  complete: {
+    label: '结束输出',
+    description: '发送尚未输出的助手消息，并结束当前请求。',
+  },
+  newline: {
+    label: '编辑器换行',
+    description: '在助手消息或思考内容编辑器的光标处插入换行。',
+  },
+  restore_draft: {
+    label: '继续编辑已输出内容',
+    description: '把本轮已经流式输出的正文放回助手消息编辑器。',
+  },
+  cycle_mode: {
+    label: '切换输出类型',
+    description: '依次切换助手消息、思考内容和工具调用；默认不绑定。',
+  },
+}
+
+function validationMessage(config: KeyboardShortcutConfig): string {
+  const issue = getKeyboardShortcutValidationIssues(config)[0]
+  if (!issue) return ''
+  const labels = issue.actions.map((action) => ACTION_COPY[action].label).join('、')
+  return issue.type === 'duplicate'
+    ? `${labels} 使用了相同的组合键，请重新设置。`
+    : `${labels} 的组合键可能覆盖打字、浏览器或系统操作，请重新设置。`
+}
+
+type DraftState = {
+  base: KeyboardShortcutConfig
+  config: KeyboardShortcutConfig
+}
+
+export function KeyboardShortcutsSettingsPanel({ userID }: { userID: string }) {
+  const externalConfig = useKeyboardShortcuts(userID)
+  const [draftState, setDraftState] = useState<DraftState | null>(null)
+  const [recordingAction, setRecordingAction] = useState<KeyboardShortcutAction | null>(null)
+  const [captureError, setCaptureError] = useState('')
+  const [saveError, setSaveError] = useState('')
+  const [announcement, setAnnouncement] = useState('')
+
+  const hasLocalChanges = Boolean(
+    draftState && !keyboardShortcutConfigsEqual(draftState.base, draftState.config),
+  )
+  const draftConfig = hasLocalChanges && draftState ? draftState.config : externalConfig
+  const configError = useMemo(() => validationMessage(draftConfig), [draftConfig])
+  const dirty = hasLocalChanges && !keyboardShortcutConfigsEqual(externalConfig, draftConfig)
+  const externalChanged = Boolean(
+    hasLocalChanges
+    && draftState
+    && !keyboardShortcutConfigsEqual(draftState.base, externalConfig)
+    && !keyboardShortcutConfigsEqual(draftState.config, externalConfig),
+  )
+
+  function updateDraft(update: (current: KeyboardShortcutConfig) => KeyboardShortcutConfig) {
+    setDraftState((current) => {
+      const currentHasChanges = Boolean(
+        current && !keyboardShortcutConfigsEqual(current.base, current.config),
+      )
+      const base = currentHasChanges && current ? current.base : externalConfig
+      const config = currentHasChanges && current ? current.config : externalConfig
+      return { base, config: update(config) }
+    })
+  }
+
+  function startRecording(action: KeyboardShortcutAction) {
+    const nextAction = recordingAction === action ? null : action
+    setRecordingAction(nextAction)
+    setCaptureError('')
+    setSaveError('')
+    setAnnouncement(nextAction ? `正在录制：${ACTION_COPY[action].label}` : '已取消录制')
+  }
+
+  function captureShortcut(action: KeyboardShortcutAction, event: KeyboardEvent<HTMLElement>) {
+    if (recordingAction !== action) return
+    event.preventDefault()
+    event.stopPropagation()
+
+    if (event.key === 'Escape') {
+      setRecordingAction(null)
+      setCaptureError('')
+      setAnnouncement(`已取消录制：${ACTION_COPY[action].label}`)
+      return
+    }
+    if (isAltGraphModifierActive(event)) {
+      setCaptureError('AltGraph 用于国际键盘输入，不能绑定为发送快捷键。')
+      return
+    }
+
+    const binding = normalizeKeyboardShortcutEvent(event)
+    if (!binding) return
+    if (!isKeyboardShortcutBindingSafe(binding)) {
+      setCaptureError('为避免误触，仅支持 Enter、Tab 及其 Shift 组合；Ctrl/⌘ 或 Alt 只能与 Enter 组合，且不支持 Ctrl+Alt。')
+      return
+    }
+
+    const conflict = KEYBOARD_SHORTCUT_ACTIONS.find((candidate) =>
+      candidate !== action
+      && keyboardShortcutBindingsEqual(draftConfig.bindings[candidate], binding),
+    )
+    if (conflict) {
+      setCaptureError(`该组合键已用于“${ACTION_COPY[conflict].label}”，请先调整或清除原绑定。`)
+      return
+    }
+
+    updateDraft((current) => setKeyboardShortcutBinding(current, action, binding))
+    setRecordingAction(null)
+    setCaptureError('')
+    setSaveError('')
+    setAnnouncement(`已将“${ACTION_COPY[action].label}”设为 ${formatKeyboardShortcutBinding(binding)}`)
+  }
+
+  function clearShortcut(action: KeyboardShortcutAction) {
+    updateDraft((current) => setKeyboardShortcutBinding(current, action, null))
+    setRecordingAction(null)
+    setCaptureError('')
+    setSaveError('')
+    setAnnouncement(`已清除：${ACTION_COPY[action].label}`)
+  }
+
+  function restoreDefaults() {
+    updateDraft(() => createDefaultKeyboardShortcutConfig())
+    setRecordingAction(null)
+    setCaptureError('')
+    setSaveError('')
+    setAnnouncement('已恢复默认快捷键，保存后生效')
+  }
+
+  function reloadExternalConfig() {
+    setDraftState(null)
+    setRecordingAction(null)
+    setCaptureError('')
+    setSaveError('')
+    setAnnouncement('已载入其他标签页保存的快捷键')
+  }
+
+  function save() {
+    if (externalChanged) {
+      setSaveError('另一标签页已更新快捷键，请先载入新配置。')
+      return
+    }
+    try {
+      saveKeyboardShortcutConfig(userID, draftConfig)
+      setDraftState(null)
+      setSaveError('')
+      setAnnouncement('快捷键已保存并立即生效')
+      appMessage.success('快捷键已保存并立即生效')
+    } catch (error) {
+      setSaveError(error instanceof Error ? error.message : '快捷键保存失败，请检查浏览器存储权限。')
+    }
+  }
+
+  if (!userID.trim()) {
+    return <Alert type="warning" showIcon message="登录后才能配置快捷键" />
+  }
+
+  return (
+    <div className="keyboard-shortcuts-settings">
+      <Alert
+        type="info"
+        showIcon
+        message="仅作用于回复编辑区"
+        description="配置按当前 ChatAPI 用户隔离并保存在此浏览器。现有默认键位保持不变；未被动作占用的按键保留浏览器原生行为，例如未绑定 Shift+Tab 时仍会反向切换焦点。"
+      />
+      <div className="keyboard-shortcuts-heading">
+        <Typography.Title level={4}>快捷键</Typography.Title>
+        <Typography.Paragraph type="secondary">
+          点击“录制”，再按下组合键。只按修饰键会继续等待，按 Esc 可取消录制。为防止误发送，编辑、浏览器和系统保留键不会被接受。
+        </Typography.Paragraph>
+      </div>
+
+      <div className="keyboard-shortcut-list">
+        {KEYBOARD_SHORTCUT_ACTIONS.map((action) => {
+          const binding = draftConfig.bindings[action]
+          const recording = recordingAction === action
+          return (
+            <div className="keyboard-shortcut-row" key={action}>
+              <div className="keyboard-shortcut-copy">
+                <Typography.Text strong>{ACTION_COPY[action].label}</Typography.Text>
+                <Typography.Text type="secondary">{ACTION_COPY[action].description}</Typography.Text>
+              </div>
+              <kbd className={binding ? 'keyboard-shortcut-key' : 'keyboard-shortcut-key is-empty'}>
+                {formatKeyboardShortcutBinding(binding)}
+              </kbd>
+              <Space size={8} className="keyboard-shortcut-actions">
+                <Button
+                  type={recording ? 'primary' : 'default'}
+                  icon={<EditOutlined />}
+                  aria-label={`${recording ? '正在录制' : '录制'}：${ACTION_COPY[action].label}`}
+                  aria-pressed={recording}
+                  onClick={() => startRecording(action)}
+                  onKeyDown={(event) => captureShortcut(action, event)}
+                  onBlur={() => {
+                    if (recording) setRecordingAction(null)
+                  }}
+                >
+                  {recording ? '请按组合键…' : '录制'}
+                </Button>
+                <Button
+                  aria-label={`清除：${ACTION_COPY[action].label}`}
+                  disabled={!binding}
+                  onClick={() => clearShortcut(action)}
+                >
+                  清除
+                </Button>
+              </Space>
+            </div>
+          )
+        })}
+      </div>
+
+      {externalChanged ? (
+        <Alert
+          className="keyboard-shortcuts-error"
+          type="warning"
+          showIcon
+          message="另一标签页已更新快捷键"
+          description="为避免覆盖较新的配置，请先载入后再重新修改。"
+          action={<Button size="small" onClick={reloadExternalConfig}>载入新配置</Button>}
+        />
+      ) : null}
+
+      {captureError || configError || saveError ? (
+        <Alert
+          className="keyboard-shortcuts-error"
+          type="error"
+          showIcon
+          message={captureError || configError || saveError}
+        />
+      ) : null}
+
+      <Space wrap className="keyboard-shortcuts-footer">
+        <Button icon={<UndoOutlined />} onClick={restoreDefaults}>恢复默认</Button>
+        <Button
+          type="primary"
+          icon={<SaveOutlined />}
+          disabled={!dirty || Boolean(configError) || Boolean(recordingAction) || externalChanged}
+          onClick={save}
+        >
+          保存到当前浏览器
+        </Button>
+      </Space>
+      <span className="keyboard-shortcut-live" aria-live="polite">{announcement}</span>
+    </div>
+  )
+}
diff --git a/frontend/src/components/settings/SettingsModal.tsx b/frontend/src/components/settings/SettingsModal.tsx
index e3f5cd0..8f66103 100644
--- a/frontend/src/components/settings/SettingsModal.tsx
+++ b/frontend/src/components/settings/SettingsModal.tsx
@@ -3,28 +3,23 @@ import { Button, Modal, Tabs, Typography } from 'antd'
 import { ControlOutlined } from '@ant-design/icons'
 import { useNavigate } from 'react-router-dom'
 
-import type { AutomationRule, AuthUser } from '../../types/chat'
+import type { AuthUser } from '../../types/chat'
 import { ApiKeyManagementPanel } from './ApiKeyManagementPanel'
-import { AutomationRulesPanel } from './AutomationRulesPanel'
+import { AutomationRulesPanel, type AutomationRulesPanelProps } from './AutomationRulesPanel'
 import { BrowserAssistSettingsPanel } from './BrowserAssistSettingsPanel'
+import { KeyboardShortcutsSettingsPanel } from './KeyboardShortcutsSettingsPanel'
 import { UserSettingsPanel } from './UserSettingsPanel'
 
-type SettingsModalProps = {
+type SettingsModalProps = AutomationRulesPanelProps & {
   automationRuleEditorOpen: boolean
-  automationRules: AutomationRule[]
-  onCreateAutomationRule: () => void | Promise<void>
-  onDeleteAutomationRule: (ruleId: string) => void | Promise<void>
-  onEditAutomationRule: (ruleId: string) => void | Promise<void>
-  onToggleAutomationRule: (ruleId: string, enabled: boolean) => void | Promise<void>
   open: boolean
   onClose: () => void
-  savingAutomationRules: boolean
   user: AuthUser | null
   totpEnabled: boolean
   onTotpRefresh: () => void
 }
 
-type TabKey = 'user-settings' | 'api-keys' | 'automation' | 'browser-assist' | 'system'
+type TabKey = 'user-settings' | 'api-keys' | 'automation' | 'browser-assist' | 'keyboard-shortcuts' | 'system'
 
 export function SettingsModal({
   automationRuleEditorOpen,
@@ -73,6 +68,16 @@ export function SettingsModal({
       label: '辅助模型',
       children: <BrowserAssistSettingsPanel open={open && activeTab === 'browser-assist'} userID={user?.id ?? ''} />,
     },
+    {
+      key: 'keyboard-shortcuts',
+      label: '快捷键',
+      children: (
+        <KeyboardShortcutsSettingsPanel
+          key={user?.id ?? 'anonymous'}
+          userID={user?.id ?? ''}
+        />
+      ),
+    },
   ]
 
   const userSettingsTab = {
diff --git a/frontend/src/features/keyboard-shortcuts/shortcuts.ts b/frontend/src/features/keyboard-shortcuts/shortcuts.ts
new file mode 100644
index 0000000..f68d020
--- /dev/null
+++ b/frontend/src/features/keyboard-shortcuts/shortcuts.ts
@@ -0,0 +1,179 @@
+export const KEYBOARD_SHORTCUT_ACTIONS = [
+  'stream',
+  'complete',
+  'newline',
+  'restore_draft',
+  'cycle_mode',
+] as const
+
+export type KeyboardShortcutAction = (typeof KEYBOARD_SHORTCUT_ACTIONS)[number]
+
+export type KeyboardShortcutBinding = {
+  key: string
+  mod: boolean
+  alt: boolean
+  shift: boolean
+}
+
+export type KeyboardShortcutBindings = Record<KeyboardShortcutAction, KeyboardShortcutBinding | null>
+
+export type KeyboardShortcutConfig = {
+  version: 1
+  bindings: KeyboardShortcutBindings
+}
+
+export type KeyboardShortcutEventLike = {
+  key?: string
+  altKey?: boolean
+  ctrlKey?: boolean
+  metaKey?: boolean
+  shiftKey?: boolean
+  getModifierState?: (key: 'AltGraph') => boolean
+}
+
+export type KeyboardShortcutValidationIssue =
+  | { type: 'unsafe'; actions: KeyboardShortcutAction[] }
+  | { type: 'duplicate'; actions: KeyboardShortcutAction[] }
+
+const MODIFIER_KEYS = new Set(['Alt', 'AltGraph', 'Control', 'Meta', 'Shift'])
+const REJECTED_KEYS = new Set(['Dead', 'Process', 'Unidentified'])
+const SAFE_UNMODIFIED_KEYS = new Set(['Enter', 'Tab'])
+
+const DEFAULT_BINDINGS: KeyboardShortcutBindings = {
+  stream: { key: 'Enter', mod: false, alt: false, shift: false },
+  complete: { key: 'Enter', mod: true, alt: false, shift: false },
+  newline: { key: 'Enter', mod: false, alt: false, shift: true },
+  restore_draft: { key: 'Enter', mod: false, alt: true, shift: false },
+  cycle_mode: null,
+}
+
+function cloneBinding(binding: KeyboardShortcutBinding | null): KeyboardShortcutBinding | null {
+  return binding ? { ...binding } : null
+}
+
+export function createDefaultKeyboardShortcutConfig(): KeyboardShortcutConfig {
+  return {
+    version: 1,
+    bindings: {
+      stream: cloneBinding(DEFAULT_BINDINGS.stream),
+      complete: cloneBinding(DEFAULT_BINDINGS.complete),
+      newline: cloneBinding(DEFAULT_BINDINGS.newline),
+      restore_draft: cloneBinding(DEFAULT_BINDINGS.restore_draft),
+      cycle_mode: cloneBinding(DEFAULT_BINDINGS.cycle_mode),
+    },
+  }
+}
+
+export function cloneKeyboardShortcutConfig(config: KeyboardShortcutConfig): KeyboardShortcutConfig {
+  return {
+    version: 1,
+    bindings: {
+      stream: cloneBinding(config.bindings.stream),
+      complete: cloneBinding(config.bindings.complete),
+      newline: cloneBinding(config.bindings.newline),
+      restore_draft: cloneBinding(config.bindings.restore_draft),
+      cycle_mode: cloneBinding(config.bindings.cycle_mode),
+    },
+  }
+}
+
+function normalizeKey(key: string | undefined): string {
+  if (!key) return ''
+  if (key === ' ') return 'Space'
+  if (key === 'Esc') return 'Escape'
+  if (key.length === 1) return key.toUpperCase()
+  return key
+}
+
+export function isAltGraphModifierActive(event: KeyboardShortcutEventLike): boolean {
+  return Boolean(event.getModifierState?.('AltGraph'))
+}
+
+export function normalizeKeyboardShortcutEvent(
+  event: KeyboardShortcutEventLike,
+): KeyboardShortcutBinding | null {
+  const key = normalizeKey(event.key)
+  if (!key || MODIFIER_KEYS.has(key) || isAltGraphModifierActive(event)) return null
+  return {
+    key,
+    mod: Boolean(event.ctrlKey || event.metaKey),
+    alt: Boolean(event.altKey),
+    shift: Boolean(event.shiftKey),
+  }
+}
+
+export function isKeyboardShortcutBindingSafe(binding: KeyboardShortcutBinding): boolean {
+  const key = normalizeKey(binding.key)
+  if (!key || key.length > 32 || MODIFIER_KEYS.has(key) || REJECTED_KEYS.has(key)) return false
+  // Ctrl+Alt is emitted by AltGraph on many international layouts. Restrict
+  // modified bindings to Enter so editing, browser, and OS shortcuts such as
+  // Mod+Z, Mod+W, Alt+Arrow, or Alt+F4 can never become send actions.
+  if (binding.mod && binding.alt) return false
+  if (binding.mod || binding.alt) return key === 'Enter'
+  return SAFE_UNMODIFIED_KEYS.has(key)
+}
+
+export function keyboardShortcutBindingID(binding: KeyboardShortcutBinding): string {
+  return `${binding.mod ? '1' : '0'}:${binding.alt ? '1' : '0'}:${binding.shift ? '1' : '0'}:${normalizeKey(binding.key)}`
+}
+
+export function keyboardShortcutBindingsEqual(
+  left: KeyboardShortcutBinding | null,
+  right: KeyboardShortcutBinding | null,
+): boolean {
+  if (!left || !right) return left === right
+  return keyboardShortcutBindingID(left) === keyboardShortcutBindingID(right)
+}
+
+export function keyboardShortcutConfigsEqual(
+  left: KeyboardShortcutConfig,
+  right: KeyboardShortcutConfig,
+): boolean {
+  return KEYBOARD_SHORTCUT_ACTIONS.every((action) =>
+    keyboardShortcutBindingsEqual(left.bindings[action], right.bindings[action]),
+  )
+}
+
+export function getKeyboardShortcutValidationIssues(
+  config: KeyboardShortcutConfig,
+): KeyboardShortcutValidationIssue[] {
+  const issues: KeyboardShortcutValidationIssue[] = []
+  const actionsByBinding = new Map<string, KeyboardShortcutAction[]>()
+
+  for (const action of KEYBOARD_SHORTCUT_ACTIONS) {
+    const binding = config.bindings[action]
+    if (!binding) continue
+    if (!isKeyboardShortcutBindingSafe(binding)) {
+      issues.push({ type: 'unsafe', actions: [action] })
+      continue
+    }
+    const id = keyboardShortcutBindingID(binding)
+    actionsByBinding.set(id, [...(actionsByBinding.get(id) ?? []), action])
+  }
+
+  for (const actions of actionsByBinding.values()) {
+    if (actions.length > 1) issues.push({ type: 'duplicate', actions })
+  }
+  return issues
+}
+
+export function findKeyboardShortcutAction(
+  event: KeyboardShortcutEventLike,
+  bindings: KeyboardShortcutBindings,
+): KeyboardShortcutAction | null {
+  const pressed = normalizeKeyboardShortcutEvent(event)
+  if (!pressed) return null
+  return KEYBOARD_SHORTCUT_ACTIONS.find((action) =>
+    keyboardShortcutBindingsEqual(bindings[action], pressed),
+  ) ?? null
+}
+
+export function formatKeyboardShortcutBinding(binding: KeyboardShortcutBinding | null): string {
+  if (!binding) return '未设置'
+  return [
+    binding.mod ? 'Ctrl/⌘' : '',
+    binding.alt ? 'Alt' : '',
+    binding.shift ? 'Shift' : '',
+    normalizeKey(binding.key),
+  ].filter(Boolean).join('+')
+}
diff --git a/frontend/src/features/keyboard-shortcuts/storage.ts b/frontend/src/features/keyboard-shortcuts/storage.ts
new file mode 100644
index 0000000..ca79c29
--- /dev/null
+++ b/frontend/src/features/keyboard-shortcuts/storage.ts
@@ -0,0 +1,99 @@
+import {
+  KEYBOARD_SHORTCUT_ACTIONS,
+  cloneKeyboardShortcutConfig,
+  createDefaultKeyboardShortcutConfig,
+  getKeyboardShortcutValidationIssues,
+  isKeyboardShortcutBindingSafe,
+  type KeyboardShortcutAction,
+  type KeyboardShortcutBinding,
+  type KeyboardShortcutConfig,
+} from './shortcuts.ts'
+
+const STORAGE_PREFIX = 'chatapi.keyboard-shortcuts.v1'
+export const KEYBOARD_SHORTCUTS_CHANGED_EVENT = 'chatapi:keyboard-shortcuts-changed'
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function parseStoredBinding(value: unknown): KeyboardShortcutBinding | null | undefined {
+  if (value === null) return null
+  if (!isObject(value)) return undefined
+  if (
+    typeof value.key !== 'string'
+    || typeof value.mod !== 'boolean'
+    || typeof value.alt !== 'boolean'
+    || typeof value.shift !== 'boolean'
+  ) {
+    return undefined
+  }
+  const binding = {
+    key: value.key,
+    mod: value.mod,
+    alt: value.alt,
+    shift: value.shift,
+  }
+  return isKeyboardShortcutBindingSafe(binding) ? binding : undefined
+}
+
+export function keyboardShortcutStorageKey(userID: string): string {
+  const normalizedUserID = userID.trim()
+  if (!normalizedUserID) throw new Error('缺少当前用户，无法读取快捷键配置')
+  return `${STORAGE_PREFIX}.${normalizedUserID}`
+}
+
+export function sanitizeKeyboardShortcutConfig(value: unknown): KeyboardShortcutConfig {
+  const fallback = createDefaultKeyboardShortcutConfig()
+  if (!isObject(value) || value.version !== 1 || !isObject(value.bindings)) return fallback
+
+  const bindings = { ...fallback.bindings }
+  for (const action of KEYBOARD_SHORTCUT_ACTIONS) {
+    if (!(action in value.bindings)) continue
+    const binding = parseStoredBinding(value.bindings[action])
+    if (binding === undefined) return fallback
+    bindings[action] = binding
+  }
+
+  const config: KeyboardShortcutConfig = { version: 1, bindings }
+  return getKeyboardShortcutValidationIssues(config).length
+    ? fallback
+    : cloneKeyboardShortcutConfig(config)
+}
+
+export function loadKeyboardShortcutConfig(userID: string): KeyboardShortcutConfig {
+  if (typeof window === 'undefined' || !userID.trim()) return createDefaultKeyboardShortcutConfig()
+  try {
+    const stored = window.localStorage.getItem(keyboardShortcutStorageKey(userID))
+    return stored ? sanitizeKeyboardShortcutConfig(JSON.parse(stored) as unknown) : createDefaultKeyboardShortcutConfig()
+  } catch {
+    return createDefaultKeyboardShortcutConfig()
+  }
+}
+
+export function saveKeyboardShortcutConfig(userID: string, config: KeyboardShortcutConfig): void {
+  const issues = getKeyboardShortcutValidationIssues(config)
+  if (issues.length) throw new Error('快捷键配置包含无效或冲突的键位')
+  const saved = cloneKeyboardShortcutConfig(config)
+  try {
+    window.localStorage.setItem(keyboardShortcutStorageKey(userID), JSON.stringify(saved))
+  } catch {
+    throw new Error('无法写入浏览器存储，请检查隐私设置或存储权限。')
+  }
+  window.dispatchEvent(new CustomEvent(KEYBOARD_SHORTCUTS_CHANGED_EVENT, {
+    detail: { userID: userID.trim() },
+  }))
+}
+
+export function setKeyboardShortcutBinding(
+  config: KeyboardShortcutConfig,
+  action: KeyboardShortcutAction,
+  binding: KeyboardShortcutBinding | null,
+): KeyboardShortcutConfig {
+  return {
+    version: 1,
+    bindings: {
+      ...config.bindings,
+      [action]: binding ? { ...binding } : null,
+    },
+  }
+}
diff --git a/frontend/src/features/keyboard-shortcuts/useKeyboardShortcuts.ts b/frontend/src/features/keyboard-shortcuts/useKeyboardShortcuts.ts
new file mode 100644
index 0000000..4f02921
--- /dev/null
+++ b/frontend/src/features/keyboard-shortcuts/useKeyboardShortcuts.ts
@@ -0,0 +1,52 @@
+import { useCallback, useMemo, useSyncExternalStore } from 'react'
+
+import { createDefaultKeyboardShortcutConfig, type KeyboardShortcutConfig } from './shortcuts'
+import {
+  KEYBOARD_SHORTCUTS_CHANGED_EVENT,
+  keyboardShortcutStorageKey,
+  sanitizeKeyboardShortcutConfig,
+} from './storage'
+
+export function useKeyboardShortcuts(userID: string): KeyboardShortcutConfig {
+  const normalizedUserID = userID.trim()
+
+  const subscribe = useCallback((onStoreChange: () => void) => {
+    if (typeof window === 'undefined' || !normalizedUserID) return () => undefined
+    const expectedStorageKey = keyboardShortcutStorageKey(normalizedUserID)
+
+    function handleLocalChange(event: Event) {
+      const detail = (event as CustomEvent<{ userID?: string }>).detail
+      if (detail?.userID === normalizedUserID) onStoreChange()
+    }
+
+    function handleStorage(event: StorageEvent) {
+      if (event.key === null || event.key === expectedStorageKey) onStoreChange()
+    }
+
+    window.addEventListener(KEYBOARD_SHORTCUTS_CHANGED_EVENT, handleLocalChange)
+    window.addEventListener('storage', handleStorage)
+    return () => {
+      window.removeEventListener(KEYBOARD_SHORTCUTS_CHANGED_EVENT, handleLocalChange)
+      window.removeEventListener('storage', handleStorage)
+    }
+  }, [normalizedUserID])
+
+  const getSnapshot = useCallback(() => {
+    if (typeof window === 'undefined' || !normalizedUserID) return ''
+    try {
+      return window.localStorage.getItem(keyboardShortcutStorageKey(normalizedUserID)) ?? ''
+    } catch {
+      return ''
+    }
+  }, [normalizedUserID])
+
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, () => '')
+  return useMemo(() => {
+    if (!snapshot) return createDefaultKeyboardShortcutConfig()
+    try {
+      return sanitizeKeyboardShortcutConfig(JSON.parse(snapshot) as unknown)
+    } catch {
+      return createDefaultKeyboardShortcutConfig()
+    }
+  }, [snapshot])
+}
diff --git a/frontend/src/hooks/chatWorkspace/composerKeyboard.test.ts b/frontend/src/hooks/chatWorkspace/composerKeyboard.test.ts
index d4b8963..8178ab4 100644
--- a/frontend/src/hooks/chatWorkspace/composerKeyboard.test.ts
+++ b/frontend/src/hooks/chatWorkspace/composerKeyboard.test.ts
@@ -3,10 +3,19 @@ import { describe, it } from 'node:test'
 
 import {
   decideComposerEnterAction,
+  decideComposerKeyboardAction,
+  getNextComposerMode,
   shouldIgnoreComposerEnter,
+  shouldUseNativeComposerNewline,
   type ComposerKeyboardContext,
   type ComposerKeyboardEventLike,
 } from './composerKeyboard.ts'
+import {
+  createDefaultKeyboardShortcutConfig,
+  getKeyboardShortcutValidationIssues,
+  normalizeKeyboardShortcutEvent,
+} from '../../features/keyboard-shortcuts/shortcuts.ts'
+import { sanitizeKeyboardShortcutConfig } from '../../features/keyboard-shortcuts/storage.ts'
 
 const baseContext: ComposerKeyboardContext = {
   sending: false,
@@ -75,8 +84,11 @@ describe('decideComposerEnterAction', () => {
     )
   })
 
-  it('keeps Shift+Enter as newline', () => {
-    assert.deepEqual(decideComposerEnterAction(event({ shiftKey: true }), baseContext), { type: 'newline' })
+  it('keeps Shift+Enter as a native textarea newline', () => {
+    const shiftEnter = event({ shiftKey: true })
+    assert.deepEqual(decideComposerEnterAction(shiftEnter, baseContext), { type: 'newline' })
+    assert.equal(shouldUseNativeComposerNewline(shiftEnter), true)
+    assert.equal(shouldUseNativeComposerNewline(event({ key: 'Tab', shiftKey: true })), false)
   })
 
   it('completes on Ctrl/Cmd+Enter only in answer mode', () => {
@@ -111,3 +123,125 @@ describe('decideComposerEnterAction', () => {
     )
   })
 })
+
+describe('custom composer shortcuts', () => {
+  it('supports Shift+Enter complete and Shift+Tab mode cycling when configured', () => {
+    const config = createDefaultKeyboardShortcutConfig()
+    config.bindings.complete = { key: 'Enter', mod: false, alt: false, shift: true }
+    config.bindings.newline = { key: 'Enter', mod: true, alt: false, shift: true }
+    config.bindings.cycle_mode = { key: 'Tab', mod: false, alt: false, shift: true }
+
+    assert.deepEqual(
+      decideComposerKeyboardAction(event({ shiftKey: true }), baseContext, config.bindings),
+      { type: 'complete' },
+    )
+    assert.deepEqual(
+      decideComposerKeyboardAction(event({ key: 'Tab', shiftKey: true }), {
+        ...baseContext,
+        isAnswerMode: false,
+        isEditorTarget: false,
+        isComposerSurfaceTarget: true,
+      }, config.bindings),
+      { type: 'cycle_mode' },
+    )
+  })
+
+  it('preserves native Shift+Tab behavior until the user binds it', () => {
+    const config = createDefaultKeyboardShortcutConfig()
+    assert.deepEqual(
+      decideComposerKeyboardAction(event({ key: 'Tab', shiftKey: true }), baseContext, config.bindings),
+      { type: 'none' },
+    )
+  })
+
+  it('does not run editor or cycle actions from nested tool controls', () => {
+    const config = createDefaultKeyboardShortcutConfig()
+    config.bindings.cycle_mode = { key: 'Tab', mod: false, alt: false, shift: true }
+    assert.deepEqual(
+      decideComposerKeyboardAction(event({}), {
+        ...baseContext,
+        isEditorTarget: false,
+        isComposerSurfaceTarget: false,
+      }, config.bindings),
+      { type: 'none' },
+    )
+    assert.deepEqual(
+      decideComposerKeyboardAction(event({ key: 'Tab', shiftKey: true }), {
+        ...baseContext,
+        isEditorTarget: false,
+        isComposerSurfaceTarget: false,
+      }, config.bindings),
+      { type: 'none' },
+    )
+  })
+
+  it('cycles only through assistant, thinking, and tool-call modes', () => {
+    assert.equal(getNextComposerMode('assistant_message'), 'thinking')
+    assert.equal(getNextComposerMode('thinking'), 'tool_call')
+    assert.equal(getNextComposerMode('tool_call'), 'assistant_message')
+    assert.equal(getNextComposerMode('builtin_tool'), 'assistant_message')
+  })
+})
+
+describe('shortcut configuration validation', () => {
+  it('normalizes Ctrl and Command to the portable Mod modifier', () => {
+    assert.deepEqual(normalizeKeyboardShortcutEvent(event({ ctrlKey: true })), {
+      key: 'Enter',
+      mod: true,
+      alt: false,
+      shift: false,
+    })
+    assert.deepEqual(normalizeKeyboardShortcutEvent(event({ metaKey: true })), {
+      key: 'Enter',
+      mod: true,
+      alt: false,
+      shift: false,
+    })
+  })
+
+  it('rejects printable, editing, browser, and AltGraph-like bindings', () => {
+    const unsafeBindings = [
+      { key: 'K', mod: false, alt: false, shift: false },
+      { key: 'Z', mod: true, alt: false, shift: false },
+      { key: 'W', mod: true, alt: false, shift: false },
+      { key: 'K', mod: true, alt: true, shift: false },
+      { key: 'ArrowLeft', mod: false, alt: true, shift: false },
+      { key: 'F5', mod: false, alt: false, shift: false },
+    ]
+    for (const binding of unsafeBindings) {
+      const config = createDefaultKeyboardShortcutConfig()
+      config.bindings.cycle_mode = binding
+      assert.equal(getKeyboardShortcutValidationIssues(config)[0]?.type, 'unsafe')
+    }
+    assert.equal(normalizeKeyboardShortcutEvent(event({
+      key: '@',
+      ctrlKey: true,
+      altKey: true,
+      getModifierState: (key) => key === 'AltGraph',
+    })), null)
+  })
+
+  it('rejects duplicate bindings', () => {
+    const config = createDefaultKeyboardShortcutConfig()
+    config.bindings.cycle_mode = { ...config.bindings.stream! }
+    assert.equal(getKeyboardShortcutValidationIssues(config)[0]?.type, 'duplicate')
+  })
+
+  it('falls back to defaults for malformed persisted settings', () => {
+    const fallback = sanitizeKeyboardShortcutConfig({
+      version: 1,
+      bindings: {
+        stream: { key: 'K', mod: false, alt: false, shift: false },
+      },
+    })
+    assert.deepEqual(fallback, createDefaultKeyboardShortcutConfig())
+  })
+
+  it('keeps explicit unbound actions when persisted settings are valid', () => {
+    const stored = createDefaultKeyboardShortcutConfig()
+    stored.bindings.stream = null
+    const parsed = sanitizeKeyboardShortcutConfig(stored)
+    assert.equal(parsed.bindings.stream, null)
+    assert.deepEqual(parsed.bindings.complete, createDefaultKeyboardShortcutConfig().bindings.complete)
+  })
+})
diff --git a/frontend/src/hooks/chatWorkspace/composerKeyboard.ts b/frontend/src/hooks/chatWorkspace/composerKeyboard.ts
index 74e7989..fc1c44b 100644
--- a/frontend/src/hooks/chatWorkspace/composerKeyboard.ts
+++ b/frontend/src/hooks/chatWorkspace/composerKeyboard.ts
@@ -1,9 +1,12 @@
-export type ComposerKeyboardEventLike = {
-  key?: string
-  altKey?: boolean
-  ctrlKey?: boolean
-  metaKey?: boolean
-  shiftKey?: boolean
+import {
+  createDefaultKeyboardShortcutConfig,
+  findKeyboardShortcutAction,
+  type KeyboardShortcutBindings,
+  type KeyboardShortcutEventLike,
+} from '../../features/keyboard-shortcuts/shortcuts.ts'
+import type { ComposerMode } from '../../types/chat'
+
+export type ComposerKeyboardEventLike = KeyboardShortcutEventLike & {
   isComposing?: boolean
   nativeEvent: {
     isComposing?: boolean
@@ -16,52 +19,100 @@ export type ComposerKeyboardContext = {
   isWaitingForUser: boolean
   isAnswerMode: boolean
   isThinkingMode: boolean
+  isEditorTarget?: boolean
+  isComposerSurfaceTarget?: boolean
   hasDraftBuffer: boolean
   hasComposerText: boolean
 }
 
-export type ComposerEnterAction =
+export type ComposerKeyboardAction =
   | { type: 'ignore' }
   | { type: 'none' }
   | { type: 'newline' }
   | { type: 'restore_draft' }
   | { type: 'complete' }
   | { type: 'stream' }
+  | { type: 'cycle_mode' }
+
+export type ComposerEnterAction = ComposerKeyboardAction
+
+const CYCLABLE_COMPOSER_MODES: ComposerMode[] = ['assistant_message', 'thinking', 'tool_call']
 
 export function shouldIgnoreComposerEnter(event: ComposerKeyboardEventLike): boolean {
   return Boolean(event.isComposing || event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229)
 }
 
-// decideComposerEnterAction is the pure keyboard policy used by the workspace
-// composer. Tests assert the full decision, not only the IME ignore half.
-export function decideComposerEnterAction(
+export function getNextComposerMode(currentMode: ComposerMode): ComposerMode {
+  const currentIndex = CYCLABLE_COMPOSER_MODES.indexOf(currentMode)
+  return CYCLABLE_COMPOSER_MODES[(currentIndex + 1) % CYCLABLE_COMPOSER_MODES.length]
+}
+
+export function shouldUseNativeComposerNewline(event: ComposerKeyboardEventLike): boolean {
+  return event.key === 'Enter'
+}
+
+export function decideComposerKeyboardAction(
   event: ComposerKeyboardEventLike,
   context: ComposerKeyboardContext,
-): ComposerEnterAction {
-  if ((event.key ?? 'Enter') !== 'Enter') {
-    return { type: 'none' }
-  }
-  if (shouldIgnoreComposerEnter(event)) {
-    return { type: 'ignore' }
-  }
-  if (event.altKey) {
-    if (context.sending || !context.isWaitingForUser || !context.isAnswerMode || !context.hasDraftBuffer) {
-      return { type: 'none' }
-    }
-    return { type: 'restore_draft' }
-  }
-  if (event.ctrlKey || event.metaKey) {
-    if (context.sending || !context.isWaitingForUser || !context.isAnswerMode) {
-      return { type: 'none' }
+  bindings: KeyboardShortcutBindings,
+): ComposerKeyboardAction {
+  if (shouldIgnoreComposerEnter(event)) return { type: 'ignore' }
+
+  const action = findKeyboardShortcutAction(event, bindings)
+  if (!action) return { type: 'none' }
+
+  const isEditorTarget = context.isEditorTarget !== false
+  switch (action) {
+    case 'newline':
+      return isEditorTarget && (context.isAnswerMode || context.isThinkingMode)
+        ? { type: 'newline' }
+        : { type: 'none' }
+    case 'restore_draft':
+      if (
+        !isEditorTarget
+        || context.sending
+        || !context.isWaitingForUser
+        || !context.isAnswerMode
+        || !context.hasDraftBuffer
+      ) {
+        return { type: 'none' }
+      }
+      return { type: 'restore_draft' }
+    case 'complete':
+      if (!isEditorTarget || context.sending || !context.isWaitingForUser || !context.isAnswerMode) {
+        return { type: 'none' }
+      }
+      return { type: 'complete' }
+    case 'stream': {
+      const canStreamChunk = isEditorTarget && (context.isAnswerMode || context.isThinkingMode)
+      if (
+        context.sending
+        || !context.isWaitingForUser
+        || !canStreamChunk
+        || !context.hasComposerText
+      ) {
+        return { type: 'none' }
+      }
+      return { type: 'stream' }
     }
-    return { type: 'complete' }
-  }
-  if (event.shiftKey) {
-    return { type: 'newline' }
-  }
-  const canStreamChunk = context.isAnswerMode || context.isThinkingMode
-  if (context.sending || !context.isWaitingForUser || !canStreamChunk || !context.hasComposerText) {
-    return { type: 'none' }
+    case 'cycle_mode':
+      return context.sending
+        || !context.isWaitingForUser
+        || (!isEditorTarget && !context.isComposerSurfaceTarget)
+        ? { type: 'none' }
+        : { type: 'cycle_mode' }
   }
-  return { type: 'stream' }
+}
+
+// Backward-compatible default policy retained for callers that only need the
+// historical Enter behavior.
+export function decideComposerEnterAction(
+  event: ComposerKeyboardEventLike,
+  context: ComposerKeyboardContext,
+): ComposerKeyboardAction {
+  return decideComposerKeyboardAction(
+    event,
+    context,
+    createDefaultKeyboardShortcutConfig().bindings,
+  )
 }
diff --git a/frontend/src/hooks/useChatWorkspace.ts b/frontend/src/hooks/useChatWorkspace.ts
index 88ff633..6b746ac 100644
--- a/frontend/src/hooks/useChatWorkspace.ts
+++ b/frontend/src/hooks/useChatWorkspace.ts
@@ -1,7 +1,13 @@
 import { useCallback, useEffect, useRef, useState, type KeyboardEvent } from 'react'
 
-import { decideComposerEnterAction } from './chatWorkspace/composerKeyboard'
+import {
+  decideComposerKeyboardAction,
+  getNextComposerMode,
+  shouldUseNativeComposerNewline,
+  type ComposerKeyboardAction,
+} from './chatWorkspace/composerKeyboard'
 
+import { useKeyboardShortcuts } from '../features/keyboard-shortcuts/useKeyboardShortcuts'
 import { requestFormJson, requestJson } from '../lib/api'
 import { appMessage } from '../lib/antdMessage'
 import {
@@ -35,6 +41,7 @@ function isResponseOpenStatus(status: string | undefined) {
 export function useChatWorkspace(isMobile: boolean) {
   const [booting, setBooting] = useState(true)
   const [auth, setAuth] = useState<AuthSession>(DEFAULT_AUTH_SESSION)
+  const keyboardShortcuts = useKeyboardShortcuts(auth.user?.id ?? '')
   const [loginLoading, setLoginLoading] = useState(false)
   const [conversations, setConversations] = useState<Conversation[]>([])
   const [selectedConversationId, setSelectedConversationId] = useState('')
@@ -612,41 +619,70 @@ export function useChatWorkspace(isMobile: boolean) {
     }
   }
 
-  function handleComposerKeyDown(event: KeyboardEvent<HTMLTextAreaElement>) {
+  function handleComposerKeyDown(event: KeyboardEvent<HTMLElement>): ComposerKeyboardAction['type'] {
     const isAnswerMode = composerMode === 'assistant_message'
     const isThinkingMode = composerMode === 'thinking'
-    const textarea = event.currentTarget
-    const decision = decideComposerEnterAction(event, {
+    const textarea = event.target instanceof HTMLTextAreaElement ? event.target : null
+    const isEditorTarget = Boolean(textarea && (isAnswerMode || isThinkingMode))
+    const editorText = isThinkingMode ? thinkingText : composer
+    const currentText = textarea?.value ?? editorText
+    const decision = decideComposerKeyboardAction(event, {
       sending,
       isWaitingForUser,
       isAnswerMode,
       isThinkingMode,
+      isEditorTarget,
+      isComposerSurfaceTarget: event.target === event.currentTarget,
       hasDraftBuffer: Boolean(draftBuffer),
-      hasComposerText: Boolean(normalizeChatText(textarea.value)),
-    })
+      hasComposerText: Boolean(normalizeChatText(currentText)),
+    }, keyboardShortcuts.bindings)
 
     switch (decision.type) {
       case 'ignore':
       case 'none':
-      case 'newline':
-        return
+        return decision.type
+      case 'newline': {
+        if (!textarea) return 'none'
+        // Enter already has the correct textarea editing semantics, including
+        // beforeinput/input events and the browser undo stack. Only non-Enter
+        // custom bindings (for example Tab) need manual insertion.
+        if (shouldUseNativeComposerNewline(event)) return decision.type
+        event.preventDefault()
+        const selectionStart = textarea.selectionStart ?? currentText.length
+        const selectionEnd = textarea.selectionEnd ?? selectionStart
+        const nextText = `${currentText.slice(0, selectionStart)}\n${currentText.slice(selectionEnd)}`
+        if (isThinkingMode) {
+          setThinkingText(nextText)
+        } else {
+          setComposer(nextText)
+        }
+        window.requestAnimationFrame(() => {
+          textarea.focus()
+          textarea.setSelectionRange(selectionStart + 1, selectionStart + 1)
+        })
+        return decision.type
+      }
       case 'restore_draft':
         event.preventDefault()
         // Only answer mode reuses the streamed draft buffer back into the editor.
         setComposer(`${draftBuffer}${composer}`)
-        return
+        return decision.type
       case 'complete':
         event.preventDefault()
         // Ending a turn is only available from answer mode (enforced in decision).
         void handleSend()
-        return
+        return decision.type
       case 'stream':
-        // Enter = stream current chunk (answer or thinking), same as clicking the stream button.
+        // The configured shortcut streams the current answer or thinking chunk.
         event.preventDefault()
-        void handleDraft(textarea.value).finally(() => {
-          window.requestAnimationFrame(() => textarea.focus())
+        void handleDraft(currentText).finally(() => {
+          window.requestAnimationFrame(() => textarea?.focus())
         })
-        return
+        return decision.type
+      case 'cycle_mode':
+        event.preventDefault()
+        selectComposerMode(getNextComposerMode(composerMode))
+        return decision.type
     }
   }
 
@@ -693,6 +729,7 @@ export function useChatWorkspace(isMobile: boolean) {
     handleTotpRefresh,
     isWaitingForUser,
     keyboardOffset,
+    keyboardShortcuts,
     loginLoading,
     messages,
     messagesLoading,