@@ -81,3 +81,68 @@ describe('useQueueUi inputBoxTitle', () => {
     expect(title).toContain('click to expand')
   })
 })
+
+/** Renders the hook's composer placeholder for the given run/queue state. */
+const placeholderFor = async (params: {
+  queuePaused?: boolean
+  queuedMessages?: QueuedMessage[]
+  terminalWidth?: number
+  steersRun?: boolean
+}) => {
+  let placeholder: string | undefined
+  const terminalWidth = params.terminalWidth ?? 100
+  const Harness = () => {
+    placeholder = useQueueUi({
+      queuePaused: params.queuePaused ?? false,
+      queuedMessages: params.queuedMessages ?? [],
+      separatorWidth: terminalWidth,
+      terminalWidth,
+      steersRun: params.steersRun,
+    }).inputPlaceholder
+    return <text>x</text>
+  }
+
+  const setup = await createTestRenderer({ width: 20, height: 2 })
+  const root = createRoot(setup.renderer)
+  flushSync(() => root.render(<Harness />))
+  await setup.renderOnce()
+  flushSync(() => root.unmount())
+  setup.renderer.destroy()
+  return placeholder
+}
+
+describe('useQueueUi inputPlaceholder', () => {
+  test('idle: the ordinary prompt', async () => {
+    expect(await placeholderFor({})).toBe(
+      'Enter a coding task or / for commands',
+    )
+  })
+
+  test('mid-run: says Enter adds to the current task', async () => {
+    expect(await placeholderFor({ steersRun: true })).toBe(
+      'Add to the current task (/ for commands)',
+    )
+    expect(await placeholderFor({ steersRun: true, terminalWidth: 50 })).toBe(
+      'Add to the current task',
+    )
+  })
+
+  test('mid-run with messages queued: no hint, since the next one queues too', async () => {
+    expect(
+      await placeholderFor({
+        steersRun: true,
+        queuedMessages: [message('first task')],
+      }),
+    ).toBe('Enter a coding task or / for commands')
+  })
+
+  test('a paused queue keeps its cancel hint', async () => {
+    expect(
+      await placeholderFor({
+        steersRun: true,
+        queuePaused: true,
+        queuedMessages: [message('first task')],
+      }),
+    ).toBe('Ctrl-C to cancel queued messages')
+  })
+})
@@ -13,6 +13,11 @@ import { useQueueControls } from './use-queue-controls'
 import { useQueueUi } from './use-queue-ui'
 import { useTimeout } from './use-timeout'
 import { useChatRuntime } from '../contexts/chat-runtime-context'
+import { useChatStore } from '../state/chat-store'
+import {
+  sponsoredTurnHoldsQueue,
+  useSponsoredRunStore,
+} from '../state/sponsored-run-store'
 
 import type { QueuedMessage, StreamStatus } from './use-message-queue'
 import type { PendingAttachment } from '../types/store'
@@ -116,6 +121,15 @@ export function useChatStreaming({
     clearQueue,
   } = runtime
 
+  // A plain message sent now joins the running task. Not during a sponsored
+  // turn: it has no steering mailbox, so messages wait in the queue.
+  const isChainInProgress = useChatStore((state) => state.isChainInProgress)
+  const sponsoredHoldsQueue = useSponsoredRunStore((state) =>
+    sponsoredTurnHoldsQueue(state.snapshot),
+  )
+  const steersRun =
+    (isStreaming || isChainInProgress) && !sponsoredHoldsQueue
+
   // Queue UI
   const {
     queuedCount,
@@ -127,6 +141,7 @@ export function useChatStreaming({
     queuedMessages,
     separatorWidth,
     terminalWidth,
+    steersRun,
   })
 
   // Exit handling
 
@@ -11,6 +11,8 @@ interface UseQueueUiParams {
   queuedMessages: QueuedMessage[]
   separatorWidth: number
   terminalWidth: number
+  /** A run the user's next plain message will be added to (steering). */
+  steersRun?: boolean
 }
 
 /** Below this the title has no room for a second segment, so the expand hint
@@ -22,6 +24,7 @@ export const useQueueUi = ({
   queuedMessages,
   separatorWidth,
   terminalWidth,
+  steersRun = false,
 }: UseQueueUiParams) => {
   const queuedCount = queuedMessages.length
   const shouldShowQueuePreview = queuedCount > 0 && !queuePaused
@@ -62,8 +65,18 @@ export const useQueueUi = ({
       return 'Ctrl-C to cancel queued messages'
     }
 
+    // Mid-run, Enter adds the message to the running task rather than
+    // queueing a new one (the router's steering path). Say so: users expected
+    // a queue and read the agent answering it as their first task skipped.
+    // With messages already queued, a submit queues too, so no hint then.
+    if (steersRun && queuedCount === 0) {
+      return terminalWidth < 65
+        ? 'Add to the current task'
+        : 'Add to the current task (/ for commands)'
+    }
+
     return base
-  }, [queuePaused, queuedCount, terminalWidth])
+  }, [queuePaused, queuedCount, terminalWidth, steersRun])
 
   return {
     queuedCount,
 
@@ -25,6 +25,7 @@ import { APICallError, RetryError } from 'ai'
 import { z } from 'zod/v4'
 
 import { loopAgentSteps } from '../run-agent-step'
+import { frameSteeringText, STEERING_NOTE } from '../util/messages'
 import { clearAgentGeneratorCache } from '../run-programmatic-step'
 import {
   MAX_CONSECUTIVE_STREAM_RECOVERIES,
@@ -1600,9 +1601,9 @@ describe('loopAgentSteps - runAgentStep vs runProgrammaticStep behavior', () =>
         },
       })
       const expected = [
-        [{ type: 'text', text: 'Text correction' }],
-        [{ type: 'text', text: 'Compare both images' }, ...images],
-        [images[1]],
+        [{ type: 'text', text: frameSteeringText('Text correction') }],
+        [{ type: 'text', text: frameSteeringText('Compare both images') }, ...images],
+        [{ type: 'text', text: frameSteeringText('') }, images[1]],
       ]
       expect(seen).toHaveLength(2)
       for (const content of expected) {
@@ -1643,6 +1644,46 @@ describe('loopAgentSteps - runAgentStep vs runProgrammaticStep behavior', () =>
       expect((steered as { tags?: string[] }).tags).toContain('USER_PROMPT')
     })
 
+    it('frames a steered message exactly once, as sent mid-turn, so the earlier request is kept', async () => {
+      const steerText = 'also add a README'
+      const seen: unknown[][] = []
+      let drained = false
+      await loopAgentSteps({
+        ...loopAgentStepsBaseParams,
+        prompt: 'build the login page',
+        drainSteeringMessages: () => {
+          if (drained) return []
+          drained = true
+          // The second is already framed (a host re-delivering it): not re-wrapped.
+          return [steerText, frameSteeringText('and a footer')]
+        },
+        promptAiSdkStream: async function* ({ messages }) {
+          seen.push(structuredClone(messages))
+          yield createToolCallChunk('end_turn', {})
+          return promptSuccess(`step-${seen.length}`)
+        },
+      })
+
+      expect(seen).toHaveLength(2)
+      const request = JSON.stringify(seen[1])
+      // The original request is still there, unframed.
+      expect(request).toContain('build the login page')
+      expect(request).not.toContain(
+        JSON.stringify(frameSteeringText('build the login page')).slice(1, -1),
+      )
+      for (const text of [steerText, 'and a footer']) {
+        expect(seen[1]).toContainEqual(
+          expect.objectContaining({
+            role: 'user',
+            content: [{ type: 'text', text: frameSteeringText(text) }],
+          }),
+        )
+      }
+      // One note per steered message, never a nested frame.
+      expect(request.split(STEERING_NOTE).length - 1).toBe(2)
+      expect(request.split('<user_message_sent_while_working>').length - 1).toBe(2)
+    })
+
     it('does not extend the turn when no steering messages arrive', async () => {
       const result = await loopAgentSteps({
         ...loopAgentStepsBaseParams,
 
@@ -76,6 +76,7 @@ import {
   withSystemTags as withSystemTags,
   buildUserMessageContent,
   expireMessages,
+  frameSteeringContent,
 } from './util/messages'
 import {
   estimateContextTokens,
@@ -1428,15 +1429,18 @@ export async function loopAgentSteps(
       // Steering: if the host fed user messages while this step ran, append them
       // now (the step's LLM call + tools have completed, so history is in a clean
       // state) and keep the turn going so the agent responds to them next step,
-      // rather than waiting for the whole turn to finish.
+      // rather than waiting for the whole turn to finish. Each message is
+      // framed as sent mid-turn: bare, the model read it as the whole new
+      // request and dropped the one it was working on.
       const steered = await params.drainSteeringMessages?.()
       if (steered?.length) {
         const messages = steered.map((message) =>
           userMessage({
-            content:
+            content: frameSteeringContent(
               typeof message === 'string'
                 ? buildUserMessageContent(message, undefined)
                 : buildUserMessageContent(message.prompt, undefined, message.content),
+            ),
             tags: ['USER_PROMPT'],
             keepDuringTruncation: true,
           }),
 
@@ -10,7 +10,7 @@ import {
   getProjectFileTreePrompt,
   getSystemInfoPrompt,
 } from '../system-prompt/prompts'
-import { parseUserMessage } from '../util/messages'
+import { parseUserMessage, unwrapSteeringText } from '../util/messages'
 
 import type { AgentTemplate, PlaceholderValue } from './types'
 import type { Logger } from '@codebuff/common/types/contracts/logger'
@@ -80,7 +80,7 @@ export async function formatPrompt(
   const lastUserMessage = messageHistory.findLast(isUserInputMessage)
   const lastUserInput = lastUserMessage
     ? (parseUserMessage(lastUserMessage.content[0].text) ??
-      lastUserMessage.content[0].text)
+      unwrapSteeringText(lastUserMessage.content[0].text))
     : undefined
 
   const agentTemplate = agentState.agentType
 
@@ -19,6 +19,10 @@ import {
   messagesWithSystem,
   getPreviouslyReadFiles,
   buildUserMessageContent,
+  frameSteeringContent,
+  frameSteeringText,
+  STEERING_NOTE,
+  unwrapSteeringText,
 } from '../../util/messages'
 import * as tokenCounter from '../token-counter'
 
@@ -733,3 +737,38 @@ describe('getPreviouslyReadFiles', () => {
     expect(result).toEqual([])
   })
 })
+
+describe('steering framing', () => {
+  it('wraps the text with the mid-turn note', () => {
+    const framed = frameSteeringText('also add tests')
+    expect(framed).toBe(
+      `<user_message_sent_while_working>\nalso add tests\n</user_message_sent_while_working>\n\n${STEERING_NOTE}`,
+    )
+  })
+
+  it('never double-wraps', () => {
+    const once = frameSteeringText('also add tests')
+    expect(frameSteeringText(once)).toBe(once)
+  })
+
+  it('unwraps back to exactly what the user typed', () => {
+    const text = 'line one\n\nline two'
+    expect(unwrapSteeringText(frameSteeringText(text))).toBe(text)
+    expect(unwrapSteeringText('plain prompt')).toBe('plain prompt')
+  })
+
+  it('frames the first text part and keeps images', () => {
+    const image = {
+      type: 'image' as const,
+      image: 'Zmlyc3Q=',
+      mediaType: 'image/png',
+    }
+    expect(
+      frameSteeringContent([{ type: 'text', text: 'look' }, image]),
+    ).toEqual([{ type: 'text', text: frameSteeringText('look') }, image])
+    expect(frameSteeringContent([image])).toEqual([
+      { type: 'text', text: frameSteeringText('') },
+      image,
+    ])
+  })
+})
@@ -67,6 +67,45 @@ export function buildUserMessageContent(
   ]
 }
 
+const STEERING_TAG = 'user_message_sent_while_working'
+const STEERING_OPEN = `<${STEERING_TAG}>`
+const STEERING_CLOSE = closeXml(STEERING_TAG)
+export const STEERING_NOTE =
+  'The user sent this while you were working. Continue the earlier request too, unless this message changes or cancels it.'
+
+/**
+ * Frame a message the user sent mid-turn (steering). Delivered bare, it reads
+ * as the whole new request, and models dropped the task they were doing to
+ * answer it. Idempotent: already-framed text is returned unchanged.
+ */
+export function frameSteeringText(text: string): string {
+  if (text.startsWith(STEERING_OPEN)) return text
+  return `${STEERING_OPEN}\n${text}\n${STEERING_CLOSE}\n\n${STEERING_NOTE}`
+}
+
+/** The user's own words from a framed steering message; other text unchanged. */
+export function unwrapSteeringText(text: string): string {
+  if (!text.startsWith(STEERING_OPEN)) return text
+  const end = text.lastIndexOf(STEERING_CLOSE)
+  if (end === -1) return text
+  return text.slice(STEERING_OPEN.length, end).replace(/^\n|\n$/g, '')
+}
+
+/** Frame the text of a steering message's content, keeping its images. */
+export function frameSteeringContent(
+  content: Array<TextPart | ImagePart>,
+): Array<TextPart | ImagePart> {
+  const index = content.findIndex((part) => part.type === 'text')
+  if (index === -1) {
+    return [{ type: 'text', text: frameSteeringText('') }, ...content]
+  }
+  return content.map((part, i) =>
+    i === index && part.type === 'text'
+      ? { ...part, text: frameSteeringText(part.text) }
+      : part,
+  )
+}
+
 export function parseUserMessage(str: string): string | undefined {
   const match = str.match(/<user_message>(.*?)<\/user_message>/s)
   return match ? match[1] : undefined