diff --git a/CHANGELOG.md b/CHANGELOG.md
index cdd46c9c5..938b2fc1a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,11 @@ between releases do not reach them. Remote-PC runtime bundles are versioned sepa
 ## [Unreleased]
 
 ### Added
+- Enter twice sends a message now while the agent works: the first Enter queues it as before, and
+  a second within a second (on the empty box, or while the first is still on its way) sends it at
+  once, as its Send now does — steering the running turn instead of waiting for it to end. It
+  works the same with automatic sending off. **Settings → Chat → Enter twice sends now** turns
+  it off.
 - **Settings → Phone & devices → Portal** gives this PC a public HTTPS address through
   [Portal](https://github.com/gosuda/portal-tunnel), with no account and no domain of your own.
   With Portal v2.6.1 or later installed, **Start** runs it on a relay you enter, dropping any
diff --git a/scripts/ci-browser.sh b/scripts/ci-browser.sh
index d35614132..66345e887 100644
--- a/scripts/ci-browser.sh
+++ b/scripts/ci-browser.sh
@@ -78,6 +78,7 @@ run_script scripts/chat-greeting-demo-regression.ts
 run_script scripts/restored-draft-demo-regression.ts
 run_script scripts/composer-fit-demo-regression.ts
 run_script scripts/held-rows-demo-regression.ts
+run_script scripts/enter-twice-demo-regression.ts
 run_script scripts/sidebar-activity-demo-regression.ts
 run_script scripts/sidebar-spacing-demo-regression.ts
 run_script scripts/workspace-touch-reorder-demo-regression.ts
diff --git a/scripts/ci-browser.test.ts b/scripts/ci-browser.test.ts
index aaf927289..6929eb72f 100644
--- a/scripts/ci-browser.test.ts
+++ b/scripts/ci-browser.test.ts
@@ -69,7 +69,8 @@ describe("browser lane", () => {
   it("summarizes every script and exits zero on success without enabling local evidence", async () => {
     const { text, code, evidence } = await lane();
     expect(code).toBe(0);
-    expect(rows(text)).toHaveLength(45);
+    expect(rows(text)).toHaveLength(46);
+    expect(rows(text).map((row) => row.script)).toContain("scripts/enter-twice-demo-regression.ts");
     expect(rows(text).map((row) => row.script)).toContain("scripts/portal-regression.ts");
     expect(rows(text).map((row) => row.script)).toContain("scripts/agy-chat-browser-qa.ts");
     expect(rows(text).filter((row) => row.script === "scripts/ui-contexts-regression.ts")).toHaveLength(1);
diff --git a/scripts/enter-twice-demo-regression.ts b/scripts/enter-twice-demo-regression.ts
new file mode 100644
index 000000000..0cfe0c649
--- /dev/null
+++ b/scripts/enter-twice-demo-regression.ts
@@ -0,0 +1,155 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Page } from "playwright-core";
+import panes from "../site/demo/fixtures/panes.json";
+import { buildDemoApp } from "./demo-build.ts";
+
+// Enter twice while the agent works (Settings → Enter twice sends now), on the unmodified app over
+// the demo's fixture transport: the first Enter queues the message, a second within a second sends
+// it now, as its Send now does — also when it comes before the bridge's receipt for the first. A
+// single Enter, a second one too late, or the setting off leaves it queued. The demo's mock turn
+// takes 2.4 s and sends what is still queued when it ends, so a message sent now is one that joins
+// the chat while the turn still works. All files and HTTP traffic stay in this disposable,
+// loopback-only app; no herdr session is opened.
+const app = mkdtempSync(join(tmpdir(), "herdr-enter-twice-demo-"));
+
+// playwright-core's bundle lazily requires packages the lockfile does not carry (chromium-bidi):
+// fine at run time, unresolvable to `bun build` — so it is imported past the bundler's analysis
+const playwrightCore = "playwright-core";
+const { chromium } = (await import(playwrightCore)) as typeof import("playwright-core");
+
+/** The user turns the chat shows, in order. */
+const userTurns = (page: Page): Promise<string[]> => page.locator(".chat-turn-user .chat-bubble").allTextContents();
+/** The demo turn's answers so far: a message sent now joins the chat before the running turn's answer. */
+const answers = (page: Page): Promise<number> => page.locator(".chat-turn-agent", { hasText: "This is the demo, so nothing ran" }).count();
+const pendingRows = (page: Page): Promise<string[]> => page.locator(".pending-message-bubble").allTextContents();
+/** The agent works: the empty box's control is Stop. */
+const working = (page: Page): Promise<void> => page.getByRole("button", { name: "Stop agent", exact: true }).waitFor({ timeout: 10_000 });
+
+try {
+  await buildDemoApp(app);
+  const index = join(app, "index.html");
+  const html = readFileSync(index, "utf8");
+  assert.match(html, /<script type="module"/);
+  // Over the demo's sockets: window.submitDelayMs holds a submit back that long before the demo
+  // sees it, so its receipt comes after a quick second Enter
+  const delay = `<script>(() => {
+    const Demo = window.WebSocket;
+    window.submitDelayMs = 0;
+    const Delaying = function (url, protocols) {
+      const socket = new Demo(url, protocols);
+      const send = socket.send.bind(socket);
+      socket.send = (data) => {
+        const message = typeof data === "string" ? JSON.parse(data) : null;
+        if (window.submitDelayMs > 0 && message !== null && message.type === "submit") setTimeout(() => send(data), window.submitDelayMs);
+        else send(data);
+      };
+      return socket;
+    };
+    Delaying.prototype = Demo.prototype;
+    Object.setPrototypeOf(Delaying, Demo);
+    window.WebSocket = Delaying;
+  })();</script>`;
+  writeFileSync(index, html.replace(/<script type="module"/, () => `<script src="./demo-transport.js"></script>\n    ${delay}\n    <script type="module"`));
+
+  const server = Bun.serve({ hostname: "127.0.0.1", port: 0, async fetch(request) {
+    const path = new URL(request.url).pathname;
+    if (!path.startsWith("/herdr-web-ui/demo/app/")) return new Response("not found", { status: 404 });
+    let file: string;
+    try { file = decodeURIComponent(path.slice("/herdr-web-ui/demo/app/".length)); }
+    catch { return new Response("bad path", { status: 400 }); }
+    if (!file || file.endsWith("/")) file += "index.html";
+    if (file.split("/").includes("..") || file.includes("\\")) return new Response("bad path", { status: 400 });
+    const body = Bun.file(join(app, file));
+    return (await body.exists()) ? new Response(body) : new Response("not found", { status: 404 });
+  } });
+  const url = `http://127.0.0.1:${server.port}/herdr-web-ui/demo/app/?pane=${encodeURIComponent(panes.infra)}`;
+  try {
+    const browser = await chromium.launch({ executablePath: process.env.CHROME_PATH ?? "/opt/google/chrome/chrome", headless: true, args: ["--no-sandbox"] });
+    try {
+      const run = async (settings: Record<string, unknown>, check: (page: Page, send: (text: string) => Promise<void>) => Promise<void>): Promise<void> => {
+        const context = await browser.newContext({ viewport: { width: 1280, height: 800 }, locale: "en-US" });
+        try {
+          await context.addInitScript(([paneId, stored]) => {
+            localStorage.setItem("herdr-web-ui:settings", stored);
+            localStorage.setItem(`herdr-web-ui:view:${paneId}`, "chat");
+          }, [panes.infra, JSON.stringify({ language: "en", ...settings })] as const);
+          const page = await context.newPage();
+          const errors: string[] = [];
+          page.on("pageerror", (error) => errors.push(error.message));
+          await page.goto(url);
+          await page.locator(".conn-live").waitFor({ state: "attached" });
+          await page.locator(".terminal-stack.is-chat").waitFor();
+          const composer = page.getByRole("textbox", { name: "Message", exact: true });
+          await composer.focus();
+          // a first message starts the demo's turn: what follows is sent while the agent works
+          await composer.fill("start the turn");
+          await page.keyboard.press("Enter");
+          await page.waitForFunction(() => [...document.querySelectorAll(".chat-turn-user")].some((turn) => turn.textContent?.includes("start the turn")), undefined, { timeout: 10_000 });
+          await working(page);
+          await check(page, async (text) => { await composer.fill(text); await page.keyboard.press("Enter"); });
+          assert.deepEqual(errors, []);
+        } finally { await context.close(); }
+      };
+
+      await run({}, async (page, send) => {
+        const turnsBefore = (await userTurns(page)).length;
+        await send("steer this");
+        await page.locator(".pending-message-bubble", { hasText: "steer this" }).waitFor();
+        await page.keyboard.press("Enter");
+        await page.waitForFunction(() => [...document.querySelectorAll(".chat-turn-user")].some((turn) => turn.textContent?.includes("steer this")), undefined, { timeout: 1_500 });
+        assert.equal((await userTurns(page)).length, turnsBefore + 1);
+        assert.equal(await answers(page), 0, "it went while the turn still worked, not when the turn ended");
+        assert.deepEqual(await pendingRows(page), [], "the row went with its message");
+        assert.equal(await page.getByRole("textbox", { name: "Message", exact: true }).inputValue(), "", "the box stays empty");
+        console.log("PASS Enter twice while the agent works sends the queued message now");
+      });
+
+      await run({}, async (page, send) => {
+        await page.evaluate(() => { (window as unknown as { submitDelayMs: number }).submitDelayMs = 400; });
+        await send("before its receipt");
+        // the second Enter lands while the first is still on its way: the box still holds the text
+        await page.keyboard.press("Enter");
+        assert.equal(await page.getByRole("textbox", { name: "Message", exact: true }).inputValue(), "before its receipt", "the first send is still on its way");
+        await page.waitForFunction(() => [...document.querySelectorAll(".chat-turn-user")].some((turn) => turn.textContent?.includes("before its receipt")), undefined, { timeout: 1_800 });
+        assert.deepEqual(await pendingRows(page), []);
+        assert.equal((await userTurns(page)).filter((text) => text.includes("before its receipt")).length, 1, "sent once");
+        assert.equal(await answers(page), 0, "it went while the turn still worked, not when the turn ended");
+        console.log("PASS a second Enter before the bridge's receipt sends the message once it is held");
+      });
+
+      await run({}, async (page, send) => {
+        await send("one enter only");
+        await page.locator(".pending-message-bubble", { hasText: "one enter only" }).waitFor();
+        await page.waitForTimeout(1_100);
+        // too late to be the second of two: Enter on the empty box does nothing
+        await page.keyboard.press("Enter");
+        await page.waitForTimeout(400);
+        assert.deepEqual(await pendingRows(page), ["one enter only"], "still waits for its turn");
+        assert.ok((await userTurns(page)).every((text) => !text.includes("one enter only")));
+        console.log("PASS one Enter, or a second one after a second, leaves the message queued for its turn");
+      });
+
+      await run({ enterTwiceSteers: false }, async (page, send) => {
+        await send("setting off");
+        await page.locator(".pending-message-bubble", { hasText: "setting off" }).waitFor();
+        await page.keyboard.press("Enter");
+        await page.waitForTimeout(400);
+        assert.deepEqual(await pendingRows(page), ["setting off"]);
+        console.log("PASS with Enter twice sends now off, a second Enter leaves the message queued");
+      });
+
+      // with automatic sending off a message waits for Send now: Enter twice is that Send now
+      await run({ autoSendQueued: false }, async (page, send) => {
+        await send("held then sent");
+        await page.locator(".pending-message-bubble", { hasText: "held then sent" }).waitFor();
+        await page.keyboard.press("Enter");
+        await page.waitForFunction(() => [...document.querySelectorAll(".chat-turn-user")].some((turn) => turn.textContent?.includes("held then sent")), undefined, { timeout: 1_500 });
+        assert.deepEqual(await pendingRows(page), []);
+        console.log("PASS a message held for Send now goes with a second Enter");
+      });
+    } finally { await browser.close(); }
+  } finally { server.stop(); }
+} finally { rmSync(app, { recursive: true, force: true }); }
diff --git a/shared/telemetry.ts b/shared/telemetry.ts
index 4ca0bf216..a2ea02604 100644
--- a/shared/telemetry.ts
+++ b/shared/telemetry.ts
@@ -49,6 +49,7 @@ export interface TelemetrySettings {
   chatWidth: "narrow" | "default" | "wide" | "full";
   enterSends: boolean;
   autoSendQueued: boolean;
+  enterTwiceSteers: boolean;
   showThinking: boolean;
   keepScreenOn: boolean;
   language: "system" | "en" | "zh" | "ja" | "ko" | "tr";
@@ -124,6 +125,7 @@ const TELEMETRY_SETTINGS_VALIDATORS = {
   chatWidth: oneOf(["narrow", "default", "wide", "full"]),
   enterSends: booleanValue,
   autoSendQueued: booleanValue,
+  enterTwiceSteers: booleanValue,
   showThinking: booleanValue,
   keepScreenOn: booleanValue,
   language: oneOf(["system", "en", "zh", "ja", "ko", "tr"]),
diff --git a/src/components/Composer.tsx b/src/components/Composer.tsx
index b7d05835a..adfa34933 100644
--- a/src/components/Composer.tsx
+++ b/src/components/Composer.tsx
@@ -78,6 +78,9 @@ export interface ComposerProps {
    * promise settles to any of them */
   onSend: (text: string, clearDraft?: string) => boolean | string | DraftRefusal | Promise<boolean | string | DraftRefusal>;
   onAbort: () => void;
+  /** a send key with nothing new to send (the box empty, or the last message still on its way): sends
+   * the message just queued now, as its Send now does; false when there is none to send, or not this soon */
+  onSendQueuedNow?: () => boolean;
   onUploadImage: (file: File) => Promise<string>;
 }
 
@@ -237,6 +240,7 @@ export function Composer({
   greeting = null,
   onSend,
   onAbort,
+  onSendQueuedNow,
   onUploadImage,
 }: ComposerProps) {
   const t = useT();
@@ -863,9 +867,11 @@ export function Composer({
         : (event.metaKey || event.ctrlKey) && !event.shiftKey;
       if (!shouldSend) return;
       event.preventDefault();
+      // the second Enter of two: the message the first one queued goes now
+      if (onSendQueuedNow && (sending || (textRef.current.trim() === "" && attachments.length === 0)) && onSendQueuedNow()) return;
       send();
     },
-    [agentStatus, choices, connected, menuDismissed, menuOpen, offered, onAbort, selectCompletion, selectedIndex, send, setTextAndCaret, settings.enterSends, trigger],
+    [agentStatus, attachments.length, choices, connected, menuDismissed, menuOpen, offered, onAbort, onSendQueuedNow, selectCompletion, selectedIndex, send, sending, setTextAndCaret, settings.enterSends, trigger],
   );
 
   const onPaste = useCallback(
diff --git a/src/components/PaneTerminal.tsx b/src/components/PaneTerminal.tsx
index 121c5d1fc..08cdb6709 100644
--- a/src/components/PaneTerminal.tsx
+++ b/src/components/PaneTerminal.tsx
@@ -58,6 +58,8 @@ import { narrowPaneFontSize } from "../lib/narrowPaneFont.ts";
 const RESIZE_SETTLE_MS = 120;
 /** How long a tab is out of use before it lets go of its pane: a glance at another window keeps it. */
 const RELEASE_AFTER_MS = 1000;
+/** A second Enter this soon after a message was queued sends it now (Settings → Enter twice sends now). */
+const SEND_QUEUED_AGAIN_MS = 1000;
 
 // Only a tab the user is in drives the shared grid. A window left open behind another app
 // still turns visible when the screen wakes, and reconnects, reloads or moves on to the next pane
@@ -2139,6 +2141,10 @@ export function PaneTerminal({
     return () => { observer.disconnect(); stack.style.removeProperty("--composer-lift"); stack.style.removeProperty("--composer-room"); setGreetingRoom(true); };
   }, [greetingDue, paneId]);
 
+  // the message the composer queued last, by time, and by ID once the bridge holds it: a second
+  // Enter sends it now, also when that Enter came before the bridge's receipt did
+  const lastQueuedRef = useRef<{ pane: string; at: number; id: string | null; now: boolean } | null>(null);
+  const actOnPendingRef = useRef<(id: string, action: "steer" | "discard") => Promise<void>>(async () => {});
   const composerSend = useCallback(
     (text: string, clearDraft?: string): boolean | string | DraftRefusal | Promise<boolean | string | DraftRefusal> => {
       const pane = paneRef.current;
@@ -2170,7 +2176,16 @@ export function PaneTerminal({
       const queued = composerDelivery(agent, agentStatus);
       const delivery: SubmitDelivery = queued === "queue" && !settings.autoSendQueued ? "hold" : queued;
       const result = submitComposerMessage(text, delivery, delivery === "immediate" ? clearDraft : undefined);
-      return result === null ? false : result.then((answer) => answer.ok ? true : submitRefusal(answer.code, answer.message, answer.draft));
+      if (result === null) return false;
+      const queuedSend = delivery !== "immediate" && pane !== null ? { pane, at: Date.now(), id: null as string | null, now: false } : null;
+      if (queuedSend) lastQueuedRef.current = queuedSend;
+      return result.then((answer) => {
+        if (queuedSend !== null && answer.ok && answer.pending) {
+          queuedSend.id = answer.pending.id;
+          if (queuedSend.now) void actOnPendingRef.current(answer.pending.id, "steer");
+        }
+        return answer.ok ? true : submitRefusal(answer.code, answer.message, answer.draft);
+      });
     },
     [agent, agentStatus, answerPanePrompt, answering, heldByOpenQueue, submitComposerMessage, queueStore, machineId, settings.autoSendQueued],
   );
@@ -2218,6 +2233,16 @@ export function PaneTerminal({
       pendingMessages.fail(owner, id, { code: "disconnected", message: t("Not confirmed. Check the terminal before sending again.") }, true);
     } finally { pendingMessages.end(owner, id); }
   }, [answering, ended, heldByOpenQueue, paneId, queueOwner, submitComposerMessage, submitRetention]);
+  actOnPendingRef.current = actOnPending;
+
+  /** The second Enter of two: the message the first one queued is sent now, once, as its Send now would. */
+  const sendQueuedNow = useCallback((): boolean => {
+    const last = lastQueuedRef.current;
+    if (!settings.enterTwiceSteers || last === null || last.now || last.pane !== paneRef.current || Date.now() - last.at > SEND_QUEUED_AGAIN_MS) return false;
+    last.now = true;
+    if (last.id !== null) void actOnPending(last.id, "steer");
+    return true;
+  }, [actOnPending, settings.enterTwiceSteers]);
 
 
   // Capture the owner's pane for the entire upload batch, even across a pane switch.
@@ -2521,6 +2546,7 @@ export function PaneTerminal({
           ) : null}
           onSend={composerSend}
           onAbort={abortTurn}
+          onSendQueuedNow={sendQueuedNow}
           onUploadImage={uploadImage}
         />
       )}
diff --git a/src/components/SettingsDialog.tsx b/src/components/SettingsDialog.tsx
index dc8c66622..91be71887 100644
--- a/src/components/SettingsDialog.tsx
+++ b/src/components/SettingsDialog.tsx
@@ -235,6 +235,9 @@ function ChatPage() {
         <SettingsRow label={t("Send queued messages automatically")} description={t("A message sent while the agent works goes by itself when the turn ends. When off, it waits until you press Send now.")}>
           <Toggle label={t("Send queued messages automatically")} checked={settings.autoSendQueued} onChange={(autoSendQueued) => update({ autoSendQueued })} />
         </SettingsRow>
+        <SettingsRow label={t("Enter twice sends now")} description={t("While the agent works, pressing Enter again right after sending sends that message at once, as Send now does, instead of waiting for the turn to end.")}>
+          <Toggle label={t("Enter twice sends now")} checked={settings.enterTwiceSteers} onChange={(enterTwiceSteers) => update({ enterTwiceSteers })} />
+        </SettingsRow>
         <SettingsRow label={t("Suggestion chip")} description={t("On a touch screen, a chip above the message box puts the prompt Claude Code suggests next into the box. With a keyboard, Tab does it.")}>
           <Toggle label={t("Suggestion chip")} checked={settings.showSuggestionChip} onChange={(showSuggestionChip) => update({ showSuggestionChip })} />
         </SettingsRow>
diff --git a/src/lib/api.test.ts b/src/lib/api.test.ts
index 3c234962f..ab322fd9e 100644
--- a/src/lib/api.test.ts
+++ b/src/lib/api.test.ts
@@ -49,7 +49,7 @@ it("posts the full safe telemetry snapshot and current notice version", async ()
   const body = JSON.parse(String(requestInit?.body)) as Record<string, unknown>;
   expect(body).toEqual(change);
   expect(body).not.toHaveProperty("changed_settings");
-  expect(Object.keys(body.settings as object)).toHaveLength(53);
+  expect(Object.keys(body.settings as object)).toHaveLength(54);
   expect(body.settings).not.toHaveProperty("terminalFontFamily");
   expect(body.settings).not.toHaveProperty("chatFontFamily");
   expect(body.settings).not.toHaveProperty("usageHidden");
diff --git a/src/lib/i18n.ja.ts b/src/lib/i18n.ja.ts
index 0d26b27dc..f07e683c5 100644
--- a/src/lib/i18n.ja.ts
+++ b/src/lib/i18n.ja.ts
@@ -590,6 +590,8 @@ export const JA: Record<string, string> = {
   "Next turn": "次のターン",
   "Waits for Send now": "「今すぐ送信」で送信します",
   "Send queued messages automatically": "送信待ちメッセージを自動で送信",
+  "Enter twice sends now": "Enter 2 回で今すぐ送信",
+  "While the agent works, pressing Enter again right after sending sends that message at once, as Send now does, instead of waiting for the turn to end.": "エージェントの作業中、送信した直後にもう一度 Enter を押すと、ターンの終わりを待たずに「今すぐ送信」と同じくそのメッセージをすぐに送ります。",
   "A message sent while the agent works goes by itself when the turn ends. When off, it waits until you press Send now.": "エージェントの作業中に送ったメッセージは、ターンが終わると自動で送信されます。オフにすると、「今すぐ送信」を押すまで待ちます。",
   "Discard saved copy": "保存したコピーを破棄",
   "Update this PC to send messages in the next turn. Your draft stayed here.": "次のターンにメッセージを送るには、このPCを更新してください。入力したメッセージはここに残っています。",
diff --git a/src/lib/i18n.ko.ts b/src/lib/i18n.ko.ts
index 7f88ee4fe..f7aa1feeb 100644
--- a/src/lib/i18n.ko.ts
+++ b/src/lib/i18n.ko.ts
@@ -588,6 +588,8 @@ export const KO: Record<string, string> = {
   "Next turn": "다음 차례",
   "Waits for Send now": "지금 보내기를 누르면 보냅니다",
   "Send queued messages automatically": "대기 메시지 자동 전송",
+  "Enter twice sends now": "엔터 두 번으로 바로 보내기",
+  "While the agent works, pressing Enter again right after sending sends that message at once, as Send now does, instead of waiting for the turn to end.": "에이전트가 작업하는 동안 메시지를 보낸 직후 Enter를 한 번 더 누르면, 턴이 끝나길 기다리지 않고 지금 보내기처럼 그 메시지를 바로 보냅니다.",
   "A message sent while the agent works goes by itself when the turn ends. When off, it waits until you press Send now.": "에이전트가 작업 중일 때 보낸 메시지는 턴이 끝나면 저절로 전송됩니다. 끄면 지금 보내기를 누를 때까지 기다립니다.",
   "Discard saved copy": "저장된 사본 버리기",
   "Update this PC to send messages in the next turn. Your draft stayed here.": "다음 차례에 메시지를 보내려면 이 PC를 업데이트하세요. 작성한 메시지는 여기에 남아 있습니다.",
diff --git a/src/lib/i18n.tr.ts b/src/lib/i18n.tr.ts
index 992dfe65b..4a2bb9228 100644
--- a/src/lib/i18n.tr.ts
+++ b/src/lib/i18n.tr.ts
@@ -558,6 +558,8 @@ export const TR: Record<string, string> = {
   "Next turn": "Sıradaki tur",
   "Waits for Send now": "Şimdi gönder'e basınca gönderilir",
   "Send queued messages automatically": "Kuyruktaki mesajları otomatik gönder",
+  "Enter twice sends now": "İki kez Enter şimdi gönderir",
+  "While the agent works, pressing Enter again right after sending sends that message at once, as Send now does, instead of waiting for the turn to end.": "Ajan çalışırken, gönderdikten hemen sonra Enter'a bir kez daha basmak, turun bitmesini beklemeden o mesajı Şimdi gönder gibi hemen gönderir.",
   "A message sent while the agent works goes by itself when the turn ends. When off, it waits until you press Send now.": "Ajan çalışırken gönderilen mesaj, tur bitince kendiliğinden gider. Kapalıyken Şimdi gönder'e basana kadar bekler.",
   "Discard saved copy": "Kayıtlı kopyayı sil",
   "Update this PC to send messages in the next turn. Your draft stayed here.": "Mesajları sıradaki turda göndermek için bu bilgisayarı güncelleyin. Taslağınız burada kaldı.",
diff --git a/src/lib/i18n.zh.ts b/src/lib/i18n.zh.ts
index 82ff70b55..123c1d31a 100644
--- a/src/lib/i18n.zh.ts
+++ b/src/lib/i18n.zh.ts
@@ -592,6 +592,8 @@ export const ZH: Record<string, string> = {
   "Next turn": "下一轮",
   "Waits for Send now": "按“立即发送”后发送",
   "Send queued messages automatically": "自动发送排队消息",
+  "Enter twice sends now": "按两次 Enter 立即发送",
+  "While the agent works, pressing Enter again right after sending sends that message at once, as Send now does, instead of waiting for the turn to end.": "在代理工作时，发送后立即再按一次 Enter，会像“立即发送”一样马上发出该消息，而不必等本轮结束。",
   "A message sent while the agent works goes by itself when the turn ends. When off, it waits until you press Send now.": "智能体工作时发送的消息会在本轮结束后自动发出。关闭后，消息会等到你按下“立即发送”。",
   "Discard saved copy": "丢弃已保存的副本",
   "Update this PC to send messages in the next turn. Your draft stayed here.": "请更新这台电脑后再发送下一轮消息。草稿仍保留在这里。",
diff --git a/src/lib/settings.test.ts b/src/lib/settings.test.ts
index bf5bbac98..38e67734c 100644
--- a/src/lib/settings.test.ts
+++ b/src/lib/settings.test.ts
@@ -44,6 +44,11 @@ it("takes twenty files from one paste, pick or drop unless this device chose ano
   expect(sanitizeSettings({ attachLimit: 0 }).attachLimit).toBe(1);
   expect(sanitizeSettings({ attachLimit: "8" }).attachLimit).toBe(20);
   expect(SETTING_SCOPE.attachLimit).toBe("device");
+  // a second Enter sends a queued message now unless turned off; a keyboard habit, so this device's
+  expect(sanitizeSettings({}).enterTwiceSteers).toBe(true);
+  expect(sanitizeSettings({ enterTwiceSteers: false }).enterTwiceSteers).toBe(false);
+  expect(sanitizeSettings({ enterTwiceSteers: "no" }).enterTwiceSteers).toBe(true);
+  expect(SETTING_SCOPE.enterTwiceSteers).toBe("device");
 });
 
 it("keeps the terminal cursor at a block that blinks unless a saved shape or blink says otherwise", () => {
@@ -111,6 +116,7 @@ describe("telemetry settings snapshot", () => {
       chatFontSize: 11,
       chatWidth: "wide",
       autoSendQueued: false,
+      enterTwiceSteers: false,
       language: "ko",
       alertDone: "always",
       usageCount: "left",
@@ -139,6 +145,7 @@ describe("telemetry settings snapshot", () => {
       chatFontSize: 11,
       chatWidth: "wide",
       autoSendQueued: false,
+      enterTwiceSteers: false,
       language: "ko",
       alertDone: "always",
       usageCount: "left",
diff --git a/src/lib/settings.ts b/src/lib/settings.ts
index 3773b4d99..0dadd7cd1 100644
--- a/src/lib/settings.ts
+++ b/src/lib/settings.ts
@@ -117,6 +117,8 @@ export interface Settings {
   attachLimit: number;
   /** true: a message sent while the agent works goes by itself when the turn ends; false: it waits for Send now */
   autoSendQueued: boolean;
+  /** true: Enter again within a second of sending a message that waits for the turn sends it now (steers), as Send now does */
+  enterTwiceSteers: boolean;
   /** show the agent's folded reasoning blocks in the chat view */
   showThinking: boolean;
   /** request a screen wake lock while a pane is open in this visible tab */
@@ -204,6 +206,7 @@ export function telemetrySettingsSnapshot(settings: Settings): TelemetrySettings
     chatWidth: settings.chatWidth,
     enterSends: settings.enterSends,
     autoSendQueued: settings.autoSendQueued,
+    enterTwiceSteers: settings.enterTwiceSteers,
     showThinking: settings.showThinking,
     keepScreenOn: settings.keepScreenOn,
     language: settings.language,
@@ -253,7 +256,7 @@ export const SETTING_SCOPE = {
   terminalInputMode: "device", keyBarExtras: "device", keyBarItems: "device", shortcutOverrides: "device", pageOverlapRows: "device", chatPageKeys: "device", density: "device",
   quietOpenedDone: "device", terminalFontSize: "device", terminalCursorStyle: "device", terminalCursorBlink: "device",
   terminalWheelSpeed: "device", terminalFontFamily: "device", paneClipboard: "device", releasePaneAway: "device",
-  narrowPaneFont: "device", chatFontSize: "device", chatFontFamily: "device", chatWidth: "device", enterSends: "device", attachLimit: "device",
+  narrowPaneFont: "device", chatFontSize: "device", chatFontFamily: "device", chatWidth: "device", enterSends: "device", enterTwiceSteers: "device", attachLimit: "device",
   keepScreenOn: "device", alertsOn: "device", alertInput: "device", alertDone: "device", alertInApp: "device", alertSound: "device",
   voiceInput: "device", voiceLanguage: "device", voicePolishChat: "device", voicePolishTerminal: "device",
   // Viewer layout follows this screen, as chatWidth does; highlighting remains shared.
@@ -295,6 +298,7 @@ export const DEFAULT_SETTINGS: Settings = {
   enterSends: true,
   attachLimit: 20,
   autoSendQueued: true,
+  enterTwiceSteers: true,
   showThinking: false,
   keepScreenOn: false,
   language: "system",
@@ -470,6 +474,7 @@ export function sanitizeSettings(raw: unknown): Settings {
       ? Math.min(ATTACH_LIMIT_MAX, Math.max(ATTACH_LIMIT_MIN, Math.round(record["attachLimit"])))
       : DEFAULT_SETTINGS.attachLimit,
     autoSendQueued: typeof record["autoSendQueued"] === "boolean" ? record["autoSendQueued"] : DEFAULT_SETTINGS.autoSendQueued,
+    enterTwiceSteers: typeof record["enterTwiceSteers"] === "boolean" ? record["enterTwiceSteers"] : DEFAULT_SETTINGS.enterTwiceSteers,
     showThinking: typeof record["showThinking"] === "boolean" ? record["showThinking"] : DEFAULT_SETTINGS.showThinking,
     keepScreenOn: typeof record["keepScreenOn"] === "boolean" ? record["keepScreenOn"] : DEFAULT_SETTINGS.keepScreenOn,
     language: LANGUAGE_SETTINGS.includes(record["language"] as LanguageSetting) ? record["language"] as LanguageSetting : DEFAULT_SETTINGS.language,
diff --git a/telemetry/worker.test.ts b/telemetry/worker.test.ts
index 154040cb7..556740671 100644
--- a/telemetry/worker.test.ts
+++ b/telemetry/worker.test.ts
@@ -31,6 +31,7 @@ const settings: TelemetrySettings = {
   chatWidth: "narrow",
   enterSends: true,
   autoSendQueued: false,
+  enterTwiceSteers: true,
   showThinking: true,
   keepScreenOn: false,
   language: "ko",