From cc6e4876d2895081f93b0b1dc24c9b1081027fda Mon Sep 17 00:00:00 2001
From: lihong <leehom0123@qq.com>
Date: Tue, 15 Sep 2026 23:27:16 +0800
Subject: [PATCH 1/4] feat(chat): click a queued message to insert it into the
 running turn

The queue rows above the composer only offered reorder/edit/delete, so a
queued prompt had to wait for the turn to end even on sessions where the
composer can steer a draft into the RUNNING turn (native `_session/steering`
push, or the `check_user_feedback` pull note). Surface that same delivery
per-row: each queued item gets an insert button riding the session's live-
feedback channel, with the composer's honest copy (Zap = instant insert on
native, Clock = waiting note on pull).

- message-queue-display: per-row steer button + single-flight guard so two
  rows can't race the same channel.
- conversation-detail-panel: handleQueueSteer reuses `feedback.steer` with
  the same block/text encoding as the composer's send; success removes the
  row, the turn-end NoActiveTurn race keeps it queued (auto-flush delivers
  it with the next turn), any other failure keeps the row and toasts.
- The button is offered only when the feature is on, the session has a
  working channel, and a turn is in flight.
---
 src/components/chat/chat-input.tsx            |  8 ++
 src/components/chat/conversation-shell.tsx    |  6 ++
 .../chat/message-queue-display.test.tsx       | 91 +++++++++++++++++++
 src/components/chat/message-queue-display.tsx | 69 +++++++++++++-
 .../conversation-detail-panel.tsx             | 60 +++++++++++-
 src/i18n/messages/ar.json                     |  4 +-
 src/i18n/messages/de.json                     |  4 +-
 src/i18n/messages/en.json                     |  4 +-
 src/i18n/messages/es.json                     |  4 +-
 src/i18n/messages/fr.json                     |  4 +-
 src/i18n/messages/ja.json                     |  4 +-
 src/i18n/messages/ko.json                     |  4 +-
 src/i18n/messages/pt.json                     |  4 +-
 src/i18n/messages/zh-CN.json                  |  4 +-
 src/i18n/messages/zh-TW.json                  |  4 +-
 15 files changed, 261 insertions(+), 13 deletions(-)
 create mode 100644 src/components/chat/message-queue-display.test.tsx

diff --git a/src/components/chat/chat-input.tsx b/src/components/chat/chat-input.tsx
index a8ce461e35..6700ffd27d 100644
--- a/src/components/chat/chat-input.tsx
+++ b/src/components/chat/chat-input.tsx
@@ -52,6 +52,11 @@ interface ChatInputProps {
   onQueueReorder?: (items: QueuedMessage[]) => void
   onQueueEdit?: (id: string) => void
   onQueueDelete?: (id: string) => void
+  /** Insert one queued item into the RUNNING turn over the session's
+   *  live-feedback channel (see `MessageQueueDisplayProps.onSteerItem`).
+   *  Threaded straight through; present only while a turn is in flight and
+   *  the session has a working channel. */
+  onQueueSteer?: (id: string) => Promise<void> | void
   editingItemId?: string | null
   editingDraftText?: string | null
   editingDraftBlocks?: PromptInputBlock[] | null
@@ -121,6 +126,7 @@ export const ChatInput = memo(function ChatInput({
   onQueueReorder,
   onQueueEdit,
   onQueueDelete,
+  onQueueSteer,
   editingItemId,
   editingDraftText,
   editingDraftBlocks,
@@ -187,6 +193,8 @@ export const ChatInput = memo(function ChatInput({
             onEdit={onQueueEdit}
             onDelete={onQueueDelete}
             editingItemId={editingItemId ?? null}
+            onSteerItem={onQueueSteer}
+            steerChannel={steerChannel}
           />
         )}
       <MessageInput
diff --git a/src/components/chat/conversation-shell.tsx b/src/components/chat/conversation-shell.tsx
index ef5af5a24f..a5157879b7 100644
--- a/src/components/chat/conversation-shell.tsx
+++ b/src/components/chat/conversation-shell.tsx
@@ -118,6 +118,10 @@ interface ConversationShellProps {
   onQueueReorder?: (items: QueuedMessage[]) => void
   onQueueEdit?: (id: string) => void
   onQueueDelete?: (id: string) => void
+  /** Insert one queued item into the RUNNING turn over the session's
+   *  live-feedback channel; threaded straight through to the composer's
+   *  queue list. See `ChatInputProps.onQueueSteer`. */
+  onQueueSteer?: (id: string) => Promise<void> | void
   editingItemId?: string | null
   editingDraftText?: string | null
   editingDraftBlocks?: PromptInputBlock[] | null
@@ -196,6 +200,7 @@ export function ConversationShell({
   onQueueReorder,
   onQueueEdit,
   onQueueDelete,
+  onQueueSteer,
   editingItemId,
   editingDraftText,
   editingDraftBlocks,
@@ -368,6 +373,7 @@ export function ConversationShell({
               onQueueReorder={onQueueReorder}
               onQueueEdit={onQueueEdit}
               onQueueDelete={onQueueDelete}
+              onQueueSteer={onQueueSteer}
               editingItemId={editingItemId}
               editingDraftText={editingDraftText}
               editingDraftBlocks={editingDraftBlocks}
diff --git a/src/components/chat/message-queue-display.test.tsx b/src/components/chat/message-queue-display.test.tsx
new file mode 100644
index 0000000000..c54df54335
--- /dev/null
+++ b/src/components/chat/message-queue-display.test.tsx
@@ -0,0 +1,91 @@
+import { render, screen, cleanup, waitFor } from "@testing-library/react"
+import userEvent from "@testing-library/user-event"
+import { NextIntlClientProvider } from "next-intl"
+import { afterEach, describe, expect, it, vi } from "vitest"
+
+import enMessages from "@/i18n/messages/en.json"
+import type { QueuedMessage } from "@/hooks/use-message-queue"
+
+import { MessageQueueDisplay } from "./message-queue-display"
+
+const TQ = enMessages.Folder.chat.messageQueue
+
+function item(id: string, text: string): QueuedMessage {
+  return {
+    id,
+    draft: { blocks: [{ type: "text", text }], displayText: text },
+    modeId: null,
+  }
+}
+
+function renderDisplay(
+  props: Partial<React.ComponentProps<typeof MessageQueueDisplay>> = {}
+) {
+  return render(
+    <NextIntlClientProvider locale="en" messages={enMessages}>
+      <MessageQueueDisplay
+        queue={[item("q1", "use pnpm"), item("q2", "run the tests")]}
+        onReorder={vi.fn()}
+        onEdit={vi.fn()}
+        onDelete={vi.fn()}
+        editingItemId={null}
+        {...props}
+      />
+    </NextIntlClientProvider>
+  )
+}
+
+afterEach(cleanup)
+
+describe("MessageQueueDisplay click-to-insert", () => {
+  it("offers no insert button without a steering handler", () => {
+    renderDisplay()
+    expect(screen.queryByTitle(TQ.steerItemNow)).toBeNull()
+    expect(screen.queryByTitle(TQ.steerItemAsNote)).toBeNull()
+  })
+
+  it("inserts the row the button belongs to, with the native promise", async () => {
+    const onSteerItem = vi.fn(async () => {})
+    renderDisplay({ onSteerItem, steerChannel: "native" })
+
+    const buttons = screen.getAllByTitle(TQ.steerItemNow)
+    expect(buttons).toHaveLength(2)
+
+    await userEvent.click(buttons[1])
+    expect(onSteerItem).toHaveBeenCalledWith("q2")
+  })
+
+  it("keys the copy to the pull channel (waiting note, not an insert)", async () => {
+    const onSteerItem = vi.fn(async () => {})
+    renderDisplay({ onSteerItem, steerChannel: "pull" })
+
+    // The insert label must not appear on a pull session — it would promise
+    // an instant injection the channel can't deliver.
+    expect(screen.queryByTitle(TQ.steerItemNow)).toBeNull()
+    await userEvent.click(screen.getAllByTitle(TQ.steerItemAsNote)[0])
+    expect(onSteerItem).toHaveBeenCalledWith("q1")
+  })
+
+  it("disables every row while an insert is in flight (single-flight)", async () => {
+    let release: () => void = () => {}
+    const onSteerItem = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          release = resolve
+        })
+    )
+    renderDisplay({ onSteerItem, steerChannel: "native" })
+
+    const buttons = screen.getAllByTitle(TQ.steerItemNow) as HTMLButtonElement[]
+    await userEvent.click(buttons[0])
+    await waitFor(() => expect(onSteerItem).toHaveBeenCalledTimes(1))
+
+    expect(buttons[1].disabled).toBe(true)
+    // A second click while in flight must not race the same channel.
+    await userEvent.click(buttons[1])
+    expect(onSteerItem).toHaveBeenCalledTimes(1)
+
+    release()
+    await waitFor(() => expect(buttons[1].disabled).toBe(false))
+  })
+})
diff --git a/src/components/chat/message-queue-display.tsx b/src/components/chat/message-queue-display.tsx
index 1b8b88385c..f9441fec22 100644
--- a/src/components/chat/message-queue-display.tsx
+++ b/src/components/chat/message-queue-display.tsx
@@ -1,8 +1,8 @@
 "use client"
 
-import { useCallback, type PointerEvent } from "react"
+import { useCallback, useRef, useState, type PointerEvent } from "react"
 import { Reorder, useDragControls } from "motion/react"
-import { GripVertical, Pencil, X } from "lucide-react"
+import { Clock, GripVertical, Pencil, X, Zap } from "lucide-react"
 import { useTranslations } from "next-intl"
 import { cn } from "@/lib/utils"
 import type { QueuedMessage } from "@/hooks/use-message-queue"
@@ -13,6 +13,18 @@ interface MessageQueueDisplayProps {
   onEdit: (id: string) => void
   onDelete: (id: string) => void
   editingItemId: string | null
+  /**
+   * Send one queued item straight into the RUNNING turn over the session's
+   * live-feedback channel (same delivery as the composer's mid-turn send).
+   * Present only while the session has a working channel AND a turn is in
+   * flight; the host decides whether the row is removed (it stays queued on
+   * the turn-end race). Resolves once delivery is settled.
+   */
+  onSteerItem?: (id: string) => Promise<void> | void
+  /** Which channel {@link onSteerItem} rides; picks the honest icon/copy,
+   *  mirroring the composer's split-button (`Zap` = instant insert,
+   *  `Clock` = note the agent reads on its next check). */
+  steerChannel?: "native" | "pull"
 }
 
 interface QueueItemProps {
@@ -21,6 +33,11 @@ interface QueueItemProps {
   isEditing: boolean
   onEdit: (id: string) => void
   onDelete: (id: string) => void
+  onSteerItem?: (id: string) => Promise<void> | void
+  steerChannel: "native" | "pull"
+  /** Whether an insert from THIS row is in flight (disables its button). */
+  steering: boolean
+  onSteerStart: (id: string) => Promise<void>
 }
 
 function QueueItem({
@@ -29,6 +46,10 @@ function QueueItem({
   isEditing,
   onEdit,
   onDelete,
+  onSteerItem,
+  steerChannel,
+  steering,
+  onSteerStart,
 }: QueueItemProps) {
   const t = useTranslations("Folder.chat.messageQueue")
   const dragControls = useDragControls()
@@ -67,6 +88,21 @@ function QueueItem({
       <span className="min-w-0 flex-1 truncate text-3xs text-foreground/80">
         {item.draft.displayText}
       </span>
+      {onSteerItem && (
+        <button
+          type="button"
+          onClick={() => void onSteerStart(item.id)}
+          disabled={steering}
+          className="shrink-0 rounded-sm p-0.5 hover:bg-muted-foreground/15 text-muted-foreground disabled:opacity-50"
+          title={t(steerChannel === "pull" ? "steerItemAsNote" : "steerItemNow")}
+        >
+          {steerChannel === "pull" ? (
+            <Clock className="h-2.5 w-2.5" />
+          ) : (
+            <Zap className="h-2.5 w-2.5" />
+          )}
+        </button>
+      )}
       <button
         type="button"
         onClick={() => onEdit(item.id)}
@@ -93,7 +129,32 @@ export function MessageQueueDisplay({
   onEdit,
   onDelete,
   editingItemId,
+  onSteerItem,
+  steerChannel = "pull",
 }: MessageQueueDisplayProps) {
+  // The id whose insert is in flight. A per-row `steering` would let a
+  // concurrent click on another row race the same channel; one shared id
+  // both disables the clicked row and (via `steeringId !== null`) the others
+  // — matching the composer's single-flight `steering` guard.
+  const [steeringId, setSteeringId] = useState<string | null>(null)
+  // Latest steeringId for the click handler's re-entrancy check without
+  // re-binding it on every state commit.
+  const steeringIdRef = useRef<string | null>(null)
+  steeringIdRef.current = steeringId
+
+  const handleSteerStart = useCallback(
+    async (id: string) => {
+      if (!onSteerItem || steeringIdRef.current !== null) return
+      setSteeringId(id)
+      try {
+        await onSteerItem(id)
+      } finally {
+        setSteeringId(null)
+      }
+    },
+    [onSteerItem]
+  )
+
   if (queue.length === 0) return null
 
   return (
@@ -113,6 +174,10 @@ export function MessageQueueDisplay({
             isEditing={editingItemId === item.id}
             onEdit={onEdit}
             onDelete={onDelete}
+            onSteerItem={onSteerItem}
+            steerChannel={steerChannel}
+            steering={steeringId !== null}
+            onSteerStart={handleSteerStart}
           />
         ))}
       </Reorder.Group>
diff --git a/src/components/conversations/conversation-detail-panel.tsx b/src/components/conversations/conversation-detail-panel.tsx
index 2c18e3ed28..9d9e4cefa9 100644
--- a/src/components/conversations/conversation-detail-panel.tsx
+++ b/src/components/conversations/conversation-detail-panel.tsx
@@ -89,7 +89,8 @@ import {
   shouldQueueDirectSend,
   shouldRejectDuplicateCreate,
 } from "@/lib/queue-flush"
-import { TurnBusyError } from "@/lib/turn-busy"
+import { TurnBusyError, isNoActiveTurnRejection } from "@/lib/turn-busy"
+import { toErrorMessage } from "@/lib/app-error"
 import {
   getConversationIdByExternalIdFromStore,
   getRuntimeSession,
@@ -239,6 +240,9 @@ const ConversationTabView = memo(function ConversationTabView({
   groupId,
 }: ConversationTabViewProps) {
   const t = useTranslations("Folder.conversation")
+  // Composer-namespace copy for the queue row's click-to-insert outcomes
+  // (same keys the composer's own mid-turn send reports).
+  const tCmp = useTranslations("Folder.chat.messageInput")
   const tWelcome = useTranslations("Folder.chat.welcomeInputPanel")
   const tDiag = useTranslations("DiagnosticsSettings")
   const sharedT = useTranslations("Folder.chat.shared")
@@ -2031,6 +2035,50 @@ const ConversationTabView = memo(function ConversationTabView({
     [feedbackSteer]
   )
 
+  // Click-to-insert for a queued row: send THAT item into the running turn
+  // over the same live-feedback channel the composer's mid-turn dropdown uses.
+  // The block/text encoding mirrors `handleSteerClick` in message-input (full
+  // blocks only when the draft holds more than text — the pull path rejects
+  // blocks as NoActiveTurn, which lands on the keep-queued fallback below).
+  // Success removes the row; the turn-end race leaves it queued so the
+  // auto-flush sends it with the next turn — never lost. Any other failure
+  // keeps the row untouched and surfaces the error.
+  const handleQueueSteer = useCallback(
+    async (id: string) => {
+      const item = msgQueue.find((m) => m.id === id)
+      if (!item) return
+      const draft = item.draft
+      const blocks = draft.blocks.some((b) => b.type !== "text")
+        ? draft.blocks
+        : undefined
+      const text = blocks
+        ? draft.displayText
+        : draft.blocks
+            .map((b) => (b.type === "text" ? b.text : ""))
+            .join("\n")
+            .trim()
+      if (!text) {
+        mqRemove(id)
+        return
+      }
+      try {
+        await feedbackSteer(text, blocks)
+        mqRemove(id)
+      } catch (err: unknown) {
+        if (isNoActiveTurnRejection(err)) {
+          // The turn ended mid-click — the queue flush will deliver it.
+          toast.info(tCmp("steerQueuedInstead"))
+          return
+        }
+        toast.error(
+          tCmp(feedback.channel === "pull" ? "steerNoteFailed" : "steerFailed"),
+          { description: toErrorMessage(err) }
+        )
+      }
+    },
+    [msgQueue, feedbackSteer, mqRemove, feedback.channel, tCmp]
+  )
+
   return (
     <ConversationShell
       topBanner={
@@ -2115,6 +2163,16 @@ const ConversationTabView = memo(function ConversationTabView({
       onQueueReorder={mqReorder}
       onQueueEdit={handleQueueEdit}
       onQueueDelete={mqRemove}
+      onQueueSteer={
+        // Same gate as the composer's mid-turn send, plus a turn actually in
+        // flight: a queued row can only be inserted into a RUNNING turn —
+        // idle sessions have the queue's own auto-flush for that.
+        feedback.featureEnabled &&
+        feedback.steerAvailable &&
+        connStatus === "prompting"
+          ? handleQueueSteer
+          : undefined
+      }
       editingItemId={mqEditingItemId}
       editingDraftText={editingQueueDraftText}
       editingDraftBlocks={editingQueueDraftBlocks}
diff --git a/src/i18n/messages/ar.json b/src/i18n/messages/ar.json
index a7b3d5d1f4..c05fdc07e1 100644
--- a/src/i18n/messages/ar.json
+++ b/src/i18n/messages/ar.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "حفظ",
         "cancelEdit": "إلغاء التعديل",
         "editItem": "تعديل",
-        "deleteItem": "حذف"
+        "deleteItem": "حذف",
+        "steerItemNow": "إدراج في الدور الحالي",
+        "steerItemAsNote": "إرسال كملاحظة للفحص التالي"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "الإعدادات > الوكلاء",
diff --git a/src/i18n/messages/de.json b/src/i18n/messages/de.json
index e18b9574cf..738a713c06 100644
--- a/src/i18n/messages/de.json
+++ b/src/i18n/messages/de.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "Speichern",
         "cancelEdit": "Bearbeitung abbrechen",
         "editItem": "Bearbeiten",
-        "deleteItem": "Entfernen"
+        "deleteItem": "Entfernen",
+        "steerItemNow": "In aktuellen Turn einfügen",
+        "steerItemAsNote": "Als Notiz für die nächste Abfrage senden"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "Einstellungen > Agenten",
diff --git a/src/i18n/messages/en.json b/src/i18n/messages/en.json
index 2e96fe7e47..d10f66487f 100644
--- a/src/i18n/messages/en.json
+++ b/src/i18n/messages/en.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "Save",
         "cancelEdit": "Cancel edit",
         "editItem": "Edit",
-        "deleteItem": "Remove"
+        "deleteItem": "Remove",
+        "steerItemNow": "Insert into current turn",
+        "steerItemAsNote": "Send as note for next check"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "Settings > Agents",
diff --git a/src/i18n/messages/es.json b/src/i18n/messages/es.json
index 71e101dc27..1bfc682cc5 100644
--- a/src/i18n/messages/es.json
+++ b/src/i18n/messages/es.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "Guardar",
         "cancelEdit": "Cancelar edición",
         "editItem": "Editar",
-        "deleteItem": "Eliminar"
+        "deleteItem": "Eliminar",
+        "steerItemNow": "Insertar en el turno actual",
+        "steerItemAsNote": "Enviar como nota para la próxima comprobación"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "Ajustes > Agentes",
diff --git a/src/i18n/messages/fr.json b/src/i18n/messages/fr.json
index 77f8d5c52e..aa04684f14 100644
--- a/src/i18n/messages/fr.json
+++ b/src/i18n/messages/fr.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "Enregistrer",
         "cancelEdit": "Annuler la modification",
         "editItem": "Modifier",
-        "deleteItem": "Supprimer"
+        "deleteItem": "Supprimer",
+        "steerItemNow": "Insérer dans le tour en cours",
+        "steerItemAsNote": "Envoyer comme note pour la prochaine vérification"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "Paramètres > Agents",
diff --git a/src/i18n/messages/ja.json b/src/i18n/messages/ja.json
index 14420120c2..43032a1947 100644
--- a/src/i18n/messages/ja.json
+++ b/src/i18n/messages/ja.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "保存",
         "cancelEdit": "編集をキャンセル",
         "editItem": "編集",
-        "deleteItem": "削除"
+        "deleteItem": "削除",
+        "steerItemNow": "現在のターンに挿入",
+        "steerItemAsNote": "メモとして送信し次回チェック時に読ませる"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "設定 > エージェント",
diff --git a/src/i18n/messages/ko.json b/src/i18n/messages/ko.json
index b212ef01c3..ce3d1ce6fd 100644
--- a/src/i18n/messages/ko.json
+++ b/src/i18n/messages/ko.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "저장",
         "cancelEdit": "편집 취소",
         "editItem": "편집",
-        "deleteItem": "삭제"
+        "deleteItem": "삭제",
+        "steerItemNow": "현재 턴에 삽입",
+        "steerItemAsNote": "메모로 보내 다음 점검 때 읽도록 함"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "설정 > 에이전트",
diff --git a/src/i18n/messages/pt.json b/src/i18n/messages/pt.json
index f72c741393..3a54375de6 100644
--- a/src/i18n/messages/pt.json
+++ b/src/i18n/messages/pt.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "Salvar",
         "cancelEdit": "Cancelar edição",
         "editItem": "Editar",
-        "deleteItem": "Remover"
+        "deleteItem": "Remover",
+        "steerItemNow": "Inserir na vez atual",
+        "steerItemAsNote": "Enviar como nota para a próxima verificação"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "Configurações > Agentes",
diff --git a/src/i18n/messages/zh-CN.json b/src/i18n/messages/zh-CN.json
index ef86afd4c6..78007fb7f9 100644
--- a/src/i18n/messages/zh-CN.json
+++ b/src/i18n/messages/zh-CN.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "保存",
         "cancelEdit": "取消编辑",
         "editItem": "编辑",
-        "deleteItem": "删除"
+        "deleteItem": "删除",
+        "steerItemNow": "插入当前回合",
+        "steerItemAsNote": "作为留言，供下次检查时读取"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "设置 > Agents",
diff --git a/src/i18n/messages/zh-TW.json b/src/i18n/messages/zh-TW.json
index 5734a40ca4..a7686f7f22 100644
--- a/src/i18n/messages/zh-TW.json
+++ b/src/i18n/messages/zh-TW.json
@@ -3092,7 +3092,9 @@
         "saveEdit": "儲存",
         "cancelEdit": "取消編輯",
         "editItem": "編輯",
-        "deleteItem": "刪除"
+        "deleteItem": "刪除",
+        "steerItemNow": "插入目前回合",
+        "steerItemAsNote": "作為留言，供下次檢查時讀取"
       },
       "welcomeInputPanel": {
         "agentsSettingsPath": "設定 > Agents",

From 642b0b33630111063af5d27db4035d7ab270ba0c Mon Sep 17 00:00:00 2001
From: lihong <leehom0123@qq.com>
Date: Wed, 16 Sep 2026 02:08:55 +0800
Subject: [PATCH 2/4] refactor(chat): share the steer payload encoding across
 both call sites

The queue row's click-to-insert repeated the composer's block/text encoding
verbatim. One shape, one builder: `buildSteerPayload(draft)` in prompt-draft
now owns the contract (full block list only when the draft holds more than
text; display text as the recorded note) and both the composer's mid-turn
send and the queue row call it, so the two can never drift.
---
 src/components/chat/message-input.tsx         | 15 +++-----
 .../conversation-detail-panel.tsx             | 27 +++++---------
 src/lib/prompt-draft.test.ts                  | 35 +++++++++++++++++++
 src/lib/prompt-draft.ts                       | 30 ++++++++++++++++
 4 files changed, 78 insertions(+), 29 deletions(-)

diff --git a/src/components/chat/message-input.tsx b/src/components/chat/message-input.tsx
index b268b33586..6510131c28 100644
--- a/src/components/chat/message-input.tsx
+++ b/src/components/chat/message-input.tsx
@@ -47,6 +47,7 @@ import { useShortcutSettings } from "@/hooks/use-shortcut-settings"
 import { imageFilesFromClipboardApi } from "@/lib/clipboard-images"
 import { toErrorMessage } from "@/lib/app-error"
 import { isNoActiveTurnRejection } from "@/lib/turn-busy"
+import { buildSteerPayload } from "@/lib/prompt-draft"
 import { ServerFileBrowserDialog } from "@/components/shared/server-file-browser-dialog"
 import { toast } from "sonner"
 import type {
@@ -1379,19 +1380,11 @@ export function MessageInput({
       resetComposer()
       toast.info(t("steerQueuedInstead"))
     }
-    const blocks = draft.blocks.some((b) => b.type !== "text")
-      ? draft.blocks
-      : undefined
-    const text = blocks
-      ? draft.displayText
-      : draft.blocks
-          .map((b) => (b.type === "text" ? b.text : ""))
-          .join("\n")
-          .trim()
-    if (!text) return
+    const payload = buildSteerPayload(draft)
+    if (!payload) return
     setSteering(true)
     try {
-      await onSteer(text, blocks)
+      await onSteer(payload.text, payload.blocks)
       resetComposer()
     } catch (err) {
       if (isNoActiveTurnRejection(err)) {
diff --git a/src/components/conversations/conversation-detail-panel.tsx b/src/components/conversations/conversation-detail-panel.tsx
index 9d9e4cefa9..92aaa08261 100644
--- a/src/components/conversations/conversation-detail-panel.tsx
+++ b/src/components/conversations/conversation-detail-panel.tsx
@@ -101,6 +101,7 @@ import {
 import { useShallow } from "zustand/react/shallow"
 import { useConversationDetail } from "@/hooks/use-conversation-detail"
 import {
+  buildSteerPayload,
   extractUserImagesFromDraft,
   getPromptDraftDisplayText,
 } from "@/lib/prompt-draft"
@@ -2037,32 +2038,22 @@ const ConversationTabView = memo(function ConversationTabView({
 
   // Click-to-insert for a queued row: send THAT item into the running turn
   // over the same live-feedback channel the composer's mid-turn dropdown uses.
-  // The block/text encoding mirrors `handleSteerClick` in message-input (full
-  // blocks only when the draft holds more than text — the pull path rejects
-  // blocks as NoActiveTurn, which lands on the keep-queued fallback below).
-  // Success removes the row; the turn-end race leaves it queued so the
-  // auto-flush sends it with the next turn — never lost. Any other failure
-  // keeps the row untouched and surfaces the error.
+  // The block/text encoding is the shared `buildSteerPayload` — one call site,
+  // no policy here beyond the row's own lifecycle: success removes the row;
+  // the turn-end race leaves it queued so the auto-flush sends it with the
+  // next turn — never lost. Any other failure keeps the row untouched and
+  // surfaces the error.
   const handleQueueSteer = useCallback(
     async (id: string) => {
       const item = msgQueue.find((m) => m.id === id)
       if (!item) return
-      const draft = item.draft
-      const blocks = draft.blocks.some((b) => b.type !== "text")
-        ? draft.blocks
-        : undefined
-      const text = blocks
-        ? draft.displayText
-        : draft.blocks
-            .map((b) => (b.type === "text" ? b.text : ""))
-            .join("\n")
-            .trim()
-      if (!text) {
+      const payload = buildSteerPayload(item.draft)
+      if (!payload) {
         mqRemove(id)
         return
       }
       try {
-        await feedbackSteer(text, blocks)
+        await feedbackSteer(payload.text, payload.blocks)
         mqRemove(id)
       } catch (err: unknown) {
         if (isNoActiveTurnRejection(err)) {
diff --git a/src/lib/prompt-draft.test.ts b/src/lib/prompt-draft.test.ts
index b11e9bb268..a4cfb5e806 100644
--- a/src/lib/prompt-draft.test.ts
+++ b/src/lib/prompt-draft.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, it } from "vitest"
 import type { PromptDraft, PromptInputBlock } from "@/lib/types"
 
 import {
+  buildSteerPayload,
   extractUserImagesFromDraft,
   extractUserResourcesFromDraft,
 } from "./prompt-draft"
@@ -27,6 +28,40 @@ const textResource: PromptInputBlock = {
   blob: null,
 }
 
+describe("buildSteerPayload", () => {
+  const text = (s: string): PromptInputBlock => ({ type: "text", text: s })
+
+  it("joins plain-text blocks and rides no block list", () => {
+    const d: PromptDraft = {
+      blocks: [text(" go "), text("left")],
+      displayText: "ignored",
+    }
+    expect(buildSteerPayload(d)).toEqual({ text: "go \nleft" })
+  })
+
+  it("returns null when there is no text at all", () => {
+    expect(buildSteerPayload({ blocks: [], displayText: "" })).toBeNull()
+    expect(
+      buildSteerPayload({ blocks: [text("   ")], displayText: "" })
+    ).toBeNull()
+  })
+
+  it("rides the full block list and display text once a non-text block is present", () => {
+    const blocks = [text("look"), grokImageResource]
+    const d: PromptDraft = { blocks, displayText: "look [附件 1]" }
+    expect(buildSteerPayload(d)).toEqual({
+      text: "look [附件 1]",
+      blocks,
+    })
+  })
+
+  it("attaches only a text resource too (it is not a text block)", () => {
+    const blocks = [text("note"), textResource]
+    const d: PromptDraft = { blocks, displayText: "note chip" }
+    expect(buildSteerPayload(d)?.blocks).toBe(blocks)
+  })
+})
+
 describe("extractUserImagesFromDraft", () => {
   it("includes native image blocks", () => {
     const images = extractUserImagesFromDraft(
diff --git a/src/lib/prompt-draft.ts b/src/lib/prompt-draft.ts
index add512c160..1a0a8a773e 100644
--- a/src/lib/prompt-draft.ts
+++ b/src/lib/prompt-draft.ts
@@ -71,6 +71,36 @@ export function getPromptDraftDisplayText(
   return trimmed || attachedResourcesFallback
 }
 
+/**
+ * Encode a draft for the live-feedback (steering) wire — the SINGLE place
+ * this encoding lives, shared by the composer's mid-turn send and the queue
+ * row's click-to-insert so the two can never drift.
+ *
+ * Returns `null` when there is nothing to steer (no text at all). Otherwise:
+ * - `blocks` carries the FULL block list only when the draft holds more than
+ *   plain text (image attachments, file badges). Only the native
+ *   `_session/steering` wire takes blocks — the pull path rejects them as
+ *   `NoActiveTurn`, which callers handle as their turn-end fallback.
+ * - `text` is the recorded/display form: the draft's display text when
+ *   blocks ride along, else the joined text blocks, trimmed.
+ */
+export function buildSteerPayload(draft: PromptDraft): {
+  text: string
+  blocks?: PromptInputBlock[]
+} | null {
+  const blocks = draft.blocks.some((b) => b.type !== "text")
+    ? draft.blocks
+    : undefined
+  const text = blocks
+    ? draft.displayText
+    : draft.blocks
+        .map((b) => (b.type === "text" ? b.text : ""))
+        .join("\n")
+        .trim()
+  if (!text) return null
+  return { text, ...(blocks ? { blocks } : {}) }
+}
+
 export function buildUserMessageTextPartsFromDraft(
   draft: PromptDraft,
   attachedResourcesFallback: string

From 90971662e93a1d611a022d063199ffc6b36b030b Mon Sep 17 00:00:00 2001
From: lihong <leehom0123@qq.com>
Date: Wed, 16 Sep 2026 09:58:30 +0800
Subject: [PATCH 3/4] style(chat): wrap the steer button title to satisfy
 prettier's 80-col rule

---
 src/components/chat/message-queue-display.tsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/components/chat/message-queue-display.tsx b/src/components/chat/message-queue-display.tsx
index f9441fec22..0def9bf6fa 100644
--- a/src/components/chat/message-queue-display.tsx
+++ b/src/components/chat/message-queue-display.tsx
@@ -94,7 +94,9 @@ function QueueItem({
           onClick={() => void onSteerStart(item.id)}
           disabled={steering}
           className="shrink-0 rounded-sm p-0.5 hover:bg-muted-foreground/15 text-muted-foreground disabled:opacity-50"
-          title={t(steerChannel === "pull" ? "steerItemAsNote" : "steerItemNow")}
+          title={t(
+            steerChannel === "pull" ? "steerItemAsNote" : "steerItemNow"
+          )}
         >
           {steerChannel === "pull" ? (
             <Clock className="h-2.5 w-2.5" />

From 52980d313252f55a640c80fbb7c941f277d0e189 Mon Sep 17 00:00:00 2001
From: xintaofei <itpkcn@gmail.com>
Date: Thu, 17 Sep 2026 07:39:51 +0800
Subject: [PATCH 4/4] fix(chat): don't send a queued row twice when its insert
 races the turn end
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A queued row stays in the queue for the whole click-to-insert round-trip, so
a turn ending mid-flight let the auto-flush dequeue and send the very row the
backend had just injected — the same instruction delivered twice. Hold the
flush until the insert settles; the hold is released in a `finally` and is a
flush dependency, so the queue resumes either way.

Three affordances also stop lying about what a click can do:

- An unsendable payload no longer REMOVES the row. That deleted queued
  content — attachments included — from a button that promises to send it.
- A row carrying attachments offers no insert on a pull-tool session. The
  backend rejects blocks there, so every click landed on the turn-end
  fallback, which for an already-queued row is a no-op.
- The row being edited offers none either: its text lives in the composer, so
  inserting would send the pre-edit draft and drop the row the save was headed
  for. The composer hides its own mid-turn send while editing for that reason.

The "more than plain text" test moves into `draftRidesBlocks`, shared with
`buildSteerPayload`, so the affordance and the encoding can't disagree.
---
 .../chat/message-queue-display.test.tsx       | 54 +++++++++++++++++++
 src/components/chat/message-queue-display.tsx | 21 +++++++-
 .../conversation-detail-panel-layout.test.ts  | 31 +++++++++++
 .../conversation-detail-panel.tsx             | 28 ++++++++--
 src/lib/prompt-draft.test.ts                  | 16 ++++++
 src/lib/prompt-draft.ts                       | 19 +++++--
 6 files changed, 159 insertions(+), 10 deletions(-)

diff --git a/src/components/chat/message-queue-display.test.tsx b/src/components/chat/message-queue-display.test.tsx
index c54df54335..629b2e3e25 100644
--- a/src/components/chat/message-queue-display.test.tsx
+++ b/src/components/chat/message-queue-display.test.tsx
@@ -18,6 +18,27 @@ function item(id: string, text: string): QueuedMessage {
   }
 }
 
+/** A queued draft that carries an attachment — only the native wire takes it. */
+function itemWithAttachment(id: string, text: string): QueuedMessage {
+  return {
+    id,
+    draft: {
+      blocks: [
+        { type: "text", text },
+        {
+          type: "resource",
+          uri: "clipboard://shot.png-1",
+          mime_type: "image/png",
+          text: null,
+          blob: "QUJD",
+        },
+      ],
+      displayText: text,
+    },
+    modeId: null,
+  }
+}
+
 function renderDisplay(
   props: Partial<React.ComponentProps<typeof MessageQueueDisplay>> = {}
 ) {
@@ -88,4 +109,37 @@ describe("MessageQueueDisplay click-to-insert", () => {
     release()
     await waitFor(() => expect(buttons[1].disabled).toBe(false))
   })
+
+  it("hides the note button on a pull row the channel cannot carry", () => {
+    // The pull tool delivers text only, so the backend rejects a draft with
+    // attachments there — the click could never insert anything. The row is
+    // still sent whole (attachment included) by the queue's own flush.
+    renderDisplay({
+      queue: [item("q1", "use pnpm"), itemWithAttachment("q2", "look at this")],
+      onSteerItem: vi.fn(async () => {}),
+      steerChannel: "pull",
+    })
+    expect(screen.getAllByTitle(TQ.steerItemAsNote)).toHaveLength(1)
+  })
+
+  it("keeps the attachment row insertable on the native wire", () => {
+    renderDisplay({
+      queue: [item("q1", "use pnpm"), itemWithAttachment("q2", "look at this")],
+      onSteerItem: vi.fn(async () => {}),
+      steerChannel: "native",
+    })
+    expect(screen.getAllByTitle(TQ.steerItemNow)).toHaveLength(2)
+  })
+
+  it("hides the insert on the row being edited (the composer owns its text)", () => {
+    // While a row is under edit its real content lives in the composer;
+    // inserting would send the stale pre-edit draft and drop the row the save
+    // was headed for.
+    renderDisplay({
+      onSteerItem: vi.fn(async () => {}),
+      steerChannel: "native",
+      editingItemId: "q1",
+    })
+    expect(screen.getAllByTitle(TQ.steerItemNow)).toHaveLength(1)
+  })
 })
diff --git a/src/components/chat/message-queue-display.tsx b/src/components/chat/message-queue-display.tsx
index 0def9bf6fa..7bfb1734ed 100644
--- a/src/components/chat/message-queue-display.tsx
+++ b/src/components/chat/message-queue-display.tsx
@@ -5,6 +5,7 @@ import { Reorder, useDragControls } from "motion/react"
 import { Clock, GripVertical, Pencil, X, Zap } from "lucide-react"
 import { useTranslations } from "next-intl"
 import { cn } from "@/lib/utils"
+import { draftRidesBlocks } from "@/lib/prompt-draft"
 import type { QueuedMessage } from "@/hooks/use-message-queue"
 
 interface MessageQueueDisplayProps {
@@ -35,7 +36,8 @@ interface QueueItemProps {
   onDelete: (id: string) => void
   onSteerItem?: (id: string) => Promise<void> | void
   steerChannel: "native" | "pull"
-  /** Whether an insert from THIS row is in flight (disables its button). */
+  /** Whether an insert from ANY row is in flight — every row's button is
+   *  disabled for the duration, so two rows can't race the one channel. */
   steering: boolean
   onSteerStart: (id: string) => Promise<void>
 }
@@ -54,6 +56,21 @@ function QueueItem({
   const t = useTranslations("Folder.chat.messageQueue")
   const dragControls = useDragControls()
 
+  // Which rows may offer the insert at all. Two rows can't, and offering a
+  // click that provably does nothing is worse than offering none:
+  // * The row under edit. Its authoritative text is in the composer now, so
+  //   inserting would send the PRE-edit draft and then drop the row the edit
+  //   was going to save into. (The composer hides its own mid-turn send while
+  //   editing for the same reason.)
+  // * A draft carrying attachments on a pull-tool session. The pull channel
+  //   delivers text, so the backend rejects blocks there — every click would
+  //   land on the turn-end fallback, which for an already-queued row is a
+  //   no-op. It still goes out whole with the next turn, via the queue.
+  const canSteer =
+    Boolean(onSteerItem) &&
+    !isEditing &&
+    (steerChannel === "native" || !draftRidesBlocks(item.draft))
+
   const startDrag = useCallback(
     (event: PointerEvent<HTMLButtonElement>) => {
       event.preventDefault()
@@ -88,7 +105,7 @@ function QueueItem({
       <span className="min-w-0 flex-1 truncate text-3xs text-foreground/80">
         {item.draft.displayText}
       </span>
-      {onSteerItem && (
+      {canSteer && (
         <button
           type="button"
           onClick={() => void onSteerStart(item.id)}
diff --git a/src/components/conversations/conversation-detail-panel-layout.test.ts b/src/components/conversations/conversation-detail-panel-layout.test.ts
index 9ec85562d2..a5376dac45 100644
--- a/src/components/conversations/conversation-detail-panel-layout.test.ts
+++ b/src/components/conversations/conversation-detail-panel-layout.test.ts
@@ -407,6 +407,37 @@ describe("ConversationDetailPanel send-path hardening", () => {
     expect(flushEffect).not.toContain("connectedWorkingDir")
   })
 
+  it("holds the queue auto-flush while a queued row is being inserted", () => {
+    // A queued row's click-to-insert leaves the row in the queue for the whole
+    // round-trip (it only goes once delivery is confirmed). If the turn ends in
+    // that window, the flush would dequeue and send the very row the backend
+    // just injected — the same instruction delivered twice. The hold is
+    // released in a `finally`, and the flag is a dependency, so the flush
+    // resumes on the next commit either way.
+    const start = source.indexOf("// Flush queued messages whenever the agent")
+    const depsEnd = source.indexOf("clearTimeout(timer)", start)
+    const effectWithDeps = source.slice(
+      start,
+      source.indexOf("])", depsEnd) + 2
+    )
+    expect(effectWithDeps).toContain("if (queueSteerInFlight) return")
+    // …and as a dependency, so releasing the hold re-runs the flush.
+    expect(effectWithDeps).toContain("queueSteerInFlight])")
+
+    const steerStart = source.indexOf("const handleQueueSteer = useCallback")
+    expect(steerStart).toBeGreaterThan(-1)
+    const steerHandler = source.slice(
+      steerStart,
+      source.indexOf("[msgQueue, feedbackSteer", steerStart)
+    )
+    // Set BEFORE the first await, cleared in a finally.
+    expect(steerHandler.indexOf("setQueueSteerInFlight(true)")).toBeLessThan(
+      steerHandler.indexOf("await feedbackSteer(")
+    )
+    expect(steerHandler).toContain("finally {")
+    expect(steerHandler).toContain("setQueueSteerInFlight(false)")
+  })
+
   it("disables the welcome composer while connected-but-not-ready", () => {
     // The composer reads a downgraded status so its send affordance is disabled
     // during the transient mismatch window instead of inviting a rejected send.
diff --git a/src/components/conversations/conversation-detail-panel.tsx b/src/components/conversations/conversation-detail-panel.tsx
index 92aaa08261..63592d6d9f 100644
--- a/src/components/conversations/conversation-detail-panel.tsx
+++ b/src/components/conversations/conversation-detail-panel.tsx
@@ -792,6 +792,15 @@ const ConversationTabView = memo(function ConversationTabView({
   // another turn while this client believes it is idle) don't spin one failed
   // send per round-trip.
   const lastFlushBounceAtRef = useRef(0)
+  // Whether a queued row's click-to-insert (`handleQueueSteer`) is mid-flight.
+  // The row STAYS in the queue for the whole round-trip — it only leaves once
+  // the backend confirms delivery — so without this the turn-end edge would
+  // hand the same row to the flush below while the insert is still settling:
+  // admitted against the ending turn AND re-sent as the next turn's prompt,
+  // i.e. the agent reads the same instruction twice. Holding the flush for one
+  // round-trip is enough, and cannot strand the queue: `handleQueueSteer`
+  // always clears this in a `finally`, which re-runs the flush effect.
+  const [queueSteerInFlight, setQueueSteerInFlight] = useState(false)
 
   // Flush queued messages whenever the agent is idle. This is the queue's send
   // engine, covering BOTH:
@@ -816,6 +825,9 @@ const ConversationTabView = memo(function ConversationTabView({
     // lifecycle reconnects — which, for a not-installed target, never happens.
     if (!connectionReady) return
     if (runtimeSyncState === "awaiting_persist") return
+    // A row being inserted into the (just-ended) turn is still queued; sending
+    // it now would deliver it twice. See `queueSteerInFlight`.
+    if (queueSteerInFlight) return
     if (msgQueue.length === 0) return
     // setTimeout (not microtask) so a COMPLETE_TURN commit settles first AND so
     // a just-bounced retry waits out the backoff window before re-sending.
@@ -842,7 +854,7 @@ const ConversationTabView = memo(function ConversationTabView({
     return () => clearTimeout(timer)
     // `connectionReady` subsumes connStatus, the connection's cwd and its agent,
     // so it is the only connection dependency this effect needs.
-  }, [connectionReady, runtimeSyncState, msgQueue.length])
+  }, [connectionReady, runtimeSyncState, msgQueue.length, queueSteerInFlight])
 
   // Mirror the connection's liveMessage into the runtime session OUTSIDE React.
   // The connection dispatch invokes this sink synchronously whenever liveMessage
@@ -2048,10 +2060,14 @@ const ConversationTabView = memo(function ConversationTabView({
       const item = msgQueue.find((m) => m.id === id)
       if (!item) return
       const payload = buildSteerPayload(item.draft)
-      if (!payload) {
-        mqRemove(id)
-        return
-      }
+      // Nothing sendable in this row (no text, and no display text standing in
+      // for its attachments). Leave it alone: removing it would delete queued
+      // content — including whatever blocks it carries — on a button that
+      // promises to SEND it.
+      if (!payload) return
+      // Set before the first await so the flush effect above is already held
+      // when the turn-end edge lands mid-round-trip.
+      setQueueSteerInFlight(true)
       try {
         await feedbackSteer(payload.text, payload.blocks)
         mqRemove(id)
@@ -2065,6 +2081,8 @@ const ConversationTabView = memo(function ConversationTabView({
           tCmp(feedback.channel === "pull" ? "steerNoteFailed" : "steerFailed"),
           { description: toErrorMessage(err) }
         )
+      } finally {
+        setQueueSteerInFlight(false)
       }
     },
     [msgQueue, feedbackSteer, mqRemove, feedback.channel, tCmp]
diff --git a/src/lib/prompt-draft.test.ts b/src/lib/prompt-draft.test.ts
index a4cfb5e806..2ee79b8660 100644
--- a/src/lib/prompt-draft.test.ts
+++ b/src/lib/prompt-draft.test.ts
@@ -4,6 +4,7 @@ import type { PromptDraft, PromptInputBlock } from "@/lib/types"
 
 import {
   buildSteerPayload,
+  draftRidesBlocks,
   extractUserImagesFromDraft,
   extractUserResourcesFromDraft,
 } from "./prompt-draft"
@@ -60,6 +61,21 @@ describe("buildSteerPayload", () => {
     const d: PromptDraft = { blocks, displayText: "note chip" }
     expect(buildSteerPayload(d)?.blocks).toBe(blocks)
   })
+
+  // The affordance gate (a pull-channel session can't carry blocks) reads the
+  // same predicate the encoder does, so the two can't disagree about which
+  // drafts need the native wire.
+  it("agrees with draftRidesBlocks about what needs the block wire", () => {
+    const plain: PromptDraft = { blocks: [text("go")], displayText: "go" }
+    const attached: PromptDraft = {
+      blocks: [text("look"), grokImageResource],
+      displayText: "look",
+    }
+    expect(draftRidesBlocks(plain)).toBe(false)
+    expect(buildSteerPayload(plain)?.blocks).toBeUndefined()
+    expect(draftRidesBlocks(attached)).toBe(true)
+    expect(buildSteerPayload(attached)?.blocks).toBe(attached.blocks)
+  })
 })
 
 describe("extractUserImagesFromDraft", () => {
diff --git a/src/lib/prompt-draft.ts b/src/lib/prompt-draft.ts
index 1a0a8a773e..cabb797bec 100644
--- a/src/lib/prompt-draft.ts
+++ b/src/lib/prompt-draft.ts
@@ -71,6 +71,21 @@ export function getPromptDraftDisplayText(
   return trimmed || attachedResourcesFallback
 }
 
+/**
+ * Whether a draft carries more than plain text (image attachments, file
+ * badges) and therefore has to ride the wire as a full block list.
+ *
+ * Exported because it is also an ELIGIBILITY fact, not just an encoding one:
+ * only the native `_session/steering` wire takes blocks, so a surface that
+ * offers a mid-turn send on a pull-tool session must not offer it for a draft
+ * this returns true for (the backend rejects it with `NoActiveTurn`). Shared
+ * with {@link buildSteerPayload} so the affordance and the encoding can never
+ * disagree about what "more than text" means.
+ */
+export function draftRidesBlocks(draft: PromptDraft): boolean {
+  return draft.blocks.some((b) => b.type !== "text")
+}
+
 /**
  * Encode a draft for the live-feedback (steering) wire — the SINGLE place
  * this encoding lives, shared by the composer's mid-turn send and the queue
@@ -88,9 +103,7 @@ export function buildSteerPayload(draft: PromptDraft): {
   text: string
   blocks?: PromptInputBlock[]
 } | null {
-  const blocks = draft.blocks.some((b) => b.type !== "text")
-    ? draft.blocks
-    : undefined
+  const blocks = draftRidesBlocks(draft) ? draft.blocks : undefined
   const text = blocks
     ? draft.displayText
     : draft.blocks