@@ -27,6 +27,104 @@ async function expectCaretVisible(input: Locator) {
     .toBe(true)
 }
 
+test("prompt shortcuts rebind through Settings, preserve newline undo, and restore defaults", async ({ page }) => {
+  const prompts: { text: unknown; delivery: unknown }[] = []
+
+  const { editor } = await openSession(page, {
+    name: "ComposerShortcuts",
+    sessionStatus: { ses_composershortcuts: { type: "running" } },
+    onPrompt: ({ body }) => void prompts.push({ text: body.text, delivery: body.delivery }),
+  })
+
+  const settings = page.getByTestId("settings-screen")
+  const binding = (id: string) => settings.locator(`[data-keybind-id="prompt.${id}"]`)
+
+  const shortcuts = async () => {
+    await page.keyboard.press("Control+,")
+    await settings.getByRole("tab", { name: "Shortcuts", exact: true }).click()
+    await expect(settings.getByRole("heading", { name: "Keyboard shortcuts", exact: true })).toBeVisible()
+  }
+
+  const record = async (id: string, keys: string, label: string | RegExp) => {
+    await binding(id).click()
+    await expect(binding(id)).toHaveText("Press keys")
+    await page.keyboard.press(keys)
+    await expect(binding(id)).toHaveText(label)
+  }
+
+  await editor.fill("hello")
+  await shortcuts()
+  await expect(binding("submit")).toHaveText("Enter")
+  // Move alternate delivery first, freeing Ctrl+Enter for primary submission.
+  await record("submit.alternate", "Control+Shift+Enter", /^(Ctrl\+Shift\+|⌃⇧)Enter$/)
+  await record("submit", "Backspace", "Unassigned")
+  await record("newline", "Enter", "Enter")
+  await record("submit", "Control+Enter", /^(Ctrl\+|⌃)Enter$/)
+  await settings.getByRole("button", { name: "Back to app", exact: true }).click()
+  await expect(editor).toHaveText("hello")
+
+  await editor.press("ControlOrMeta+Home")
+  await editor.press("ArrowRight")
+  await editor.press("Shift+ArrowRight")
+  await editor.press("Shift+ArrowRight")
+  await editor.press("Shift+ArrowRight")
+  await expect.poll(() => page.evaluate(() => window.getSelection()?.toString())).toBe("ell")
+  await editor.press("Enter")
+  await expect.poll(() => editor.innerText()).toBe("h\no")
+  await editor.press("ControlOrMeta+z")
+  await expect(editor).toHaveText("hello")
+
+  await page.locator('[data-action="composer-submit"]').hover()
+  await expect(page.getByRole("tooltip").locator('[data-slot="keybind-v2-label"]')).toHaveText([/^(Ctrl|⌃)$/, "Enter"])
+  await editor.press("Control+Enter")
+  await expect(editor).toBeEmpty()
+  await expect.poll(() => prompts).toEqual([{ text: "hello", delivery: "steer" }])
+
+  await editor.fill("queued follow-up")
+  await expect(page.locator('[data-action="composer-alternate-delivery"]')).toHaveText(/Queue.*Enter/)
+  await expect(page.locator('[data-action="composer-alternate-delivery"] [data-slot="keybind-v2-label"]')).toHaveText([
+    /^(Ctrl|⌃)$/,
+    /^(Shift|⇧)$/,
+    "Enter",
+  ])
+  await editor.press("Control+Shift+Enter")
+  await expect(editor).toBeEmpty()
+  await expect
+    .poll(() => prompts)
+    .toEqual([
+      { text: "hello", delivery: "steer" },
+      { text: "queued follow-up", delivery: "queue" },
+    ])
+
+  await shortcuts()
+
+  for (const id of ["submit", "newline", "submit.alternate"]) await record(id, "Backspace", "Unassigned")
+  await settings.getByRole("button", { name: "Back to app", exact: true }).click()
+  await editor.fill("disabled shortcuts")
+
+  for (const keys of ["Enter", "Control+Enter", "Control+Shift+Enter"]) await editor.press(keys)
+  await expect(editor).toHaveText("disabled shortcuts")
+  await expect(page.locator('[data-action="composer-alternate-delivery"] [data-slot="keybind-v2-label"]')).toHaveCount(
+    0,
+  )
+  expect(prompts).toHaveLength(2)
+
+  await shortcuts()
+  await settings.getByRole("button", { name: "Reset to defaults", exact: true }).click()
+  await expect(binding("submit")).toHaveText("Enter")
+  await settings.getByRole("button", { name: "Back to app", exact: true }).click()
+  await editor.fill("restored defaults")
+  await editor.press("Enter")
+  await expect(editor).toBeEmpty()
+  await expect
+    .poll(() => prompts)
+    .toEqual([
+      { text: "hello", delivery: "steer" },
+      { text: "queued follow-up", delivery: "queue" },
+      { text: "restored defaults", delivery: "steer" },
+    ])
+})
+
 test("keeps a 25000-line crash report editable in a new session", async ({ page }) => {
   const input = await draft(page)
   const text = "Thread 0 Crashed:\n" + "0   Example  0x0000000100000000 frame + 32\n".repeat(25000) + "End of report"
 
@@ -8,10 +8,11 @@ import { type BaseRouterProps, Router } from "@solidjs/router"
 import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
 import { type Component, createRenderEffect, ErrorBoundary, type JSX, type ParentProps } from "solid-js"
 import { Dynamic } from "solid-js/web"
-import { CommandProvider } from "@/shell/commands/command"
+import { CommandProvider, useCommand } from "@/shell/commands/command"
 import { DesktopCommands } from "@/shell/commands/desktop"
+import { promptKeybindOptions, PROMPT_KEYBINDS } from "@/composer/keybinds"
 import { GlobalProvider } from "@/runtime/server/runtime"
-import { LanguageProvider, UiI18nBridge, type Locale } from "@/runtime/i18n/language"
+import { LanguageProvider, UiI18nBridge, type Locale, useLanguage } from "@/runtime/i18n/language"
 import { ServerConnection, ServersProvider } from "@/runtime/server/registry"
 import { SettingsProvider } from "@/settings/model"
 import { TabsProvider } from "@/shell/tabs/tabs"
@@ -45,6 +46,21 @@ function BodyTypography() {
   return null
 }
 
+function PromptCommands() {
+  const command = useCommand()
+  const language = useLanguage()
+
+  command.register("prompt", () =>
+    promptKeybindOptions({
+      submit: language.t(PROMPT_KEYBINDS.submit.title),
+      newline: language.t(PROMPT_KEYBINDS.newline.title),
+      alternate: language.t(PROMPT_KEYBINDS.alternate.title),
+    }),
+  )
+
+  return null
+}
+
 export function AppBaseProviders(
   props: ParentProps<{
     locale?: Locale
@@ -98,6 +114,7 @@ export function AppInterface(props: {
       <GlobalProvider>
         <BodyTypography />
         <CommandProvider>
+          <PromptCommands />
           <DesktopCommands />
           {props.children}
           {rootProps.children}
 
@@ -1,4 +1,4 @@
-import { Show, createMemo, onMount, type JSX } from "solid-js"
+import { Show, createMemo, onCleanup, onMount, type JSX } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { ModelSelection } from "@/providers/models/selection"
 import { STORY_MODEL, emptySessionDocument, pendingAndQueuedDocument } from "@opencode/session-ui/storybook"
@@ -11,6 +11,8 @@ import { promptLength } from "./prompt-parts"
 import { SessionPreview } from "@/session/story-model"
 import { Skill } from "@opencode/schema/skill"
 import { resolveSessionComposerSelection } from "@/session/composer/selection"
+import { useSettings } from "@/settings/model"
+import { PROMPT_KEYBINDS } from "./keybinds"
 
 const selectedModel = {
   id: STORY_MODEL.id,
@@ -209,8 +211,7 @@ function ComposerStory(props: {
               : `Submitted: ${value}`,
           )
         },
-        onStop: () =>
-          setStory("activity", props.continueOnStop ? "POST /interrupt · resume: true" : "Stop requested"),
+        onStop: () => setStory("activity", props.continueOnStop ? "POST /interrupt · resume: true" : "Stop requested"),
       },
     },
   })
@@ -250,6 +251,57 @@ export const EmptyDraft = { render: () => <ComposerStory /> }
 
 export const TextDraft = { render: () => <ComposerStory prompt={text("Explain this change")} /> }
 
+export const ConfigurableShortcuts = {
+  render: () => {
+    const settings = useSettings()
+
+    const original = {
+      submit: settings.keybinds.get(PROMPT_KEYBINDS.submit.id),
+      newline: settings.keybinds.get(PROMPT_KEYBINDS.newline.id),
+    }
+
+    onCleanup(() => {
+      for (const action of ["submit", "newline"] as const) {
+        const value = original[action]
+
+        if (value === undefined) settings.keybinds.reset(PROMPT_KEYBINDS[action].id)
+
+        if (value !== undefined) settings.keybinds.set(PROMPT_KEYBINDS[action].id, value)
+      }
+    })
+
+    return (
+      <div>
+        <button
+          onClick={() => {
+            settings.keybinds.reset(PROMPT_KEYBINDS.submit.id)
+            settings.keybinds.reset(PROMPT_KEYBINDS.newline.id)
+          }}
+        >
+          Default shortcuts
+        </button>
+        <button
+          onClick={() => {
+            settings.keybinds.set(PROMPT_KEYBINDS.submit.id, "ctrl+enter")
+            settings.keybinds.set(PROMPT_KEYBINDS.newline.id, "enter")
+          }}
+        >
+          Enter for newline
+        </button>
+        <button
+          onClick={() => {
+            settings.keybinds.set(PROMPT_KEYBINDS.submit.id, "none")
+            settings.keybinds.set(PROMPT_KEYBINDS.newline.id, "none")
+          }}
+        >
+          Disable shortcuts
+        </button>
+        <ComposerStory prompt={text("Explain this change")} />
+      </div>
+    )
+  },
+}
+
 export const MultilineDraft = {
   render: () => <ComposerStory prompt={text("Review the implementation\nThen run the focused tests")} />,
 }
 
@@ -12,6 +12,7 @@ import { DialogSelectModelUnpaid } from "@/providers/models/unpaid"
 import { formatKeybind, useCommand } from "@/shell/commands/command"
 import { useLanguage } from "@/runtime/i18n/language"
 import type { ComposerModel } from "./model"
+import { createPromptKeybinds, PROMPT_KEYBINDS } from "./keybinds"
 
 export function Composer(props: {
   class?: string
@@ -23,6 +24,7 @@ export function Composer(props: {
   const dialog = useDialog()
   const command = useCommand()
   const language = useLanguage()
+  const keybinds = createPromptKeybinds()
 
   return (
     <div class="flex flex-col gap-3">
@@ -34,9 +36,11 @@ export function Composer(props: {
         modelControlsVisible={!props.model.model.loading}
         attachKeybind={command.keybindParts("file.attach")}
         attachShortcut={command.keybind("file.attach")}
-        alternateKeybind={[formatKeybind("mod", language.t), "↵"]}
+        alternateKeybind={command.keybindParts(PROMPT_KEYBINDS.alternate.id)}
         exitShellKeybind={[formatKeybind("esc", language.t)]}
         suggestionBoundary={props.suggestionBoundary}
+        keybinds={keybinds}
+        submitKeybind={command.keybindParts(PROMPT_KEYBINDS.submit.id)}
         modelControl={
           <ComposerModelControl
             loading={props.model.model.loading}
 
@@ -45,6 +45,7 @@ import type {
 } from "../types"
 import type { ComposerEditorModel, ComposerSelectControl } from "./interaction"
 import { isAttachment } from "../prompt-parts"
+import { handleComposerKeyDown, type ComposerKeybinds } from "./keybind"
 import "../attachments/attachments.css"
 import "./editor.css"
 
@@ -89,6 +90,8 @@ export type ComposerEditorProps = {
   alternateKeybind?: string[]
   exitShellKeybind?: string[]
   suggestionBoundary?: () => HTMLElement | undefined
+  keybinds?: ComposerKeybinds
+  submitKeybind?: string[]
 }
 
 export function ComposerEditor(props: ComposerEditorProps) {
@@ -117,6 +120,7 @@ export function ComposerEditor(props: ComposerEditorProps) {
     onCleanup(() => observer.disconnect())
   })
   let localInput = false
+  let composing = false
 
   const updateCursor = () => {
     if (!editor || !window.getSelection()?.isCollapsed) return
@@ -255,22 +259,28 @@ export function ComposerEditor(props: ComposerEditorProps) {
               props.controller.onInput(prompt.map((part) => part.content).join(""), [...prompt, ...attachments], cursor)
             }}
             onKeyDown={(event) => {
-              if (!view.draftOnly && props.controller.onKeyDown(event)) return
-              const mod = event.metaKey || event.ctrlKey
-
-              if (mod && event.key === "ArrowUp" && !event.shiftKey && !event.altKey) {
-                if (view.submit.queue?.editFirst()) event.preventDefault()
-
-                return
-              }
-
-              if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {
-                event.preventDefault()
-
-                if (event.repeat) return
-                props.controller.submit(mod ? { alternate: true } : undefined)
-              }
+              handleComposerKeyDown({
+                event,
+                keybinds: props.keybinds,
+                composing,
+                selectSuggestion: () => {
+                  const popover = state.popover
+
+                  if (popover.type === "closed") return false
+                  const item = props.controller.suggestions().find((entry) => entry.id === popover.activeID)
+
+                  if (item) props.controller.dispatch({ type: "popover.select", item })
+
+                  return true
+                },
+                handleController: () => !view.draftOnly && props.controller.onKeyDown(event),
+                editFirst: view.submit.queue?.editFirst,
+                insertNewline: props.controller.insertNewline,
+                submit: (alternate) => props.controller.submit(alternate ? { alternate: true } : undefined),
+              })
             }}
+            onCompositionStart={() => (composing = true)}
+            onCompositionEnd={() => (composing = false)}
             onKeyUp={updateCursor}
             onPointerUp={updateCursor}
             onPaste={(event) => {
@@ -401,6 +411,7 @@ export function ComposerEditor(props: ComposerEditorProps) {
               disabled={!props.controller.canSubmit()}
               sendLabel={i18n.t("ui.promptInput.send")}
               stopLabel={i18n.t("ui.promptInput.stop")}
+              sendKeybind={props.submitKeybind}
               onSubmit={() => props.controller.submit()}
               onStop={props.controller.stop}
             />
@@ -1074,8 +1085,8 @@ function composerSuggestionMaxHeight(boundaryHeight: number, search: boolean) {
   )
 }
 
-// "Steer ⌘⏎" / "Queue ⌘⏎" hint next to the submit button: submits with the
-// delivery opposite to what plain Enter does. Visible only while the queue
+// Steer / Queue action with its configured shortcut: submits with the
+// delivery opposite to normal submission. Visible only while the queue
 // exposes an alternate (turn running and composer holding a value), so it
 // disappears on its own when the current turn ends.
 function ComposerEditorAlternateDelivery(props: { controller: ComposerEditorModel; keybind: string[] }) {
@@ -1129,14 +1140,26 @@ export function ComposerEditorSubmitButton(props: {
   disabled: boolean
   sendLabel: string
   stopLabel: string
+  sendKeybind?: string[]
   onSubmit: () => void
   onStop: () => void
 }) {
   return (
     <Tooltip
       placement="top"
       inactive={!props.stopping && props.disabled}
-      value={props.stopping ? props.stopLabel : props.sendLabel}
+      value={
+        props.stopping ? (
+          props.stopLabel
+        ) : (
+          <>
+            {props.sendLabel}
+            <Show when={props.sendKeybind?.length}>
+              <Keybind keys={props.sendKeybind ?? []} variant="neutral" />
+            </Show>
+          </>
+        )
+      }
     >
       <IconButton
         data-action="composer-submit"