From d246203f397b590ff4d4fa92c8db615dc44f2e77 Mon Sep 17 00:00:00 2001
From: AI Bot <bot@ai.com>
Date: Tue, 13 Oct 2026 17:21:45 +0900
Subject: [PATCH] feat(chat): Enter twice sends a queued message now

While the agent works, Enter queues the message for the turn's end (or
holds it for Send now). There was no keyboard way to steer: only the row's
Send now button. A second Enter within a second of the one that queued it
now does what Send now does, on the same pending ID and through the same
`pending-action` steer, so nothing new crosses the wire.

The second Enter counts on an empty box, or while the first send is still
on its way (the box keeps its text until the bridge's receipt): then the
message is sent now as soon as the receipt names its ID. It acts once, only
on the message this tab queued last, and only in the pane it was queued in.
Settings -> Chat -> Enter twice sends now (default on, this device's)
turns it off; the setting is reported with the other safe values.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                           |   5 +
 scripts/ci-browser.sh                  |   1 +
 scripts/ci-browser.test.ts             |   3 +-
 scripts/enter-twice-demo-regression.ts | 155 +++++++++++++++++++++++++
 shared/telemetry.ts                    |   2 +
 src/components/Composer.tsx            |   8 +-
 src/components/PaneTerminal.tsx        |  28 ++++-
 src/components/SettingsDialog.tsx      |   3 +
 src/lib/api.test.ts                    |   2 +-
 src/lib/i18n.ja.ts                     |   2 +
 src/lib/i18n.ko.ts                     |   2 +
 src/lib/i18n.tr.ts                     |   2 +
 src/lib/i18n.zh.ts                     |   2 +
 src/lib/settings.test.ts               |   7 ++
 src/lib/settings.ts                    |   7 +-
 telemetry/worker.test.ts               |   1 +
 16 files changed, 225 insertions(+), 5 deletions(-)
 create mode 100644 scripts/enter-twice-demo-regression.ts

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",