Merge master into fix/subagent-stack-end-result

apps/web/tests/lifecycle-chrome.e2e.ts

@@ -158,8 +158,24 @@ describe('web e2e: lifecycle & chrome (workspace flow / reload / dark mode)', ()
     }
     const settled = scaffold.whenTurnSettled()
     await input.fill(PROMPT)
-    await input.press('Enter')
-    const sessionId = await settled
+    const observeTurn = async () => {
+      const originalViewport = page.viewportSize() ?? { width: 1680, height: 1000 }
+      if (MODE !== 'record') await page.setViewportSize({ width: 480, height: 1000 })
+      try {
+        await input.press('Enter')
+        if (MODE !== 'record') {
+          const liveTail = page.locator('[data-variant="think"][data-state="running"] [data-follow-end]')
+          await expect.poll(async () => await liveTail.evaluate(element => (
+            element.scrollWidth > element.clientWidth
+              && element.scrollLeft >= element.scrollWidth - element.clientWidth - 1
+          )), { timeout: 10_000, interval: 10 }).toBe(true)
+        }
+        return await settled
+      } finally {
+        if (MODE !== 'record') await page.setViewportSize(originalViewport)
+      }
+    }
+    const sessionId = await observeTurn()
     if (MODE === 'record') {
       await recordFixture(scaffold, sessionId, FIXTURE)
     }

apps/web/tests/queue-actions.e2e.ts

@@ -22,6 +22,7 @@ const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/queue-actions', import.m
 const FIXTURE = fileURLToPath(new URL('./snapshots/live-interactions/session.jsonl', import.meta.url))
 const COLLAPSED_EXPECTED = join(SNAPSHOT_DIR, 'collapsed.expected.md')
 const EDITING_EXPECTED = join(SNAPSHOT_DIR, 'editing.expected.md')
+const LAYOUT_EXPECTED = join(SNAPSHOT_DIR, 'layout.expected.md')
 const PRESERVED_EXPECTED = join(SNAPSHOT_DIR, 'preserved.expected.md')
 const UI_EXPECTED = join(SNAPSHOT_DIR, 'ui.expected.md')
 const MODE = webSnapshotMode()
@@ -172,10 +173,95 @@ describe('web e2e: queue row actions', () => {
     await expect.poll(() => page.locator('[data-queue-dock]').count()).toBe(0)
   }, 120_000)
 
+  it.skipIf(MODE === 'record')('orders Todo before Goal and Queue on one responsive card column', async () => {
+    overrideDir = await mkdtemp(join(tmpdir(), 'dsh-web-context-layout-'))
+    const readyFile = join(overrideDir, '.hang-ready')
+    const overridePath = join(overrideDir, 'replay.override.json')
+    await writeFile(overridePath, JSON.stringify([{ kind: 'hang', readyFile } satisfies ReplayEntry]))
+
+    const sessionEvents: SessionEvent[] = []
+    scaffold = await launchWebScaffold({ replayFixture: FIXTURE, replayOverride: overridePath })
+    scaffold.ctx.on('session/event', (_session, event: SessionEvent) => { sessionEvents.push(event) })
+    browser = await chromium.launch()
+    page = await newEnglishPage(browser)
+    const tripwire = watchConsole(page)
+    await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    await connectFreshWorkspace(page, scaffold.workspaceCwd)
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-context-layout'))
+
+    const input = page.locator('textarea').first()
+    const settled = scaffold.whenTurnSettled()
+    await input.fill('/goal Keep the composer context panels aligned')
+    await input.press('Enter')
+    await expect.poll(() => existsSync(readyFile), { timeout: 15_000 }).toBe(true)
+    await page.locator('[data-goal-bar]').waitFor({ timeout: 10_000 })
+
+    const sessions = scaffold.ctx.sessions.list()
+    expect(sessions).toHaveLength(1)
+    sessions[0]!.append('todo/write', {
+      todos: [
+        { content: 'Confirm the panel order', status: 'completed' },
+        { content: 'Align the panel widths', status: 'in_progress' },
+      ],
+    })
+    await page.locator('[data-testid="todo-panel"]').waitFor({ timeout: 10_000 })
+
+    for (const text of ['Layout queue first', 'Layout queue second']) {
+      await input.fill(text)
+      await input.press('Enter')
+    }
+    const queueHeader = page.getByRole('button', { name: '2 queued messages' })
+    await expect.poll(() => queueHeader.getAttribute('aria-expanded'), { timeout: 10_000 })
+      .toBe('false')
+
+    const layoutSnapshot = await captureStableAria(
+      page,
+      '[class*="centerCol"]',
+      scaffold.workspaceCwd,
+    )
+    await compareOrRefreshGolden(LAYOUT_EXPECTED, layoutSnapshot, MODE)
+
+    const expectAlignedContextPanels = async () => {
+      const queuePanelBox = await page.locator('[data-queue-dock] > div').boundingBox()
+      const todoBox = await page.locator('[data-testid="todo-panel"]').boundingBox()
+      const goalBox = await page.locator('[data-goal-bar] > div').boundingBox()
+      expect(queuePanelBox).not.toBeNull()
+      expect(todoBox).not.toBeNull()
+      expect(goalBox).not.toBeNull()
+      expect(todoBox!.y).toBeLessThan(goalBox!.y)
+      expect(goalBox!.y).toBeLessThan(queuePanelBox!.y)
+      expect(todoBox!.x).toBeCloseTo(goalBox!.x, 1)
+      expect(todoBox!.x).toBeCloseTo(queuePanelBox!.x, 1)
+      expect(todoBox!.width).toBeCloseTo(goalBox!.width, 1)
+      expect(todoBox!.width).toBeCloseTo(queuePanelBox!.width, 1)
+    }
+    await expectAlignedContextPanels()
+    await page.setViewportSize({ width: 640, height: 1000 })
+    await expectAlignedContextPanels()
+    await page.setViewportSize({ width: 1680, height: 1000 })
+
+    await queueHeader.click()
+    const removeButtons = page.getByRole('button', { name: 'Remove queued message' })
+    await expect.poll(() => removeButtons.count(), { timeout: 10_000 }).toBe(2)
+    await removeButtons.first().click()
+    await expect.poll(() => removeButtons.count(), { timeout: 10_000 }).toBe(1)
+    await removeButtons.first().click()
+    await expect.poll(() => page.locator('[data-queue-dock]').count(), { timeout: 10_000 }).toBe(0)
+    await page.getByRole('button', { name: 'Clear goal' }).click()
+    await expect.poll(() => page.locator('[data-goal-bar]').count(), { timeout: 10_000 }).toBe(0)
+    await page.getByRole('button', { name: 'Stop generating' }).click()
+    await settled
+
+    expect(turnEndReasons(sessionEvents)).toEqual(['aborted'])
+    expect(tripwire.pageErrors).toEqual([])
+    expect(tripwire.warnings).toEqual([])
+  }, 120_000)
+
   it.skipIf(MODE === 'record')('keeps its snapshot inventory closed', async () => {
     await assertFixtureInventory(
       SNAPSHOT_DIR,
-      ['collapsed.expected.md', 'editing.expected.md', 'preserved.expected.md', 'ui.expected.md'],
+      ['collapsed.expected.md', 'editing.expected.md', 'layout.expected.md', 'preserved.expected.md', 'ui.expected.md'],
     )
   })
 })

apps/web/tests/settings-chrome.e2e.ts

@@ -2,8 +2,9 @@
 // section switching, both close paths), the Appearance preference row (the
 // real theme gesture — click 深色 and the whole cascade runs: ThemeService preference -> localStorage dsh.theme
 // -> theme/change -> ui-layout's presenter -> body attribute -> alias token)
-// and the Language row (settings-scoped localization + persisted dsh.locale),
-// plus Permission as the persisted default for subsequently created sessions.
+// the Language row (settings-scoped localization + persisted dsh.locale),
+// the busy-state Enter preference, plus Permission as the persisted default
+// for subsequently created sessions.
 // Zero model calls: everything is pure client + persistence state on a blank
 // frame, so there is no fixture and a stray stream would fail loud on the
 // open llm seam.
@@ -182,6 +183,32 @@ describe('web e2e: settings modal and General preferences', () => {
     expect(tripwire.pageErrors).toEqual([])
   }, 90_000)
 
+  it('persists the busy-state Enter behavior across reload and restores Queue', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-settings-enter-behavior'))
+    await page.getByRole('button', { name: '设置', exact: true }).click()
+    const dialog = page.getByRole('dialog', { name: '设置' })
+    await dialog.waitFor({ timeout: 10_000 })
+    await dialog.getByRole('button', { name: '排队发送' }).click()
+    await page.getByRole('menuitem', { name: '插话发送' }).click()
+    await dialog.getByRole('button', { name: '插话发送' }).waitFor({ timeout: 10_000 })
+    expect(await page.evaluate(() => localStorage.getItem('dsh.conversation.busyEnter'))).toBe('steer')
+    await page.keyboard.press('Escape')
+
+    const warningStart = tripwire.warnings.length
+    await page.reload({ waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    acknowledgeReloadConnectionLoss(tripwire, warningStart)
+    await page.getByRole('button', { name: '设置', exact: true }).click()
+    const reloaded = page.getByRole('dialog', { name: '设置' })
+    await reloaded.getByRole('button', { name: '插话发送' }).waitFor({ timeout: 10_000 })
+    await reloaded.getByRole('button', { name: '插话发送' }).click()
+    await page.getByRole('menuitem', { name: '排队发送' }).click()
+    await reloaded.getByRole('button', { name: '排队发送' }).waitFor({ timeout: 10_000 })
+    expect(await page.evaluate(() => localStorage.getItem('dsh.conversation.busyEnter'))).toBe('queue')
+    await page.keyboard.press('Escape')
+    expect(tripwire.pageErrors).toEqual([])
+  }, 90_000)
+
   it('switches the settings surface language and persists dsh.locale', async () => {
     onTestFailed(() => saveFailureShot(page, 'web-e2e-settings-language'))
     await page.getByRole('button', { name: '设置', exact: true }).click()

apps/web/tests/snapshots/queue-actions/editing.expected.md

@@ -23,6 +23,8 @@
       - img
     - button "Remove queued message":
       - img
+    - button "Steer queued message":
+      - img
   - listitem:
     - textbox "Edit queued message": Edited queue item
     - button "Save queued message":

apps/web/tests/snapshots/queue-actions/layout.expected.md

@@ -0,0 +1,43 @@
+- banner:
+  - navigation "Session hierarchy":
+    - button "workspace" [disabled]
+  - tablist:
+    - tab "Chat" [selected]
+    - tab "Trajectory"
+- 'button "goal Goal created Status: active Objective: Keep the composer context panels aligned Rounds: 0/256 Activation: armed Commands: /goal edit <objective>, /goal pause, /goal clear"':
+  - img
+  - img
+  - text: "goal Goal created Status: active Objective: Keep the composer context panels aligned Rounds: 0/256 Activation: armed Commands: /goal edit <objective>, /goal pause, /goal clear"
+- button "Context injection":
+  - img
+  - img
+  - text: Context injection
+- button "Context injection":
+  - img
+  - img
+  - text: Context injection
+- button "Context injection":
+  - img
+  - img
+  - text: Context injection
+- paragraph: partial
+- status: Deep diving...
+- region "To-dos":
+  - button "To-dos 1/2 tasks · 1 in progress"
+- img
+- text: Ongoing Goal Keep the composer context panels aligned
+- button "Pause goal":
+  - img
+- button "Edit goal":
+  - img
+- button "Clear goal":
+  - img
+- button "2 queued messages"
+- textbox "Message the agent"
+- button "Commands":
+  - img
+- 'button "Access mode, current: Workspace Write"': Workspace Write
+- button "Select model, current DeepSeek-V4-Flash":
+  - text: DeepSeek-V4-Flash
+  - img
+- button "Stop generating"

apps/web/tests/snapshots/queue-actions/preserved.expected.md

@@ -33,6 +33,8 @@
       - img
     - button "Remove queued message":
       - img
+    - button "Steer queued message":
+      - img
 - textbox "Message the agent"
 - button "Commands":
   - img

apps/web/tests/snapshots/queue-actions/ui.expected.md

@@ -22,6 +22,8 @@
       - img
     - button "Remove queued message":
       - img
+    - button "Steer queued message":
+      - img
 - textbox "Message the agent"
 - button "Commands":
   - img

apps/web/tests/snapshots/settings-chrome/dialog.expected.md

@@ -28,3 +28,7 @@
   - button "跟随系统" [pressed]:
     - img
     - text: 跟随系统
+  - text: 繁忙时 Enter 键行为 仅在智能体运行时生效；Cmd/Ctrl+Enter 使用另一行为
+  - button "排队发送":
+    - text: 排队发送
+    - img

apps/web/tests/snapshots/steering/mid-steer.expected.md

@@ -23,6 +23,9 @@
   - img
   - text: Ask question waiting
 - status: Deep diving...
+- text: "Interjection: include the word BANANA in your final reply."
+- button "Copy":
+  - img
 - region "Ready to continue?":
   - text: Checkpoint
   - heading "Ready to continue?" [level=2]

apps/web/tests/snapshots/steering/settled.expected.md

@@ -21,7 +21,11 @@
   - img
   - img
   - text: Ask question 1/1 answered
-- text: "Interjection: include the word BANANA in your final reply."
+- text: "Interjection: include the word BANANA in your final reply. {{clock}}"
+- button "Copy":
+  - img
+- button "Branch into a new conversation":
+  - img
 - button "Think The user selected \"Yes\" and wants me to include the word \"BANANA\" in my final reply. Let me acknowledge their answer.":
   - img
   - img

apps/web/tests/steering.e2e.ts

@@ -1,15 +1,7 @@
-// Web e2e scenario: mid-turn steering over the host wire. The Web UI has no
-// steer entry, so the steer is POSTed from the page over the same
-// same-origin /api transport the client uses. Everything downstream is
-// product: the gateway routes mode:'steer' to Agent.steer, the loop drains
-// it at the step boundary into a durable steering/message event, the SSE mux
-// pushes it, and the transcript shows the text as a plain bubble (no
-// interjection chrome). The question composer supplies the deterministic
-// mid-turn window: while ask_user_question blocks, the turn is provably
-// running, so record and replay perform the identical steer-then-answer
-// sequence with zero timing dependence — and the recorded final reply proves
-// the steer reached the MODEL (it obeys an instruction that only the
-// steering message carries).
+// Web e2e scenarios for both steering entry points: QueueDock strictly
+// transfers one queued occurrence, while the complementary composer gestures
+// choose Queue or Steer. The question tool supplies a deterministic pending-
+// steering snapshot before the step can drain.
 import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
 import { join } from 'node:path'
@@ -26,16 +18,18 @@ import { connectFreshWorkspace, newEnglishPage, saveFailureShot } from './suppor
 
 const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/steering', import.meta.url))
 const FIXTURE = join(SNAPSHOT_DIR, 'session.jsonl')
-// Two goldens for the two distinct states this interaction produces: the
-// mid-turn moment (steer ACCEPTED but deliberately invisible — the loop
-// drains steering at the step boundary, so no steering text exists while
-// the question still blocks the step) and the settled transcript (plain
-// bubble in place, final reply obeying it). The pair pins the timing
-// semantics visually: if the client ever starts rendering pending steers
-// eagerly, the mid-steer golden flips first.
+// Two goldens pin the transient Host projection and its durable handoff: the
+// mid-turn state renders accepted steering from session/queue while the
+// question blocks admission, then the settled state renders the same message
+// from steering/message beside the reply that obeys it.
 const MID_EXPECTED = join(SNAPSHOT_DIR, 'mid-steer.expected.md')
 const SETTLED_EXPECTED = join(SNAPSHOT_DIR, 'settled.expected.md')
 const MODE = webSnapshotMode()
+// The question composer replaces the textarea, so fill → Queue row → Steer
+// must finish inside the first replay chunk window. At 15 ms that window is
+// shorter than Playwright's round trips; 100 ms supplies test-only headroom,
+// while larger values lengthen all three replay scenarios linearly.
+const REPLAY_PACE_MS = 100
 
 const PROMPT = 'Use the ask_user_question tool to ask me exactly one question with id "checkpoint", question "Ready to continue?", header "Checkpoint", and options labeled "Yes" and "No". After I answer, reply with one short sentence acknowledging my answer and stop.'
 const STEER = 'Interjection: include the word BANANA in your final reply.'
@@ -56,15 +50,13 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
   let browser: Browser
   let page: Page
   let tripwire: ReturnType<typeof watchConsole>
-  let liveSessionId: string | undefined
   const sessionEvents: SessionEvent[] = []
 
   beforeAll(async () => {
-    scaffold = await launchWebScaffold(MODE === 'record' ? {} : { replayFixture: FIXTURE, paceMs: 15 })
-    scaffold.ctx.on('session/event', (session, event) => {
-      liveSessionId ??= session.id
-      sessionEvents.push(event)
-    })
+    scaffold = await launchWebScaffold(MODE === 'record'
+      ? {}
+      : { replayFixture: FIXTURE, paceMs: REPLAY_PACE_MS })
+    scaffold.ctx.on('session/event', (_session, event) => { sessionEvents.push(event) })
     browser = await chromium.launch()
     page = await newEnglishPage(browser)
     tripwire = watchConsole(page)
@@ -79,7 +71,7 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
     await scaffold?.close()
   })
 
-  it('steers during the blocked step; the message is logged, rendered, and obeyed', async () => {
+  it('strictly steers one queued row; the interjection is logged, rendered, and obeyed', async () => {
     onTestFailed(() => saveFailureShot(page, 'web-e2e-steering'))
     if (MODE !== 'record') {
       // The steer must NOT be a user/message — it lands as steering/message.
@@ -91,36 +83,29 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
     await input.fill(PROMPT)
     await input.press('Enter')
 
-    // The blocked composer is the mid-turn barrier: its presence proves the
-    // ask_user_question step is executing, i.e. the turn is running NOW.
+    // Enter remains the Queue gesture. The row action then atomically moves
+    // this exact occurrence into the current turn's steering outbox.
+    await input.fill(STEER)
+    await input.press('Enter')
+    const queued = page.getByText(STEER, { exact: true })
+    await queued.waitFor({ timeout: 10_000 })
+    const queuedRow = page.getByRole('listitem').filter({ hasText: STEER })
+    const steerButton = queuedRow.getByRole('button', { name: 'Steer queued message' })
+    await expect.poll(() => steerButton.isEnabled(), { timeout: 10_000 }).toBe(true)
+    await steerButton.click({ timeout: 10_000 })
+    const pendingSteering = page.locator('[data-pending-steering]').filter({ hasText: STEER })
+    // A timeout while the Queue row remains means strict steer lost to a
+    // closing window (`steer-unavailable`); inspect replay pacing first.
+    await pendingSteering.waitFor({ timeout: 10_000 })
+
+    // The blocked composer keeps steering pending long enough to observe the
+    // Host-authoritative mirror before the loop admits it durably.
     const composer = page.locator('[data-question-key]')
     await composer.waitFor({ timeout: MODE === 'record' ? 120_000 : 30_000 })
 
-    // Steer through the real wire from the page (same envelope + endpoint the
-    // web client's session.prompt uses). accepted:true is the transport proof.
-    expect(liveSessionId).toBeDefined()
-    const reply = await page.evaluate(async ({ sessionId, text }) => {
-      const response = await fetch('/api/session.prompt', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-          type: 'client-request',
-          rpcId: crypto.randomUUID(),
-          method: 'session.prompt',
-          payload: { sessionId, mode: 'steer', content: [{ type: 'text', text }] },
-        }),
-      })
-      return await response.json() as { result?: { ok?: boolean } }
-    }, { sessionId: liveSessionId!, text: STEER })
-    expect(reply.result?.ok).toBe(true)
-
     if (MODE !== 'record') {
-      // Mid-turn golden: the ACCEPTED steer is durable in the inbox but the
-      // loop drains steering only at the step boundary, so no steering/message
-      // exists yet and no steer text renders — the composer still blocks,
-      // alone. The DOM is stable here (no further SSE frames can arrive until
-      // the question is answered), making this state capturable.
-      expect(await page.getByText(STEER, { exact: true }).count()).toBe(0)
+      expect(await page.getByText(STEER, { exact: true }).count()).toBe(1)
+      expect(await pendingSteering.count()).toBe(1)
       expect(await page.getByRole('button', { name: 'Edit queued message' }).count()).toBe(0)
       const snapshot = await captureStableAria(page, '[class*="centerCol"]', scaffold.workspaceCwd)
       await compareOrRefreshGolden(MID_EXPECTED, snapshot, MODE)
@@ -156,6 +141,7 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
     // Visible: the plain steering bubble plus the reply that obeys it
     // (steer text + final reply each contain the marker word).
     await expect.poll(() => page.getByText(STEER, { exact: true }).count(), { timeout: 15_000 }).toBe(1)
+    expect(await pendingSteering.count()).toBe(0)
     await expect.poll(() => page.getByText('BANANA', { exact: false }).count(), { timeout: 10_000 }).toBeGreaterThanOrEqual(2)
     expect(await page.locator('[data-question-key]').count()).toBe(0)
     // Settled golden: steer text between the question round trip and the
@@ -170,3 +156,120 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
     await assertFixtureInventory(SNAPSHOT_DIR, ['session.jsonl', 'mid-steer.expected.md', 'settled.expected.md'])
   })
 })
+
+describe('web e2e: composer shortcut steers directly', () => {
+  let scaffold: WebScaffold
+  let browser: Browser
+  let page: Page
+  let tripwire: ReturnType<typeof watchConsole>
+  const sessionEvents: SessionEvent[] = []
+
+  beforeAll(async () => {
+    scaffold = await launchWebScaffold({ replayFixture: FIXTURE, paceMs: REPLAY_PACE_MS })
+    scaffold.ctx.on('session/event', (_session, event) => { sessionEvents.push(event) })
+    browser = await chromium.launch()
+    page = await newEnglishPage(browser)
+    tripwire = watchConsole(page)
+    await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    await connectFreshWorkspace(page, scaffold.workspaceCwd)
+  }, 120_000)
+
+  afterAll(async () => {
+    await browser?.close()
+    await scaffold?.close()
+  })
+
+  it.skipIf(MODE === 'record')('uses Cmd+Enter without creating a Queue row', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-composer-steering'))
+    expect(fixtureUserPrompts(await readFile(FIXTURE, 'utf8'))).toEqual([PROMPT])
+    const input = page.locator('textarea').first()
+    await input.waitFor({ timeout: 10_000 })
+    const settled = scaffold.whenTurnSettled(30_000)
+    await input.fill(PROMPT)
+    await input.press('Enter')
+    await page.getByRole('button', { name: 'Stop generating' }).waitFor({ timeout: 10_000 })
+
+    await input.fill(STEER)
+    await input.press('Meta+Enter')
+    await expect.poll(() => input.inputValue(), { timeout: 5_000 }).toBe('')
+    expect(await page.locator('[data-queue-dock]').count()).toBe(0)
+
+    const composer = page.locator('[data-question-key]')
+    await composer.waitFor({ timeout: 30_000 })
+    const pendingSteering = page.locator('[data-pending-steering]').filter({ hasText: STEER })
+    await pendingSteering.waitFor({ timeout: 10_000 })
+    await composer.getByRole('radio', { name: 'Yes' }).click()
+    await composer.getByRole('radio', { name: 'Yes' }).press('Enter')
+    await settled
+
+    const steerEvents = sessionEvents.filter(event => event.type === 'steering/message')
+    expect(steerEvents).toHaveLength(1)
+    expect((steerEvents[0] as SessionEvent & { data: { turn: number } }).data.turn).toBe(1)
+    await expect.poll(() => page.getByText(STEER, { exact: true }).count(), { timeout: 15_000 }).toBe(1)
+    expect(await pendingSteering.count()).toBe(0)
+    await expect.poll(() => page.getByText('BANANA', { exact: false }).count(), { timeout: 10_000 })
+      .toBeGreaterThanOrEqual(2)
+    expect(tripwire.pageErrors).toEqual([])
+    expect(tripwire.warnings).toEqual([])
+  }, 90_000)
+})
+
+describe('web e2e: composer shortcut follows the swapped busy behavior', () => {
+  let scaffold: WebScaffold
+  let browser: Browser
+  let page: Page
+  let tripwire: ReturnType<typeof watchConsole>
+  const sessionEvents: SessionEvent[] = []
+
+  beforeAll(async () => {
+    scaffold = await launchWebScaffold({ replayFixture: FIXTURE, paceMs: REPLAY_PACE_MS })
+    scaffold.ctx.on('session/event', (_session, event) => { sessionEvents.push(event) })
+    browser = await chromium.launch()
+    page = await newEnglishPage(browser)
+    tripwire = watchConsole(page)
+    await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    await connectFreshWorkspace(page, scaffold.workspaceCwd)
+  }, 120_000)
+
+  afterAll(async () => {
+    await browser?.close()
+    await scaffold?.close()
+  })
+
+  it.skipIf(MODE === 'record')('queues Cmd+Enter when plain Enter is configured to Steer', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-composer-swapped-shortcut'))
+    await page.getByRole('button', { name: 'Settings', exact: true }).click()
+    const dialog = page.getByRole('dialog', { name: 'Settings' })
+    await dialog.getByRole('button', { name: 'Queue' }).click()
+    await page.getByRole('menuitem', { name: 'Steer' }).click()
+    await dialog.getByRole('button', { name: 'Steer' }).waitFor({ timeout: 10_000 })
+    await page.keyboard.press('Escape')
+
+    const input = page.locator('textarea').first()
+    const settled = scaffold.whenTurnSettled(30_000)
+    await input.fill(PROMPT)
+    await input.press('Enter')
+    await page.getByRole('button', { name: 'Stop generating' }).waitFor({ timeout: 10_000 })
+
+    const queuedText = 'Queued by the complementary Cmd+Enter shortcut.'
+    await input.fill(queuedText)
+    await input.press('Meta+Enter')
+    const queuedRow = page.locator('[data-queue-dock]').getByRole('listitem').filter({ hasText: queuedText })
+    await queuedRow.getByText(queuedText, { exact: true }).waitFor({ timeout: 10_000 })
+    expect(await page.locator('[data-pending-steering]').filter({ hasText: queuedText }).count()).toBe(0)
+    expect(sessionEvents.filter(event => event.type === 'steering/message')).toHaveLength(0)
+
+    // Remove the asserted Queue row, then finish the recorded question turn
+    // so replay teardown still proves that every fixture call was consumed.
+    await queuedRow.getByRole('button', { name: 'Remove queued message' }).click()
+    const composer = page.locator('[data-question-key]')
+    await composer.waitFor({ timeout: 30_000 })
+    await composer.getByRole('radio', { name: 'Yes' }).click()
+    await composer.getByRole('radio', { name: 'Yes' }).press('Enter')
+    await settled
+    expect(tripwire.pageErrors).toEqual([])
+    expect(tripwire.warnings).toEqual([])
+  }, 90_000)
+})