@@ -66,6 +66,12 @@ version with its date and start a fresh empty `[Unreleased]` above it.
   failure) now fully clean up the streaming state and queue indicator,
   so the composer no longer stays stuck as "streaming" after an early
   send error.
+- Steering a queued message no longer drops or misplaces the opening of
+  the steered reply: chunks that arrive while the chat swaps streaming
+  bubbles are buffered and replayed into the fresh bubble in order.
+- The steered reply streams incrementally again: the interrupted turn's
+  receipt no longer triggers a context-usage request that stalled the
+  response consumer, which made the whole reply appear only at the end.
 
 ## [1.0.5] - 2026-08-18
 
 
@@ -79,6 +79,13 @@ export class InputController {
   private readonly inputCommands: InputCommandController;
   private readonly queuedMessages: QueuedMessageController;
   private activeStreamingAssistantMessage: ChatMessage | null = null;
+  // While a steer splice is swapping the render target (finalizing the old
+  // bubble is async), the send loop buffers successor chunks instead of
+  // rendering them into the old bubble; the splice replays them into the
+  // fresh bubble afterwards. Without this, the steered reply's opening
+  // tokens land in the interrupted bubble and look lost/misplaced.
+  private steerSpliceActive = false;
+  private steerSpliceBuffer: StreamChunk[] = [];
   // Contract: `user_message_start` / `assistant_message_start` boundary
   // chunks currently have no producer in the runtime — they are a reserved
   // mechanism, so the handlers below are dormant. Steering relies on
@@ -393,6 +400,11 @@ export class InputController {
           continue;
         }
 
+        if (this.steerSpliceActive) {
+          this.steerSpliceBuffer.push(chunk);
+          continue;
+        }
+
         await streamController.handleStreamChunk(
           chunk,
           this.activeStreamingAssistantMessage ?? assistantMsg,
@@ -569,13 +581,53 @@ export class InputController {
     if (!text) return false;
     const accepted = this.getAgentService()?.steerTurn?.(text) ?? false;
     if (!accepted) return false;
-    void this.spliceRuntimeUserMessage({
+    this.beginSteerSplice({
       displayContent: turn.displayContent,
       persistedContent: text,
     });
     return true;
   }
 
+  /**
+   * Runs the steer splice with chunk buffering active: successor chunks that
+   * arrive while the splice awaits the old bubble's finalization are held
+   * back and replayed into the fresh bubble once the splice completes.
+   */
+  private beginSteerSplice(details: { displayContent: string; persistedContent?: string }): void {
+    if (!this.steerSpliceActive) {
+      this.steerSpliceActive = true;
+      this.steerSpliceBuffer = [];
+    }
+    void this.spliceRuntimeUserMessage(details)
+      .catch(() => undefined)
+      .then(() => this.drainSteerSpliceBuffer())
+      .catch(() => {
+        this.steerSpliceActive = false;
+        this.steerSpliceBuffer = [];
+      });
+  }
+
+  /** Replays chunks buffered during the splice, then reopens direct rendering. */
+  private async drainSteerSpliceBuffer(): Promise<void> {
+    try {
+      while (this.steerSpliceBuffer.length > 0) {
+        const chunk = this.steerSpliceBuffer.shift()!;
+        const target = this.activeStreamingAssistantMessage;
+        if (target) await this.deps.streamController.handleStreamChunk(chunk, target);
+      }
+    } catch (error) {
+      const target = this.activeStreamingAssistantMessage;
+      if (target) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        await this.deps.streamController
+          .handleStreamChunk({ type: 'error', content: message }, target)
+          .catch(() => undefined);
+      }
+    } finally {
+      this.steerSpliceActive = false;
+    }
+  }
+
   private async buildTurnSubmission(options: {
     content: string;
     images?: ChatMessage['images'];
 
@@ -145,6 +145,19 @@ export class QoderResponseRouter {
 
     if (!isTurnCompleteMessage(message)) return;
 
+    // A priority-'now' steer emits an aborted result for the interrupted
+    // turn, but the persistent Query is already running its successor turn.
+    // Do not ask the Query for context usage here: that control request waits
+    // for the successor to become idle, which blocks this sole response
+    // consumer and batches every successor delta until the turn finishes.
+    // The message channel must also remain active so another steer can be
+    // accepted while the successor is running.
+    if (isAbortedResult(message)) {
+      handler?.resetStreamText();
+      handler?.resetStreamThinking();
+      return;
+    }
+
     const contextUsageChunk = await this.deps.turnTracker.fetchContextUsage({
       query: this.deps.getCurrentQuery(),
       isCurrentQuery: query => this.deps.getCurrentQuery() === query,
@@ -160,13 +173,7 @@ export class QoderResponseRouter {
     if (handler) {
       handler.resetStreamText();
       handler.resetStreamThinking();
-      // A deliberately aborted turn (Esc or priority-'now' steer) is followed
-      // by its successor turn or by consumer teardown — never by session
-      // idle with the handler still waiting. Keep the handler alive so the
-      // successor's chunks keep streaming into the same turn generator.
-      if (!isAbortedResult(message)) {
-        handler.onDone();
-      }
+      handler.onDone();
     } else {
       await this.flushAutoTurnBuffer();
     }
 
@@ -7,10 +7,11 @@ import { createResponseHandler } from '@/qoder/runtime/types';
 
 function createRouterHarness() {
   const onTurnComplete = jest.fn();
+  const fetchContextUsage = jest.fn().mockResolvedValue(null);
   const deps = {
     turnTracker: {
       getTransformOptions: () => ({}),
-      fetchContextUsage: async () => null,
+      fetchContextUsage,
       bufferUsage: (chunk: StreamChunk) => chunk,
       updateContextWindow: () => null,
       record: jest.fn(),
@@ -35,7 +36,7 @@ function createRouterHarness() {
   });
   router.register(handler);
 
-  return { router, handler, chunks, events, onTurnComplete };
+  return { router, handler, chunks, events, fetchContextUsage, onTurnComplete };
 }
 
 function buildAbortResult(): SDKResultError {
@@ -54,18 +55,27 @@ describe('QoderResponseRouter', () => {
 
       await router.route(buildAbortResult());
 
-      expect(onTurnComplete).toHaveBeenCalledTimes(1);
+      expect(onTurnComplete).not.toHaveBeenCalled();
       expect(events.onDone).not.toHaveBeenCalled();
     });
 
+    it('does not block successor streaming on a context-usage request', async () => {
+      const { router, fetchContextUsage } = createRouterHarness();
+
+      await router.route(buildAbortResult());
+
+      expect(fetchContextUsage).not.toHaveBeenCalled();
+    });
+
     it('completes the handler on the successor turn result', async () => {
-      const { router, events } = createRouterHarness();
+      const { router, events, onTurnComplete } = createRouterHarness();
 
       await router.route(buildAbortResult());
       expect(events.onDone).not.toHaveBeenCalled();
 
       await router.route(buildSDKMessage({ type: 'result', subtype: 'success' }));
       expect(events.onDone).toHaveBeenCalledTimes(1);
+      expect(onTurnComplete).toHaveBeenCalledTimes(1);
     });
 
     it('routes nothing to the handler for an abort receipt', async () => {