@@ -883,7 +883,9 @@ test("keeps a line added at the end of a scrolling prompt clear of the bottom fa
         const viewport = element.closest('[data-component="composer-scroll"]')!
         const range = document.createRange()
         range.selectNodeContents(element)
-        const line = Array.from(range.getClientRects()).reduce((last, rect) => (rect.bottom > last.bottom ? rect : last))
+        const line = Array.from(range.getClientRects()).reduce((last, rect) =>
+          rect.bottom > last.bottom ? rect : last,
+        )
         const fade = parseFloat(getComputedStyle(viewport).getPropertyValue("--composer-fade-bottom"))
 
         return Math.max(0, Math.round(line.bottom - (viewport.getBoundingClientRect().bottom - fade)))
@@ -892,6 +894,65 @@ test("keeps a line added at the end of a scrolling prompt clear of the bottom fa
     .toBe(0)
 })
 
+test("Enter that confirms an IME candidate never sends, even after Safari's early compositionend", async ({ page }) => {
+  const prompts: Parameters<NonNullable<MockServerConfig["onPrompt"]>>[0]["body"][] = []
+  const view = await openSession(page, { name: "ComposerImeEnter", onPrompt: (input) => void prompts.push(input.body) })
+
+  const enter = (keyCode: number) =>
+    view.editor.evaluate(
+      (element, keyCode) =>
+        element.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", keyCode, bubbles: true, cancelable: true })),
+      keyCode,
+    )
+
+  await view.editor.fill("にほん")
+  // Safari delivers the confirming Enter after compositionend, so isComposing is false and only keyCode marks it.
+  await enter(229)
+  await expect(view.editor).toHaveText("にほん")
+  await enter(13)
+  await expect.poll(() => prompts.map((body) => body.text)).toEqual(["にほん"])
+})
+
+test.describe("touch keyboard", () => {
+  test.use({ viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true })
+
+  test("Return only adds a line, even over suggestions; the touch bar and Cmd+Return send", async ({ page }) => {
+    const prompts: Parameters<NonNullable<MockServerConfig["onPrompt"]>>[0]["body"][] = []
+    const view = await openSession(page, {
+      name: "ComposerTouchReturn",
+      onPrompt: (input) => void prompts.push(input.body),
+    })
+    const bar = page.locator('[data-slot="composer-touch-bar"]')
+    await expect(bar).toBeVisible()
+    await expect(page.locator('[data-action="composer-attach"]')).toHaveCount(0)
+    await expect(view.editor).toHaveAttribute("enterkeyhint", "enter")
+
+    await view.editor.fill("/model")
+    await expect(page.locator('[data-suggestion-id="model.choose"]')).toHaveAttribute("data-active", "")
+    await view.editor.press("Enter")
+    await expect(page.locator('[data-component="composer-suggestions"]')).toBeHidden()
+    await expect.poll(() => view.editor.innerText()).toMatch(/^\/model\n/)
+    await expect(page.getByRole("dialog", { name: "Select model", exact: true })).toBeHidden()
+
+    await view.editor.fill("first line")
+    await view.editor.press("Enter")
+    await view.editor.pressSequentially("second line")
+    await expect.poll(() => view.editor.innerText()).toBe("first line\nsecond line")
+    expect(prompts).toEqual([])
+
+    await bar.getByRole("button", { name: "Send", exact: true }).tap()
+    await expect.poll(() => prompts.map((body) => body.text)).toEqual(["first line\nsecond line"])
+    await expect(view.editor).toBeEmpty()
+
+    // A hardware keyboard, as on an iPad, still sends with Cmd+Return.
+    await view.editor.fill("from the iPad keyboard")
+    await view.editor.press("ControlOrMeta+Enter")
+    await expect
+      .poll(() => prompts.map((body) => body.text))
+      .toEqual(["first line\nsecond line", "from the iPad keyboard"])
+  })
+})
+
 test("a key-up never moves the caret back after later navigation", async ({ page }) => {
   const input = await draft(page)
   await input.pressSequentially("first line")
 
@@ -16,6 +16,9 @@ for (const { width, direction } of [
 
     const editor = page.getByRole("textbox", { name: "Prompt", exact: true })
     await expect(editor).toBeEditable()
+    // A narrow window with a mouse is not a phone: it keeps the desktop toolbar and Enter to send.
+    await expect(page.locator('[data-action="composer-attach"]')).toBeVisible()
+    await expect(page.locator('[data-slot="composer-touch-bar"]')).toHaveCount(0)
     await editor.fill("Please check focus after sending.")
     await expect(editor).toBeFocused()
 
 
@@ -732,7 +732,8 @@ for (const device of ["Pixel 7", "iPhone 13"]) {
               timestamp: restingTimestamp(),
             })
 
-            for (let step = 1; step <= 23; step++)
+            // Far enough that the delayed image above the anchor comes back into the mounted window.
+            for (let step = 1; step <= 25; step++)
               await devtools.send("Input.dispatchTouchEvent", {
                 type: "touchMove",
                 touchPoints: [{ x: point.x, y: point.y + step * 30 }],
@@ -767,7 +768,7 @@ for (const device of ["Pixel 7", "iPhone 13"]) {
             await expect(hidden).toHaveCount(1)
           }
 
-          const anchor = page.getByText(detach === "scroll" ? "Part 48." : "Reading 20.", { exact: true })
+          const anchor = page.getByText(detach === "scroll" ? "Part 50." : "Reading 20.", { exact: true })
           await expect(anchor).toBeInViewport()
           const before = await anchor.evaluate((element) => element.getBoundingClientRect().top)
           image.resolve()
 
@@ -260,6 +260,49 @@ test("a blank Enter leaves the running session alone while Stop still interrupts
   expect(mock.prompts).toEqual([])
 })
 
+test.describe("touch keyboard", () => {
+  test.use({ viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true })
+
+  test("the touch bar stops, queues and steers a running session while Return only adds a line", async ({ page }) => {
+    const mock = createQueueMock([])
+    const view = await openQueue(page, mock, "steer")
+    const bar = page.locator('[data-slot="composer-touch-bar"]')
+    const stop = bar.getByRole("button", { name: "Stop", exact: true })
+    const interrupted = page.waitForRequest((request) =>
+      new URL(request.url()).pathname.endsWith(`/${sessionID}/interrupt`),
+    )
+
+    await stop.tap()
+    await interrupted
+
+    await view.input.fill("check the logs")
+    await expect(stop).toHaveCount(0)
+    await view.input.press("Enter")
+    await view.input.pressSequentially("then the tests")
+    expect(mock.prompts).toEqual([])
+    await bar.getByRole("button", { name: "Queue", exact: true }).tap()
+    await expect
+      .poll(() => mock.prompts.map((prompt) => [prompt.delivery, prompt.text]))
+      .toEqual([["queue", "check the logs\nthen the tests"]])
+
+    await view.input.fill("use the staging database")
+    await bar.getByRole("button", { name: "Steer", exact: true }).tap()
+    await expect
+      .poll(() => mock.prompts.map((prompt) => [prompt.delivery, prompt.text]))
+      .toEqual([
+        ["queue", "check the logs\nthen the tests"],
+        ["steer", "use the staging database"],
+      ])
+    await expect(view.input).toBeEmpty()
+
+    // Editing a queued prompt: the primary action puts it back in the queue, the other steers it.
+    await view.rows.filter({ hasText: "check the logs" }).locator('[data-action="session-queue-edit"]').tap()
+    await expect(view.input).toHaveText(/check the logs/)
+    await expect(bar.locator('[data-action="composer-alternate-delivery"]')).toHaveText("Steer")
+    await expect(bar.locator('[data-action="composer-submit"]')).toHaveText("Queue")
+  })
+})
+
 test("a steer shows as pending in the timeline as the composer clears, before the server admits it", async ({
   page,
 }) => {