diff --git a/docs/design/web-shell/web-shell-image-drag-and-drop.md b/docs/design/web-shell/web-shell-image-drag-and-drop.md
new file mode 100644
index 00000000000..0c273961e68
--- /dev/null
+++ b/docs/design/web-shell/web-shell-image-drag-and-drop.md
@@ -0,0 +1,688 @@
+# Web Shell 图片拖放
+
+## 状态
+
+针对 [#8321](https://github.com/QwenLM/qwen-code/issues/8321) 的实现方案。初始实现由
+`48d1e1d69` 落地，review 修正由 `afb55ebae` 补齐 admission、恢复和资源边界。
+
+该功能只补齐 Web Shell composer 的图片拖放入口，并复用现有图片粘贴、
+附件预览、prompt 提交和多模态模型链路。daemon wire format、ACP、Core 和公开
+Web Shell API 均不变；内部 WebUI action contract 增加 admission 边界和确认删除结果。
+
+## 问题与现状
+
+Web Shell 已经支持从剪贴板粘贴图片：`useComposerCore` 从
+`DataTransferItemList` 读取 PNG、JPEG、GIF、WebP，转成 `PromptImage` 后由
+`ChatEditor` 展示缩略图；提交时 WebUI 把图片转换成
+`{ type: 'image', data, mimeType }`，再经 daemon 和 ACP 进入 Core 的
+`inlineData`。图片字节到模型的链路已经存在。
+
+当前缺口是 composer 没有接管浏览器文件拖放。把图片从文件管理器拖到
+CodeMirror 或移动端 textarea 时，图片不会成为附件；浏览器的默认文件 drop
+行为还可能插入无意义内容或离开当前页面。
+
+现有粘贴实现还存在三个异步边界，新增拖放时需要一并收口：
+
+- 多个 `FileReader` 按完成时间逐个追加，不能保证多图顺序；
+- 图片读取完成前仍可能提交已有文字，导致本次图片漏发；
+- session、workspace 或 composer 已清空后，晚到的 reader 仍可能把图片写入新状态。
+
+此外，当前 `submitComposerText` 在文字和 tag 都为空时直接返回，没有把
+`pastedImages` 纳入最终提交条件。因此已有缩略图并不等于可以发送 image-only
+prompt；本方案把这一点作为拖放可用性的必要修复，而不是新增协议能力。
+
+## 目标
+
+- 从桌面文件管理器向 composer 拖放一张或多张图片，并沿用现有附件缩略图和删除交互。
+- 桌面 CodeMirror 与触摸设备 textarea 使用同一个 drop 入口和同一条图片摄取链路。
+- 粘贴和拖放统一支持 PNG、JPEG、GIF、WebP、BMP。
+- 保证跨文件和跨批次的用户选择顺序。
+- 图片读取期间不允许提交不完整的 prompt。
+- 文字、tag 或图片任一存在时都可以提交，包括 image-only prompt。
+- clear、session/workspace 切换和卸载后，旧异步任务不能污染当前 composer。
+- 文件拖入 composer 时提供轻量、可访问且不影响布局的视觉反馈。
+- 保持现有 public API、daemon wire format 和模型模态处理不变。
+
+## 非目标
+
+- 不增加文件选择按钮、上传接口或 daemon 端临时文件。
+- 不支持 SVG、TIFF、HEIC、PDF、目录或远程 URL 拖放。
+- 不改变模型是否支持图片输入的判断；拖放与现有粘贴遵循相同的模型行为。
+- 不承诺从 daemon 的 text-only pending summary 跨页面重载恢复图片；summary-only prompt
+  保持可执行/可删除，但不能编辑为一个缺少原附件的 payload。
+- 不复制 daemon、代理或 Core 的 production 限制作为客户端 admission 策略。composer
+  仅使用固定的并发和 encoded-data 预算保护浏览器资源；读取成功仍不代表 daemon 已接纳
+  prompt，超出服务端请求上限时继续沿用既有发送失败与重试提示。
+- 不让浏览器根据扩展名覆盖一个明确但不受支持的 MIME 类型。
+
+## 架构与所有权
+
+```mermaid
+flowchart LR
+  SOURCE["剪贴板或文件管理器"] --> EVENT["Composer DOM 事件<br/>paste / drag / drop"]
+  EVENT --> INGESTOR["共享图片摄取器<br/>识别、规范化、排队、读取"]
+  INGESTOR --> STATE["useComposerCore<br/>附件与 pending 状态"]
+  STATE --> PREVIEW["ChatEditor<br/>缩略图、删除、拖入高亮"]
+  STATE --> SUBMIT["ChatPane / App<br/>提交或排队"]
+  SUBMIT --> WEBUI["WebUI<br/>toDaemonPromptContent"]
+  WEBUI --> DAEMON["daemon / ACP"]
+  DAEMON --> CORE["Core<br/>inlineData 与模型模态处理"]
+```
+
+职责边界如下：
+
+- `ChatEditor` 只拥有 composer surface 的 capture 事件接入和视觉状态展示，子级
+  CodeMirror/textarea 不再拥有图片 paste/drop handler。
+- `useComposerCore` 拥有图片批次、generation lane、同步 pending 门禁、附件状态和每批
+  notice 发射，是摄取结果和提示语义的唯一提交者。
+- 一个内部图片摄取 helper 只负责从浏览器传输对象提取 `File`、规范化类型并读取
+  base64；它返回结构化结果，不读写 React 状态、不操作 queue，也不发 toast。
+- WebUI、daemon、ACP 和 Core 继续使用现有 `PromptImage` 和 image content block，
+  不感知图片来自 paste 还是 drop。
+
+提示通过一条显式但仅内部使用的 callback 链进入现有 Web Shell toast owner：
+
+```ts
+type ImageIngestionNotice = (
+  tone: 'warning' | 'error',
+  message: string,
+) => void;
+
+onImageIngestionNotice?: ImageIngestionNotice;
+```
+
+该签名与现有 `pushToast(tone, message)` 的调用形态相同，不需要在中间层做对象到位置参数的
+适配。`useComposerCore` 每批最多调用一次相应分类的 callback；`ChatEditor` 只透传。主 App
+直接绑定 `pushToast`。split 链路通过 `SplitView` 传到 `ChatPane`；side-task 的真实
+链路是 App → `ArtifactPanel` → `SideTaskPanel` → `ChatPane`，这些内部 props 都要求透传
+同一 callback。App 的 drawer 与 docked 两个 `ArtifactPanel` 渲染点都必须传
+`pushToast`。这样主聊天、split pane 和 side-task pane 都经过宿主的同一
+ToastHost/`onToast` 转发策略，无新 context、无嵌套 ToastHost，也不增加公开
+`WebShell` prop。缺少 callback 只允许出现在隔离单元测试，并降级为 console，不作为
+生产 wiring。
+
+## 图片识别与规范化
+
+共享 helper 接收事件发生时的 `DataTransfer`，并同步复制 `File` 引用，避免异步阶段
+继续访问已经失效的浏览器事件对象。
+
+提取规则：
+
+1. `files` 非空时以它为权威来源；否则遍历 `items` 中 `kind === 'file'` 且
+   `getAsFile()` 成功的项目。两者不合并，避免同一文件被添加两次。
+2. MIME 类型允许 `image/png`、`image/jpeg`、`image/gif`、`image/webp` 和
+   `image/bmp`。
+3. `image/x-bmp` 与 `image/x-ms-bmp` 规范化为 `image/bmp`。
+4. 仅当 MIME 为空或为 `application/octet-stream` 时，才根据
+   `.png`、`.jpg`、`.jpeg`、`.gif`、`.webp`、`.bmp` 推导规范 MIME。
+5. 明确的非图片 MIME 即使扩展名看似图片也拒绝，避免把浏览器已经识别出的其他内容
+   伪装成图片。
+
+粘贴中只要存在受支持图片，或存在 MIME 受支持但 `getAsFile()` 失败的 image item，
+就阻止本次原生 paste，与当前“图片优先”语义一致；只有文本或只有明确不支持的文件时，
+不接管 paste。drop 只要包含文件载荷就必须被 composer 接管，即使最终没有受支持图片，
+也要阻止浏览器默认导航，并给出一次聚合警告。
+
+## 共享异步摄取
+
+每次被接管的 paste/drop 形成一个不可变批次。helper 返回以下语义等价的结构，不直接
+产生 UI 副作用：
+
+```ts
+interface ImageIngestionBatchResult {
+  accepted: PromptImage[];
+  rejected: Array<{
+    name?: string;
+    reason: 'unsupported' | 'unavailable' | 'too-large' | 'read-failed';
+  }>;
+}
+```
+
+`useComposerCore` 使用 generation-scoped promise queue 串行处理批次。每批先按 base64
+encoded-data 估算筛选候选文件，再由最多四个 worker 并行读取，并在全部 reader settled
+后一次性追加成功结果：
+
+- helper 默认给单次调用 `8 * 1024 * 1024` bytes 的 base64 预算；`useComposerCore` 用该
+  预算减去已有附件的 `data.length`，候选文件按 `ceil(file.size / 3) * 4` 预估，超过剩余
+  预算的文件以 `too-large` 拒绝且不创建 `FileReader`；
+- 同时活动的 `FileReader` 不超过四个，worker 把结果写回候选文件的原始索引，因此完成
+  顺序不改变附件顺序；
+- promise queue 保持批次到达顺序；
+- 某个文件失败不阻止同批其他文件；
+- `useComposerCore` 作为唯一提示所有者，把不支持、超预算和读取失败分别聚合为 warning、
+  warning 和 error，每类每批最多一条 toast；
+- queue 的 rejection 在内部消化，不能让一次失败阻断后续批次。
+
+`imageIngestionLaneRef.current.pendingBatches` 是唯一同步权威，不再维护第二个 pending
+ref。React `pendingImageBatchCount` state 只镜像当前 lane 的值以触发渲染：事件被接管时
+先同步递增捕获 lane 的字段，若它仍是当前 lane 再写 state；批次结束时按同样的 owner
+检查递减并镜像。reset 替换 lane 时同步把 state 置零。这样同一 render 间隔内立刻按
+Enter 也会被 `submitComposerText` 的最终 ref 检查拒绝，同时按钮只消费渲染镜像。发送
+按钮在 pending 期间禁用并显示现有 loading 图标，composer surface 设置
+`aria-busy="true"`。批次完成后恢复普通提交，不自动发送。
+
+按钮、Enter keymap、imperative `submit()` 和最终 `submitComposerText` 必须读取同一
+不变量，不能分别推导：
+
+```ts
+hasSubmittableContent =
+  trimmedText.length > 0 ||
+  topTags.length > 0 ||
+  inlineTags.length > 0 ||
+  pastedImages.length > 0;
+
+canSubmit = !disabled && pendingImageBatchCount === 0 && hasSubmittableContent;
+```
+
+最终 submit guard 使用同一个内容谓词，并在调用 consumer 前重新读取
+`imageIngestionLaneRef.current.pendingBatches`，因此不能被尚未 render 的 state 镜像绕过。
+它也必须包含 `pastedImages`，从而允许 image-only prompt。pending 或 consumer 同步拒绝
+的提交保持文字、tag 和图片不变；consumer 一旦同步接受，则继续遵循各自已有的
+optimistic/commit 语义，不在本功能中统一改写 prompt admission 生命周期。
+
+该不变量必须沿调用链应用到所有消费者。尤其 `ChatPane.handleSubmit` 当前的
+`if (!trimmed) return false` 改为只有 `!trimmed && !images?.length` 才拒绝；main App、
+split pane 和 side-task pane 都必须允许空 text block 搭配非空 images。slash command
+判断只在 text 非空时生效，不得把 image-only 误判成本地命令。
+
+busy/queue 路径使用同一个条件。`useQueuedPrompts.enqueuePrompt` 当前的
+`if (!trimmed) return true` 必须改为仅在 `!trimmed && !images?.length` 时返回；非空
+images 加空 text 必须建立真实 `QueuedPrompt`。由于带图片的 prompt 按现有规则不走
+mid-turn text insertion，它进入 ordinary pending submission，保留图片副本并在 session
+转 idle 后按现有流程发送。enqueue 返回成功前，队列对象必须已经可观察，不能把空文字
+image-only 当成已消费的 no-op。
+
+### Queued prompt 完整性与所有权
+
+队列的关联、编辑、清理和明确 admission 拒绝后的恢复也必须按完整 prompt payload 处理，不能
+继续把“文字是否发生变化”当成“图片是否已经恢复”的替代信号。以下保证明确限定在同一
+mounted composer owner 内：daemon 的 `DaemonPendingPromptSummary` 不含图片，页面重载或
+只有服务端 summary 时无法从现有协议重建附件，设计不得声称可以跨重载恢复原图。
+
+`QueuedPrompt` 复用本地创建后不变的递增 `id` 作为恢复 key，并增加内部字段
+`payloadCompleteness: 'complete' | 'summary-only'`。本地 prompt 始终是 `complete`；只从
+daemon summary 物化的 row 是 `summary-only`，因为即使它有非空 text 也无法判断原 prompt
+是否还带图片。summary-only row 可以继续执行或删除，但禁用 edit/restore-to-editor，UI
+给出“重新载入后附件不可用于编辑”的明确说明，不能静默恢复残缺 payload。若未来要求
+跨重载完整编辑，必须让 pending API 返回 canonical content；这属于单独的协议变更。
+
+本地 image prompt 的 `submitPrompt` 请求以 captured local id 和 queued-prompt owner token
+建立关联；成功收到 admission response 和 `promptId` 时按 local id 精确绑定并删除同 id
+的临时 summary row。对 `payloadCompleteness === 'complete'` 的 row，后续 refresh 只更新
+server id/state，绝不让 daemon 的展示摘要覆盖原始 text、images 或 annotations；ACP 对
+image-only 生成的 `[image]` 只用于 summary-only row 展示，不能进入 canonical payload。
+`syncServerQueuedPrompts` 不再按 text 匹配任何带图片的 submitting row；只要同一 owner
+仍有未决、可能对应某个 summary 的本地 image submission，就暂缓物化无法精确归属的
+server row，待请求收到明确结果后立即 refresh。这样多个 canonical text 都为 `''`、
+summary text 都为 `[image]` 的并发 image-only prompt 不会因文本碰撞错误绑定。成功响应
+可以消除对应的临时重复 row；没有本地关联的 server row 才以 summary-only 物化。
+
+admission error 必须保守分类：只有能够证明请求在 daemon `sendPrompt` 之前被拒绝的响应
+（例如 JSON body parser 的结构化 `413`）才是 `definitely-rejected`，可以移除本地 row 并
+恢复 payload。网络断开、timeout、client abort、response parse 失败以及无法证明边界的
+5xx 都是 `outcome-unknown`：daemon 可能已经接纳 prompt，只是 202 response 丢失。此时
+保留 complete row 并标记 `admissionOutcome: 'unknown'`，停止自动发送、恢复和 retry，触发
+refresh 并显示“提交结果未知，请先检查 transcript/queue”的持久提示。用户只能显式丢弃
+本地副本，或在确认“可能重复执行”的警告后把副本恢复到 editor；恢复只复制、不自动发送。
+unknown row 不再阻塞 server summary 物化；无法关联的 summary-only row 与本地 unknown
+row 分组显示“二者可能对应”，但绝不自动合并或声称去重，因为现有协议没有证明关系。
+queue clear 遇到已经 dispatch 且尚无 `promptId` 的 row 也采用同一 unknown 状态，不能以
+abort 成功推断 daemon 未接纳。彻底自动消除该不确定性需要 client-generated idempotency/
+correlation id，属于本功能禁止的协议变更。
+
+同一 mounted owner 内的恢复 helper 接收有序 `QueuedPrompt[]`，并遵循以下原子语义：
+
+1. 先校验 captured owner token、payload 是 complete 且 editor handle 存在；不满足时不
+   修改状态、也不记录 key；
+2. 过滤已经恢复的 key；把非空文字按 queue order 连接为一个 block，再只调用一次
+   `mergeRestoredPromptText(current, block)`，没有非空文字时跳过文字 merge；
+3. 图片按同一 queue order 展平；`inputAnnotations` 按合并后文字位置平移，再通过 editor
+   handle 恢复。已有 annotation 在新 block 前插时同步平移，普通编辑发生在范围之前时映射
+   offset，编辑与范围重叠时删除 annotation，避免提交 stale metadata；
+4. 文字、图片和 annotations 都同步写入成功后才记录对应 key，再恢复焦点；同一 owner 内
+   重复的 abort catch 或 refresh callback 因相同 key 成为 no-op；
+5. 批量恢复只适用于明确拒绝或已确认从 server 删除的 complete prompt；一次完成上述
+   合并，保证 `[A, B]` 得到 `A\nB` 和 `[A-images, B-images]`，不能逐项正序调用前插 helper。
+
+`popQueuedPromptForEdit` 相应改为返回 `QueuedPrompt | null`，调用方只判断 `null`，不能用
+空字符串的 truthiness 判断是否找到了 prompt。这样本地 image-only queued prompt 在
+安全恢复路径中不会丢图，也不会因为同一恢复路径执行两次而复制附件；outcome-unknown
+明确不进入该 helper。
+
+queued-prompt 生命周期另设对象身份的 `QueuedPromptOwner`，在 session、workspace 或
+composer owner 每次变化时同步替换；即使 session id 从 S1 切到 S2 再回到 S1，对象也不
+复用。submit、remove、refresh 和 pending-event handler 都在启动时捕获 token，并在修改
+queue、恢复 editor、append transcript、发错误提示前检查引用相等。已恢复 `id` 集合属于
+该 token 并随新 owner 新建，而不是清空后继续只靠 session id 比较，从而关闭 ABA 窗口。
+
+`pending_prompt_started` 也必须保留 image-only 的本地 transcript 语义。找到精确 local
+prompt 后，append guard 使用 `text.length > 0 || prompt.images?.length > 0`，继续传
+`toStoreImages` 并以 `displayedServerPromptIdsRef` 去重。若 started event 早于 admission
+response，先按 `promptId` 缓存在 captured owner；response 精确绑定 local id 后再追加，
+不能用空 text 猜测多个 image prompt 的归属。main、split 和 side-task 因而都会即时显示
+一次含图 user block。
+
+response 前的生命周期证据在 `QueuedPromptOwner` 内按 prompt id 保存，并限制为最多 200
+项。一个 attempt 进入 outcome unknown 不得清除其他 attempt 的 started 证据；refresh 也
+不能因为 terminal 已让 prompt 离开 pending list，就过早删除仍在等待 response 精确绑定的
+证据。实现分别保留 started、已经 append、settled 和 removed 状态：
+
+- started/terminal 都早于 response 时，response 绑定 local payload 后只 append 一次；文本
+  prompt 即使 started 时已经 append，也不会在 terminal 或 response 后重复追加；
+- queued prompt 被删除时，bridge 会发送 `pending_prompt_completed{removed}`，随后发送
+  `turn_complete{stopReason:'cancelled'}`。若没有 started 证据，该 prompt 从未 dispatch，
+  response 到达后直接移除本地 row，不追加 user block；
+- started 后被取消仍保留已执行过的本地 user block；turn error 和普通 completion 在 response
+  到达后按 exact prompt id flush；
+- exact response 消费对应证据，owner 替换清空 owner 状态，超过容量时按插入顺序淘汰。
+
+```mermaid
+flowchart TD
+  LOCAL["本地 complete QueuedPrompt<br/>local id + owner token"] --> REQUEST["submitPrompt"]
+  REQUEST --> OUTCOME{"admission 结果"}
+  OUTCOME -->|"明确 pre-admission 拒绝"| RESTORE["幂等恢复完整 payload"]
+  OUTCOME -->|"transport outcome unknown"| UNKNOWN["保留 unknown row<br/>禁止自动恢复或重试"]
+  UNKNOWN --> REFRESH["刷新 daemon pending summary<br/>不破坏其他 attempt 证据"]
+  OUTCOME -->|"收到 prompt id"| RESPONSE{"response 返回时<br/>owner 仍相同?"}
+  RESPONSE -->|"否"| STALE["丢弃旧 callback"]
+  RESPONSE -->|"是"| BIND["按 local id 绑定 server prompt id"]
+  STARTED["pending_prompt_started"] --> KNOWN{"已精确绑定本地 payload?"}
+  KNOWN -->|"是"| ECHO["追加一次 text-or-images user block"]
+  KNOWN -->|"尚未"| BUFFER["按 prompt id 暂存到当前 owner"]
+  TERMINAL["turn_complete / turn_error / removed"] --> EVIDENCE["按 prompt id 保留<br/>settled / removed 证据"]
+  BIND --> FLUSH{"存在 started / appended /<br/>settled / removed 证据?"}
+  BUFFER --> FLUSH
+  EVIDENCE --> FLUSH
+  FLUSH -->|"是"| ECHO
+  FLUSH -->|"否"| QUEUED["保持精确绑定的 queued row"]
+  REFRESH["daemon pending summary"] --> LOCAL_PENDING{"仍在等待 admission response?"}
+  LOCAL_PENDING -->|"是"| DEFER["暂缓物化，等待 response 后 refresh"]
+  LOCAL_PENDING -->|"否"| SUMMARY["创建 summary-only row<br/>可执行/删除，禁用编辑"]
+```
+
+`onSessionChange` 的 public payload 不增加图片字段，`prompt` 仍是原始字符串；但 main
+App 的 direct submit、`onSubmitBefore` queued submit 和普通 queued submit 三处事件门禁
+都必须从 `text.trim()` 改为 `text.trim() || images?.length`。因此 image-only admission
+会发出 `{ type: 'submit', prompt: '', queued: ... }`，使宿主收到真实 session activity，
+而不是伪造占位文字或悄悄漏掉事件；direct 路径仍按现有逻辑安排 session-list reload。
+
+main App 的 post-admission turn-error retry 同样采用 text-or-images 内容谓词：retry hint 和
+`handleRetry` 都在 `lastSubmittedPromptRef` 非空或 `lastSubmittedImagesRef` 非空时允许重试，
+并继续以 `optimisticUserMessage: false` 重发保存的原 MIME/base64 和 input annotations。
+owner 变化时完整 last-submitted payload 与 retryable error 一起失效，避免把旧 session
+payload 重发到新 session。
+这与前述 pre-admission `413` failed-prompt retry 是两条不同路径，两者都要覆盖。
+上述 definite/unknown 分类同样约束 main App 与 `ChatPane` 的 admission catch：只有明确
+pre-admission 拒绝才进入 failed-prompt retry；transport outcome unknown 时 optimistic
+message 标成未知、不可一键重试，并等待 transcript/queue 刷新。post-turn retry 若在
+`onAdmitted` 前丢失 response，也建立保存完整 payload 的相同 unknown 状态；`turn_error`
+已经证明 admission 成功，所以 `onAdmitted` 之后的 reject 只按 turn error 处理。
+
+两个 direct consumer 与 queue 共用一个仅内部的 definitely-rejected/outcome-unknown
+分类 helper，但各自保存 owner-scoped 状态，不增加 transcript store 或公开 Web Shell API。
+当前 definitely-rejected allowlist 只有结构化 `413` 和 endpoint 不支持的 `501`；
+`400`、`408`、`429`、`499`、5xx 和 transport/parse error 都按 unknown 处理。
+
+WebUI action 在本地 active-prompt guard 和 payload 组装完成后、调用 daemon
+`submitPrompt` 前触发内部 `onAdmissionStarted`。consumer 只有收到该边界后才把非明确拒绝
+视为 outcome unknown；本地 guard rejection 仍是普通错误。action 收到 admission 后先触发
+`onAdmitted`，随后 turn completion 的 reject 不得回退为 admission unknown：
+
+- attempt 捕获 owner token、session id、完整 payload、composer commit callback；App 继续
+  用发送前后 transcript snapshot 得到 optimistic user `messageId`；
+- App 把 `{ sessionId, messageId, outcome: 'unknown' }` 保存为独立于 `FailedPrompt` 的本地
+  状态，并在 composer 上方显示持久警告，只提供“丢弃本地副本”和经过重复执行确认的
+  “恢复副本”，绝不复用 `sendFailed` 的 retry 按钮；
+- `ChatPane` 保存相同 attempt；如果无法取得 message id，则在 pane 内显示同等警告。进入
+  unknown 后 composer（包括按钮、Enter、imperative submit、编辑和附件删除）进入只读
+  锁定，不能靠保留下来的 payload 直接再次发送；“丢弃本地副本”调用 captured commit 后
+  解锁，“继续编辑”先显示可能重复执行的确认，确认后只解锁、既不 commit 也不发送；
+- owner 替换清除 UI 投影并使旧 action/callback 失效。明确 `413` 不进入 unknown 锁：App
+  继续现有 failed-prompt 语义，`ChatPane` 保留可编辑 composer；已收到 `onAdmitted` 的
+  turn error 也不进入该锁。
+
+unknown marker 与可恢复 payload 分开保存：“丢弃/恢复本地副本”只清理 payload 和解除
+composer 锁，composer 上方仍保留“结果未知”警告；只有后续 transcript/queue 证据能够
+确认结果，或 owner 被替换时，才清除 marker。
+
+因此 outcome-unknown 的状态 owner、UI 投影和解除动作均有单一来源；仅设置一条
+toast 或只禁用 failed-message retry 都不满足安全门禁。
+
+side-task 的自动命名定义为“第一个 admission 成功的非空文本 prompt”，而不是“第一个
+user block”。`ChatPane` 只有在 `trimmed.length > 0` 时才设置
+`firstPromptAdmittedRef` 并调用 `onFirstPromptAdmitted`。`SideTaskPanel` 用已完整载入的
+transcript 中 `block.kind === 'user' && block.text.trim().length > 0` 判断是否已经存在可命名
+prompt；仅有 image-only user block 的新建或恢复 session 仍保留命名资格。这样首次
+image-only admission 不会用空标题消耗资格，随后第一条非空文字仍只触发一次既有 rename
+重试流程。direct、ordinary queued 和 mid-turn insertion 都在各自精确 admission 成功时调用
+同一个 once-only callback。
+
+### Generation 与清理
+
+单独的 generation 数字不足以隔离 queue tail、pending 和活动 reader。实现使用一个
+lane 对象作为所有权令牌：
+
+```ts
+interface ImageIngestionLane {
+  generation: number;
+  tail: Promise<void>;
+  pendingBatches: number;
+  activeReaders: Set<FileReader>;
+}
+```
+
+每个批次在入队时捕获 lane 对象；读取结果、toast、pending 镜像和 `finally` 只有在
+`imageIngestionLaneRef.current === capturedLane` 时才能提交。`activeReaders` 只拥有尚未
+settle 的 reader；每个 reader promise 的 `load`、`error` 和 `abort` 路径通过一次性
+settle helper 保证恰好结束一次。该 helper 在所有终态的第一步都从 captured lane 删除
+reader，再 resolve/reject 并释放对 data URL 结果的额外引用；正常完成的 reader 不能
+一直保留到下一次 reset。
+
+以下操作同步创建一个带全新 resolved `tail`、零 pending 和空 active-reader set 的 lane，
+替换 ref 后再 abort 旧 lane 的活动 `FileReader`：
+
+- 清空 composer 文本和图片；
+- session 或 workspace 所有者变化；
+- hook 卸载。
+
+新 generation 的批次进入新 tail，不等待旧 tail。尚未开始的旧批次出队时直接结束；
+已 abort 的 reader 必须 settled，但因为 lane 已变化，不更新附件、pending 镜像或
+toast。旧批次的 `finally` 也不能递减新 lane 的 pending。每批任务无论 helper 成功或
+抛错，都会在 tail 上转成已处理的 fulfilled 结果，保证同 lane 后续任务继续执行。
+
+删除单张已经完成读取的附件不会推进 generation，也不会取消同一 composer 中仍在
+读取的其他批次。提交路径在 pending 为零时才可进入，因此提交成功后的现有清空逻辑
+不需要处理活动 reader。
+
+```mermaid
+flowchart TD
+  DRAG["file dragenter / dragover"] --> FEEDBACK["preventDefault<br/>更新轻量高亮"]
+  FEEDBACK --> WAIT["等待 drop、dragleave 或 dragend"]
+  DROP["file drop"] --> CLAIM_DROP["preventDefault + stopPropagation<br/>清除高亮"]
+  CLAIM_DROP --> EDITABLE{"composer 可编辑?"}
+  EDITABLE -->|"否"| STOP["不读取文件"]
+  EDITABLE -->|"是"| EXTRACT["同步复制 File 并规范化 MIME"]
+  PASTE["paste"] --> SUPPORTED{"存在支持类型的 image item?"}
+  SUPPORTED -->|"否"| NATIVE["保留编辑器原生行为"]
+  SUPPORTED -->|"是"| CLAIM_PASTE["preventDefault"]
+  CLAIM_PASTE --> EXTRACT
+  EXTRACT --> ENQUEUE["捕获 lane<br/>递增 pending 并入队"]
+  ENQUEUE --> READ["批次内并行 FileReader"]
+  READ --> CURRENT{"lane 仍是当前所有者?"}
+  CURRENT -->|"否"| DISCARD["丢弃旧结果"]
+  CURRENT -->|"是"| APPEND["按选择顺序追加成功图片"]
+  APPEND --> NOTICE["聚合提示不支持或失败的文件"]
+  NOTICE --> READY["pending 归零后允许提交"]
+```
+
+## Composer 事件与拖放交互
+
+图片 `paste` 和文件 drag/drop 都挂在带 `data-web-shell-composer-surface` 的 composer
+根容器 React capture handlers 上，而不是 `editorArea`，也不分别实现 CodeMirror 和
+textarea 两套逻辑。该根容器同时包住 attachment/tag、输入区和 toolbar，所以 drop 在
+composer 任意可见区域都不会落到浏览器默认文件导航。capture 阶段先于 CodeMirror 的
+默认处理。实现时删除 CodeMirror `domEventHandlers.paste` 和 mobile backend `onPaste`
+的图片摄取职责，避免同一事件被添加两次；纯文本仍自然落入子编辑器的默认处理。
+
+| 事件           | 文件载荷                   | 处理                                                                |
+| -------------- | -------------------------- | ------------------------------------------------------------------- |
+| `paste`        | 至少一个可接管 image item  | `preventDefault()`，形成一个图片批次                                |
+| `paste`        | 只有文本或明确不支持的文件 | 不拦截，保留原生 paste                                              |
+| `dragenter`    | 任意 file payload          | `preventDefault()`；可编辑时进入高亮态                              |
+| `dragover`     | 任意 file payload          | `preventDefault()` 并设置 `dropEffect = 'copy'`                     |
+| `drop`         | 任意 file payload          | `preventDefault()`、`stopPropagation()`、清除高亮；可编辑时形成批次 |
+| 任意 drag/drop | 只有文本或 URL             | 不拦截，保留 CodeMirror/textarea 默认行为                           |
+
+file payload 通过 `dataTransfer.types` 中的 `Files` 或可见 file item 识别。disabled
+composer 仍独占并阻止任意文件 drop 以防页面导航，但不读取文件、不发错误 toast，也不
+显示激活态。
+
+仅在 composer 可编辑时设置 `data-image-drag-active`；CSS 使用现有主题 border 和
+background token 做轻量高亮，不新增 overlay、不改变尺寸，也不添加动画。
+
+高亮状态使用 composer 根容器内部 drag depth，并辅以 `relatedTarget` containment，
+避免指针在缩略图、tag、CodeMirror 和 toolbar 子节点间移动时闪烁。以下路径无条件把
+depth 和 active state
+归零：surface `drop`、全局 `dragend`、window `blur`、composer disabled/reset、
+generation lane 替换和组件卸载。全局监听器只在 active 期间安装，并在清理时移除。
+
+成功接管 drop 后保持当前输入内容，并把焦点还给当前输入后端。轻量高亮是辅助反馈；
+最终成功状态仍以现有附件缩略图为准。键盘和触摸用户继续使用 paste，因此不新增只能
+通过拖放访问的能力。
+
+## 失败与兼容性
+
+| 场景                         | 行为                                                            |
+| ---------------------------- | --------------------------------------------------------------- |
+| 不支持的 drop 文件           | 阻止浏览器默认导航，不添加附件，聚合 warning                    |
+| 混合支持/不支持文件          | 按原顺序添加支持的图片，并聚合提示跳过数量                      |
+| `getAsFile()` 返回 `null`    | 记为 unavailable；同批其他文件继续                              |
+| `FileReader` error/空结果    | 不添加该文件；当前 lane 下聚合 read-failed error                |
+| 超过客户端 encoded-data 预算 | 不创建 reader；跳过该文件并聚合 too-large warning               |
+| generation reset 触发 abort  | 静默 settle，不更新旧 lane 的附件、pending 或 toast             |
+| 图片仍在读取时提交           | 同步拒绝提交，保持文字和附件，等待后由用户再次发送              |
+| 读取中切换 session/workspace | abort 并丢弃旧 generation，不提示新会话                         |
+| 模型不支持图片               | 沿用 Core 的现有模态降级/错误语义                               |
+| 请求体过大                   | 沿用现有 failed-prompt 与 retry，不在 composer 复制 daemon 限制 |
+
+helper 只返回结构化 accepted/rejected；toast 只能由当前 lane 的 `useComposerCore`
+产生。混合成功与失败时先追加成功图片，再按 unsupported/unavailable/read-failed 分类
+聚合计数。用户 clear、owner 切换或 unmount 引起的 abort 静默，不属于读取失败。
+
+### 既有大小边界
+
+这里存在三个独立且计量对象不同的边界：
+
+- Web Shell 在每次 paste/drop ingestion 中以 `8 MiB` base64 data 预算减去当前已有附件，
+  限制本批可读候选，属于固定的浏览器资源保护，不是 daemon admission 阈值；
+- `qwen serve` 的 `express.json({ limit: '10mb' })` 限制整个已经 base64 编码并包含 JSON
+  envelope 的 HTTP 请求体；超过后在路由前返回结构化 `413`。
+- Core 的 `DEFAULT_MAX_INLINE_MEDIA_BYTES = 10 * 1024 * 1024` 限制单个
+  `inlineData` 的估算 decoded bytes，只有请求先通过 daemon parser 后才生效，且可由
+  daemon 环境配置覆盖。
+
+base64 通常比原始文件大约增加三分之一，因此不存在“某个固定大小的原图一定可通过 Web
+Shell 发送”的契约。composer 的 `8 MiB` 是独立的客户端资源预算，不复制可能被 daemon
+配置或部署代理改变的阈值，也不把本地读取成功显示成 admission 成功。HTTP `413` 走现有
+prompt send-failure 路径。主 App 的 active-session 路径保持现有 optimistic clear：失败的
+user message
+保存原始文字和图片副本并提供同 payload retry，但原 composer 不承诺原位保留或编辑；
+用户需要重新创建较小的 prompt。`ChatPane` 继续只在 `onAdmitted` 后调用 composer
+commit，因此该消费端在 pre-admission `413` 时保留原 composer。两条路径都必须按各自
+既有契约测试，不能用其中一条替另一条作全局声明。
+
+既有限制的边界测试按各自真实计量对象断言：daemon 测试构造序列化后
+`Buffer.byteLength(body)` 分别为 `10 MiB - 1`、`10 MiB`、`10 MiB + 1` 的 JSON body，
+前两者进入路由、后者返回 `413`；Core 测试构造估算 decoded bytes 为
+`limit - 1`、`limit`、`limit + 1` 的 base64，前两者保留 `inlineData`、后者替换为
+oversized placeholder。它们验证既有服务端契约；Web Shell helper 测试单独验证四路并发、
+候选顺序和 encoded-data 剩余预算。
+
+BMP 以 `image/bmp` 进入缩略图 data URL 和 daemon image block。Core 的
+`SUPPORTED_IMAGE_MIME_TYPES` 明确包含 `image/bmp`，`ImageTokenizer` 解析 BMP 尺寸，
+OpenAI converter 把启用 image modality 的 `inlineData` 原样构造成
+`data:image/bmp;base64,...`；Gemini 路径保留相同 `inlineData`。因此 V1 不在浏览器转码。
+浏览器若不能解码缩略图，不影响附件数据传输，但 E2E 必须覆盖 Chromium 解码，
+Firefox/Linux 必须完成人工验收。
+
+提交后的 user transcript 还经过 `isSafeImageSrc`，因此其被动位图 data-URI allowlist 必须
+加入精确的 `image/bmp;base64,`，否则 composer 预览可见而 user message 会静默隐藏 BMP。
+只扩展这一种 base64 raster MIME；SVG、任意 `data:` 和其他主动内容继续被拒绝。
+`UserMessage` 使用同一安全 helper，不另开绕过白名单的 BMP 渲染分支。
+
+保证范围只到 Web Shell → daemon → ACP → Core canonical `inlineData`，以及当前
+OpenAI/Gemini 的图片路径。Anthropic converter 的既有 allowlist 仅包含 JPEG、PNG、
+GIF、WebP，BMP 会被明确转换为 `Unsupported inline media type: image/bmp` 文本，而不是
+作为图片发给服务端；本功能保留并测试这一既有 provider 降级。若产品未来要求 BMP 在
+所有 image-capable provider 上保持图片语义，需要单独设计 Core/provider 转码，不能在
+Web Shell 输入层静默改变格式。
+
+该变更不需要 feature flag：旧 daemon 已能接收同一 image block，新 Web Shell 只是增加
+一种本地输入来源。宿主公开的 `WebShell` props、`PromptImage` 结构和能力协商均不变。
+
+## 测试方案
+
+### Helper 单元测试
+
+- `files` 权威来源与 `items` 回退不会重复文件。
+- 五种规范 MIME、BMP 两种别名、空 MIME/`application/octet-stream` 扩展名回退。
+- 明确的非图片 MIME、SVG、TIFF、目录和 `getAsFile() === null`。
+- 多文件读取乱序完成、部分失败和空 reader 结果仍输出有序成功项和正确计数。
+- 同时活动的 reader 不超过四个；超过 encoded-data 剩余预算的文件不创建 reader，并返回
+  `too-large`。
+- `load`、`error`、`abort` 竞态只 settle 一次；helper 只返回结构化结果且从不发 toast。
+
+### Hook 与 DOM 测试
+
+- composer 根 surface 的 capture handler 接管 PNG/BMP 单图和多图 drop，设置
+  `dropEffect=copy`，并阻止默认文件行为；子 CodeMirror handler 不再摄取图片。
+- 文本/URL drop 不被接管；不支持文件 drop 被拦截且仅由 composer core 产生一条聚合
+  提示。
+- 图片 paste 同样只经过外层 capture handler；纯文本 paste 落入 CodeMirror 或
+  textarea 原生路径，移动 backend 不保留第二套图片 handler。
+- dragenter、子节点穿越、离开 surface、drop、dragend、window blur、disabled/reset 和
+  unmount 的激活态转换。
+- 在 editor、已有缩略图、tag 和 toolbar 上分别 drop 支持/不支持文件；全部只摄取一次，
+  disabled 状态全部阻止默认文件行为且不摄取。
+- 两个批次以事件顺序追加；同批 reader 乱序完成不改变文件顺序。
+- 当前 lane 的唯一 pending 字段在 React 更新前即可阻止 Enter、imperative submit 和最终
+  submit guard，state 镜像驱动按钮；reset 与 stale `finally` 不会造成两者分叉，完成后
+  不会自动提交。
+- 只有图片时，按钮和 Enter 均可提交；`ChatPane` 的空文本 guard 接受非空 images，
+  split pane 和 side-task pane 至少各有一个消费端回归测试。
+- main App、split pane、side-task pane 在 responding/busy 状态提交 image-only 时都会
+  创建带原始图片的 `QueuedPrompt`，随后走 ordinary submit；`useQueuedPrompts` hook 测试
+  断言它不是成功 no-op，也不进入 mid-turn text lane。
+- 同一 mounted owner 内，image-only queued prompt 在明确 admission 拒绝或确认删除后的
+  edit/restore 中恢复原始图片恰好一次；文字为空或已经位于 editor 顶部时也不抑制首次
+  图片恢复。批量恢复 `[A, B]` 具体断言文字为 `A\nB`、图片为
+  `[A-images, B-images]`，annotations 按文字 offset 合并；范围前编辑会平移 annotation，
+  范围内编辑会删除它。owner 不匹配或 editor 尚未就绪时不写入、也不提前消费恢复 id，
+  `popQueuedPromptForEdit` 不把空 text 当成未找到。
+- 模拟 daemon 已接纳但 202 response 丢失：queued、main App 和 `ChatPane` 都标记
+  outcome unknown，不自动恢复/重试、不生成第二次请求。App 显示独立的持久 unknown
+  警告而不显示 retry；`ChatPane` 的按钮、Enter、imperative submit、编辑和附件删除
+  全部锁定。显式“恢复副本”或“继续编辑”需要重复执行确认且绝不自动发送。明确 `413`
+  则仍走 definitely-rejected 路径且 `ChatPane` 不锁定；clear 一个已 dispatch 且没有
+  prompt id 的 row 也不得把 abort 当成明确拒绝。
+- 多个并发 image-only submission 遇到 refresh/start-event/response 乱序时只能按 local id
+  与返回的 server prompt id 精确绑定，不按空 text 或 `[image]` 匹配；收到成功 response
+  的请求不产生重复 row，started event 最终只追加一次包含原图的本地 user block，
+  main/split/side-task 都覆盖。outcome unknown 则保留独立、带歧义说明的 local/server rows，
+  不做未经证明的合并。
+- complete image-only row 绑定后再 refresh/started/edit/retry，canonical text 始终是 `''`；
+  daemon 的 `[image]` 只能成为 summary-only 展示文案，不能覆盖本地 payload。
+- started、terminal 和 response 的乱序同时覆盖 image-only 与 text prompt：已执行 prompt
+  恰好 append 一次。真实 `pending_prompt_completed{removed}` → cancelled terminal 且没有
+  started 的 queued prompt 不 append；started 后取消仍保留已经显示的 user block。
+- 一个 attempt outcome unknown 不清除另一个 attempt 的 started 证据；exact response、owner
+  替换和超过 200 项分别消费、清空或淘汰关联状态。
+- action 的 `onAdmissionStarted` 只在本地 guard 通过后触发；`onAdmitted` 后的 turn error 不
+  建立 unknown。clear abort 后若 server removal 确认成功，返回 `removedAfterAbort` 并删除
+  local row；remove 失败或结果不明确才保留 unknown。
+- reload 后只有 daemon summary 的 prompt 标为 summary-only：仍可执行或删除，但 edit 被
+  禁用并显示附件无法恢复的说明；不得承诺或测试跨重载恢复原图。非空 text 加图片的
+  summary 同样不能被误当成完整 payload。
+- queued-prompt owner 的 S1 → S2 → S1 ABA 测试让旧 submit/remove/refresh/started callback
+  在返回后无法修改新 queue、editor、transcript 或 toast；新 owner 的合法 callback 正常
+  工作。
+- main App 的 direct、`onSubmitBefore` queued 和普通 queued 三条 image-only 路径都发出
+  一次 `onSessionChange` submit event，断言 `prompt === ''`、`queued` 标记正确且 direct
+  路径仍触发延迟 session-list reload；真正无文字且无图片时不发事件。
+- main App 的 image-only turn_error 会显示 retry hint，按钮和 Ctrl+Y 都用保存的原
+  MIME/base64 重发且 `optimisticUserMessage: false`，不追加重复 optimistic message；
+  session/owner 切换后旧 payload 不可重试。
+- side-task 先 admission image-only、再 admission 非空文字时，只用后者命名一次；新建与
+  已恢复的 image-only-only transcript 都保留资格，已有非空 user text 的 transcript
+  不重新命名，rename 失败继续走既有重试语义。
+- clear、session/workspace 切换和 unmount 会立即建立新 lane 并 abort 旧 reader；新
+  batch 不等待旧 tail，旧结果、旧 toast、旧 pending 和旧 `finally` 都不能修改新 lane。
+- 单批 helper 抛错后同 lane 的下一批仍执行；load、error、abort 和部分失败批次的
+  `activeReaders` 都在 settle 后归零，不能持有已经完成的 data URL。
+- paste 回归覆盖纯文本放行、混合文本/图片的图片优先语义，以及 PNG/JPEG/GIF/WebP
+  原行为；新增 BMP paste 覆盖。
+- `isSafeImageSrc` 只新增允许 `data:image/bmp;base64,`，`UserMessage` 与 direct/queued
+  transcript 均渲染 BMP；SVG 和其他 data URI 继续被拒绝。
+- 图片删除、附件状态通知、prompt queue 和 retry 继续携带规范化 MIME。
+- 主 App、split pane 和 side-task pane 分别验证 warning/error callback 到现有 toast
+  owner；side-task 测试覆盖 drawer、docked App → ArtifactPanel → SideTaskPanel 透传，
+  stale lane 和 lifecycle abort 不调用 callback。
+
+### 浏览器 E2E
+
+在现有 Web Shell mock daemon smoke 测试中构造真实 `DataTransfer`：
+
+1. 在页面上下文中用真实 PNG/BMP bytes 创建两个 `File`，加入一个 `DataTransfer`；
+2. 向 `[data-web-shell-composer-surface]` 依次派发可取消、冒泡的
+   `dragenter`、`dragover`、`drop`，完整经过 React capture 路径；
+3. 验证拖放高亮清理、两个缩略图可解码且顺序一致；
+4. 不输入文字，直接发送 image-only prompt；
+5. 通过现有 mock daemon 的 request recorder 断言最终 prompt body 依次包含 text、
+   `image/png`、`image/bmp`，并核对 base64 内容而不只核对数量；提交后的 user transcript
+   也显示两张可解码图片，证明 BMP 没有被安全白名单隐藏；
+6. 覆盖删除一张图片后只发送剩余附件，以及纯文本 drop 仍进入编辑器；
+7. 让 mock daemon 对 main App active-session 的带图片 prompt 返回 `413`，验证原
+   composer 按既有 optimistic 语义清空，failed user message 保留原始文字、MIME、
+   base64 和 retry，且 retry 不创建重复 optimistic message；另在 `ChatPane` 测试中验证
+   pre-admission `413` 不调用 commit、原 composer 保留；
+8. 让 prompt admission 成功后产生 `turn_error`，验证 image-only retry hint 可见，触发
+   retry 后 request recorder 收到相同 MIME/base64，transcript 不增加第二条 optimistic
+   user message。
+
+BMP 的下游回归不只停在 mock HTTP 入参：在既有 ACP session prompt 转换测试中加入
+`image/bmp`，验证最终 Core canonical content 保持
+`inlineData.mimeType === 'image/bmp'`；OpenAI/Gemini converter/tokenizer 聚焦测试验证
+各自既有图片路径，Anthropic 聚焦测试明确断言 BMP 转为 unsupported-media 文本。daemon
+已有结构化 `413` 测试，Core 已有 inline-media within/over limit 测试；本功能不复制
+production 限制，只确认 Web Shell 对这些既有失败语义的状态保留。
+
+Playwright CI 当前只安装 Chromium，因此 issue 中报告的 Linux Firefox 场景采用明确的
+人工验收：从文件管理器拖入 PNG、BMP、多图、混合非法文件，并验证页面不跳转、顺序、
+预览、删除和发送。后续若仓库统一增加 Firefox browser matrix，再把该用例加入自动化，
+本功能不单独扩大整个 Web Shell CI 浏览器安装范围。
+
+### 验证命令
+
+实现阶段从 `packages/web-shell` 运行定向 Vitest、`npm run typecheck`、`npm run lint`、
+`npm run build` 和 `npm run test:e2e:smoke`。设计文档本身使用 Prettier check 和
+`git diff --check` 验证格式。
+
+`afb55ebae` 的 review 修正验证包括 Web Shell 7 个聚焦文件 530 tests、WebUI 2 个聚焦文件
+237 tests、两包 lint、相关文件 Prettier、全仓 `npm run build && npm run typecheck` 和
+`git diff --check`。该修正没有改变浏览器 drag/drop DOM 路径，因此没有重复运行原功能的
+browser smoke。
+
+## 验收标准
+
+- PNG、JPEG、GIF、WebP、BMP 可通过 paste 或文件 drop 成为同一种 composer 附件。
+- image-only、文字加图片和 tag 加图片共用同一 `canSubmit` 不变量。
+- main App、split pane 和 side-task pane 都接受 image-only，并保持各自既有 admission
+  commit 语义。
+- busy 状态的 image-only 一定生成并发送真实 queued prompt，不会因空文本静默丢图。
+- 同一 mounted owner 内，image-only queued prompt 在明确拒绝或确认删除后的安全恢复
+  保留原图且恰好一次；批量恢复保持 prompt 顺序，owner token 阻止包括 S1 → S2 → S1
+  在内的旧 callback 污染。
+- admission outcome unknown 不自动恢复或重试；它保留完整本地副本并明确提示可能已经执行，
+  只有用户确认风险后才能恢复一个不自动发送的副本。
+- 并发 image prompt 不按 text 关联 server row，started event 只产生一条含图 user block；
+  reload 后的 summary-only row 不伪装成可恢复的完整 payload，继续执行/删除与禁用编辑的
+  边界明确，`[image]` summary 不覆盖 complete row 的 canonical 空 text。
+- direct 与两条 queued admission 都为 image-only 发出内容准确的 session-change 事件；
+  side-task 的首次自动命名资格留给第一条 admission 成功的非空文本。
+- image-only 的 post-admission turn error 可以重试原图片且不复制 optimistic user message。
+- 多图、多批次、部分失败时，成功附件始终保持用户选择顺序。
+- 图片读取最多使用四个并发 reader；paste/drop ingestion 按已有附件计算剩余预算，不接纳
+  会使估算 base64 data 超过 `8 MiB` 的新候选。该预算不宣称等于 daemon admission 限制。
+- 图片读取期间无法发送不完整 prompt；读取完成后用户可以正常发送或删除附件。
+- 当前 ingestion lane 的 `pendingBatches` 是唯一同步提交门禁，渲染 state 只做镜像。
+- 清空、切换 owner 或卸载后没有跨 composer 的晚到附件或提示。
+- 新 generation 的 batch 不被旧 queue tail 阻塞，任何 reader 终态都能可靠 settle 并从
+  `activeReaders` 释放。
+- 文件拖入有轻量高亮，composer 的 attachment、editor、tag、toolbar 任一位置 drop 都
+  不会触发浏览器导航，文本 drop 语义不变。
+- 每个生产 composer 的 ingestion notice 都进入现有 ToastHost/宿主 `onToast`；drawer
+  与 docked side-task 的 ArtifactPanel hop 均有覆盖，生命周期 abort 静默。
+- BMP 在 composer、user transcript、Core canonical content、OpenAI/Gemini 图片路径和
+  Anthropic 文本降级上的语义都有明确测试，不承诺跨 provider 一致图片语义。
+- daemon wire format、ACP、Core 和公开 Web Shell API 没有协议或类型变更；内部 WebUI
+  action contract 增加 `onAdmissionStarted` 和 `removedAfterAbort`。
diff --git a/packages/core/src/core/anthropicContentGenerator/converter.test.ts b/packages/core/src/core/anthropicContentGenerator/converter.test.ts
index e61de715926..8495e20c9c2 100644
--- a/packages/core/src/core/anthropicContentGenerator/converter.test.ts
+++ b/packages/core/src/core/anthropicContentGenerator/converter.test.ts
@@ -570,64 +570,67 @@ describe('AnthropicContentConverter', () => {
       });
     });
 
-    it('renders non-image inlineData as a text block (avoids invalid image media_type)', () => {
-      const { messages } = converter.convertGeminiRequestToAnthropic({
-        model: 'models/test',
-        contents: [
-          {
-            role: 'model',
-            parts: [
-              {
-                functionCall: {
-                  id: 'call-1',
-                  name: 'Read',
-                  args: {},
+    it.each(['audio/mpeg', 'image/bmp'])(
+      'renders unsupported %s inlineData as a text block',
+      (mimeType) => {
+        const { messages } = converter.convertGeminiRequestToAnthropic({
+          model: 'models/test',
+          contents: [
+            {
+              role: 'model',
+              parts: [
+                {
+                  functionCall: {
+                    id: 'call-1',
+                    name: 'Read',
+                    args: {},
+                  },
                 },
-              },
-            ],
-          },
-          {
-            role: 'user',
-            parts: [
-              {
-                functionResponse: {
-                  id: 'call-1',
-                  name: 'Read',
-                  response: { output: 'Audio content' },
-                  parts: [
-                    {
-                      inlineData: {
-                        mimeType: 'audio/mpeg',
-                        data: 'base64encodedaudiodata',
+              ],
+            },
+            {
+              role: 'user',
+              parts: [
+                {
+                  functionResponse: {
+                    id: 'call-1',
+                    name: 'Read',
+                    response: { output: 'Unsupported content' },
+                    parts: [
+                      {
+                        inlineData: {
+                          mimeType,
+                          data: 'base64encodeddata',
+                        },
                       },
-                    },
-                  ],
+                    ],
+                  },
                 },
-              },
-            ],
-          },
-        ],
-      });
+              ],
+            },
+          ],
+        });
 
-      expect(messages).toHaveLength(2);
-      expect(messages[1]?.role).toBe('user');
+        expect(messages).toHaveLength(2);
+        expect(messages[1]?.role).toBe('user');
 
-      const toolResult = messages[1]?.content?.[0] as {
-        type: string;
-        content: Array<{ type: string; text?: string }>;
-      };
-      expect(toolResult.type).toBe('tool_result');
-      expect(Array.isArray(toolResult.content)).toBe(true);
-      expect(toolResult.content[0]).toEqual({
-        type: 'text',
-        text: 'Audio content',
-      });
-      expect(toolResult.content[1]?.type).toBe('text');
-      expect(toolResult.content[1]?.text).toContain(
-        'Unsupported inline media type',
-      );
-      expect(toolResult.content[1]?.text).toContain('audio/mpeg');
-    });
+        const toolResult = messages[1]?.content?.[0] as {
+          type: string;
+          content: Array<{ type: string; text?: string }>;
+        };
+        expect(toolResult.type).toBe('tool_result');
+        expect(Array.isArray(toolResult.content)).toBe(true);
+        expect(toolResult.content[0]).toEqual({
+          type: 'text',
+          text: 'Unsupported content',
+        });
+        expect(toolResult.content[1]?.type).toBe('text');
+        expect(toolResult.content[1]?.text).toContain(
+          'Unsupported inline media type',
+        );
+        expect(toolResult.content[1]?.text).toContain(mimeType);
+      },
+    );
 
     it('converts inlineData with PDF into document block', () => {
       const { messages } = converter.convertGeminiRequestToAnthropic({
diff --git a/packages/core/src/core/openaiContentGenerator/converter.test.ts b/packages/core/src/core/openaiContentGenerator/converter.test.ts
index 0b939fecf43..453c4764364 100644
--- a/packages/core/src/core/openaiContentGenerator/converter.test.ts
+++ b/packages/core/src/core/openaiContentGenerator/converter.test.ts
@@ -7391,20 +7391,24 @@ describe('modality filtering', () => {
     expect(parts[0].text).toContain('does not support image input');
   });
 
-  it('keeps image when image modality is enabled', () => {
+  it('keeps BMP image data when image modality is enabled', () => {
     const conv = OpenAIContentConverter;
     const request = makeRequest([
       {
-        inlineData: { mimeType: 'image/png', data: 'abc123' },
+        inlineData: { mimeType: 'image/bmp', data: 'abc123' },
       } as unknown as Part,
     ]);
     const messages = conv.convertGeminiRequestToOpenAI(
       request,
       makeRequestContext('gpt-4o', { image: true }),
     );
-    const parts = getUserContentParts(messages);
+    const parts = getUserContentParts(messages) as Array<{
+      type: string;
+      image_url?: { url: string };
+    }>;
     expect(parts).toHaveLength(1);
     expect(parts[0].type).toBe('image_url');
+    expect(parts[0].image_url?.url).toBe('data:image/bmp;base64,abc123');
   });
 
   it('replaces PDF with placeholder when pdf modality is disabled', () => {
diff --git a/packages/web-shell/client/App.module.css b/packages/web-shell/client/App.module.css
index fad4f199621..e259740c1af 100644
--- a/packages/web-shell/client/App.module.css
+++ b/packages/web-shell/client/App.module.css
@@ -1031,6 +1031,12 @@
   color: var(--foreground);
 }
 
+.queuedPromptAmbiguity {
+  color: var(--secondary-foreground);
+  font-size: 12px;
+  line-height: 18px;
+}
+
 .queuedPrompt + .queuedPrompt {
   border-top: 0;
 }
diff --git a/packages/web-shell/client/App.test.tsx b/packages/web-shell/client/App.test.tsx
index 2ea86430f1a..32862d2d07c 100644
--- a/packages/web-shell/client/App.test.tsx
+++ b/packages/web-shell/client/App.test.tsx
@@ -2,14 +2,15 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { act, createRef, type CSSProperties, type ReactNode } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
-import type {
-  DaemonInputAnnotation,
-  DaemonSessionContextUsageStatus,
-  DaemonSessionMonitorTaskStatus,
-  DaemonSessionShellTaskStatus,
-  DaemonSessionStatsStatus,
-  DaemonSettingDescriptor,
-  DaemonWorkspaceGitStatus,
+import {
+  DaemonHttpError,
+  type DaemonInputAnnotation,
+  type DaemonSessionContextUsageStatus,
+  type DaemonSessionMonitorTaskStatus,
+  type DaemonSessionShellTaskStatus,
+  type DaemonSessionStatsStatus,
+  type DaemonSettingDescriptor,
+  type DaemonWorkspaceGitStatus,
 } from '@qwen-code/sdk/daemon';
 import type { WebShellApi } from './App';
 import type { Message } from './adapters/types';
@@ -148,6 +149,7 @@ const {
   editorCommit,
   editorFocus,
   editorInsertText,
+  editorRestoreInputAnnotations,
   settingsReload,
   settingsSetValue,
   qualifiedWorkspaceSettings,
@@ -358,6 +360,7 @@ const {
     editorCommit: vi.fn(),
     editorFocus: vi.fn(),
     editorInsertText: vi.fn(),
+    editorRestoreInputAnnotations: vi.fn(),
     settingsReload: vi.fn().mockResolvedValue(undefined),
     settingsSetValue,
     qualifiedWorkspaceSettings,
@@ -479,6 +482,14 @@ vi.mock('./components/ChatEditor', async () => {
           hasAttachments: () => boolean;
           hasInput: () => boolean;
           insertText: (text: string) => void;
+          getText: () => string;
+          setText: (text: string) => void;
+          restoreImages: (
+            images: readonly { data: string; media_type: string }[],
+          ) => void;
+          restoreInputAnnotations: (
+            inputAnnotations: readonly DaemonInputAnnotation[],
+          ) => void;
           submit: (input?: { text?: string }) => void;
           focus: () => void;
         }>,
@@ -508,6 +519,12 @@ vi.mock('./components/ChatEditor', async () => {
             ),
           hasInput: () => testState.prompt.trim().length > 0,
           insertText: editorInsertText,
+          getText: () => testState.prompt,
+          setText: (text) => {
+            testState.prompt = text;
+          },
+          restoreImages: () => undefined,
+          restoreInputAnnotations: editorRestoreInputAnnotations,
           submit: (input) => {
             const accepted = props.onSubmit(
               input?.text ?? testState.prompt,
@@ -4298,6 +4315,7 @@ beforeEach(() => {
   editorClear.mockClear();
   editorCommit.mockClear();
   editorFocus.mockClear();
+  editorRestoreInputAnnotations.mockClear();
   editorInsertText.mockClear();
   settingsReload.mockClear();
   settingsReload.mockResolvedValue(undefined);
@@ -9591,6 +9609,49 @@ describe('App session callbacks', () => {
     expect(sidebarTokens.at(-1)).not.toBe(tokenAfterSubmit);
   });
 
+  it('dispatches direct and queued submit events for image-only prompts', async () => {
+    const onSessionChange = vi.fn();
+    const images = [{ data: 'Ym1w', media_type: 'image/bmp' }];
+    const { rerender } = renderApp({ onSessionChange });
+    await flush();
+
+    act(() => {
+      testState.latestChatEditorProps?.onSubmit('', images);
+    });
+    await flush();
+    expect(mockSessionActions.sendPrompt).toHaveBeenCalledWith(
+      '',
+      expect.objectContaining({ images }),
+    );
+    expect(onSessionChange).toHaveBeenCalledWith({
+      type: 'submit',
+      sessionId: 'session-1',
+      prompt: '',
+      queued: false,
+    });
+
+    onSessionChange.mockClear();
+    act(() => {
+      testState.streamingState = 'responding';
+      rerender({ onSessionChange });
+    });
+    act(() => {
+      testState.latestChatEditorProps?.onSubmit('', images);
+    });
+    expect(rawEnqueuePrompt).toHaveBeenCalledWith(
+      '',
+      images,
+      undefined,
+      undefined,
+    );
+    expect(onSessionChange).toHaveBeenCalledWith({
+      type: 'submit',
+      sessionId: 'session-1',
+      prompt: '',
+      queued: true,
+    });
+  });
+
   it('cancels an approved direct submission after the session changes', async () => {
     let approve: (() => void) | undefined;
     const onSubmitBefore = vi.fn(
@@ -10675,6 +10736,73 @@ describe('App session callbacks', () => {
     });
   });
 
+  it('locks an image retry when its admission response is lost', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const retrySend = deferred<void>();
+    const images = [{ data: 'aGVsbG8=', media_type: 'image/png' }];
+    const inputAnnotations: DaemonInputAnnotation[] = [
+      {
+        type: 'reference',
+        start: 0,
+        end: 5,
+        text: 'hello',
+        reference: { id: 'file:hello', kind: 'file', value: 'hello' },
+      },
+    ];
+    const { container, rerender } = renderApp();
+    await flush();
+
+    act(() => {
+      testState.latestChatEditorProps?.onSubmit('hello', images, editorCommit, {
+        inputAnnotations,
+      });
+    });
+    await flush();
+    mockSessionActions.sendPrompt.mockClear();
+    act(() => {
+      testState.blocks = [
+        {
+          kind: 'error',
+          source: 'turn_error',
+          id: 'turn-error-retry',
+          errorKind: 'model_stream_interrupted',
+          text: 'terminated',
+        },
+      ];
+      rerender();
+    });
+    expect(container.querySelector('[data-testid="retry"]')).not.toBeNull();
+    mockSessionActions.sendPrompt.mockReturnValueOnce(retrySend.promise);
+
+    await act(async () => {
+      container
+        .querySelector<HTMLButtonElement>('[data-testid="retry"]')
+        ?.click();
+      await Promise.resolve();
+    });
+    await vi.waitFor(() => {
+      expect(mockSessionActions.sendPrompt).toHaveBeenCalledOnce();
+    });
+    const retryOptions = mockSessionActions.sendPrompt.mock.calls[0]?.[1];
+    expect(retryOptions).toMatchObject({
+      images,
+      inputAnnotations,
+      optimisticUserMessage: false,
+      retry: true,
+    });
+    act(() => retryOptions?.onAdmissionStarted?.());
+    await act(async () => {
+      retrySend.reject(new Error('response lost'));
+      await Promise.resolve();
+    });
+
+    expect(
+      container.querySelector('[data-testid="prompt-admission-unknown"]'),
+    ).not.toBeNull();
+    expect(testState.latestChatEditorProps?.disabled).toBe(true);
+    warn.mockRestore();
+  });
+
   it('gates queued submissions and only enqueues after approval', async () => {
     let approve: (() => void) | undefined;
     const onSubmitBefore = vi.fn(
@@ -13907,6 +14035,167 @@ describe('App session callbacks', () => {
 });
 
 describe('App prompt send failure retry', () => {
+  it('does not mark delivery unknown when lazy session creation fails before prompt admission', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    mockConnection.sessionId = undefined;
+    mockSessionActions.createSession.mockRejectedValueOnce(
+      new Error('session creation failed'),
+    );
+    renderApp();
+    await flush();
+
+    act(() => {
+      testState.latestChatEditorProps?.onSubmit(
+        'hello',
+        undefined,
+        editorCommit,
+      );
+    });
+    await flush();
+
+    expect(mockSessionActions.sendPrompt).not.toHaveBeenCalled();
+    expect(editorCommit).not.toHaveBeenCalled();
+    expect(
+      document.querySelector('[data-testid="prompt-admission-unknown"]'),
+    ).toBeNull();
+    expect(testState.latestChatEditorProps?.disabled).toBe(false);
+  });
+
+  it('keeps an unknown lazy-session admission scoped to its allocated session', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    mockConnection.sessionId = undefined;
+    mockSessionActions.createSession.mockResolvedValueOnce({
+      sessionId: 'session-created',
+    });
+    const firstSend = deferred<void>();
+    mockSessionActions.sendPrompt.mockReturnValueOnce(firstSend.promise);
+    const { rerender } = renderApp();
+    await flush();
+
+    act(() => {
+      testState.latestChatEditorProps?.onSubmit(
+        'hello',
+        undefined,
+        editorCommit,
+      );
+    });
+    await vi.waitFor(() => {
+      expect(mockSessionActions.sendPrompt).toHaveBeenCalledOnce();
+    });
+    const firstSendOptions = mockSessionActions.sendPrompt.mock.calls[0]?.[1];
+    act(() => firstSendOptions?.onAdmissionStarted?.());
+    act(() => {
+      mockConnection.sessionId = 'session-created';
+      rerender();
+    });
+    await act(async () => {
+      firstSend.reject(new Error('connection closed before response'));
+      await Promise.resolve();
+    });
+
+    expect(editorCommit).toHaveBeenCalledOnce();
+    expect(
+      document.querySelector('[data-testid="prompt-admission-unknown"]'),
+    ).not.toBeNull();
+  });
+
+  it('locks duplicate submission when prompt admission is unknown', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const firstSend = deferred<void>();
+    mockSessionActions.sendPrompt.mockImplementationOnce((_text, options) => {
+      options?.onAdmissionStarted?.();
+      return firstSend.promise;
+    });
+    const { rerender } = renderApp();
+    await flush();
+
+    act(() => {
+      testState.latestChatEditorProps?.onSubmit('hello');
+    });
+    await act(async () => {
+      firstSend.reject(new Error('connection closed before response'));
+      await Promise.resolve();
+    });
+
+    const notice = document.querySelector(
+      '[data-testid="prompt-admission-unknown"]',
+    );
+    expect(notice).not.toBeNull();
+    expect(
+      document.querySelector('[data-testid="failed-prompt-retry"]'),
+    ).toBeNull();
+    expect(testState.latestChatEditorProps?.disabled).toBe(true);
+
+    act(() => {
+      testState.streamingState = 'responding';
+      rerender();
+    });
+    expect(
+      document.querySelector('[data-testid="prompt-admission-unknown"]'),
+    ).not.toBeNull();
+    expect(testState.latestChatEditorProps?.disabled).toBe(true);
+
+    act(() => {
+      notice?.querySelectorAll('button').item(1).click();
+    });
+
+    expect(testState.latestChatEditorProps?.disabled).toBe(false);
+    expect(mockSessionActions.sendPrompt).toHaveBeenCalledTimes(1);
+    expect(
+      document.querySelector('[data-testid="prompt-admission-unknown"]'),
+    ).not.toBeNull();
+  });
+
+  it('restores direct prompt annotations after uncertain admission', async () => {
+    const confirm = vi.spyOn(window, 'confirm').mockReturnValue(true);
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const firstSend = deferred<void>();
+    mockSessionActions.sendPrompt.mockImplementationOnce((_text, options) => {
+      options?.onAdmissionStarted?.();
+      return firstSend.promise;
+    });
+    const inputAnnotations: DaemonInputAnnotation[] = [
+      {
+        type: 'reference',
+        start: 0,
+        end: 8,
+        text: '@file.ts',
+        reference: { id: 'file:file.ts', kind: 'file', value: 'file.ts' },
+      },
+    ];
+    renderApp();
+    await flush();
+
+    act(() => {
+      testState.latestChatEditorProps?.onSubmit(
+        '@file.ts fix',
+        undefined,
+        editorCommit,
+        { inputAnnotations },
+      );
+    });
+    await vi.waitFor(() => {
+      expect(mockSessionActions.sendPrompt).toHaveBeenCalledOnce();
+    });
+    await act(async () => {
+      firstSend.reject(new Error('response lost'));
+      await Promise.resolve();
+    });
+    act(() => {
+      document
+        .querySelector('[data-testid="prompt-admission-unknown"]')
+        ?.querySelectorAll('button')
+        .item(0)
+        .click();
+    });
+
+    expect(editorRestoreInputAnnotations).toHaveBeenCalledWith(
+      inputAnnotations,
+    );
+    confirm.mockRestore();
+    warn.mockRestore();
+  });
+
   it('marks the failed message and retries its original payload without a duplicate', async () => {
     vi.spyOn(console, 'error').mockImplementation(() => {});
     const firstSend = deferred<void>();
@@ -13934,7 +14223,7 @@ describe('App prompt send failure retry', () => {
     });
     testState.messages = [{ id: 'u1', role: 'user', content: 'hello' }];
     await act(async () => {
-      firstSend.reject(new Error('network down'));
+      firstSend.reject(new DaemonHttpError(413, {}, 'Prompt too large'));
       await Promise.resolve();
     });
 
@@ -13993,7 +14282,7 @@ describe('App prompt send failure retry', () => {
       rerender();
     });
     await act(async () => {
-      firstSend.reject(new Error('network down'));
+      firstSend.reject(new DaemonHttpError(413, {}, 'Prompt too large'));
       await Promise.resolve();
     });
 
@@ -14023,7 +14312,7 @@ describe('App prompt send failure retry', () => {
     });
     testState.messages = [{ id: 'u1', role: 'user', content: 'hello' }];
     await act(async () => {
-      firstSend.reject(new Error('network down'));
+      firstSend.reject(new DaemonHttpError(413, {}, 'Prompt too large'));
       await Promise.resolve();
     });
     act(() =>
@@ -14032,7 +14321,7 @@ describe('App prompt send failure retry', () => {
         ?.click(),
     );
     await act(async () => {
-      retrySend.reject(new Error('still down'));
+      retrySend.reject(new DaemonHttpError(413, {}, 'Prompt too large'));
       await Promise.resolve();
     });
 
@@ -14086,7 +14375,7 @@ describe('App prompt send failure retry', () => {
     });
     testState.messages = [{ id: 'u1', role: 'user', content: 'hello' }];
     await act(async () => {
-      firstSend.reject(new Error('network down'));
+      firstSend.reject(new DaemonHttpError(413, {}, 'Prompt too large'));
       await Promise.resolve();
     });
 
@@ -14157,7 +14446,7 @@ describe('App prompt send failure retry', () => {
     });
     testState.messages = [{ id: 'u1', role: 'user', content: 'first' }];
     await act(async () => {
-      firstSend.reject(new Error('network down'));
+      firstSend.reject(new DaemonHttpError(413, {}, 'Prompt too large'));
       await Promise.resolve();
     });
     expect(
diff --git a/packages/web-shell/client/App.tsx b/packages/web-shell/client/App.tsx
index 70db4cf0306..2d3affaca0f 100644
--- a/packages/web-shell/client/App.tsx
+++ b/packages/web-shell/client/App.tsx
@@ -254,6 +254,7 @@ import {
   shouldDisableComposerInput,
   type ComposerPlaceholderState,
 } from './utils/composerInputState';
+import { isDefinitelyRejectedPromptAdmission } from './utils/promptAdmission';
 import type { ACPToolCall, Message, PermissionRequest } from './adapters/types';
 import { isBackgroundSubAgentToolCall } from './adapters/toolClassification';
 import {
@@ -480,6 +481,7 @@ interface SendPromptOptionsWithRetry {
   images?: PromptImage[];
   inputAnnotations?: DaemonInputAnnotation[];
   retry?: boolean;
+  onAdmissionStarted?: () => void;
   clearComposerOnPromptStart?: boolean;
   commitComposerAccepted?: ComposerSubmitCommit;
   onAdmitted?: () => void;
@@ -506,6 +508,15 @@ interface FailedPromptRetry {
   settled: boolean;
 }
 
+interface UnknownPromptAdmission {
+  sessionId: string;
+  messageId?: string;
+  text?: string;
+  images?: PromptImage[];
+  inputAnnotations?: DaemonInputAnnotation[];
+  payloadAvailable: boolean;
+}
+
 function getLatestUserBlockId(
   blocks: readonly DaemonTranscriptBlock[],
 ): string | undefined {
@@ -2216,6 +2227,16 @@ export function App({
   const failedPromptRef = useRef<FailedPrompt | null>(failedPrompt);
   const [failedPromptRetry, setFailedPromptRetry] =
     useState<FailedPromptRetry | null>(null);
+  const [unknownPromptAdmission, setUnknownPromptAdmission] =
+    useState<UnknownPromptAdmission | null>(null);
+  const unknownPromptAdmissionRef = useRef<UnknownPromptAdmission | null>(null);
+  const updateUnknownPromptAdmission = useCallback(
+    (next: UnknownPromptAdmission | null) => {
+      unknownPromptAdmissionRef.current = next;
+      setUnknownPromptAdmission(next);
+    },
+    [],
+  );
   const updateFailedPrompt = useCallback((next: FailedPrompt | null) => {
     failedPromptRef.current = next;
     setFailedPrompt(next);
@@ -2276,6 +2297,12 @@ export function App({
       updateFailedPrompt(null);
     }
   }, [connection.sessionId, displayMessages, failedPrompt, updateFailedPrompt]);
+  useEffect(() => {
+    const unknown = unknownPromptAdmissionRef.current;
+    if (unknown && unknown.sessionId !== connection.sessionId) {
+      updateUnknownPromptAdmission(null);
+    }
+  }, [connection.sessionId, updateUnknownPromptAdmission]);
   const {
     artifacts,
     loading: artifactsLoading,
@@ -3673,6 +3700,12 @@ export function App({
   }, [displayMessages, streamingState]);
   const lastSubmittedPromptRef = useRef<string>('');
   const lastSubmittedImagesRef = useRef<PromptImage[] | undefined>(undefined);
+  const lastSubmittedInputAnnotationsRef = useRef<
+    DaemonInputAnnotation[] | undefined
+  >(undefined);
+  const lastSubmittedSourceVersionRef = useRef(
+    composerSourceVersionRef.current,
+  );
   const retryableTurnErrorIdRef = useRef<string | null>(null);
   const retriedTurnErrorIdRef = useRef<string | null>(null);
   const [showRetryHint, setShowRetryHint] = useState(false);
@@ -4681,6 +4714,7 @@ export function App({
         inputAnnotations?: DaemonInputAnnotation[];
         clearComposerOnPromptStart?: boolean;
         commitComposerAccepted?: ComposerSubmitCommit;
+        onAdmissionStarted?: (sessionId: string | undefined) => void;
         onAdmitted?: () => void;
         onOptimisticUserMessage?: (message: OptimisticUserMessage) => void;
       },
@@ -4688,18 +4722,29 @@ export function App({
       const isUserPrompt = !text.trimStart().startsWith('/');
       const previousLastSubmittedPrompt = lastSubmittedPromptRef.current;
       const previousLastSubmittedImages = lastSubmittedImagesRef.current;
+      const previousLastSubmittedInputAnnotations =
+        lastSubmittedInputAnnotationsRef.current;
+      const previousLastSubmittedSourceVersion =
+        lastSubmittedSourceVersionRef.current;
       const previousRetriedTurnErrorId = retriedTurnErrorIdRef.current;
       const previousShowRetryHint = showRetryHintRef.current;
       const restoreCancelledSubmitState = () => {
         setIsPreparingPrompt(false);
         lastSubmittedPromptRef.current = previousLastSubmittedPrompt;
         lastSubmittedImagesRef.current = previousLastSubmittedImages;
+        lastSubmittedInputAnnotationsRef.current =
+          previousLastSubmittedInputAnnotations;
+        lastSubmittedSourceVersionRef.current =
+          previousLastSubmittedSourceVersion;
         retriedTurnErrorIdRef.current = previousRetriedTurnErrorId;
         setShowRetryHint(previousShowRetryHint);
       };
       if (!opts?.retry && isUserPrompt) {
         lastSubmittedPromptRef.current = text;
         lastSubmittedImagesRef.current = images;
+        lastSubmittedInputAnnotationsRef.current = opts?.inputAnnotations;
+        lastSubmittedSourceVersionRef.current =
+          composerSourceVersionRef.current;
         retriedTurnErrorIdRef.current = null;
       }
       setShowRetryHint(false);
@@ -4755,6 +4800,14 @@ export function App({
         inputAnnotations: opts?.inputAnnotations,
         optimisticUserMessage: opts?.optimisticUserMessage,
         retry: opts?.retry,
+        ...(opts?.onAdmissionStarted
+          ? {
+              onAdmissionStarted: () =>
+                opts.onAdmissionStarted?.(
+                  connectionRef.current.sessionId ?? allocatedSessionId,
+                ),
+            }
+          : {}),
         ...(opts?.onAdmitted ? { onAdmitted: opts.onAdmitted } : {}),
       };
       if (opts?.commitComposerAccepted) {
@@ -4764,7 +4817,7 @@ export function App({
       }
       const sessionIdAfterEnsure =
         connectionRef.current.sessionId ?? allocatedSessionId;
-      if (sessionIdAfterEnsure && text.trim()) {
+      if (sessionIdAfterEnsure && (text.trim() || (images?.length ?? 0) > 0)) {
         dispatchSessionChangeRef.current?.({
           type: 'submit',
           sessionId: sessionIdAfterEnsure,
@@ -4989,6 +5042,15 @@ export function App({
       updateFailedPrompt(null);
       return;
     }
+    const retryOwner = {
+      sourceVersion: composerSourceVersionRef.current,
+      sessionId: connectionRef.current.sessionId,
+      workspaceCwd: getComposerWorkspaceCwd(),
+    };
+    const retryOwnerIsCurrent = () =>
+      composerSourceVersionRef.current === retryOwner.sourceVersion &&
+      connectionRef.current.sessionId === retryOwner.sessionId &&
+      getComposerWorkspaceCwd() === retryOwner.workspaceCwd;
     updateFailedPrompt(null);
     const retryStartedAt = Date.now();
     setFailedPromptRetry({
@@ -4999,11 +5061,16 @@ export function App({
       settled: false,
     });
     let admitted = false;
+    let admissionStarted = false;
     sendPrompt(failed.text, failed.images, {
       optimisticUserMessage: false,
       inputAnnotations: failed.inputAnnotations,
+      onAdmissionStarted: () => {
+        admissionStarted = true;
+      },
       onAdmitted: () => {
         admitted = true;
+        if (!retryOwnerIsCurrent()) return;
         setFailedPromptRetry((current) =>
           current?.sessionId === failed.sessionId &&
           current.messageId === failed.messageId
@@ -5013,6 +5080,24 @@ export function App({
       },
     })
       .catch((error: unknown) => {
+        if (!retryOwnerIsCurrent()) return;
+        const definitelyRejected = isDefinitelyRejectedPromptAdmission(error);
+        if (admissionStarted && !admitted && !definitelyRejected) {
+          updateUnknownPromptAdmission({
+            sessionId: failed.sessionId,
+            messageId: failed.messageId,
+            text: failed.text,
+            images: failed.images ? [...failed.images] : undefined,
+            inputAnnotations: failed.inputAnnotations,
+            payloadAvailable: true,
+          });
+          pushToast('warning', t('queue.admissionUnknown'));
+          console.warn(
+            '[WebShell] prompt retry admission outcome is unknown',
+            error,
+          );
+          return;
+        }
         if (
           !admitted &&
           connectionRef.current.sessionId === failed.sessionId &&
@@ -5023,6 +5108,7 @@ export function App({
         reportError(error, 'Failed to resend message');
       })
       .finally(() => {
+        if (!retryOwnerIsCurrent()) return;
         setFailedPromptRetry((current) =>
           current?.sessionId === failed.sessionId &&
           current.messageId === failed.messageId
@@ -5030,7 +5116,16 @@ export function App({
             : current,
         );
       });
-  }, [reportError, sendPrompt, store, updateFailedPrompt]);
+  }, [
+    getComposerWorkspaceCwd,
+    pushToast,
+    reportError,
+    sendPrompt,
+    store,
+    t,
+    updateFailedPrompt,
+    updateUnknownPromptAdmission,
+  ]);
   const canMutateMidTurn =
     connection.capabilities?.features.includes(
       'session_mid_turn_message_mutation',
@@ -5043,6 +5138,8 @@ export function App({
     editQueuedPrompt,
     editLastQueuedPrompt,
     clearQueuedPrompts,
+    restoreUnknownQueuedPrompt,
+    discardUnknownQueuedPrompt,
   } = useQueuedPrompts({
     connected,
     sessionId: connection.sessionId,
@@ -5094,7 +5191,7 @@ export function App({
                 editorRef.current?.clear();
               }
             }
-            if (sourceSessionId && text.trim()) {
+            if (sourceSessionId && (text.trim() || (images?.length ?? 0) > 0)) {
               dispatchSessionChangeRef.current?.({
                 type: 'submit',
                 sessionId: sourceSessionId,
@@ -5118,7 +5215,7 @@ export function App({
         inputAnnotations,
       );
       const sessionId = connectionRef.current.sessionId;
-      if (sessionId && text.trim()) {
+      if (sessionId && (text.trim() || (images?.length ?? 0) > 0)) {
         dispatchSessionChangeRef.current?.({
           type: 'submit',
           sessionId,
@@ -5964,7 +6061,10 @@ export function App({
       connected &&
       retryableTurnErrorId !== null &&
       retryableTurnErrorId !== retriedTurnErrorIdRef.current &&
-      lastSubmittedPromptRef.current.length > 0;
+      lastSubmittedSourceVersionRef.current ===
+        composerSourceVersionRef.current &&
+      (lastSubmittedPromptRef.current.length > 0 ||
+        (lastSubmittedImagesRef.current?.length ?? 0) > 0);
     retryableTurnErrorIdRef.current = canRetry ? retryableTurnErrorId : null;
     setShowRetryHint(canRetry);
   }, [blocks, connected]);
@@ -6777,6 +6877,7 @@ export function App({
 
   const loadSidebarSession = useCallback(
     async (sessionId: string, workspaceCwd?: string) => {
+      composerSourceVersionRef.current += 1;
       composerFocusRequestRef.current += 1;
       setSidebarSwitchingSessionId(sessionId);
       setGitModeIntent({ mode: 'current' });
@@ -7181,6 +7282,13 @@ export function App({
       commitComposerAccepted?: ComposerSubmitCommit,
       metadata?: { inputAnnotations?: DaemonInputAnnotation[] },
     ) => {
+      if (
+        unknownPromptAdmissionRef.current?.payloadAvailable &&
+        unknownPromptAdmissionRef.current.sessionId ===
+          connectionRef.current.sessionId
+      ) {
+        return false;
+      }
       if (
         invokeSlashCommandHandler(text, onSlashCommandRef.current, reportError)
       ) {
@@ -7212,18 +7320,34 @@ export function App({
           trackSendFailure?: boolean;
         },
       ) => {
+        const admissionOwner = {
+          sourceVersion: composerSourceVersionRef.current,
+          sessionId: connectionRef.current.sessionId,
+          workspaceCwd: getComposerWorkspaceCwd(),
+        };
+        const admissionOwnerIsCurrent = () =>
+          composerSourceVersionRef.current === admissionOwner.sourceVersion &&
+          (admissionOwner.sessionId === undefined ||
+            (connectionRef.current.sessionId === admissionOwner.sessionId &&
+              getComposerWorkspaceCwd() === admissionOwner.workspaceCwd));
         const { trackSendFailure = false, ...sendOptions } = opts ?? {};
         const deferComposerCommit = Boolean(onSubmitBeforeRef.current);
         const clearComposerOnPromptStart =
           !connectionRef.current.sessionId || deferComposerCommit;
         let optimisticUserMessage: OptimisticUserMessage | undefined;
         let admitted = false;
+        let admissionStarted = false;
+        let admissionSessionId: string | undefined;
         sendPrompt(promptText, promptImages, {
           ...sendOptions,
           clearComposerOnPromptStart,
           commitComposerAccepted: clearComposerOnPromptStart
             ? commitComposerAccepted
             : undefined,
+          onAdmissionStarted: (sessionId) => {
+            admissionStarted = true;
+            admissionSessionId = sessionId;
+          },
           onAdmitted: () => {
             admitted = true;
           },
@@ -7235,7 +7359,32 @@ export function App({
               }
             : {}),
         }).catch((error: unknown) => {
+          if (!admissionOwnerIsCurrent()) return;
           const failedMessage = optimisticUserMessage;
+          const definitelyRejected = isDefinitelyRejectedPromptAdmission(error);
+          if (admissionStarted && !admitted && !definitelyRejected) {
+            updateFailedPrompt(null);
+            const uncertainSessionId =
+              failedMessage?.sessionId ??
+              admissionSessionId ??
+              connectionRef.current.sessionId;
+            if (uncertainSessionId) {
+              updateUnknownPromptAdmission({
+                sessionId: uncertainSessionId,
+                messageId: failedMessage?.messageId,
+                text: promptText,
+                images: promptImages ? [...promptImages] : undefined,
+                inputAnnotations: sendOptions.inputAnnotations,
+                payloadAvailable: true,
+              });
+            }
+            pushToast('warning', t('queue.admissionUnknown'));
+            console.warn(
+              '[WebShell] prompt admission outcome is unknown',
+              error,
+            );
+            return;
+          }
           if (
             trackSendFailure &&
             !admitted &&
@@ -8177,6 +8326,7 @@ export function App({
       blockLocalCommandDuringTurn,
       createSideTask,
       sideTasksAvailable,
+      getComposerWorkspaceCwd,
       openEnvironmentTasksPanel,
       hiddenCommands,
       pushToast,
@@ -8196,6 +8346,7 @@ export function App({
       t,
       workspaceActions,
       updateFailedPrompt,
+      updateUnknownPromptAdmission,
     ],
   );
 
@@ -8264,6 +8415,49 @@ export function App({
     }
     editorRef.current?.focus();
   }, []);
+  const discardUnknownPromptPayload = useCallback(() => {
+    const current = unknownPromptAdmissionRef.current;
+    if (
+      !current?.payloadAvailable ||
+      current.sessionId !== connectionRef.current.sessionId
+    ) {
+      return;
+    }
+    updateUnknownPromptAdmission({
+      sessionId: current.sessionId,
+      messageId: current.messageId,
+      payloadAvailable: false,
+    });
+  }, [updateUnknownPromptAdmission]);
+  const restoreUnknownPromptPayload = useCallback(() => {
+    const current = unknownPromptAdmissionRef.current;
+    const editor = editorRef.current;
+    if (
+      !current?.payloadAvailable ||
+      current.sessionId !== connectionRef.current.sessionId ||
+      !editor
+    ) {
+      return;
+    }
+    if (!window.confirm(t('queue.continueEditingConfirm'))) return;
+    const draft = editor.getText();
+    const restoredText = current.text?.trim()
+      ? draft.trim()
+        ? `${current.text}\n${draft}`
+        : current.text
+      : draft;
+    if (restoredText !== draft) editor.setText(restoredText);
+    if (current.images?.length) editor.restoreImages(current.images);
+    if (current.inputAnnotations?.length) {
+      editor.restoreInputAnnotations?.(current.inputAnnotations);
+    }
+    editor.focus();
+    updateUnknownPromptAdmission({
+      sessionId: current.sessionId,
+      messageId: current.messageId,
+      payloadAvailable: false,
+    });
+  }, [t, updateUnknownPromptAdmission]);
   const handleCanScrollToBottomChange = useCallback(
     (canScrollToBottom: boolean) => {
       setCanScrollMessageListToBottom(canScrollToBottom);
@@ -8278,10 +8472,18 @@ export function App({
       streamingStateRef.current === 'idle' &&
       retryableTurnErrorIdRef.current &&
       connectionRef.current.sessionId &&
-      lastSubmittedPromptRef.current
+      (lastSubmittedPromptRef.current ||
+        (lastSubmittedImagesRef.current?.length ?? 0) > 0)
     ) {
       const retryErrorId = retryableTurnErrorIdRef.current;
       const retrySessionId = connectionRef.current.sessionId;
+      const retrySourceVersion = composerSourceVersionRef.current;
+      const retryText = lastSubmittedPromptRef.current;
+      const retryImages = lastSubmittedImagesRef.current;
+      const retryInputAnnotations = lastSubmittedInputAnnotationsRef.current;
+      const retryOwnerIsCurrent = () =>
+        composerSourceVersionRef.current === retrySourceVersion &&
+        connectionRef.current.sessionId === retrySessionId;
       retriedTurnErrorIdRef.current = retryErrorId;
       setShowRetryHint(false);
       setFailedPromptRetry({
@@ -8291,24 +8493,49 @@ export function App({
         admitted: false,
         settled: false,
       });
-      sendPrompt(
-        lastSubmittedPromptRef.current,
-        lastSubmittedImagesRef.current,
-        {
-          optimisticUserMessage: false,
-          retry: true,
-          onAdmitted: () => {
-            setFailedPromptRetry((current) =>
-              current?.sessionId === retrySessionId &&
-              current.messageId === retryErrorId
-                ? { ...current, admitted: true }
-                : current,
-            );
-          },
+      let admissionStarted = false;
+      let admitted = false;
+      sendPrompt(retryText, retryImages, {
+        optimisticUserMessage: false,
+        retry: true,
+        inputAnnotations: retryInputAnnotations,
+        onAdmissionStarted: () => {
+          admissionStarted = true;
         },
-      )
-        .catch((error: unknown) => reportError(error, 'Failed to retry prompt'))
+        onAdmitted: () => {
+          admitted = true;
+          if (!retryOwnerIsCurrent()) return;
+          setFailedPromptRetry((current) =>
+            current?.sessionId === retrySessionId &&
+            current.messageId === retryErrorId
+              ? { ...current, admitted: true }
+              : current,
+          );
+        },
+      })
+        .catch((error: unknown) => {
+          if (!retryOwnerIsCurrent()) return;
+          const definitelyRejected = isDefinitelyRejectedPromptAdmission(error);
+          if (admissionStarted && !admitted && !definitelyRejected) {
+            updateUnknownPromptAdmission({
+              sessionId: retrySessionId,
+              messageId: retryErrorId,
+              text: retryText,
+              images: retryImages ? [...retryImages] : undefined,
+              inputAnnotations: retryInputAnnotations,
+              payloadAvailable: true,
+            });
+            pushToast('warning', t('queue.admissionUnknown'));
+            console.warn(
+              '[WebShell] post-turn retry admission outcome is unknown',
+              error,
+            );
+            return;
+          }
+          reportError(error, 'Failed to retry prompt');
+        })
         .finally(() => {
+          if (!retryOwnerIsCurrent()) return;
           setFailedPromptRetry((current) =>
             current?.sessionId === retrySessionId &&
             current.messageId === retryErrorId
@@ -8319,7 +8546,15 @@ export function App({
     } else {
       store.dispatch([{ type: 'status', text: t('retry.none') }]);
     }
-  }, [connected, sendPrompt, reportError, store, t]);
+  }, [
+    connected,
+    pushToast,
+    reportError,
+    sendPrompt,
+    store,
+    t,
+    updateUnknownPromptAdmission,
+  ]);
 
   useEffect(() => {
     const onGlobalShortcut = (e: KeyboardEvent) => {
@@ -9134,6 +9369,7 @@ export function App({
     onNestedArtifactsChange: handlePaneArtifactsChange,
     onError: reportError,
     sessionWorkflowEnabled,
+    onImageIngestionNotice: pushToast,
     onClose: closeArtifactPanel,
     fullscreen: artifactPanelFullscreen,
     onToggleFullscreen: toggleArtifactPanelFullscreen,
@@ -10152,6 +10388,7 @@ export function App({
                         // is launched from), not the single-session chat.
                         onExit={handleSplitExit}
                         onError={reportError}
+                        onImageIngestionNotice={pushToast}
                         onSlashCommand={onSlashCommand}
                         onRightPanelOpen={handleTurnOutputOpen}
                         onOpenMonitor={openMonitorPanel}
@@ -10544,17 +10781,61 @@ export function App({
                             {t('editor.escClearHint')}
                           </div>
                         ) : null}
+                        {unknownPromptAdmission &&
+                          unknownPromptAdmission.sessionId ===
+                            connection.sessionId && (
+                          <div
+                            className={styles.composerActionTip}
+                            role="status"
+                            data-testid="prompt-admission-unknown"
+                          >
+                            <span
+                              className={styles.composerActionTipIcon}
+                              aria-hidden="true"
+                            >
+                              !
+                            </span>
+                            <span className={styles.composerActionTipText}>
+                              {t('queue.admissionUnknown')}
+                            </span>
+                            {unknownPromptAdmission.payloadAvailable && (
+                              <div
+                                className={styles.composerActionTipActions}
+                              >
+                                <button
+                                  type="button"
+                                  className={`${styles.composerActionTipButton} ${styles.composerActionTipButtonPrimary}`}
+                                  onClick={restoreUnknownPromptPayload}
+                                >
+                                  {t('queue.restoreUnknown')}
+                                </button>
+                                <button
+                                  type="button"
+                                  className={styles.composerActionTipButton}
+                                  onClick={discardUnknownPromptPayload}
+                                >
+                                  {t('queue.discardUnknown')}
+                                </button>
+                              </div>
+                            )}
+                          </div>
+                        )}
                         <QueuedPromptDisplay
                           prompts={queuedPrompts}
                           t={t}
                           canMutateMidTurn={canMutateMidTurn}
                           onDelete={removeQueuedPrompt}
                           onEdit={editQueuedPrompt}
+                          onRestoreUnknown={restoreUnknownQueuedPrompt}
+                          onDiscardUnknown={discardUnknownQueuedPrompt}
                         />
                         {CustomComposerHeader && (
                           <div className={styles.composerHeader}>
                             <CustomComposerHeader
-                              disabled={isDisabled}
+                              disabled={
+                                isDisabled ||
+                                unknownPromptAdmission?.payloadAvailable === true
+                              }
                               isRunning={streamingState !== 'idle'}
                               currentMode={currentMode}
                               currentModel={currentModel}
@@ -10569,6 +10850,7 @@ export function App({
                           onAttachmentsChange={
                             handleComposerAttachmentsChange
                           }
+                          onImageIngestionNotice={pushToast}
                           onCycleMode={handleCycleMode}
                           onToggleShortcuts={handleToggleShortcuts}
                           onCancel={handleCancel}
@@ -10581,7 +10863,8 @@ export function App({
                             isDisabled ||
                             isStartingNewSessionSuggestion ||
                             interactionBlocked ||
-                            approvalOverlayActive
+                            approvalOverlayActive ||
+                            unknownPromptAdmission?.payloadAvailable === true
                           }
                           commands={commands}
                           skills={loadedSkills}
diff --git a/packages/web-shell/client/components/ChatEditor.module.css b/packages/web-shell/client/components/ChatEditor.module.css
index 606b085a0da..d4fb6ebab92 100644
--- a/packages/web-shell/client/components/ChatEditor.module.css
+++ b/packages/web-shell/client/components/ChatEditor.module.css
@@ -39,6 +39,15 @@
   padding: 12px;
 }
 
+.container[data-image-drag-active] .content {
+  border-color: var(--primary);
+  background: color-mix(
+    in srgb,
+    var(--primary) 6%,
+    var(--chat-editor-bg-primary)
+  );
+}
+
 .specularEffect {
   position: absolute;
   inset: -20px;
@@ -1788,11 +1797,16 @@
   border-radius: 0 0 0 4px;
 }
 
-.imageRemove:hover {
+.imageRemove:not(:disabled):hover {
   background: var(--error-color);
   color: var(--chat-editor-text-primary);
 }
 
+.imageRemove:disabled {
+  cursor: default;
+  opacity: 0.55;
+}
+
 .searchPanel {
   display: flex;
   flex-direction: column;
diff --git a/packages/web-shell/client/components/ChatEditor.test.tsx b/packages/web-shell/client/components/ChatEditor.test.tsx
index b5a33bfa0d4..746c54d2423 100644
--- a/packages/web-shell/client/components/ChatEditor.test.tsx
+++ b/packages/web-shell/client/components/ChatEditor.test.tsx
@@ -136,6 +136,10 @@ vi.mock('../hooks/useComposerCore', async (importOriginal) => {
         mockComposerCoreState.pastedImages.length > 0 ||
         mockComposerCoreState.composerTags.length > 0,
       hasContent: false,
+      canSubmit: false,
+      pendingImageBatchCount: 0,
+      imageDragActive: false,
+      imageTransferHandlers: {},
       handle: {
         focus: vi.fn(),
         insertText: vi.fn(),
@@ -527,6 +531,15 @@ describe('ChatEditor attachment reporting', () => {
       onAttachmentsChange: onImageAttachmentsChange,
     });
     expect(onImageAttachmentsChange).toHaveBeenLastCalledWith(true);
+
+    const disabled = renderChatEditor({
+      disabled: true,
+      pastedImages: [{ data: 'abc', media_type: 'image/png' }],
+    });
+    expect(disabled.querySelector('img')?.nextElementSibling).toHaveProperty(
+      'disabled',
+      true,
+    );
   });
 });
 
diff --git a/packages/web-shell/client/components/ChatEditor.tsx b/packages/web-shell/client/components/ChatEditor.tsx
index 9b6e8c07fc2..c43fd0cc0a6 100644
--- a/packages/web-shell/client/components/ChatEditor.tsx
+++ b/packages/web-shell/client/components/ChatEditor.tsx
@@ -201,6 +201,7 @@ interface ChatEditorProps {
   composerTagIcons?: WebShellComposerTagIconMap;
   voiceTarget?: VoiceWorkspaceTarget;
   voiceStatusRevision?: VoiceStatusRevision;
+  onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
 }
 
 const CHAT_EDITOR_THEME = {
@@ -1203,6 +1204,7 @@ export const ChatEditor = memo(
       composerTagIcons,
       voiceTarget,
       voiceStatusRevision,
+      onImageIngestionNotice,
     } = props;
 
     const {
@@ -1245,6 +1247,7 @@ export const ChatEditor = memo(
       renderComposerTag,
       renderComposerTagTooltip,
       onComposerTagClick,
+      onImageIngestionNotice,
       editorTheme: CHAT_EDITOR_THEME,
     });
 
@@ -1688,6 +1691,7 @@ export const ChatEditor = memo(
     const showModeLabel = toolbarLabelVisibility.mode;
     const showModelLabel = toolbarLabelVisibility.model;
     const showCancelButton = isRunning && !core.hasContent;
+    const composerPreparing = isPreparing || core.pendingImageBatchCount > 0;
     const mobileVoiceActive = showQuickActions && voiceActive;
 
     useEffect(() => {
@@ -1881,6 +1885,9 @@ export const ChatEditor = memo(
           className={styles.container}
           data-web-shell-composer-surface
           data-typewriter-visible={showTypewriterPlaceholder || undefined}
+          data-image-drag-active={core.imageDragActive || undefined}
+          aria-busy={core.pendingImageBatchCount > 0 || undefined}
+          {...core.imageTransferHandlers}
           onClick={() => {
             setModeDropdownOpen(false);
             setModelDropdownOpen(false);
@@ -2013,9 +2020,12 @@ export const ChatEditor = memo(
                           alt=""
                         />
                         <button
+                          type="button"
                           className={styles.imageRemove}
+                          disabled={disabled}
                           onClick={(e) => {
                             e.stopPropagation();
+                            if (disabled) return;
                             core.removeImage(i);
                           }}
                         >
@@ -2085,7 +2095,6 @@ export const ChatEditor = memo(
                   value={core.mobileComposer.value}
                   onChange={core.mobileComposer.onChange}
                   onBlur={core.mobileComposer.onBlur}
-                  onPaste={core.mobileComposer.onPaste}
                   placeholder={core.mobileComposer.placeholder}
                   disabled={core.disabled}
                   rows={1}
@@ -2398,23 +2407,23 @@ export const ChatEditor = memo(
                 )}
                 <button
                   className={
-                    isPreparing || showCancelButton
+                    composerPreparing || showCancelButton
                       ? `${styles.sendBtn} ${styles.sendBtnRunning}${
                           cancelArmed ? ` ${styles.sendBtnArmed}` : ''
                         }`
                       : styles.sendBtn
                   }
                   disabled={
-                    isPreparing
+                    composerPreparing
                       ? true
                       : showCancelButton
                         ? !onCancel
-                        : core.disabled || !core.hasContent
+                        : !core.canSubmit
                   }
                   data-web-shell-composer-submit
                   onClick={(e) => {
                     e.stopPropagation();
-                    if (isPreparing) {
+                    if (composerPreparing) {
                       return;
                     }
                     if (showCancelButton) {
@@ -2424,7 +2433,7 @@ export const ChatEditor = memo(
                     core.submitText();
                   }}
                   aria-label={
-                    isPreparing
+                    composerPreparing
                       ? t('common.loading')
                       : showCancelButton
                         ? cancelArmed
@@ -2438,7 +2447,7 @@ export const ChatEditor = memo(
                       : undefined
                   }
                 >
-                  {isPreparing ? (
+                  {composerPreparing ? (
                     <LoadingIcon />
                   ) : showCancelButton ? (
                     cancelArmed ? (
diff --git a/packages/web-shell/client/components/ChatPane.module.css b/packages/web-shell/client/components/ChatPane.module.css
index 2abe4aa85db..ea20b9b6cd9 100644
--- a/packages/web-shell/client/components/ChatPane.module.css
+++ b/packages/web-shell/client/components/ChatPane.module.css
@@ -199,3 +199,32 @@
 .approval {
   margin-bottom: 8px;
 }
+
+.admissionUnknown {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin-bottom: 8px;
+  padding: 7px 9px;
+  border: 1px solid var(--warning-border);
+  border-radius: 8px;
+  background: var(--warning-bg);
+  color: var(--warning-color);
+  font-size: 12px;
+}
+
+.admissionUnknownActions {
+  display: inline-flex;
+  flex: 0 0 auto;
+  gap: 6px;
+}
+
+.admissionUnknownActions button {
+  border: 1px solid var(--warning-border);
+  border-radius: 6px;
+  padding: 3px 7px;
+  background: var(--background);
+  color: inherit;
+  cursor: pointer;
+}
diff --git a/packages/web-shell/client/components/ChatPane.test.tsx b/packages/web-shell/client/components/ChatPane.test.tsx
index b31e3d60e82..ba04f6c5b5c 100644
--- a/packages/web-shell/client/components/ChatPane.test.tsx
+++ b/packages/web-shell/client/components/ChatPane.test.tsx
@@ -8,6 +8,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { act, forwardRef, useImperativeHandle } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
+import { DaemonHttpError } from '@qwen-code/sdk/daemon';
 import { I18nProvider } from '../i18n';
 import {
   WebShellCustomizationProvider,
@@ -762,6 +763,7 @@ describe('ChatPane', () => {
     );
     expect(sendPrompt).toHaveBeenCalledTimes(1);
     expect(sendPrompt).toHaveBeenCalledWith('hello there', {
+      onAdmissionStarted: expect.any(Function),
       onAdmitted: expect.any(Function),
     });
     expect(clearFollowup).not.toHaveBeenCalled();
@@ -797,6 +799,7 @@ describe('ChatPane', () => {
 
     expect(onSlashCommand).toHaveBeenCalledTimes(1);
     expect(sendPrompt).toHaveBeenCalledWith('/deploy staging', {
+      onAdmissionStarted: expect.any(Function),
       onAdmitted: expect.any(Function),
     });
   });
@@ -831,6 +834,7 @@ describe('ChatPane', () => {
       'onSlashCommand callback failed',
     );
     expect(sendPrompt).toHaveBeenCalledWith('/deploy staging', {
+      onAdmissionStarted: expect.any(Function),
       onAdmitted: expect.any(Function),
     });
   });
@@ -845,6 +849,7 @@ describe('ChatPane', () => {
 
     expect(onSlashCommand).not.toHaveBeenCalled();
     expect(sendPrompt).toHaveBeenCalledWith('/usr/local/bin/tool', {
+      onAdmissionStarted: expect.any(Function),
       onAdmitted: expect.any(Function),
     });
   });
@@ -871,10 +876,35 @@ describe('ChatPane', () => {
     });
     expect(sendPrompt).toHaveBeenCalledWith('with image', {
       images,
+      onAdmissionStarted: expect.any(Function),
       onAdmitted: expect.any(Function),
     });
   });
 
+  it('submits image-only prompts and preserves first-text naming eligibility', () => {
+    const images = [{ data: 'image-data', media_type: 'image/png' }];
+    const onFirstPromptAdmitted = vi.fn();
+    render({ onFirstPromptAdmitted });
+
+    act(() => {
+      latestOnSubmit!('', images);
+    });
+    expect(sendPrompt).toHaveBeenCalledWith('', {
+      images,
+      onAdmissionStarted: expect.any(Function),
+      onAdmitted: expect.any(Function),
+    });
+    act(() => sendPromptAdmit!());
+    expect(onFirstPromptAdmitted).not.toHaveBeenCalled();
+
+    act(() => {
+      latestOnSubmit!('name this task');
+    });
+    act(() => sendPromptAdmit!());
+    expect(onFirstPromptAdmitted).toHaveBeenCalledOnce();
+    expect(onFirstPromptAdmitted).toHaveBeenCalledWith('name this task');
+  });
+
   it('forwards composer annotations with an idle prompt', () => {
     const inputAnnotations = [
       {
@@ -893,6 +923,7 @@ describe('ChatPane', () => {
     });
     expect(sendPrompt).toHaveBeenCalledWith('check @.husky/', {
       inputAnnotations,
+      onAdmissionStarted: expect.any(Function),
       onAdmitted: expect.any(Function),
     });
   });
@@ -906,10 +937,34 @@ describe('ChatPane', () => {
       returned = latestOnSubmit!('queued next', undefined, commit);
     });
     expect(returned).toBe(true);
-    expect(enqueuePrompt).toHaveBeenCalledWith('queued next', undefined);
+    expect(enqueuePrompt).toHaveBeenCalledWith(
+      'queued next',
+      undefined,
+      undefined,
+      undefined,
+      expect.any(Function),
+    );
     expect(sendPrompt).not.toHaveBeenCalled();
   });
 
+  it('names a side task when its first text prompt is admitted from the queue', () => {
+    streamingStateValue = 'responding';
+    const onFirstPromptAdmitted = vi.fn();
+    render({ onFirstPromptAdmitted });
+
+    act(() => {
+      latestOnSubmit!('name this queued task');
+    });
+
+    const onAdmitted = enqueuePrompt.mock.calls[0]?.[4] as
+      | (() => void)
+      | undefined;
+    expect(onAdmitted).toEqual(expect.any(Function));
+    act(() => onAdmitted?.());
+    expect(onFirstPromptAdmitted).toHaveBeenCalledOnce();
+    expect(onFirstPromptAdmitted).toHaveBeenCalledWith('name this queued task');
+  });
+
   it('forwards composer annotations with a queued prompt', () => {
     streamingStateValue = 'responding';
     const inputAnnotations = [
@@ -932,6 +987,7 @@ describe('ChatPane', () => {
       undefined,
       undefined,
       inputAnnotations,
+      expect.any(Function),
     );
     expect(sendPrompt).not.toHaveBeenCalled();
   });
@@ -943,7 +999,26 @@ describe('ChatPane', () => {
     act(() => {
       latestOnSubmit!('queued image', images);
     });
-    expect(enqueuePrompt).toHaveBeenCalledWith('queued image', images);
+    expect(enqueuePrompt).toHaveBeenCalledWith(
+      'queued image',
+      images,
+      undefined,
+      undefined,
+      expect.any(Function),
+    );
+  });
+
+  it('queues an image-only prompt while the pane is already running', () => {
+    streamingStateValue = 'responding';
+    const images = [{ data: 'image-data', media_type: 'image/bmp' }];
+    render();
+
+    act(() => {
+      latestOnSubmit!('', images);
+    });
+
+    expect(enqueuePrompt).toHaveBeenCalledWith('', images);
+    expect(sendPrompt).not.toHaveBeenCalled();
   });
 
   it('does not submit while the pane is disconnected', () => {
@@ -984,10 +1059,16 @@ describe('ChatPane', () => {
     expect(sendPrompt).not.toHaveBeenCalled();
   });
 
-  it('reports an idle prompt failure to the pane error handler', async () => {
+  it('locks the pane when idle prompt admission outcome is unknown', async () => {
     const onError = vi.fn();
-    sendPrompt.mockRejectedValueOnce(new Error('disconnected'));
-    render({ onError });
+    const onImageIngestionNotice = vi.fn();
+    const confirm = vi.spyOn(window, 'confirm').mockReturnValue(false);
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    sendPrompt.mockImplementationOnce(async (_text, options) => {
+      options?.onAdmissionStarted?.();
+      throw new Error('disconnected');
+    });
+    render({ onError, onImageIngestionNotice });
     const commit = vi.fn();
     await act(async () => {
       latestOnSubmit!('hi', undefined, commit);
@@ -995,12 +1076,134 @@ describe('ChatPane', () => {
     });
     expect(commit).not.toHaveBeenCalled();
     expect(clearFollowup).not.toHaveBeenCalled();
+    expect(onError).not.toHaveBeenCalled();
+    expect(onImageIngestionNotice).toHaveBeenCalledWith(
+      'warning',
+      expect.stringContaining('uncertain'),
+    );
+    const notice = testid('pane-prompt-admission-unknown');
+    expect(notice).not.toBeNull();
+    expect(latestChatEditorProps.disabled).toBe(true);
+    act(() => latestOnSubmit!('do not retry'));
+    expect(sendPrompt).toHaveBeenCalledTimes(1);
+
+    act(() => {
+      notice?.querySelectorAll('button').item(0).click();
+    });
+    expect(confirm).toHaveBeenCalledOnce();
+    expect(latestChatEditorProps.disabled).toBe(true);
+
+    confirm.mockReturnValue(true);
+    act(() => {
+      notice?.querySelectorAll('button').item(0).click();
+    });
+    expect(commit).not.toHaveBeenCalled();
+    expect(latestChatEditorProps.disabled).toBe(false);
+    expect(testid('pane-prompt-admission-unknown')).not.toBeNull();
+    expect(sendPrompt).toHaveBeenCalledTimes(1);
+    confirm.mockRestore();
+    warn.mockRestore();
+  });
+
+  it('keeps an unknown admission locked across an unrelated stream', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    sendPrompt.mockImplementationOnce(async (_text, options) => {
+      options?.onAdmissionStarted?.();
+      throw new Error('response lost');
+    });
+    render();
+
+    await act(async () => {
+      latestOnSubmit!('hi');
+      await Promise.resolve();
+    });
+    expect(testid('pane-prompt-admission-unknown')).not.toBeNull();
+
+    streamingStateValue = 'responding';
+    rerender();
+
+    expect(testid('pane-prompt-admission-unknown')).not.toBeNull();
+    expect(latestChatEditorProps.disabled).toBe(true);
+    warn.mockRestore();
+  });
+
+  it('does not mark a turn error unknown after admission', async () => {
+    const onError = vi.fn();
+    let rejectTurn!: (error: unknown) => void;
+    sendPrompt.mockImplementationOnce((_text, options) => {
+      options?.onAdmissionStarted?.();
+      sendPromptAdmit = options?.onAdmitted;
+      return new Promise((_resolve, reject) => {
+        rejectTurn = reject;
+      });
+    });
+    render({ onError });
+    const commit = vi.fn();
+
+    act(() => {
+      latestOnSubmit!('hi', undefined, commit);
+      sendPromptAdmit?.();
+    });
+    await act(async () => {
+      rejectTurn(new Error('turn failed'));
+      await Promise.resolve();
+    });
+
+    expect(commit).toHaveBeenCalledOnce();
+    expect(testid('pane-prompt-admission-unknown')).toBeNull();
+    expect(latestChatEditorProps.disabled).toBe(false);
     expect(onError).toHaveBeenCalledWith(
-      expect.any(Error),
+      expect.objectContaining({ message: 'turn failed' }),
       'Failed to send prompt',
     );
   });
 
+  it('discards an unknown local payload without hiding its marker', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    sendPrompt.mockImplementationOnce(async (_text, options) => {
+      options?.onAdmissionStarted?.();
+      throw new Error('disconnected');
+    });
+    render();
+    const commit = vi.fn();
+    await act(async () => {
+      latestOnSubmit!('hi', undefined, commit);
+      await Promise.resolve();
+    });
+
+    act(() => {
+      testid('pane-prompt-admission-unknown')
+        ?.querySelectorAll('button')
+        .item(1)
+        .click();
+    });
+
+    expect(commit).toHaveBeenCalledOnce();
+    expect(latestChatEditorProps.disabled).toBe(false);
+    expect(testid('pane-prompt-admission-unknown')).not.toBeNull();
+    expect(sendPrompt).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+
+  it('keeps the pane editable after a definite 413 rejection', async () => {
+    const onError = vi.fn();
+    sendPrompt.mockRejectedValueOnce(
+      new DaemonHttpError(413, undefined, 'Too large'),
+    );
+    render({ onError });
+
+    await act(async () => {
+      latestOnSubmit!('hi');
+      await Promise.resolve();
+    });
+
+    expect(onError).toHaveBeenCalledWith(
+      expect.any(DaemonHttpError),
+      'Failed to send prompt',
+    );
+    expect(latestChatEditorProps.disabled).toBe(false);
+  });
+
   it('keeps pane approvals click-only (no global keyboard shortcuts)', () => {
     pendingPermission = { id: 'perm-1', toolName: 'write_file', rawInput: {} };
     render();
diff --git a/packages/web-shell/client/components/ChatPane.tsx b/packages/web-shell/client/components/ChatPane.tsx
index 7298810110c..521d9945516 100644
--- a/packages/web-shell/client/components/ChatPane.tsx
+++ b/packages/web-shell/client/components/ChatPane.tsx
@@ -4,7 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { useCallback, useEffect, useMemo, useRef, type ReactNode } from 'react';
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ReactNode,
+} from 'react';
 import { Maximize2Icon, Minimize2Icon } from 'lucide-react';
 import {
   useActions,
@@ -16,10 +23,10 @@ import {
   useWorkspace,
   type DaemonSessionActions,
 } from '@qwen-code/webui/daemon-react-sdk';
-import type {
-  DaemonSessionArtifact,
-  DaemonSessionMonitorTaskStatus,
-  DaemonWorkspaceCapability,
+import {
+  type DaemonSessionArtifact,
+  type DaemonSessionMonitorTaskStatus,
+  type DaemonWorkspaceCapability,
 } from '@qwen-code/sdk/daemon';
 import type { ACPToolCall } from '../adapters/types';
 import { SubagentDetailsProvider } from '../subagentDetailsContext';
@@ -45,6 +52,7 @@ import { isAskUserPermission } from '../utils/askUserPermission';
 import { isDaemonApprovalMode } from '../utils/sessionPreparation';
 import { isVisibleComposerModel } from '../utils/composerModels';
 import { shouldBlockComposerSubmit } from '../utils/composerInputState';
+import { isDefinitelyRejectedPromptAdmission } from '../utils/promptAdmission';
 import {
   getActiveTodosForPlanRevision,
   isExitPlanApprovalRequest,
@@ -124,6 +132,12 @@ export type PaneHeaderActionsRenderer = (
   info: PaneHeaderActionsInfo,
 ) => ReactNode;
 
+interface UnknownPromptAdmission {
+  owner: { sessionId: string | undefined };
+  commitAccepted?: ComposerSubmitCommit;
+  payloadAvailable: boolean;
+}
+
 export interface ChatPaneProps {
   /** Header label; falls back to the session's own display name / id. */
   title?: string;
@@ -161,6 +175,7 @@ export interface ChatPaneProps {
   /** Whether this pane is currently the maximized (solo) one. */
   isMaximized?: boolean;
   onError?: (error: unknown, fallback: string) => void;
+  onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
   /** Host slash-command callback shared with the main chat composer. */
   onSlashCommand?: WebShellSlashCommandHandler;
   onRightPanelOpen?: (request: TurnOutputOpenRequest) => void;
@@ -202,6 +217,7 @@ export function ChatPane({
   onToggleMaximize,
   isMaximized = false,
   onError,
+  onImageIngestionNotice,
   onSlashCommand,
   onRightPanelOpen,
   onOpenMonitor,
@@ -299,6 +315,44 @@ export function ChatPane({
   const streamingStateRef = useRef(streamingState);
   streamingStateRef.current = streamingState;
   const firstPromptAdmittedRef = useRef(false);
+  const [unknownPromptAdmission, setUnknownPromptAdmission] =
+    useState<UnknownPromptAdmission | null>(null);
+  const admissionOwnerRef = useRef({ sessionId: connection.sessionId });
+  if (admissionOwnerRef.current.sessionId !== connection.sessionId) {
+    admissionOwnerRef.current = { sessionId: connection.sessionId };
+  }
+  useEffect(() => {
+    firstPromptAdmittedRef.current = false;
+    setUnknownPromptAdmission(null);
+  }, [connection.sessionId]);
+  const admissionPayloadLocked =
+    unknownPromptAdmission?.payloadAvailable === true;
+  const discardUnknownPromptPayload = useCallback(() => {
+    const current = unknownPromptAdmission;
+    if (!current?.payloadAvailable) return;
+    if (admissionOwnerRef.current !== current.owner) {
+      setUnknownPromptAdmission(null);
+      return;
+    }
+    current.commitAccepted?.();
+    setUnknownPromptAdmission({
+      owner: current.owner,
+      payloadAvailable: false,
+    });
+  }, [unknownPromptAdmission]);
+  const continueEditingUnknownPrompt = useCallback(() => {
+    if (!window.confirm(t('queue.continueEditingConfirm'))) return;
+    const current = unknownPromptAdmission;
+    if (!current?.payloadAvailable) return;
+    if (admissionOwnerRef.current !== current.owner) {
+      setUnknownPromptAdmission(null);
+      return;
+    }
+    setUnknownPromptAdmission({
+      owner: current.owner,
+      payloadAvailable: false,
+    });
+  }, [t, unknownPromptAdmission]);
   const reloadTranscript = useCallback(
     async (signal: AbortSignal) => {
       if (!connection.sessionId) return;
@@ -420,6 +474,8 @@ export function ChatPane({
     editQueuedPrompt,
     editLastQueuedPrompt,
     clearQueuedPrompts,
+    restoreUnknownQueuedPrompt,
+    discardUnknownQueuedPrompt,
   } = useQueuedPrompts({
     connected: connection.status === 'connected',
     sessionId: connection.sessionId,
@@ -453,8 +509,10 @@ export function ChatPane({
       metadata?: ComposerSubmitMetadata,
     ): boolean => {
       const trimmed = text.trim();
-      if (!trimmed) return false;
+      if (!trimmed && (images?.length ?? 0) === 0) return false;
+      if (admissionPayloadLocked) return false;
       if (
+        trimmed &&
         invokeSlashCommandHandler(text, onSlashCommandRef.current, reportError)
       ) {
         return true;
@@ -469,38 +527,79 @@ export function ChatPane({
         return false;
       }
       const inputAnnotations = metadata?.inputAnnotations;
+      const notifyFirstPromptAdmitted = () => {
+        if (
+          trimmed &&
+          !firstPromptAdmittedRef.current &&
+          onFirstPromptAdmitted
+        ) {
+          firstPromptAdmittedRef.current = true;
+          onFirstPromptAdmitted(trimmed);
+        }
+      };
       if (streamingStateRef.current === 'idle') {
+        const admissionOwner = admissionOwnerRef.current;
+        let admissionStarted = false;
+        let admitted = false;
         actions
           .sendPrompt(trimmed, {
             ...(images && images.length ? { images } : {}),
             ...(inputAnnotations ? { inputAnnotations } : {}),
+            onAdmissionStarted: () => {
+              admissionStarted = true;
+            },
             onAdmitted: () => {
-              if (!firstPromptAdmittedRef.current && onFirstPromptAdmitted) {
-                firstPromptAdmittedRef.current = true;
-                onFirstPromptAdmitted(trimmed);
-              }
+              if (admissionOwnerRef.current !== admissionOwner) return;
+              admitted = true;
+              notifyFirstPromptAdmitted();
               clearFollowup();
               commitAccepted?.();
             },
           })
-          .catch((error: unknown) =>
-            reportError(error, 'Failed to send prompt'),
-          );
+          .catch((error: unknown) => {
+            if (admissionOwnerRef.current !== admissionOwner) return;
+            const definitelyRejected =
+              isDefinitelyRejectedPromptAdmission(error);
+            if (admitted || !admissionStarted || definitelyRejected) {
+              reportError(error, 'Failed to send prompt');
+              return;
+            }
+            setUnknownPromptAdmission({
+              owner: admissionOwner,
+              commitAccepted,
+              payloadAvailable: true,
+            });
+            onImageIngestionNotice?.('warning', t('queue.admissionUnknown'));
+            console.warn(
+              '[ChatPane] prompt admission outcome is unknown',
+              error,
+            );
+          });
         return false;
       }
-      return inputAnnotations
-        ? enqueuePrompt(trimmed, images, undefined, inputAnnotations)
-        : enqueuePrompt(trimmed, images);
+      if (!trimmed && !inputAnnotations) {
+        return enqueuePrompt(trimmed, images);
+      }
+      return enqueuePrompt(
+        trimmed,
+        images,
+        undefined,
+        inputAnnotations,
+        notifyFirstPromptAdmitted,
+      );
     },
     [
       actions,
+      admissionPayloadLocked,
       clearFollowup,
       connection.sessionId,
       connection.status,
       enqueuePrompt,
       onFirstPromptAdmitted,
+      onImageIngestionNotice,
       reportError,
       restartSseOnPrompt,
+      t,
     ],
   );
 
@@ -850,7 +949,28 @@ export function ChatPane({
           canMutateMidTurn={canMutateMidTurn}
           onDelete={removeQueuedPrompt}
           onEdit={editQueuedPrompt}
+          onRestoreUnknown={restoreUnknownQueuedPrompt}
+          onDiscardUnknown={discardUnknownQueuedPrompt}
         />
+        {unknownPromptAdmission && (
+          <div
+            className={styles.admissionUnknown}
+            role="status"
+            data-testid="pane-prompt-admission-unknown"
+          >
+            <span>{t('queue.admissionUnknown')}</span>
+            {unknownPromptAdmission.payloadAvailable && (
+              <span className={styles.admissionUnknownActions}>
+                <button type="button" onClick={continueEditingUnknownPrompt}>
+                  {t('queue.continueEditing')}
+                </button>
+                <button type="button" onClick={discardUnknownPromptPayload}>
+                  {t('queue.discardUnknown')}
+                </button>
+              </span>
+            )}
+          </div>
+        )}
         <ChatEditor
           ref={editorRef}
           onSubmit={handleSubmit}
@@ -871,12 +991,13 @@ export function ChatPane({
           onSelectMode={handleSelectMode}
           onSelectModel={handleSelectModel}
           dialogOpen={approvalActive}
-          disabled={approvalActive}
+          disabled={approvalActive || admissionPayloadLocked}
           voiceTarget={hidden ? undefined : voiceTarget}
           voiceStatusRevision={voiceStatusRevision}
           followupState={followupState}
           onAcceptFollowup={onAcceptFollowup}
           onDismissFollowup={onDismissFollowup}
+          onImageIngestionNotice={onImageIngestionNotice}
           sessionId={connection.sessionId}
           atWorkspaceCwd={paneWorkspaceCwd}
           placeholderText={t('splitView.composerPlaceholder')}
@@ -884,7 +1005,7 @@ export function ChatPane({
         />
         {CustomComposerFooter && (
           <CustomComposerFooter
-            disabled={approvalActive}
+            disabled={approvalActive || admissionPayloadLocked}
             isRunning={isResponding}
             currentMode={connection.currentMode ?? 'default'}
             currentModel={connection.currentModel ?? ''}
diff --git a/packages/web-shell/client/components/QueuedPromptDisplay.test.tsx b/packages/web-shell/client/components/QueuedPromptDisplay.test.tsx
index 42f6e85014a..224057dea57 100644
--- a/packages/web-shell/client/components/QueuedPromptDisplay.test.tsx
+++ b/packages/web-shell/client/components/QueuedPromptDisplay.test.tsx
@@ -40,6 +40,8 @@ function setup(
   const handlers = {
     onDelete: vi.fn(),
     onEdit: vi.fn(),
+    onRestoreUnknown: vi.fn(),
+    onDiscardUnknown: vi.fn(),
   };
   const prompts: QueuedPrompt[] = overrides.prompts
     ? [...overrides.prompts]
@@ -89,6 +91,31 @@ describe('QueuedPromptDisplay', () => {
     expect(container.textContent).not.toContain('插入');
   });
 
+  it('allows deleting but not editing a summary-only server row', () => {
+    const { container } = setup({
+      prompts: [
+        {
+          id: 1,
+          text: '[image]',
+          serverPromptId: 'server-1',
+          serverState: 'queued',
+          payloadCompleteness: 'summary-only',
+        },
+      ],
+    });
+
+    const deleteButton = container.querySelector<HTMLButtonElement>(
+      `[aria-label="${t('queue.delete')}"]`,
+    );
+    const editButton = container.querySelector<HTMLButtonElement>(
+      `[aria-label="${t('queue.edit')}"]`,
+    );
+    expect(deleteButton?.disabled).toBe(false);
+    expect(editButton?.disabled).toBe(true);
+    expect(editButton?.title).toBe(t('queue.summaryEditDisabled'));
+    expect(container.textContent).not.toContain(t('queue.footer'));
+  });
+
   it('keeps a mid-turn prompt queued until injection', () => {
     const { container } = setup({
       prompts: [
@@ -152,6 +179,61 @@ describe('QueuedPromptDisplay', () => {
     ).toBeTruthy();
   });
 
+  it('requires confirmation before restoring an unknown local payload', () => {
+    const confirm = vi.spyOn(window, 'confirm').mockReturnValue(false);
+    const { container, handlers } = setup({
+      prompts: [
+        {
+          id: 1,
+          text: '',
+          images: [{ data: 'cG5n', media_type: 'image/png' }],
+          admissionOutcome: 'unknown',
+          payloadCompleteness: 'complete',
+          payloadAvailable: true,
+        },
+      ],
+    });
+    const restore = container.querySelector<HTMLButtonElement>(
+      `[aria-label="${t('queue.restoreUnknown')}"]`,
+    );
+    const discard = container.querySelector<HTMLButtonElement>(
+      `[aria-label="${t('queue.discardUnknown')}"]`,
+    );
+
+    act(() => restore?.click());
+    expect(handlers.onRestoreUnknown).not.toHaveBeenCalled();
+    confirm.mockReturnValue(true);
+    act(() => restore?.click());
+    expect(handlers.onRestoreUnknown).toHaveBeenCalledWith(1);
+    act(() => discard?.click());
+    expect(handlers.onDiscardUnknown).toHaveBeenCalledWith(1);
+    expect(container.textContent).not.toContain(t('queue.footer'));
+    confirm.mockRestore();
+  });
+
+  it('warns when an unknown local copy may match a server summary', () => {
+    const { container } = setup({
+      prompts: [
+        {
+          id: 1,
+          text: 'uncertain',
+          admissionOutcome: 'unknown',
+          payloadCompleteness: 'complete',
+          payloadAvailable: true,
+        },
+        {
+          id: 2,
+          text: '[image]',
+          serverPromptId: 'server-1',
+          serverState: 'queued',
+          payloadCompleteness: 'summary-only',
+        },
+      ],
+    });
+
+    expect(container.textContent).toContain(t('queue.mayCorrespond'));
+  });
+
   it('renders queued reference annotations as tags', () => {
     const serialized = '<context id="orders">orders</context>';
     const text = `inspect ${serialized} now`;
diff --git a/packages/web-shell/client/components/QueuedPromptDisplay.tsx b/packages/web-shell/client/components/QueuedPromptDisplay.tsx
index 24d4007339a..954b18bb74c 100644
--- a/packages/web-shell/client/components/QueuedPromptDisplay.tsx
+++ b/packages/web-shell/client/components/QueuedPromptDisplay.tsx
@@ -124,6 +124,7 @@ export interface QueuedPrompt {
   images?: PromptImage[];
   inputAnnotations?: DaemonInputAnnotation[];
   onComplete?: () => void;
+  onAdmitted?: () => void;
   serverPromptId?: string;
   serverState?: 'submitting' | 'queued' | 'running';
   midTurnState?: 'submitting' | 'queued';
@@ -131,6 +132,9 @@ export interface QueuedPrompt {
   midTurnFailedAction?: 'delete' | 'edit';
   isEditing?: boolean;
   isRemoving?: boolean;
+  payloadCompleteness?: 'complete' | 'summary-only';
+  admissionOutcome?: 'unknown';
+  payloadAvailable?: boolean;
 }
 
 export function QueuedPromptDisplay({
@@ -139,12 +143,16 @@ export function QueuedPromptDisplay({
   canMutateMidTurn = false,
   onDelete,
   onEdit,
+  onRestoreUnknown,
+  onDiscardUnknown,
 }: {
   prompts: readonly QueuedPrompt[];
   t: ReturnType<typeof getTranslator>;
   canMutateMidTurn?: boolean;
   onDelete: (id: number) => void;
   onEdit: (id: number) => void;
+  onRestoreUnknown?: (id: number) => void;
+  onDiscardUnknown?: (id: number) => void;
 }) {
   const {
     parseUserMessageContent,
@@ -161,10 +169,24 @@ export function QueuedPromptDisplay({
     latestPrompt.serverState !== 'submitting' &&
     latestPrompt.serverState !== 'running' &&
     !latestPrompt.isEditing &&
-    !latestPrompt.isRemoving;
+    !latestPrompt.isRemoving &&
+    latestPrompt.payloadCompleteness !== 'summary-only' &&
+    latestPrompt.admissionOutcome !== 'unknown';
+  const mayContainDuplicateAdmission =
+    prompts.some((prompt) => prompt.admissionOutcome === 'unknown') &&
+    prompts.some(
+      (prompt) =>
+        prompt.payloadCompleteness === 'summary-only' &&
+        prompt.serverPromptId !== undefined,
+    );
 
   return (
     <div className={styles.queuedPrompts}>
+      {mayContainDuplicateAdmission ? (
+        <div className={styles.queuedPromptAmbiguity} role="status">
+          {t('queue.mayCorrespond')}
+        </div>
+      ) : null}
       {prompts.map((prompt) => {
         const preview = truncateQueuedPromptParts(
           getQueuedPromptParts(prompt, parseUserMessageContent),
@@ -177,6 +199,10 @@ export function QueuedPromptDisplay({
         const isMidTurnLocked =
           prompt.midTurnState === 'submitting' ||
           (prompt.midTurnState === 'queued' && !prompt.midTurnMessageId);
+        const isSummaryOnly = prompt.payloadCompleteness === 'summary-only';
+        const isAdmissionUnknown = prompt.admissionOutcome === 'unknown';
+        const hasUnknownPayload =
+          isAdmissionUnknown && prompt.payloadAvailable !== false;
         const showActions = !isMidTurnPending || canMutateMidTurn;
         const isRemoving = prompt.isRemoving === true;
         const hasStateSpinner =
@@ -188,11 +214,17 @@ export function QueuedPromptDisplay({
           isSubmitting ||
           isRunning ||
           isMidTurnLocked ||
+          isAdmissionUnknown ||
           prompt.isEditing === true ||
           isRemoving;
+        const isEditDisabled = isBusy || isSummaryOnly;
         let editTitle = t('queue.editTip');
-        if (isBusy) {
-          editTitle = t('queue.submittingDisabled');
+        if (isEditDisabled) {
+          editTitle = isSummaryOnly
+            ? t('queue.summaryEditDisabled')
+            : isAdmissionUnknown
+              ? t('queue.admissionUnknown')
+              : t('queue.submittingDisabled');
         }
         const deleteTitle = isBusy
           ? t('queue.submittingDisabled')
@@ -225,10 +257,14 @@ export function QueuedPromptDisplay({
               {imageCount > 0
                 ? ` ${t('queue.imageCount', { count: imageCount })}`
                 : ''}
+              {isAdmissionUnknown && !hasUnknownPayload
+                ? ` ${t('queue.localCopyDiscarded')}`
+                : ''}
             </span>
             {isSubmitting ||
             isQueued ||
             isMidTurnPending ||
+            isAdmissionUnknown ||
             prompt.isEditing ||
             isRemoving ? (
               <span
@@ -247,14 +283,41 @@ export function QueuedPromptDisplay({
                       ? t('queue.editing')
                       : isMidTurnPending
                         ? t('queue.midTurnQueued')
-                        : isQueued
-                          ? t('queue.serverQueued')
-                          : t('queue.submitting')}
+                        : isAdmissionUnknown
+                          ? t('queue.admissionUnknown')
+                          : isQueued
+                            ? t('queue.serverQueued')
+                            : t('queue.submitting')}
                 </span>
               </span>
             ) : null}
             <span className={styles.queuedPromptActions}>
-              {showActions ? (
+              {hasUnknownPayload ? (
+                <>
+                  <button
+                    type="button"
+                    className={styles.queuedPromptAction}
+                    onClick={() => {
+                      if (window.confirm(t('queue.continueEditingConfirm'))) {
+                        onRestoreUnknown?.(prompt.id);
+                      }
+                    }}
+                    aria-label={t('queue.restoreUnknown')}
+                    title={t('queue.restoreUnknown')}
+                  >
+                    {t('queue.restoreUnknown')}
+                  </button>
+                  <button
+                    type="button"
+                    className={styles.queuedPromptAction}
+                    onClick={() => onDiscardUnknown?.(prompt.id)}
+                    aria-label={t('queue.discardUnknown')}
+                    title={t('queue.discardUnknown')}
+                  >
+                    {t('queue.discardUnknown')}
+                  </button>
+                </>
+              ) : showActions && !isAdmissionUnknown ? (
                 <>
                   <button
                     type="button"
@@ -274,7 +337,7 @@ export function QueuedPromptDisplay({
                     type="button"
                     className={styles.queuedPromptAction}
                     onClick={() => onEdit(prompt.id)}
-                    disabled={isBusy}
+                    disabled={isEditDisabled}
                     aria-label={t('queue.edit')}
                     title={editTitle}
                   >
diff --git a/packages/web-shell/client/components/SplitView.tsx b/packages/web-shell/client/components/SplitView.tsx
index 592b96e808a..3ca9f611502 100644
--- a/packages/web-shell/client/components/SplitView.tsx
+++ b/packages/web-shell/client/components/SplitView.tsx
@@ -56,6 +56,7 @@ export interface SplitViewProps {
   /** Leave the split view (back to the single-session chat). */
   onExit: () => void;
   onError?: (error: unknown, fallback: string) => void;
+  onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
   onSlashCommand?: WebShellSlashCommandHandler;
   onRightPanelOpen?: (request: TurnOutputOpenRequest) => void;
   onOpenMonitor?: (
@@ -104,6 +105,7 @@ export function SplitView({
   onPanesChange,
   onExit,
   onError,
+  onImageIngestionNotice,
   onSlashCommand,
   onRightPanelOpen,
   onOpenMonitor,
@@ -526,6 +528,7 @@ export function SplitView({
                       }
                       isMaximized={isMaximized}
                       onError={onError}
+                      onImageIngestionNotice={onImageIngestionNotice}
                       onSlashCommand={onSlashCommand}
                       onRightPanelOpen={onRightPanelOpen}
                       onOpenMonitor={onOpenMonitor}
diff --git a/packages/web-shell/client/components/artifacts/ArtifactPanel.tsx b/packages/web-shell/client/components/artifacts/ArtifactPanel.tsx
index c5c20257ab8..5a1e5fcfdf7 100644
--- a/packages/web-shell/client/components/artifacts/ArtifactPanel.tsx
+++ b/packages/web-shell/client/components/artifacts/ArtifactPanel.tsx
@@ -251,6 +251,7 @@ interface ArtifactPanelProps {
   ) => void;
   onError?: (error: unknown, fallback: string) => void;
   sessionWorkflowEnabled?: boolean;
+  onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
   onClose: () => void;
   variant?: 'docked' | 'drawer';
   fullscreen?: boolean;
@@ -285,6 +286,7 @@ export function ArtifactPanel({
   onNestedArtifactsChange,
   onError,
   sessionWorkflowEnabled,
+  onImageIngestionNotice,
   onClose,
   variant = 'docked',
   fullscreen = false,
@@ -716,6 +718,7 @@ export function ArtifactPanel({
             onArtifactsChange={onNestedArtifactsChange}
             onError={onError}
             sessionWorkflowEnabled={sessionWorkflowEnabled}
+            onImageIngestionNotice={onImageIngestionNotice}
           />
         ) : (
           <ScheduledTaskDetail
diff --git a/packages/web-shell/client/components/artifacts/SideTaskPanel.test.tsx b/packages/web-shell/client/components/artifacts/SideTaskPanel.test.tsx
index d895b8955bd..39a23967f5f 100644
--- a/packages/web-shell/client/components/artifacts/SideTaskPanel.test.tsx
+++ b/packages/web-shell/client/components/artifacts/SideTaskPanel.test.tsx
@@ -38,7 +38,11 @@ const {
     },
   ),
   transcript: {
-    blocks: [] as Array<{ kind: string }>,
+    blocks: [] as Array<{
+      kind: string;
+      text?: string;
+      images?: Array<{ data: string; mimeType: string }>;
+    }>,
     hasMore: false,
     loading: false,
     capacityReached: false,
@@ -310,6 +314,29 @@ it('names a restored empty side task from its first prompt', async () => {
   );
 });
 
+it('keeps first-text naming available after an image-only user prompt', () => {
+  connection.sessionId = 'side-session-1';
+  connection.displayName = 'Side task';
+  connection.status = 'connected';
+  transcript.blocks = [
+    {
+      kind: 'user',
+      images: [{ data: 'Ym1w', mimeType: 'image/bmp' }],
+    },
+  ];
+  container = document.createElement('div');
+  document.body.appendChild(container);
+  root = createRoot(container);
+
+  act(() => {
+    renderSideTask();
+  });
+
+  expect(latestChatPaneProps.current?.['onFirstPromptAdmitted']).toEqual(
+    expect.any(Function),
+  );
+});
+
 it('truncates the first-prompt title by code point, not code unit', async () => {
   connection.sessionId = 'side-session-1';
   connection.displayName = 'Side task';
diff --git a/packages/web-shell/client/components/artifacts/SideTaskPanel.tsx b/packages/web-shell/client/components/artifacts/SideTaskPanel.tsx
index fe240389517..6d5038de879 100644
--- a/packages/web-shell/client/components/artifacts/SideTaskPanel.tsx
+++ b/packages/web-shell/client/components/artifacts/SideTaskPanel.tsx
@@ -43,6 +43,7 @@ interface SideTaskPanelProps {
   ) => void;
   onError?: (error: unknown, fallback: string) => void;
   sessionWorkflowEnabled?: boolean;
+  onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
 }
 
 const FIRST_PROMPT_RENAME_ATTEMPTS = 3;
@@ -62,6 +63,7 @@ export function SideTaskPanel({
   onArtifactsChange,
   onError,
   sessionWorkflowEnabled,
+  onImageIngestionNotice,
 }: SideTaskPanelProps) {
   if (!sessionId) {
     return (
@@ -99,6 +101,7 @@ export function SideTaskPanel({
         onArtifactsChange={onArtifactsChange}
         onError={onError}
         sessionWorkflowEnabled={sessionWorkflowEnabled}
+        onImageIngestionNotice={onImageIngestionNotice}
       />
     </DaemonSessionProvider>
   );
@@ -191,6 +194,7 @@ function SideTaskSession({
   onArtifactsChange,
   onError,
   sessionWorkflowEnabled,
+  onImageIngestionNotice,
 }: Omit<
   SideTaskPanelProps,
   'sessionId' | 'parentSessionId' | 'createSession' | 'onCreated'
@@ -200,7 +204,13 @@ function SideTaskSession({
   const actions = useActions();
   const blocks = useTranscriptBlocks();
   const transcriptHistory = useTranscriptHistory();
-  const hasUserPrompt = blocks.some((block) => block.kind === 'user');
+  const hasTextualUserPrompt = blocks.some(
+    (block) =>
+      block.kind === 'user' &&
+      (typeof block.text === 'string'
+        ? block.text.trim().length > 0
+        : !block.images?.length),
+  );
   const restoredEmptySession =
     connection.status === 'connected' &&
     !connection.loadingTranscript &&
@@ -209,9 +219,10 @@ function SideTaskSession({
     !transcriptHistory.hasMore &&
     !transcriptHistory.capacityReached &&
     !transcriptHistory.paginationError &&
-    !hasUserPrompt;
+    !hasTextualUserPrompt;
   const canNameFromFirstPrompt =
-    !hasUserPrompt && (shouldNameFromFirstPrompt || restoredEmptySession);
+    !hasTextualUserPrompt &&
+    (shouldNameFromFirstPrompt || restoredEmptySession);
   useEffect(() => {
     const displayName = connection.displayName?.trim();
     if (displayName) onTitleChange(tabId, displayName);
@@ -276,6 +287,7 @@ function SideTaskSession({
       title={connection.displayName?.trim() || title}
       workspaceCwd={workspaceCwd}
       onError={onError}
+      onImageIngestionNotice={onImageIngestionNotice}
       embedded
       onFirstPromptAdmitted={
         canNameFromFirstPrompt ? nameFromFirstPrompt : undefined
diff --git a/packages/web-shell/client/components/messages/Markdown.test.ts b/packages/web-shell/client/components/messages/Markdown.test.ts
index d575fdab455..432d7b1aa5e 100644
--- a/packages/web-shell/client/components/messages/Markdown.test.ts
+++ b/packages/web-shell/client/components/messages/Markdown.test.ts
@@ -101,6 +101,10 @@ describe('isSafeImageSrc', () => {
     expect(isSafeImageSrc('data:image/webp;base64,UklG')).toBe(true);
   });
 
+  it('allows data:image/bmp base64', () => {
+    expect(isSafeImageSrc('data:image/bmp;base64,Qk0=')).toBe(true);
+  });
+
   it('blocks data:image/svg+xml (can load external resources)', () => {
     expect(isSafeImageSrc('data:image/svg+xml;base64,PHN2Zz4=')).toBe(false);
   });
diff --git a/packages/web-shell/client/components/messages/Markdown.tsx b/packages/web-shell/client/components/messages/Markdown.tsx
index 554e697186f..5ce36724e63 100644
--- a/packages/web-shell/client/components/messages/Markdown.tsx
+++ b/packages/web-shell/client/components/messages/Markdown.tsx
@@ -149,7 +149,7 @@ export function resolveFenceLanguage(
 }
 
 const SAFE_HREF_SCHEMES = /^(https?:|mailto:)/i;
-const SAFE_IMAGE_DATA_URI = /^data:image\/(png|jpeg|gif|webp);base64,/i;
+const SAFE_IMAGE_DATA_URI = /^data:image\/(png|jpeg|gif|webp|bmp);base64,/i;
 
 export function isSafeHref(url: string | undefined): boolean {
   if (!url) return false;
diff --git a/packages/web-shell/client/components/messages/UserMessage.test.tsx b/packages/web-shell/client/components/messages/UserMessage.test.tsx
index 65b3a97cbbe..610eba2b4a6 100644
--- a/packages/web-shell/client/components/messages/UserMessage.test.tsx
+++ b/packages/web-shell/client/components/messages/UserMessage.test.tsx
@@ -339,6 +339,18 @@ describe('UserMessage', () => {
     expect(img!.getAttribute('src')).toBe('data:image/png;base64,abc');
   });
 
+  it('renders BMP images through the shared safe-source policy', () => {
+    const container = render(
+      <UserMessage
+        content=""
+        images={[{ data: 'Qk0=', mimeType: 'image/bmp' }]}
+      />,
+    );
+    expect(container.querySelector('img')?.getAttribute('src')).toBe(
+      'data:image/bmp;base64,Qk0=',
+    );
+  });
+
   it('uses a custom content renderer when provided', () => {
     const container = render(
       <WebShellCustomizationProvider
diff --git a/packages/web-shell/client/e2e/web-shell.smoke.spec.ts b/packages/web-shell/client/e2e/web-shell.smoke.spec.ts
index e0deb8b34ad..e73b3c680a0 100644
--- a/packages/web-shell/client/e2e/web-shell.smoke.spec.ts
+++ b/packages/web-shell/client/e2e/web-shell.smoke.spec.ts
@@ -987,6 +987,56 @@ test('lets a pasted image grow the composer without collapsing the text viewport
   await expect.poll(() => composerHeight(page)).toBe(initialHeight);
 });
 
+test('drops ordered PNG and BMP images and submits them without text @smoke', async ({
+  page,
+}, testInfo) => {
+  const scenario = createWebShellDaemonScenario();
+  const daemon = await installScenario(page, scenario, testInfo);
+
+  await gotoSession(page, scenario, daemon);
+  const surface = page.locator('[data-web-shell-composer-surface]');
+  await dragComposerFileOver(surface);
+  await expect(surface).toHaveAttribute('data-image-drag-active', 'true');
+
+  await dropComposerImages(surface);
+  await expect(surface).not.toHaveAttribute('data-image-drag-active');
+  await expect(surface).not.toHaveAttribute('aria-busy');
+  const images = surface.locator(
+    '[data-web-shell-composer-attachments] img[src^="data:image/"]',
+  );
+  await expect(images).toHaveCount(2);
+  await expectImagesDecoded(images);
+
+  const submit = page.locator('[data-web-shell-composer-submit]');
+  await expect(submit).toBeEnabled();
+  await submit.click();
+
+  await expect.poll(() => daemon.promptRequests().length).toBe(1);
+  const prompt = requestBodyRecord(firstRequest(daemon.promptRequests()))[
+    'prompt'
+  ];
+  expect(Array.isArray(prompt)).toBe(true);
+  const blocks = prompt as Array<Record<string, unknown>>;
+  expect(blocks[0]).toMatchObject({ type: 'text', text: '' });
+  expect(blocks.slice(1)).toEqual([
+    {
+      type: 'image',
+      data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+      mimeType: 'image/png',
+    },
+    {
+      type: 'image',
+      data: 'Qk06AAAAAAAAADYAAAAoAAAAAQAAAAEAAAABABgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AA==',
+      mimeType: 'image/bmp',
+    },
+  ]);
+  const transcriptImages = page.locator(
+    '[data-web-shell-message-list] img[src^="data:image/"]',
+  );
+  await expect(transcriptImages).toHaveCount(2);
+  await expectImagesDecoded(transcriptImages);
+});
+
 async function installScenario(
   page: Page,
   scenario: WebShellDaemonScenario,
@@ -1095,6 +1145,64 @@ async function pasteComposerImages(page: Page, count: number): Promise<void> {
   }, count);
 }
 
+async function dragComposerFileOver(surface: Locator): Promise<void> {
+  await surface.evaluate((element) => {
+    const transfer = new DataTransfer();
+    transfer.items.add(
+      new File([new Uint8Array([0])], 'dragged.png', { type: 'image/png' }),
+    );
+    element.dispatchEvent(
+      new DragEvent('dragenter', {
+        bubbles: true,
+        cancelable: true,
+        dataTransfer: transfer,
+      }),
+    );
+  });
+}
+
+async function dropComposerImages(surface: Locator): Promise<void> {
+  await surface.evaluate((element) => {
+    const pngBase64 =
+      'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=';
+    const binary = atob(pngBase64);
+    const pngBytes = Uint8Array.from(binary, (byte) => byte.charCodeAt(0));
+    const bmpBytes = new Uint8Array(58);
+    const view = new DataView(bmpBytes.buffer);
+    bmpBytes.set([0x42, 0x4d]);
+    view.setUint32(2, bmpBytes.length, true);
+    view.setUint32(10, 54, true);
+    view.setUint32(14, 40, true);
+    view.setInt32(18, 1, true);
+    view.setInt32(22, 1, true);
+    view.setUint16(26, 1, true);
+    view.setUint16(28, 24, true);
+    view.setUint32(34, 4, true);
+    bmpBytes.set([0x00, 0x00, 0xff, 0x00], 54);
+    const transfer = new DataTransfer();
+    transfer.items.add(
+      new File([pngBytes], 'first.png', { type: 'image/png' }),
+    );
+    transfer.items.add(
+      new File([bmpBytes], 'second.bmp', { type: 'image/bmp' }),
+    );
+    element.dispatchEvent(
+      new DragEvent('dragover', {
+        bubbles: true,
+        cancelable: true,
+        dataTransfer: transfer,
+      }),
+    );
+    element.dispatchEvent(
+      new DragEvent('drop', {
+        bubbles: true,
+        cancelable: true,
+        dataTransfer: transfer,
+      }),
+    );
+  });
+}
+
 async function expectImagesDecoded(images: Locator): Promise<void> {
   await expect
     .poll(() =>
diff --git a/packages/web-shell/client/hooks/useComposerCore.dom.test.tsx b/packages/web-shell/client/hooks/useComposerCore.dom.test.tsx
index e93e2939b3a..293be347600 100644
--- a/packages/web-shell/client/hooks/useComposerCore.dom.test.tsx
+++ b/packages/web-shell/client/hooks/useComposerCore.dom.test.tsx
@@ -32,6 +32,7 @@ function Harness({
   sessionId,
   atWorkspaceCwd,
   commands,
+  onImageIngestionNotice,
 }: {
   composerInput?: WebShellComposerInput;
   onSubmit: ReturnType<typeof vi.fn>;
@@ -46,6 +47,7 @@ function Harness({
   sessionId?: string;
   atWorkspaceCwd?: string;
   commands?: UseComposerCoreOptions['commands'];
+  onImageIngestionNotice?: UseComposerCoreOptions['onImageIngestionNotice'];
 }) {
   const composer = useComposerCore({
     onSubmit,
@@ -59,10 +61,15 @@ function Harness({
     atWorkspaceCwd,
     composerInput,
     composerInputVersion: composerInput ? 1 : undefined,
+    onImageIngestionNotice,
   });
   latest = composer;
 
-  return <div ref={composer.containerRef} />;
+  return (
+    <div data-web-shell-composer-surface {...composer.imageTransferHandlers}>
+      <div ref={composer.containerRef} />
+    </div>
+  );
 }
 
 async function mount({
@@ -75,6 +82,7 @@ async function mount({
   sessionId,
   atWorkspaceCwd,
   commands,
+  onImageIngestionNotice,
 }: {
   composerInput?: WebShellComposerInput;
   onSubmit?: ReturnType<typeof vi.fn>;
@@ -89,6 +97,7 @@ async function mount({
   sessionId?: string;
   atWorkspaceCwd?: string;
   commands?: UseComposerCoreOptions['commands'];
+  onImageIngestionNotice?: UseComposerCoreOptions['onImageIngestionNotice'];
 } = {}) {
   container = document.createElement('div');
   document.body.append(container);
@@ -111,6 +120,7 @@ async function mount({
             sessionId={currentSessionId}
             atWorkspaceCwd={currentWorkspaceCwd}
             commands={commands}
+            onImageIngestionNotice={onImageIngestionNotice}
           />
         </I18nProvider>
       </WebShellPortalRootContext.Provider>,
@@ -159,6 +169,7 @@ afterEach(() => {
   root = null;
   container = null;
   latest = null;
+  vi.unstubAllGlobals();
 });
 
 function pressHistoryKey(key: 'ArrowUp' | 'ArrowDown') {
@@ -749,7 +760,9 @@ describe('useComposerCore paste', () => {
     const event = new Event('paste', { bubbles: true, cancelable: true });
     Object.defineProperty(event, 'clipboardData', {
       value: {
-        items: [{ type: 'text/plain', getAsFile: () => null }],
+        files: [],
+        items: [{ kind: 'string', type: 'text/plain', getAsFile: () => null }],
+        types: ['text/plain'],
         getData: () => 'line\n'.repeat(200),
       },
     });
@@ -761,9 +774,327 @@ describe('useComposerCore paste', () => {
     expect(latest!.getText()).toBe('line\n'.repeat(200));
     expect(latest!.getText()).not.toContain('Pasted Content');
   });
+
+  it('claims image drops, blocks submit while reading, and submits image-only', async () => {
+    const onSubmit = vi.fn();
+    await mount({ onSubmit });
+    const file = new File(['png'], 'photo.png', { type: 'image/png' });
+    const event = new Event('drop', { bubbles: true, cancelable: true });
+    Object.defineProperty(event, 'dataTransfer', {
+      value: { files: [file], items: [], types: ['Files'], dropEffect: 'none' },
+    });
+
+    act(() => {
+      container!
+        .querySelector('[data-web-shell-composer-surface]')!
+        .dispatchEvent(event);
+      latest!.submitText();
+    });
+    expect(event.defaultPrevented).toBe(true);
+    expect(onSubmit).not.toHaveBeenCalled();
+    expect(latest!.pendingImageBatchCount).toBe(1);
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    });
+    expect(latest!.pendingImageBatchCount).toBe(0);
+    expect(latest!.pastedImages).toMatchObject([{ media_type: 'image/png' }]);
+
+    act(() => latest!.submitText());
+    expect(onSubmit).toHaveBeenCalledWith(
+      '',
+      [expect.objectContaining({ media_type: 'image/png' })],
+      expect.any(Function),
+      undefined,
+    );
+  });
+
+  it('keeps drag feedback across composer children and clears it globally', async () => {
+    await mount();
+    const surface = container!.querySelector(
+      '[data-web-shell-composer-surface]',
+    )!;
+    const editor = container!.querySelector('.cm-content')!;
+    const dataTransfer = {
+      files: [],
+      items: [{ kind: 'file', type: 'image/png', getAsFile: () => null }],
+      types: ['Files'],
+      dropEffect: 'none',
+    };
+    const dispatchDrag = (
+      target: Element,
+      type: 'dragenter' | 'dragleave' | 'dragover',
+      relatedTarget: EventTarget | null = null,
+    ) => {
+      const event = new Event(type, { bubbles: true, cancelable: true });
+      Object.defineProperties(event, {
+        dataTransfer: { value: dataTransfer },
+        relatedTarget: { value: relatedTarget },
+      });
+      target.dispatchEvent(event);
+      return event;
+    };
+
+    act(() => {
+      dispatchDrag(editor, 'dragenter');
+    });
+    expect(latest!.imageDragActive).toBe(true);
+
+    act(() => {
+      dispatchDrag(editor, 'dragleave', surface);
+      dispatchDrag(editor, 'dragover');
+    });
+    expect(latest!.imageDragActive).toBe(true);
+    expect(dataTransfer.dropEffect).toBe('copy');
+
+    act(() => {
+      window.dispatchEvent(new Event('dragend'));
+    });
+    expect(latest!.imageDragActive).toBe(false);
+  });
+
+  it('keeps batch order, normalizes BMP, and aggregates rejected drops', async () => {
+    const onImageIngestionNotice = vi.fn();
+    await mount({ onImageIngestionNotice });
+    const first = new File(['first'], 'first.bmp', { type: 'image/x-bmp' });
+    const unsupported = new File(['text'], 'notes.txt', {
+      type: 'text/plain',
+    });
+    const second = new File(['second'], 'second.png', { type: 'image/png' });
+    const drop = (files: File[]) => {
+      const event = new Event('drop', { bubbles: true, cancelable: true });
+      Object.defineProperty(event, 'dataTransfer', {
+        value: { files, items: [], types: ['Files'], dropEffect: 'none' },
+      });
+      container!
+        .querySelector('[data-web-shell-composer-surface]')!
+        .dispatchEvent(event);
+    };
+
+    act(() => {
+      drop([first, unsupported]);
+      drop([second]);
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 30));
+    });
+
+    expect(latest!.pastedImages.map((image) => image.media_type)).toEqual([
+      'image/bmp',
+      'image/png',
+    ]);
+    expect(onImageIngestionNotice).toHaveBeenCalledTimes(1);
+    expect(onImageIngestionNotice).toHaveBeenCalledWith(
+      'warning',
+      expect.stringContaining('1'),
+    );
+  });
+
+  it('continues later image batches when the notice consumer throws', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    const onImageIngestionNotice = vi.fn(() => {
+      throw new Error('host notice failed');
+    });
+    await mount({ onImageIngestionNotice });
+    const drop = (files: File[]) => {
+      const event = new Event('drop', { bubbles: true, cancelable: true });
+      Object.defineProperty(event, 'dataTransfer', {
+        value: { files, items: [], types: ['Files'], dropEffect: 'none' },
+      });
+      container!
+        .querySelector('[data-web-shell-composer-surface]')!
+        .dispatchEvent(event);
+    };
+
+    act(() => {
+      drop([new File(['text'], 'notes.txt', { type: 'text/plain' })]);
+      drop([new File(['png'], 'photo.png', { type: 'image/png' })]);
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 30));
+    });
+
+    expect(onImageIngestionNotice).toHaveBeenCalledOnce();
+    expect(latest!.pastedImages).toMatchObject([{ media_type: 'image/png' }]);
+    expect(latest!.pendingImageBatchCount).toBe(0);
+  });
+
+  it('aborts and isolates readers when the composer owner changes', async () => {
+    class DeferredFileReader {
+      static instances: DeferredFileReader[] = [];
+      result: string | ArrayBuffer | null = null;
+      onload: ((event: ProgressEvent<FileReader>) => void) | null = null;
+      onerror: ((event: ProgressEvent<FileReader>) => void) | null = null;
+      onabort: ((event: ProgressEvent<FileReader>) => void) | null = null;
+      abort = vi.fn(() => this.onabort?.({} as ProgressEvent<FileReader>));
+
+      constructor() {
+        DeferredFileReader.instances.push(this);
+      }
+
+      readAsDataURL() {}
+    }
+    vi.stubGlobal('FileReader', DeferredFileReader);
+    const onImageIngestionNotice = vi.fn();
+    const mounted = await mount({
+      sessionId: 'session-a',
+      atWorkspaceCwd: '/workspace/a',
+      onImageIngestionNotice,
+    });
+    const file = new File(['png'], 'photo.png', { type: 'image/png' });
+    const event = new Event('drop', { bubbles: true, cancelable: true });
+    Object.defineProperty(event, 'dataTransfer', {
+      value: { files: [file], items: [], types: ['Files'], dropEffect: 'none' },
+    });
+
+    act(() => {
+      container!
+        .querySelector('[data-web-shell-composer-surface]')!
+        .dispatchEvent(event);
+    });
+    await act(async () => Promise.resolve());
+    expect(latest!.pendingImageBatchCount).toBe(1);
+    expect(DeferredFileReader.instances).toHaveLength(1);
+
+    mounted.switchSession('session-b', '/workspace/b');
+    expect(DeferredFileReader.instances[0]!.abort).toHaveBeenCalledOnce();
+    expect(latest!.pendingImageBatchCount).toBe(0);
+    expect(latest!.pastedImages).toEqual([]);
+    expect(onImageIngestionNotice).not.toHaveBeenCalled();
+  });
 });
 
 describe('useComposerCore tags', () => {
+  it('resubmits restored input annotations with the draft', async () => {
+    const { onSubmit } = await mount();
+    const inputAnnotations = [
+      {
+        type: 'reference' as const,
+        start: 0,
+        end: 8,
+        text: '@file.ts',
+        reference: { id: 'file:file.ts', kind: 'file', value: 'file.ts' },
+      },
+    ];
+
+    act(() => {
+      latest!.handle.setText('@file.ts\n\nfix it');
+      latest!.handle.restoreInputAnnotations?.(inputAnnotations);
+      latest!.submitText();
+    });
+
+    expect(onSubmit).toHaveBeenCalledWith(
+      '@file.ts\n\nfix it',
+      undefined,
+      expect.any(Function),
+      { inputAnnotations },
+    );
+  });
+
+  it('keeps earlier annotations when another restored prompt is prepended', async () => {
+    const { onSubmit } = await mount();
+
+    act(() => {
+      latest!.handle.setText('@a old');
+      latest!.handle.restoreInputAnnotations?.([
+        {
+          type: 'reference',
+          start: 0,
+          end: 2,
+          text: '@a',
+          reference: { id: 'file:a' },
+        },
+      ]);
+      latest!.handle.setText('@b new\n@a old');
+      latest!.handle.restoreInputAnnotations?.([
+        {
+          type: 'reference',
+          start: 0,
+          end: 2,
+          text: '@b',
+          reference: { id: 'file:b' },
+        },
+      ]);
+      latest!.submitText();
+    });
+
+    expect(onSubmit).toHaveBeenCalledWith(
+      '@b new\n@a old',
+      undefined,
+      expect.any(Function),
+      {
+        inputAnnotations: [
+          expect.objectContaining({ start: 0, end: 2, text: '@b' }),
+          expect.objectContaining({ start: 7, end: 9, text: '@a' }),
+        ],
+      },
+    );
+  });
+
+  it('maps restored annotations through edits before their range', async () => {
+    const { onSubmit } = await mount();
+
+    act(() => {
+      latest!.handle.setText('@file.ts\n\nfix it');
+      latest!.handle.restoreInputAnnotations?.([
+        {
+          type: 'reference',
+          start: 0,
+          end: 8,
+          text: '@file.ts',
+          reference: { id: 'file:file.ts', kind: 'file', value: 'file.ts' },
+        },
+      ]);
+      latest!.viewRef.current!.dispatch({
+        changes: { from: 0, insert: 'please ' },
+      });
+      latest!.submitText();
+    });
+
+    expect(onSubmit).toHaveBeenCalledWith(
+      'please @file.ts\n\nfix it',
+      undefined,
+      expect.any(Function),
+      {
+        inputAnnotations: [
+          expect.objectContaining({
+            start: 7,
+            end: 15,
+            text: '@file.ts',
+          }),
+        ],
+      },
+    );
+  });
+
+  it('drops a restored annotation when its range is edited', async () => {
+    const { onSubmit } = await mount();
+
+    act(() => {
+      latest!.handle.setText('@file.ts\n\nfix it');
+      latest!.handle.restoreInputAnnotations?.([
+        {
+          type: 'reference',
+          start: 0,
+          end: 8,
+          text: '@file.ts',
+          reference: { id: 'file:file.ts', kind: 'file', value: 'file.ts' },
+        },
+      ]);
+      latest!.viewRef.current!.dispatch({
+        changes: { from: 1, to: 2, insert: 'X' },
+      });
+      latest!.submitText();
+    });
+
+    expect(onSubmit).toHaveBeenCalledWith(
+      '@Xile.ts\n\nfix it',
+      undefined,
+      expect.any(Function),
+      undefined,
+    );
+  });
+
   it('keeps the composer API stable across tag updates', async () => {
     await mount();
     const api = latest!.handle;
diff --git a/packages/web-shell/client/hooks/useComposerCore.mobile.dom.test.tsx b/packages/web-shell/client/hooks/useComposerCore.mobile.dom.test.tsx
index 7722a06edc8..863a3cb0cef 100644
--- a/packages/web-shell/client/hooks/useComposerCore.mobile.dom.test.tsx
+++ b/packages/web-shell/client/hooks/useComposerCore.mobile.dom.test.tsx
@@ -71,18 +71,21 @@ function Harness({
   // Mirrors the ChatEditor render seam: the mobile backend renders a plain
   // controlled textarea at the single mount point, desktop keeps the
   // CodeMirror container div.
-  return composer.mobileComposer ? (
-    <textarea
-      ref={composer.mobileComposer.textareaRef}
-      value={composer.mobileComposer.value}
-      onChange={composer.mobileComposer.onChange}
-      onBlur={composer.mobileComposer.onBlur}
-      onPaste={composer.mobileComposer.onPaste}
-      placeholder={composer.mobileComposer.placeholder}
-      data-web-shell-composer-editor
-    />
-  ) : (
-    <div ref={composer.containerRef} data-web-shell-composer-editor />
+  return (
+    <div {...composer.imageTransferHandlers} data-web-shell-composer-surface>
+      {composer.mobileComposer ? (
+        <textarea
+          ref={composer.mobileComposer.textareaRef}
+          value={composer.mobileComposer.value}
+          onChange={composer.mobileComposer.onChange}
+          onBlur={composer.mobileComposer.onBlur}
+          placeholder={composer.mobileComposer.placeholder}
+          data-web-shell-composer-editor
+        />
+      ) : (
+        <div ref={composer.containerRef} data-web-shell-composer-editor />
+      )}
+    </div>
   );
 }
 
@@ -373,17 +376,23 @@ describe('useComposerCore mobile textarea backend', () => {
     await mount();
     const preventDefault = vi.fn();
     const imageItem = {
+      kind: 'file',
       type: 'image/png',
       getAsFile: () =>
         new File([new Uint8Array([137, 80, 78, 71])], 'x.png', {
           type: 'image/png',
         }),
     };
+    const imageEvent = new Event('paste', {
+      bubbles: true,
+      cancelable: true,
+    });
+    Object.defineProperty(imageEvent, 'clipboardData', {
+      value: { files: [], items: [imageItem], types: ['Files'] },
+    });
     await act(async () => {
-      latest!.mobileComposer!.onPaste({
-        clipboardData: { items: [imageItem] },
-        preventDefault,
-      } as unknown as React.ClipboardEvent<HTMLTextAreaElement>);
+      imageEvent.preventDefault = preventDefault;
+      container!.querySelector('textarea')!.dispatchEvent(imageEvent);
       await new Promise((resolve) => setTimeout(resolve, 20));
     });
     expect(preventDefault).toHaveBeenCalled();
@@ -391,13 +400,20 @@ describe('useComposerCore mobile textarea backend', () => {
     expect(latest!.pastedImages[0].media_type).toBe('image/png');
 
     const textPreventDefault = vi.fn();
+    const textEvent = new Event('paste', {
+      bubbles: true,
+      cancelable: true,
+    });
+    Object.defineProperty(textEvent, 'clipboardData', {
+      value: {
+        files: [],
+        items: [{ kind: 'string', type: 'text/plain', getAsFile: () => null }],
+        types: ['text/plain'],
+      },
+    });
     act(() => {
-      latest!.mobileComposer!.onPaste({
-        clipboardData: {
-          items: [{ type: 'text/plain', getAsFile: () => null }],
-        },
-        preventDefault: textPreventDefault,
-      } as unknown as React.ClipboardEvent<HTMLTextAreaElement>);
+      textEvent.preventDefault = textPreventDefault;
+      container!.querySelector('textarea')!.dispatchEvent(textEvent);
     });
     expect(textPreventDefault).not.toHaveBeenCalled();
   });
diff --git a/packages/web-shell/client/hooks/useComposerCore.ts b/packages/web-shell/client/hooks/useComposerCore.ts
index 6890d8cb849..b3c17231bba 100644
--- a/packages/web-shell/client/hooks/useComposerCore.ts
+++ b/packages/web-shell/client/hooks/useComposerCore.ts
@@ -6,6 +6,8 @@ import {
   useCallback,
   useMemo,
   type ReactNode,
+  type ClipboardEventHandler,
+  type DragEventHandler,
 } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
 import {
@@ -97,6 +99,12 @@ import type {
   WebShellAtProvider,
 } from '../customization';
 import { useWebShellPortalRoot } from '../portalRoot';
+import {
+  extractImageTransfer,
+  hasFileTransferPayload,
+  MAX_IMAGE_ATTACHMENT_DATA_BYTES,
+  readImageTransfer,
+} from '../utils/imageIngestion';
 
 const TOOLTIP_STYLE_ID = 'web-shell-tooltip-styles';
 const TOOLTIP_STYLES = `
@@ -907,6 +915,9 @@ export interface EditorHandle extends WebShellComposerApi {
   hasInput(): boolean;
   retryLast(): void;
   restoreImages(images: readonly PromptImage[]): void;
+  restoreInputAnnotations?(
+    inputAnnotations: readonly DaemonInputAnnotation[],
+  ): void;
 }
 
 // ---- Compartments (shared) ----
@@ -934,6 +945,55 @@ function getFollowupRemainder(
   return remainder.length > 0 ? remainder : null;
 }
 
+function mapRestoredInputAnnotationsAfterTextChange(
+  annotations: readonly DaemonInputAnnotation[],
+  previousText: string,
+  nextText: string,
+): DaemonInputAnnotation[] {
+  if (previousText === nextText) return [...annotations];
+  if (previousText && nextText.endsWith(`\n${previousText}`)) {
+    const offset = nextText.length - previousText.length;
+    return annotations.map((annotation) => ({
+      ...annotation,
+      start: annotation.start + offset,
+      end: annotation.end + offset,
+    }));
+  }
+
+  let from = 0;
+  while (
+    from < previousText.length &&
+    from < nextText.length &&
+    previousText[from] === nextText[from]
+  ) {
+    from += 1;
+  }
+  let previousTo = previousText.length;
+  let nextTo = nextText.length;
+  while (
+    previousTo > from &&
+    nextTo > from &&
+    previousText[previousTo - 1] === nextText[nextTo - 1]
+  ) {
+    previousTo -= 1;
+    nextTo -= 1;
+  }
+  const delta = nextTo - previousTo;
+
+  return annotations.flatMap((annotation) => {
+    let start = annotation.start;
+    let end = annotation.end;
+    if (previousTo <= start) {
+      start += delta;
+      end += delta;
+    } else if (from < end) {
+      return [];
+    }
+    if (nextText.slice(start, end) !== annotation.text) return [];
+    return [{ ...annotation, start, end }];
+  });
+}
+
 class FollowupGhostWidget extends WidgetType {
   constructor(private readonly text: string) {
     super();
@@ -1040,6 +1100,7 @@ export interface UseComposerCoreOptions {
   renderComposerTag?: ComposerTagRenderer;
   renderComposerTagTooltip?: ComposerTagRenderer;
   onComposerTagClick?: ComposerTagClickHandler;
+  onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
   /** CodeMirror theme extension for the editor view. Each variant provides its own. */
   editorTheme: Parameters<typeof EditorView.theme>[0];
 }
@@ -1185,36 +1246,6 @@ function handleMultilineHistoryBoundary(
   return 'history';
 }
 
-/**
- * Extracts pasteable images from a clipboard, shared by the CodeMirror paste
- * handler and the mobile textarea backend. Returns whether any image was
- * found; matched files are decoded asynchronously and reported via `addImage`.
- */
-function collectClipboardImages(
-  items: DataTransferItemList,
-  addImage: (image: PromptImage) => void,
-): boolean {
-  let hasImage = false;
-  for (const item of items) {
-    if (
-      item.type.startsWith('image/') &&
-      /^image\/(png|jpeg|gif|webp)$/i.test(item.type)
-    ) {
-      hasImage = true;
-      const file = item.getAsFile();
-      if (!file) continue;
-      const mediaType = item.type;
-      const reader = new FileReader();
-      reader.onload = () => {
-        const base64 = (reader.result as string).split(',')[1];
-        addImage({ data: base64, media_type: mediaType });
-      };
-      reader.readAsDataURL(file);
-    }
-  }
-  return hasImage;
-}
-
 /**
  * Editor backend for touch devices: instead of a CodeMirror EditorView, the
  * composer renders a plain controlled `<textarea>` wired to these fields.
@@ -1227,10 +1258,33 @@ export interface MobileComposerBackend {
   value: string;
   onChange: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
   onBlur: () => void;
-  onPaste: (event: React.ClipboardEvent<HTMLTextAreaElement>) => void;
   placeholder: string;
 }
 
+export interface ComposerImageTransferHandlers {
+  onPasteCapture: ClipboardEventHandler<HTMLDivElement>;
+  onDragEnterCapture: DragEventHandler<HTMLDivElement>;
+  onDragOverCapture: DragEventHandler<HTMLDivElement>;
+  onDragLeaveCapture: DragEventHandler<HTMLDivElement>;
+  onDropCapture: DragEventHandler<HTMLDivElement>;
+}
+
+interface ImageIngestionLane {
+  generation: number;
+  tail: Promise<void>;
+  pendingBatches: number;
+  activeReaders: Set<FileReader>;
+}
+
+function createImageIngestionLane(generation: number): ImageIngestionLane {
+  return {
+    generation,
+    tail: Promise.resolve(),
+    pendingBatches: 0,
+    activeReaders: new Set(),
+  };
+}
+
 export interface UseComposerCoreReturn {
   containerRef: React.RefObject<HTMLDivElement | null>;
   viewRef: React.RefObject<EditorView | null>;
@@ -1242,6 +1296,10 @@ export interface UseComposerCoreReturn {
   hasInput: () => boolean;
   hasAttachments: boolean;
   hasContent: boolean;
+  canSubmit: boolean;
+  pendingImageBatchCount: number;
+  imageDragActive: boolean;
+  imageTransferHandlers: ComposerImageTransferHandlers;
   handle: EditorHandle;
   pastedImages: PromptImage[];
   removeImage: (index: number) => void;
@@ -1318,6 +1376,7 @@ export function useComposerCore(
     renderComposerTag,
     renderComposerTagTooltip,
     onComposerTagClick,
+    onImageIngestionNotice,
     editorTheme,
   } = options;
 
@@ -1348,6 +1407,8 @@ export function useComposerCore(
   );
   const mobileTextRef = useRef(mobileText);
   const mobileTextVersionRef = useRef(0);
+  const restoredInputAnnotationsRef = useRef<DaemonInputAnnotation[]>([]);
+  const skipNextRestoredAnnotationMappingRef = useRef(false);
   const draftIdentityRef = useRef({
     sessionId,
     workspaceCwd: atWorkspaceCwd,
@@ -1377,6 +1438,12 @@ export function useComposerCore(
   // typing or programmatic (setText, clear, history restore, post-submit
   // clear) — notifies onInputTextChange, so parent trackers never go stale.
   const setMobileText = useCallback((text: string) => {
+    restoredInputAnnotationsRef.current =
+      mapRestoredInputAnnotationsAfterTextChange(
+        restoredInputAnnotationsRef.current,
+        mobileTextRef.current,
+        text,
+      );
     mobileTextVersionRef.current += 1;
     mobileTextRef.current = text;
     setMobileTextState(text);
@@ -1418,6 +1485,8 @@ export function useComposerCore(
   onAcceptFollowupRef.current = onAcceptFollowup;
   const onDismissFollowupRef = useRef(onDismissFollowup);
   onDismissFollowupRef.current = onDismissFollowup;
+  const onImageIngestionNoticeRef = useRef(onImageIngestionNotice);
+  onImageIngestionNoticeRef.current = onImageIngestionNotice;
   const onFocusFooterRef = useRef(onFocusFooter);
   onFocusFooterRef.current = onFocusFooter;
   const languageRef = useRef(language);
@@ -1576,6 +1645,189 @@ export function useComposerCore(
   const searchDraftRef = useRef('');
   const [pastedImages, setPastedImages] = useState<PromptImage[]>([]);
   const pastedImagesRef = useRef<PromptImage[]>([]);
+  const [pendingImageBatchCount, setPendingImageBatchCount] = useState(0);
+  const [imageDragActive, setImageDragActive] = useState(false);
+  const imageDragDepthRef = useRef(0);
+  const imageIngestionLaneRef = useRef<ImageIngestionLane>(
+    createImageIngestionLane(0),
+  );
+  const clearImageDragState = useCallback(() => {
+    imageDragDepthRef.current = 0;
+    setImageDragActive(false);
+  }, []);
+  const resetImageIngestion = useCallback((updateState = true) => {
+    const previousLane = imageIngestionLaneRef.current;
+    imageIngestionLaneRef.current = createImageIngestionLane(
+      previousLane.generation + 1,
+    );
+    pastedImagesRef.current = [];
+    for (const reader of previousLane.activeReaders) {
+      reader.abort();
+    }
+    previousLane.activeReaders.clear();
+    imageDragDepthRef.current = 0;
+    if (updateState) {
+      setPastedImages([]);
+      setPendingImageBatchCount(0);
+      setImageDragActive(false);
+    }
+  }, []);
+  const emitImageIngestionNotice = useCallback(
+    (tone: 'warning' | 'error', message: string) => {
+      const handler = onImageIngestionNoticeRef.current;
+      if (handler) {
+        try {
+          handler(tone, message);
+        } catch (error) {
+          console.error('[WebShell] image ingestion notice failed', error);
+        }
+      } else if (tone === 'error') {
+        console.error(message);
+      } else {
+        console.warn(message);
+      }
+    },
+    [],
+  );
+  const enqueueImageTransfer = useCallback(
+    (dataTransfer: DataTransfer, source: 'paste' | 'drop') => {
+      const transfer = extractImageTransfer(dataTransfer, source);
+      if (!transfer.claimed) return false;
+      if (disabledRef.current) return true;
+
+      const lane = imageIngestionLaneRef.current;
+      lane.pendingBatches += 1;
+      setPendingImageBatchCount(lane.pendingBatches);
+      lane.tail = lane.tail
+        .then(async () => {
+          if (imageIngestionLaneRef.current !== lane) return;
+          const result = await readImageTransfer(transfer, {
+            onReaderCreated: (reader) => lane.activeReaders.add(reader),
+            onReaderSettled: (reader) => lane.activeReaders.delete(reader),
+            maxEncodedBytes: Math.max(
+              0,
+              MAX_IMAGE_ATTACHMENT_DATA_BYTES -
+                pastedImagesRef.current.reduce(
+                  (total, image) => total + image.data.length,
+                  0,
+                ),
+            ),
+          });
+          if (imageIngestionLaneRef.current !== lane) return;
+          if (result.accepted.length > 0) {
+            const next = [...pastedImagesRef.current, ...result.accepted];
+            pastedImagesRef.current = next;
+            setPastedImages(next);
+          }
+          const skipped = result.rejected.filter(
+            ({ reason }) => reason !== 'read-failed' && reason !== 'too-large',
+          ).length;
+          const tooLarge = result.rejected.filter(
+            ({ reason }) => reason === 'too-large',
+          ).length;
+          const failed = result.rejected.filter(
+            ({ reason }) => reason === 'read-failed',
+          ).length;
+          if (skipped > 0) {
+            emitImageIngestionNotice(
+              'warning',
+              tRef.current('editor.imagesSkipped', { count: skipped }),
+            );
+          }
+          if (failed > 0) {
+            emitImageIngestionNotice(
+              'error',
+              tRef.current('editor.imagesReadFailed', { count: failed }),
+            );
+          }
+          if (tooLarge > 0) {
+            emitImageIngestionNotice(
+              'warning',
+              tRef.current('editor.imagesTooLarge', { count: tooLarge }),
+            );
+          }
+        })
+        .catch(() => {
+          if (imageIngestionLaneRef.current === lane) {
+            emitImageIngestionNotice(
+              'error',
+              tRef.current('editor.imagesReadFailed', { count: 1 }),
+            );
+          }
+        })
+        .then(() => {
+          if (imageIngestionLaneRef.current !== lane) return;
+          lane.pendingBatches = Math.max(0, lane.pendingBatches - 1);
+          setPendingImageBatchCount(lane.pendingBatches);
+        });
+      return true;
+    },
+    [emitImageIngestionNotice],
+  );
+  const imageTransferHandlers = useMemo<ComposerImageTransferHandlers>(
+    () => ({
+      onPasteCapture: (event) => {
+        if (enqueueImageTransfer(event.clipboardData, 'paste')) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      },
+      onDragEnterCapture: (event) => {
+        if (!hasFileTransferPayload(event.dataTransfer)) return;
+        event.preventDefault();
+        imageDragDepthRef.current += 1;
+        if (!disabledRef.current) setImageDragActive(true);
+      },
+      onDragOverCapture: (event) => {
+        if (!hasFileTransferPayload(event.dataTransfer)) return;
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'copy';
+      },
+      onDragLeaveCapture: (event) => {
+        if (!hasFileTransferPayload(event.dataTransfer)) return;
+        imageDragDepthRef.current = Math.max(0, imageDragDepthRef.current - 1);
+        const nextTarget = event.relatedTarget;
+        if (
+          !(nextTarget instanceof Node) ||
+          !event.currentTarget.contains(nextTarget)
+        ) {
+          clearImageDragState();
+        }
+      },
+      onDropCapture: (event) => {
+        if (!hasFileTransferPayload(event.dataTransfer)) return;
+        event.preventDefault();
+        event.stopPropagation();
+        clearImageDragState();
+        if (disabledRef.current) return;
+        enqueueImageTransfer(event.dataTransfer, 'drop');
+        if (isTouchComposer) {
+          mobileTextareaRef.current?.focus();
+        } else {
+          viewRef.current?.focus();
+        }
+      },
+    }),
+    [clearImageDragState, enqueueImageTransfer, isTouchComposer],
+  );
+  useEffect(() => {
+    if (!imageDragActive) return;
+    window.addEventListener('dragend', clearImageDragState);
+    window.addEventListener('blur', clearImageDragState);
+    return () => {
+      window.removeEventListener('dragend', clearImageDragState);
+      window.removeEventListener('blur', clearImageDragState);
+    };
+  }, [clearImageDragState, imageDragActive]);
+  useEffect(() => {
+    if (disabled) clearImageDragState();
+  }, [clearImageDragState, disabled]);
+  useEffect(
+    () => () => {
+      resetImageIngestion(false);
+    },
+    [resetImageIngestion],
+  );
   const [composerTags, setComposerTags] = useState<WebShellComposerTag[]>([]);
   const composerTagsRef = useRef<WebShellComposerTag[]>([]);
   composerTagsRef.current = composerTags;
@@ -1984,8 +2236,6 @@ export function useComposerCore(
   };
   const shellHistoryActionsRef = useRef(shellHistory);
   shellHistoryActionsRef.current = shellHistory;
-  pastedImagesRef.current = pastedImages;
-
   const getSearchMatches = useCallback((query: string) => {
     const isShellMode = shellModeRef.current;
     const history = isShellMode
@@ -2118,21 +2368,6 @@ export function useComposerCore(
     }
   }, [isTouchComposer, mobileText]);
 
-  const handleMobilePaste = useCallback(
-    (event: React.ClipboardEvent<HTMLTextAreaElement>) => {
-      const items = event.clipboardData?.items;
-      if (!items) return;
-      const hasImage = collectClipboardImages(items, (image) =>
-        setPastedImages((prev) => [...prev, image]),
-      );
-      // Plain text falls through to the native paste.
-      if (hasImage) {
-        event.preventDefault();
-      }
-    },
-    [],
-  );
-
   // Lives in the render scope (not the editor-creation effect) so the mobile
   // textarea backend, which never instantiates an EditorView, can reuse the
   // exact same submit pipeline with `view === null`.
@@ -2142,6 +2377,12 @@ export function useComposerCore(
     tagsOverride?: readonly WebShellComposerTag[],
     suppressFollowupCompletion = false,
   ) => {
+    if (
+      disabledRef.current ||
+      imageIngestionLaneRef.current.pendingBatches > 0
+    ) {
+      return true;
+    }
     const inlineTags =
       tagsOverride === undefined && view
         ? getInlineComposerTagPlacements(view)
@@ -2173,26 +2414,56 @@ export function useComposerCore(
             }))
         : [];
     const tags = tagsOverride ?? composerTagsRef.current;
-    if (!rawText && tags.length === 0 && inlineTags.length === 0) return true;
+    const images = pastedImagesRef.current;
+    if (
+      !rawText &&
+      tags.length === 0 &&
+      inlineTags.length === 0 &&
+      images.length === 0
+    ) {
+      return true;
+    }
     const textWithInlineTags =
       tagsOverride === undefined
         ? replaceInlineTagPlacements(rawText, normalizedInlineTags)
         : rawText;
     const text = textWithInlineTags;
     const prompt = buildComposerPrompt(text, tags);
-    const images = pastedImagesRef.current;
     const isShellMode = shellModeRef.current;
-    const promptText = isShellMode ? `!${prompt}` : prompt;
-    const inputAnnotations = createInputAnnotationsFromComposerTags(
+    const promptText = isShellMode && prompt ? `!${prompt}` : prompt;
+    const generatedInputAnnotations = createInputAnnotationsFromComposerTags(
       promptText,
       [...tags, ...normalizedInlineTags.map((placement) => placement.tag)],
     );
+    const inputAnnotations = [...generatedInputAnnotations];
+    const annotationKeys = new Set(
+      generatedInputAnnotations.map(
+        (annotation) =>
+          `${annotation.start}:${annotation.end}:${annotation.text}:${annotation.reference.id}`,
+      ),
+    );
+    for (const annotation of restoredInputAnnotationsRef.current) {
+      if (
+        annotation.start < 0 ||
+        annotation.end > promptText.length ||
+        promptText.slice(annotation.start, annotation.end) !== annotation.text
+      ) {
+        continue;
+      }
+      const key = `${annotation.start}:${annotation.end}:${annotation.text}:${annotation.reference.id}`;
+      if (annotationKeys.has(key)) continue;
+      annotationKeys.add(key);
+      inputAnnotations.push(annotation);
+    }
+    inputAnnotations.sort((left, right) => left.start - right.start);
     const submissionIdentity = { ...composerIdentityRef.current };
     const draftTextAtSubmit = editorText;
     const editorDocAtSubmit = view?.state.doc;
     const mobileTextVersionAtSubmit = mobileTextVersionRef.current;
     const composerTagsAtSubmit = composerTagsRef.current;
     const pastedImagesAtSubmit = pastedImagesRef.current;
+    const restoredInputAnnotationsAtSubmit =
+      restoredInputAnnotationsRef.current;
     const shellModeAtSubmit = shellModeRef.current;
     let committed = false;
     const commitAccepted = () => {
@@ -2239,6 +2510,8 @@ export function useComposerCore(
           : mobileTextVersionRef.current === mobileTextVersionAtSubmit) &&
         composerTagsRef.current === composerTagsAtSubmit &&
         pastedImagesRef.current === pastedImagesAtSubmit &&
+        restoredInputAnnotationsRef.current ===
+          restoredInputAnnotationsAtSubmit &&
         shellModeRef.current === shellModeAtSubmit;
       historyBrowseActiveRef.current = false;
       if (!composerUnchanged) return;
@@ -2251,6 +2524,8 @@ export function useComposerCore(
       onDismissFollowupRef.current?.();
       clearPromptHistoryDraftTags();
       setComposerTags([]);
+      pastedImagesRef.current = [];
+      restoredInputAnnotationsRef.current = [];
       setPastedImages([]);
       if (view) {
         view.dispatch({
@@ -2823,6 +3098,17 @@ export function useComposerCore(
           }
           if (update.docChanged) {
             const text = getDocText(update.state);
+            if (skipNextRestoredAnnotationMappingRef.current) {
+              skipNextRestoredAnnotationMappingRef.current = false;
+            } else if (restoredInputAnnotationsRef.current.length > 0) {
+              restoredInputAnnotationsRef.current =
+                restoredInputAnnotationsRef.current.flatMap((annotation) => {
+                  const start = update.changes.mapPos(annotation.start, 1);
+                  const end = update.changes.mapPos(annotation.end, -1);
+                  if (text.slice(start, end) !== annotation.text) return [];
+                  return [{ ...annotation, start, end }];
+                });
+            }
             if (draftIdentityRef.current.storageKey === undefined) {
               unscopedDraftEditedRef.current = true;
             }
@@ -2884,18 +3170,6 @@ export function useComposerCore(
             }, 0);
             return false;
           },
-          paste(event) {
-            const items = event.clipboardData?.items;
-            if (!items) return false;
-            const hasImage = collectClipboardImages(items, (image) =>
-              setPastedImages((prev) => [...prev, image]),
-            );
-            if (hasImage) {
-              event.preventDefault();
-              return true;
-            }
-            return false;
-          },
         }),
         EditorView.theme(editorTheme),
       ],
@@ -2954,6 +3228,8 @@ export function useComposerCore(
 
     if (!sessionChanged && !workspaceChanged) return;
 
+    resetImageIngestion();
+    restoredInputAnnotationsRef.current = [];
     historyActionsRef.current.reset();
     shellHistoryActionsRef.current.reset();
     historyBrowseActiveRef.current = false;
@@ -2997,7 +3273,6 @@ export function useComposerCore(
     }
 
     setComposerTags([]);
-    setPastedImages([]);
     if (view) {
       view.dispatch({
         changes: { from: 0, to: view.state.doc.length, insert: nextText },
@@ -3015,6 +3290,7 @@ export function useComposerCore(
     clearPromptHistoryDraftTags,
     composerDraftStorageKey,
     isTouchComposer,
+    resetImageIngestion,
     sessionId,
     setMobileText,
   ]);
@@ -3368,6 +3644,18 @@ export function useComposerCore(
       }
       const view = viewRef.current;
       if (!view) return;
+      if (restoredInputAnnotationsRef.current.length > 0) {
+        const currentText = view.state.doc.toString();
+        if (currentText !== text) {
+          restoredInputAnnotationsRef.current =
+            mapRestoredInputAnnotationsAfterTextChange(
+              restoredInputAnnotationsRef.current,
+              currentText,
+              text,
+            );
+          skipNextRestoredAnnotationMappingRef.current = true;
+        }
+      }
       view.dispatch({
         changes: { from: 0, to: view.state.doc.length, insert: text },
         effects: clearInlineTagsEffect.of(),
@@ -3417,7 +3705,8 @@ export function useComposerCore(
         setMobileText('');
       }
       if (clearTextOpt) {
-        setPastedImages([]);
+        restoredInputAnnotationsRef.current = [];
+        resetImageIngestion();
       }
       if (clearTags) {
         setComposerTags([]);
@@ -3426,7 +3715,7 @@ export function useComposerCore(
         }
       }
     },
-    [isTouchComposer, removeInlineTags, setMobileText],
+    [isTouchComposer, removeInlineTags, resetImageIngestion, setMobileText],
   );
 
   const clearText = useCallback(() => {
@@ -3551,12 +3840,20 @@ export function useComposerCore(
   );
 
   const retryLast = useCallback(() => {
+    if (
+      disabledRef.current ||
+      imageIngestionLaneRef.current.pendingBatches > 0
+    ) {
+      return;
+    }
     const last = historyActionsRef.current.getLastEntry(
       (e) => !e.startsWith('/') && !e.startsWith('!'),
     );
     if (!last) return;
     const accepted = onSubmitRef.current(last);
     if (accepted === false) return;
+    pastedImagesRef.current = [];
+    restoredInputAnnotationsRef.current = [];
     setPastedImages([]);
   }, []);
 
@@ -3716,6 +4013,12 @@ export function useComposerCore(
 
   const submitSearchMatch = useCallback(
     (match: string) => {
+      if (
+        disabledRef.current ||
+        imageIngestionLaneRef.current.pendingBatches > 0
+      ) {
+        return;
+      }
       const view = viewRef.current;
       if (!view && !isTouchComposer) return;
       closeSearch(false);
@@ -3738,6 +4041,8 @@ export function useComposerCore(
       onDismissFollowupRef.current?.();
       shellHistoryActionsRef.current.push(text);
       shellHistoryActionsRef.current.reset();
+      pastedImagesRef.current = [];
+      restoredInputAnnotationsRef.current = [];
       setPastedImages([]);
       replaceEditorText('');
     },
@@ -3804,11 +4109,14 @@ export function useComposerCore(
   };
 
   const removeImage = useCallback((index: number) => {
-    setPastedImages((prev) => prev.filter((_, idx) => idx !== index));
+    const next = pastedImagesRef.current.filter((_, idx) => idx !== index);
+    pastedImagesRef.current = next;
+    setPastedImages(next);
   }, []);
 
   // ---- Computed ----
 
+  const canSubmit = !disabled && pendingImageBatchCount === 0 && hasContent;
   const showShortcutHints =
     !shellMode &&
     !searchMode &&
@@ -3819,8 +4127,30 @@ export function useComposerCore(
   // ---- Imperative handle ----
 
   const restoreImages = useCallback((images: readonly PromptImage[]) => {
-    setPastedImages((prev) => [...prev, ...images]);
+    const next = [...pastedImagesRef.current, ...images];
+    pastedImagesRef.current = next;
+    setPastedImages(next);
   }, []);
+  const restoreInputAnnotations = useCallback(
+    (inputAnnotations: readonly DaemonInputAnnotation[]) => {
+      const restored = new Map(
+        restoredInputAnnotationsRef.current.map((annotation) => [
+          `${annotation.start}:${annotation.end}:${annotation.text}:${annotation.reference.id}`,
+          annotation,
+        ]),
+      );
+      for (const annotation of inputAnnotations) {
+        restored.set(
+          `${annotation.start}:${annotation.end}:${annotation.text}:${annotation.reference.id}`,
+          annotation,
+        );
+      }
+      restoredInputAnnotationsRef.current = [...restored.values()].sort(
+        (left, right) => left.start - right.start,
+      );
+    },
+    [],
+  );
   const handle = useMemo<EditorHandle>(() => {
     return {
       clearText,
@@ -3835,6 +4165,7 @@ export function useComposerCore(
       insertText,
       retryLast,
       restoreImages,
+      restoreInputAnnotations,
       submit,
     };
   }, [
@@ -3848,6 +4179,7 @@ export function useComposerCore(
     insertText,
     removeTopTag,
     restoreImages,
+    restoreInputAnnotations,
     retryLast,
     setText,
     submit,
@@ -3862,7 +4194,6 @@ export function useComposerCore(
           value: mobileText,
           onChange: handleMobileChange,
           onBlur: () => saveCurrentDraftRef.current(),
-          onPaste: handleMobilePaste,
           placeholder: composerPlaceholder,
         }
       : null,
@@ -3878,6 +4209,10 @@ export function useComposerCore(
     hasAttachments:
       hasInlineTags || composerTags.length > 0 || pastedImages.length > 0,
     hasContent,
+    canSubmit,
+    pendingImageBatchCount,
+    imageDragActive,
+    imageTransferHandlers,
     handle,
     pastedImages,
     removeImage,
diff --git a/packages/web-shell/client/hooks/useQueuedPrompts.dom.test.tsx b/packages/web-shell/client/hooks/useQueuedPrompts.dom.test.tsx
index 3e2f5e723fb..f9a5ba7ba29 100644
--- a/packages/web-shell/client/hooks/useQueuedPrompts.dom.test.tsx
+++ b/packages/web-shell/client/hooks/useQueuedPrompts.dom.test.tsx
@@ -4,7 +4,10 @@ import { act } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { DaemonSessionActions } from '@qwen-code/webui/daemon-react-sdk';
-import type { DaemonTranscriptStore } from '@qwen-code/sdk/daemon';
+import {
+  DaemonHttpError,
+  type DaemonTranscriptStore,
+} from '@qwen-code/sdk/daemon';
 import { getTranslator } from '../i18n';
 import {
   useQueuedPrompts,
@@ -12,7 +15,21 @@ import {
 } from './useQueuedPrompts';
 
 const sdk = vi.hoisted(() => ({
-  pendingEvents: [],
+  pendingEvents: [] as Array<{
+    type:
+      | 'pending_prompt_started'
+      | 'pending_prompt_completed'
+      | 'turn_complete'
+      | 'turn_error';
+    originatorClientId?: string;
+    data: {
+      sessionId: string;
+      promptId?: string;
+      text?: string;
+      state?: string;
+      stopReason?: string;
+    };
+  }>,
   batches: [] as Array<{
     sessionId: string;
     messages: readonly string[];
@@ -57,12 +74,14 @@ function mount(
   streamingState: 'idle' | 'waiting' | 'responding' | 'thinking',
   sessionActions: DaemonSessionActions,
   canMutateMidTurn = true,
+  connected = false,
 ) {
   const editor = {
     getText: vi.fn(() => ''),
     setText: vi.fn(),
     focus: vi.fn(),
     restoreImages: vi.fn(),
+    restoreInputAnnotations: vi.fn(),
   };
   const store = {
     appendLocalUserMessage: vi.fn(),
@@ -70,10 +89,16 @@ function mount(
   } as unknown as DaemonTranscriptStore;
   const reportError = vi.fn();
 
-  function Harness({ state }: { state: typeof streamingState }) {
+  function Harness({
+    state,
+    activeSessionId,
+  }: {
+    state: typeof streamingState;
+    activeSessionId: string;
+  }) {
     latest = useQueuedPrompts({
-      connected: false,
-      sessionId: 'session-1',
+      connected,
+      sessionId: activeSessionId,
       clientId: 'client-1',
       canMutateMidTurn,
       streamingState: state,
@@ -86,19 +111,31 @@ function mount(
     return null;
   }
 
-  const render = (state: typeof streamingState) => {
-    act(() => root.render(<Harness state={state} />));
+  let activeSessionId = 'session-1';
+  const render = (
+    state: typeof streamingState,
+    nextSessionId = activeSessionId,
+  ) => {
+    activeSessionId = nextSessionId;
+    act(() =>
+      root.render(<Harness state={state} activeSessionId={activeSessionId} />),
+    );
   };
   render(streamingState);
-  return { editor, render, reportError };
+  return { editor, render, reportError, store };
 }
 
 function createActions() {
-  const pendingSubmit = deferred<{ promptId: string }>();
+  const pendingSubmit = deferred<{
+    promptId: string;
+    removedAfterAbort?: true;
+  }>();
   return {
     actions: {
       enqueueMidTurnMessage: vi.fn(),
       removeMidTurnMessage: vi.fn(),
+      removePendingPrompt: vi.fn(),
+      getPendingPrompts: vi.fn().mockResolvedValue({ pendingPrompts: [] }),
       submitPrompt: vi.fn(() => pendingSubmit.promise),
     } as unknown as DaemonSessionActions,
     pendingSubmit,
@@ -110,6 +147,7 @@ beforeEach(() => {
   document.body.appendChild(container);
   root = createRoot(container);
   sdk.batches = [];
+  sdk.pendingEvents = [];
   sdk.consume.mockReset();
 });
 
@@ -119,6 +157,558 @@ afterEach(() => {
 });
 
 describe('useQueuedPrompts default mid-turn insertion', () => {
+  it('queues and submits an image-only prompt without using mid-turn text insertion', () => {
+    const { actions } = createActions();
+    mount('responding', actions);
+    const images = [{ data: 'Ym1w', media_type: 'image/bmp' }];
+
+    act(() => latest.enqueuePrompt('', images));
+
+    expect(actions.enqueueMidTurnMessage).not.toHaveBeenCalled();
+    expect(actions.submitPrompt).toHaveBeenCalledWith(
+      '',
+      expect.objectContaining({
+        images,
+        optimisticUserMessage: false,
+      }),
+    );
+    expect(latest.queuedPrompts).toMatchObject([
+      {
+        text: '',
+        images,
+        payloadCompleteness: 'complete',
+        serverState: 'submitting',
+      },
+    ]);
+  });
+
+  it('materializes daemon-only queue rows as summary-only payloads', async () => {
+    const { actions } = createActions();
+    vi.mocked(actions.getPendingPrompts).mockResolvedValue({
+      pendingPrompts: [
+        {
+          promptId: 'server-image',
+          text: '[image]',
+          state: 'queued',
+        },
+      ],
+    });
+    const { editor } = mount('responding', actions, true, true);
+
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(latest.queuedPrompts).toMatchObject([
+      {
+        text: '[image]',
+        serverPromptId: 'server-image',
+        serverState: 'queued',
+        payloadCompleteness: 'summary-only',
+      },
+    ]);
+    await act(async () => latest.editQueuedPrompt(1));
+    expect(editor.setText).not.toHaveBeenCalled();
+    expect(editor.restoreImages).not.toHaveBeenCalled();
+  });
+
+  it('buffers an image-only started event until its exact response binds', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { render, store } = mount('responding', actions);
+    const images = [{ data: 'Ym1w', media_type: 'image/bmp' }];
+
+    act(() => latest.enqueuePrompt('', images));
+    sdk.pendingEvents = [
+      {
+        type: 'pending_prompt_started',
+        originatorClientId: 'client-1',
+        data: {
+          sessionId: 'session-1',
+          promptId: 'server-image',
+          text: '[image]',
+        },
+      },
+    ];
+    render('responding');
+    expect(store.appendLocalUserMessage).not.toHaveBeenCalled();
+
+    await act(async () => {
+      pendingSubmit.resolve({ promptId: 'server-image' });
+      await Promise.resolve();
+    });
+
+    expect(store.appendLocalUserMessage).toHaveBeenCalledOnce();
+    expect(store.appendLocalUserMessage).toHaveBeenCalledWith(
+      '',
+      [{ data: 'Ym1w', mimeType: 'image/bmp' }],
+      undefined,
+    );
+    expect(latest.queuedPrompts).toMatchObject([
+      {
+        text: '',
+        images,
+        serverPromptId: 'server-image',
+        serverState: 'queued',
+      },
+    ]);
+  });
+
+  it('keeps another prompt started buffer when one admission is unknown', async () => {
+    const firstSubmit = deferred<{ promptId: string }>();
+    const secondSubmit = deferred<{ promptId: string }>();
+    const { actions } = createActions();
+    vi.mocked(actions.submitPrompt)
+      .mockReturnValueOnce(firstSubmit.promise)
+      .mockReturnValueOnce(secondSubmit.promise);
+    const { render, store } = mount('responding', actions);
+    const firstImages = [{ data: 'Zmlyc3Q=', media_type: 'image/png' }];
+    const secondImages = [{ data: 'c2Vjb25k', media_type: 'image/png' }];
+
+    act(() => latest.enqueuePrompt('', firstImages));
+    act(() => latest.enqueuePrompt('', secondImages));
+    sdk.pendingEvents = [
+      {
+        type: 'pending_prompt_started',
+        originatorClientId: 'client-1',
+        data: {
+          sessionId: 'session-1',
+          promptId: 'server-second',
+          text: '[image]',
+        },
+      },
+    ];
+    render('responding');
+
+    await act(async () => {
+      firstSubmit.reject(new TypeError('response lost'));
+      await Promise.resolve();
+      secondSubmit.resolve({ promptId: 'server-second' });
+      await Promise.resolve();
+    });
+
+    expect(store.appendLocalUserMessage).toHaveBeenCalledOnce();
+    expect(store.appendLocalUserMessage).toHaveBeenCalledWith(
+      '',
+      [{ data: 'c2Vjb25k', mimeType: 'image/png' }],
+      undefined,
+    );
+  });
+
+  it('binds an image prompt when its terminal event precedes admission response', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { render, store } = mount('responding', actions);
+    const images = [{ data: 'dGVybWluYWw=', media_type: 'image/png' }];
+
+    act(() => latest.enqueuePrompt('', images));
+    sdk.pendingEvents = [
+      {
+        type: 'pending_prompt_started',
+        originatorClientId: 'client-1',
+        data: {
+          sessionId: 'session-1',
+          promptId: 'server-terminal',
+          text: '[image]',
+        },
+      },
+      {
+        type: 'turn_complete',
+        data: {
+          sessionId: 'session-1',
+          promptId: 'server-terminal',
+        },
+      },
+    ];
+    render('responding');
+
+    await act(async () => {
+      pendingSubmit.resolve({ promptId: 'server-terminal' });
+      await Promise.resolve();
+    });
+
+    expect(store.appendLocalUserMessage).toHaveBeenCalledOnce();
+    expect(store.appendLocalUserMessage).toHaveBeenCalledWith(
+      '',
+      [{ data: 'dGVybWluYWw=', mimeType: 'image/png' }],
+      undefined,
+    );
+  });
+
+  it('does not append text twice when its terminal precedes admission response', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { render, store } = mount('idle', actions);
+
+    act(() => latest.enqueuePrompt('run once'));
+    sdk.pendingEvents = [
+      {
+        type: 'pending_prompt_started',
+        originatorClientId: 'client-1',
+        data: {
+          sessionId: 'session-1',
+          promptId: 'server-text-terminal',
+          text: 'run once',
+        },
+      },
+      {
+        type: 'turn_complete',
+        originatorClientId: 'client-1',
+        data: {
+          sessionId: 'session-1',
+          promptId: 'server-text-terminal',
+        },
+      },
+    ];
+    render('idle');
+    expect(store.appendLocalUserMessage).toHaveBeenCalledOnce();
+
+    await act(async () => {
+      pendingSubmit.resolve({ promptId: 'server-text-terminal' });
+      await Promise.resolve();
+    });
+
+    expect(store.appendLocalUserMessage).toHaveBeenCalledOnce();
+  });
+
+  it('does not append a prompt removed before its admission response', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { render, store } = mount('responding', actions);
+
+    act(() =>
+      latest.enqueuePrompt('', [
+        { data: 'cmVtb3ZlZA==', media_type: 'image/png' },
+      ]),
+    );
+    sdk.pendingEvents = [
+      {
+        type: 'pending_prompt_completed',
+        originatorClientId: 'client-1',
+        data: {
+          sessionId: 'session-1',
+          promptId: 'server-removed',
+          state: 'removed',
+        },
+      },
+      {
+        type: 'turn_complete',
+        originatorClientId: 'client-1',
+        data: {
+          sessionId: 'session-1',
+          promptId: 'server-removed',
+          stopReason: 'cancelled',
+        },
+      },
+    ];
+    render('idle');
+
+    await act(async () => {
+      pendingSubmit.resolve({ promptId: 'server-removed' });
+      await Promise.resolve();
+    });
+
+    expect(store.appendLocalUserMessage).not.toHaveBeenCalled();
+  });
+
+  it('does not create a duplicate summary while an image response is pending', async () => {
+    const { actions } = createActions();
+    const refresh = deferred<{
+      pendingPrompts: Array<{
+        promptId: string;
+        text: string;
+        state: 'queued';
+      }>;
+    }>();
+    vi.mocked(actions.getPendingPrompts).mockReturnValue(refresh.promise);
+    mount('responding', actions, true, true);
+    const images = [{ data: 'Ym1w', media_type: 'image/bmp' }];
+
+    act(() => latest.enqueuePrompt('', images));
+    await act(async () => {
+      refresh.resolve({
+        pendingPrompts: [
+          { promptId: 'server-image', text: '[image]', state: 'queued' },
+        ],
+      });
+      await Promise.resolve();
+    });
+
+    expect(latest.queuedPrompts).toHaveLength(1);
+    expect(latest.queuedPrompts[0]).toMatchObject({
+      text: '',
+      images,
+      serverState: 'submitting',
+      payloadCompleteness: 'complete',
+    });
+  });
+
+  it('refreshes deferred server summaries after an image response binds exactly', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const initialRefresh = deferred<{
+      pendingPrompts: Array<{
+        promptId: string;
+        text: string;
+        state: 'queued';
+      }>;
+    }>();
+    vi.mocked(actions.getPendingPrompts)
+      .mockReturnValueOnce(initialRefresh.promise)
+      .mockResolvedValue({
+        pendingPrompts: [
+          { promptId: 'server-image', text: '[image]', state: 'queued' },
+          { promptId: 'server-other', text: 'other', state: 'queued' },
+        ],
+      });
+    mount('responding', actions, true, true);
+    const images = [{ data: 'Ym1w', media_type: 'image/bmp' }];
+
+    act(() => latest.enqueuePrompt('', images));
+    await act(async () => {
+      initialRefresh.resolve({
+        pendingPrompts: [
+          { promptId: 'server-image', text: '[image]', state: 'queued' },
+          { promptId: 'server-other', text: 'other', state: 'queued' },
+        ],
+      });
+      await Promise.resolve();
+    });
+    expect(latest.queuedPrompts).toHaveLength(1);
+
+    await act(async () => {
+      pendingSubmit.resolve({ promptId: 'server-image' });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(actions.getPendingPrompts).toHaveBeenCalledTimes(2);
+    expect(latest.queuedPrompts).toMatchObject([
+      {
+        text: '',
+        images,
+        serverPromptId: 'server-image',
+        payloadCompleteness: 'complete',
+      },
+      {
+        text: 'other',
+        serverPromptId: 'server-other',
+        payloadCompleteness: 'summary-only',
+      },
+    ]);
+  });
+
+  it('ignores an old submit response after an S1 to S2 to S1 owner change', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { render, store } = mount('responding', actions);
+
+    act(() =>
+      latest.enqueuePrompt('', [{ data: 'b2xk', media_type: 'image/png' }]),
+    );
+    render('responding', 'session-2');
+    render('responding', 'session-1');
+    await act(async () => {
+      pendingSubmit.resolve({ promptId: 'old-server-prompt' });
+      await Promise.resolve();
+    });
+
+    expect(latest.queuedPrompts).toEqual([]);
+    expect(actions.removePendingPrompt).not.toHaveBeenCalled();
+    expect(store.appendLocalUserMessage).not.toHaveBeenCalled();
+  });
+
+  it('ignores an old refresh after an S1 to S2 to S1 owner change', async () => {
+    const { actions } = createActions();
+    const oldRefresh = deferred<{
+      pendingPrompts: Array<{
+        promptId: string;
+        text: string;
+        state: 'queued';
+      }>;
+    }>();
+    vi.mocked(actions.getPendingPrompts)
+      .mockReturnValueOnce(oldRefresh.promise)
+      .mockResolvedValue({ pendingPrompts: [] });
+    const { render } = mount('responding', actions, true, true);
+
+    render('responding', 'session-2');
+    render('responding', 'session-1');
+    await act(async () => {
+      oldRefresh.resolve({
+        pendingPrompts: [
+          { promptId: 'stale-prompt', text: 'stale', state: 'queued' },
+        ],
+      });
+      await Promise.resolve();
+    });
+
+    expect(latest.queuedPrompts).toEqual([]);
+  });
+
+  it('restores image-only payloads exactly once after definite rejection', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { editor } = mount('responding', actions);
+    const images = [{ data: 'cG5n', media_type: 'image/png' }];
+
+    act(() => latest.enqueuePrompt('', images));
+    await act(async () => {
+      pendingSubmit.reject(new DaemonHttpError(413, undefined, 'Too large'));
+      await Promise.resolve();
+    });
+
+    expect(latest.queuedPrompts).toEqual([]);
+    expect(editor.setText).not.toHaveBeenCalled();
+    expect(editor.restoreImages).toHaveBeenCalledOnce();
+    expect(editor.restoreImages).toHaveBeenCalledWith(images);
+  });
+
+  it('does not change an existing draft when restoring image-only payloads', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { editor } = mount('responding', actions);
+    vi.mocked(editor.getText).mockReturnValue('current draft');
+    const images = [{ data: 'cG5n', media_type: 'image/png' }];
+
+    act(() => latest.enqueuePrompt('', images));
+    await act(async () => {
+      pendingSubmit.reject(new DaemonHttpError(413, undefined, 'Too large'));
+      await Promise.resolve();
+    });
+
+    expect(editor.setText).not.toHaveBeenCalled();
+    expect(editor.restoreImages).toHaveBeenCalledWith(images);
+  });
+
+  it('does not duplicate attachments when restored text is already present', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { editor } = mount('responding', actions);
+    vi.mocked(editor.getText).mockReturnValue('describe');
+    const images = [{ data: 'cG5n', media_type: 'image/png' }];
+    const inputAnnotations = [
+      {
+        type: 'reference' as const,
+        start: 0,
+        end: 8,
+        text: 'describe',
+        reference: { id: 'file:describe', kind: 'file', value: 'describe' },
+      },
+    ];
+
+    act(() =>
+      latest.enqueuePrompt('describe', images, undefined, inputAnnotations),
+    );
+    await act(async () => {
+      pendingSubmit.reject(new DaemonHttpError(413, undefined, 'Too large'));
+      await Promise.resolve();
+    });
+
+    expect(latest.queuedPrompts).toEqual([]);
+    expect(editor.setText).not.toHaveBeenCalled();
+    expect(editor.restoreImages).not.toHaveBeenCalled();
+    expect(editor.restoreInputAnnotations).not.toHaveBeenCalled();
+  });
+
+  it('restores an uncertain local payload only after an explicit action', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { editor, reportError } = mount('responding', actions);
+    const images = [{ data: 'cG5n', media_type: 'image/png' }];
+
+    act(() => latest.enqueuePrompt('', images));
+    await act(async () => {
+      pendingSubmit.reject(new TypeError('network disconnected'));
+      await Promise.resolve();
+    });
+
+    expect(latest.queuedPrompts).toMatchObject([
+      {
+        text: '',
+        images,
+        admissionOutcome: 'unknown',
+        serverState: undefined,
+        payloadAvailable: true,
+      },
+    ]);
+    expect(editor.restoreImages).not.toHaveBeenCalled();
+    expect(actions.submitPrompt).toHaveBeenCalledTimes(1);
+    expect(reportError).toHaveBeenCalledWith(
+      expect.any(TypeError),
+      t('queue.admissionUnknown'),
+    );
+
+    act(() => {
+      expect(latest.restoreUnknownQueuedPrompt(1)).toBe(true);
+    });
+    expect(editor.restoreImages).toHaveBeenCalledOnce();
+    expect(editor.restoreImages).toHaveBeenCalledWith(images);
+    expect(latest.queuedPrompts).toMatchObject([
+      {
+        text: '',
+        images: undefined,
+        admissionOutcome: 'unknown',
+        payloadAvailable: false,
+      },
+    ]);
+    expect(latest.restoreUnknownQueuedPrompt(1)).toBe(false);
+    expect(editor.restoreImages).toHaveBeenCalledOnce();
+    expect(actions.submitPrompt).toHaveBeenCalledTimes(1);
+  });
+
+  it('restores queued input annotations with the local payload', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { editor } = mount('responding', actions);
+    const inputAnnotations = [
+      {
+        type: 'reference' as const,
+        start: 0,
+        end: 8,
+        text: '@file.ts',
+        reference: { id: 'file:file.ts', kind: 'file', value: 'file.ts' },
+      },
+    ];
+
+    act(() =>
+      latest.enqueuePrompt(
+        '@file.ts\n\nfix it',
+        undefined,
+        undefined,
+        inputAnnotations,
+      ),
+    );
+    await act(async () => {
+      pendingSubmit.reject(new TypeError('response lost'));
+      await Promise.resolve();
+    });
+    act(() => {
+      expect(latest.restoreUnknownQueuedPrompt(1)).toBe(true);
+    });
+
+    expect(editor.restoreInputAnnotations).toHaveBeenCalledWith(
+      inputAnnotations,
+    );
+  });
+
+  it('discards an uncertain local payload without sending it again', async () => {
+    const { actions, pendingSubmit } = createActions();
+    const { editor } = mount('responding', actions);
+    const images = [{ data: 'cG5n', media_type: 'image/png' }];
+
+    act(() => latest.enqueuePrompt('describe', images));
+    await act(async () => {
+      pendingSubmit.reject(new TypeError('network disconnected'));
+      await Promise.resolve();
+    });
+    act(() => {
+      expect(latest.discardUnknownQueuedPrompt(1)).toBe(true);
+    });
+
+    expect(editor.setText).not.toHaveBeenCalled();
+    expect(editor.restoreImages).not.toHaveBeenCalled();
+    expect(latest.queuedPrompts).toMatchObject([
+      {
+        text: '',
+        images: undefined,
+        admissionOutcome: 'unknown',
+        payloadAvailable: false,
+      },
+    ]);
+    expect(actions.submitPrompt).toHaveBeenCalledTimes(1);
+  });
+
   it('keeps an accepted message queued until its injection event', async () => {
     const { actions } = createActions();
     vi.mocked(actions.enqueueMidTurnMessage).mockResolvedValue({
@@ -490,7 +1080,7 @@ describe('useQueuedPrompts default mid-turn insertion', () => {
     expect(actions.enqueueMidTurnMessage).not.toHaveBeenCalled();
   });
 
-  it('retains mid-turn rows and clears ordinary rows on clearQueuedPrompts', async () => {
+  it('retains mid-turn rows and marks in-flight admissions unknown on clear', async () => {
     const { actions } = createActions();
     vi.mocked(actions.enqueueMidTurnMessage).mockResolvedValue({
       accepted: true,
@@ -508,11 +1098,41 @@ describe('useQueuedPrompts default mid-turn insertion', () => {
     act(() => latest.clearQueuedPrompts());
 
     expect(latest.queuedPrompts).toMatchObject([
+      {
+        text: '普通排队',
+        admissionOutcome: 'unknown',
+        payloadAvailable: true,
+      },
       { text: '中途消息', midTurnState: 'queued', midTurnMessageId: 'mid-1' },
     ]);
     expect(actions.removeMidTurnMessage).not.toHaveBeenCalled();
   });
 
+  it('clears a submitting row after the server confirms abort cleanup', async () => {
+    const { actions, pendingSubmit } = createActions();
+    mount('responding', actions);
+
+    act(() =>
+      latest.enqueuePrompt('clear me', [
+        { data: 'eA==', media_type: 'image/png' },
+      ]),
+    );
+    act(() => latest.clearQueuedPrompts());
+    expect(latest.queuedPrompts[0]).toMatchObject({
+      admissionOutcome: 'unknown',
+    });
+
+    await act(async () => {
+      pendingSubmit.resolve({
+        promptId: 'server-cleared',
+        removedAfterAbort: true,
+      });
+      await Promise.resolve();
+    });
+
+    expect(latest.queuedPrompts).toEqual([]);
+  });
+
   it('edits the last mid-turn row via editLastQueuedPrompt', async () => {
     const { actions } = createActions();
     vi.mocked(actions.enqueueMidTurnMessage).mockResolvedValue({
diff --git a/packages/web-shell/client/hooks/useQueuedPrompts.ts b/packages/web-shell/client/hooks/useQueuedPrompts.ts
index d4a2ddb722d..509d120af04 100644
--- a/packages/web-shell/client/hooks/useQueuedPrompts.ts
+++ b/packages/web-shell/client/hooks/useQueuedPrompts.ts
@@ -22,15 +22,16 @@ import {
   type DaemonSessionActions,
   type DaemonStreamingState,
 } from '@qwen-code/webui/daemon-react-sdk';
-import type {
-  DaemonInputAnnotation,
-  DaemonPendingPromptSummary,
-  DaemonTranscriptStore,
+import {
+  type DaemonInputAnnotation,
+  type DaemonPendingPromptSummary,
+  type DaemonTranscriptStore,
 } from '@qwen-code/sdk/daemon';
 import type { PromptImage } from '../adapters/promptTypes';
 import type { EditorHandle } from './useComposerCore';
 import { removeInjectedFromQueue } from '../midTurnDedup';
 import { isCommandPrompt } from '../utils/localCommandQueue';
+import { isDefinitelyRejectedPromptAdmission } from '../utils/promptAdmission';
 import type { getTranslator } from '../i18n';
 import type { QueuedPrompt } from '../components/QueuedPromptDisplay';
 
@@ -99,6 +100,9 @@ function areQueuedPromptsEqual(
       prompt.midTurnFailedAction === other.midTurnFailedAction &&
       prompt.isEditing === other.isEditing &&
       prompt.isRemoving === other.isRemoving &&
+      prompt.payloadCompleteness === other.payloadCompleteness &&
+      prompt.admissionOutcome === other.admissionOutcome &&
+      prompt.payloadAvailable === other.payloadAvailable &&
       (prompt.images?.length ?? 0) === (other.images?.length ?? 0) &&
       (prompt.inputAnnotations?.length ?? 0) ===
         (other.inputAnnotations?.length ?? 0)
@@ -124,11 +128,14 @@ export interface UseQueuedPromptsResult {
     images?: PromptImage[],
     onComplete?: () => void,
     inputAnnotations?: DaemonInputAnnotation[],
+    onAdmitted?: () => void,
   ) => boolean;
   removeQueuedPrompt: (id: number) => void;
   editQueuedPrompt: (id: number) => Promise<void>;
   editLastQueuedPrompt: () => boolean;
   clearQueuedPrompts: () => boolean;
+  restoreUnknownQueuedPrompt: (id: number) => boolean;
+  discardUnknownQueuedPrompt: (id: number) => boolean;
 }
 
 export function useQueuedPrompts({
@@ -145,6 +152,10 @@ export function useQueuedPrompts({
 }: UseQueuedPromptsArgs): UseQueuedPromptsResult {
   const [queuedPrompts, setQueuedPrompts] = useState<QueuedPrompt[]>([]);
   const queuedPromptsRef = useRef<QueuedPrompt[]>([]);
+  const ownerTokenRef = useRef({ sessionId });
+  if (ownerTokenRef.current.sessionId !== sessionId) {
+    ownerTokenRef.current = { sessionId };
+  }
   const nextQueuedPromptIdRef = useRef(1);
   const latestSessionIdRef = useRef(sessionId);
   const midTurnEnqueueAbortRef = useRef<AbortController | null>(null);
@@ -154,8 +165,25 @@ export function useQueuedPrompts({
   const completionCallbacksRef = useRef<Map<string, () => void>>(new Map());
   const completedPromptIdsRef = useRef<Set<string>>(new Set());
   const completedPromptIdOrderRef = useRef<string[]>([]);
+  const appendedBeforeResponsePromptIdsRef = useRef<Set<string>>(new Set());
+  const removedBeforeResponsePromptIdsRef = useRef<Set<string>>(new Set());
   const latestStreamingStateRef = useRef(streamingState);
   const refreshRequestSeqRef = useRef(0);
+  const restoredPromptIdsRef = useRef<Set<number>>(new Set());
+  const pendingStartedByPromptIdRef = useRef<Map<string, string>>(new Map());
+
+  const rememberCompletedPromptId = useCallback((promptId: string) => {
+    if (completedPromptIdsRef.current.has(promptId)) return;
+    completedPromptIdsRef.current.add(promptId);
+    completedPromptIdOrderRef.current.push(promptId);
+    while (
+      completedPromptIdOrderRef.current.length > MAX_COMPLETED_PROMPT_IDS
+    ) {
+      const expiredPromptId = completedPromptIdOrderRef.current.shift();
+      if (expiredPromptId)
+        completedPromptIdsRef.current.delete(expiredPromptId);
+    }
+  }, []);
 
   latestSessionIdRef.current = sessionId;
   latestStreamingStateRef.current = streamingState;
@@ -172,15 +200,19 @@ export function useQueuedPrompts({
   useEffect(() => {
     queuedPromptsRef.current = [];
     setQueuedPrompts([]);
-    completionCallbacksRef.current.clear();
-    completedPromptIdsRef.current.clear();
+    completionCallbacksRef.current = new Map();
+    completedPromptIdsRef.current = new Set();
     completedPromptIdOrderRef.current = [];
+    appendedBeforeResponsePromptIdsRef.current = new Set();
+    removedBeforeResponsePromptIdsRef.current = new Set();
     for (const controller of submitAbortControllersRef.current) {
       controller.abort();
     }
     submitAbortControllersRef.current.clear();
-    removingServerPromptIdsRef.current.clear();
-    displayedServerPromptIdsRef.current.clear();
+    removingServerPromptIdsRef.current = new Set();
+    displayedServerPromptIdsRef.current = new Set();
+    restoredPromptIdsRef.current = new Set();
+    pendingStartedByPromptIdRef.current = new Map();
     initialRefreshSessionIdRef.current = undefined;
     midTurnEnqueueAbortRef.current?.abort();
     midTurnEnqueueAbortRef.current = null;
@@ -211,7 +243,9 @@ export function useQueuedPrompts({
           }
           next[existingIndex] = {
             ...next[existingIndex]!,
-            text: serverPrompt.text,
+            ...(next[existingIndex]!.payloadCompleteness === 'summary-only'
+              ? { text: serverPrompt.text }
+              : {}),
             serverState: serverPrompt.state,
           };
           continue;
@@ -220,6 +254,8 @@ export function useQueuedPrompts({
           (p) =>
             !p.serverPromptId &&
             p.serverState === 'submitting' &&
+            p.admissionOutcome !== 'unknown' &&
+            (p.images?.length ?? 0) === 0 &&
             p.text === serverPrompt.text,
         );
         if (submittingMatches.length === 1) {
@@ -238,12 +274,21 @@ export function useQueuedPrompts({
         if (serverPrompt.state === 'running' || hasDisplayedPrompt) {
           continue;
         }
+        const hasUnboundImageSubmission = next.some(
+          (prompt) =>
+            !prompt.serverPromptId &&
+            prompt.serverState === 'submitting' &&
+            prompt.admissionOutcome !== 'unknown' &&
+            (prompt.images?.length ?? 0) > 0,
+        );
+        if (hasUnboundImageSubmission) continue;
         next.push({
           id: nextQueuedPromptIdRef.current++,
           sessionId: targetSessionId,
           text: serverPrompt.text,
           serverPromptId: serverPrompt.promptId,
           serverState: serverPrompt.state,
+          payloadCompleteness: 'summary-only',
         });
       }
       if (areQueuedPromptsEqual(queuedPromptsRef.current, next)) return;
@@ -259,13 +304,19 @@ export function useQueuedPrompts({
     ): Promise<RefreshPendingPromptsResult> => {
       if (!connected || !targetSessionId) return 'skipped';
       if (latestSessionIdRef.current !== targetSessionId) return 'skipped';
+      const ownerToken = ownerTokenRef.current;
       const requestSeq = ++refreshRequestSeqRef.current;
       try {
         const result = await sessionActions.getPendingPrompts({
           sessionId: targetSessionId,
         });
         if (requestSeq !== refreshRequestSeqRef.current) return 'superseded';
-        if (latestSessionIdRef.current !== targetSessionId) return 'skipped';
+        if (
+          ownerTokenRef.current !== ownerToken ||
+          latestSessionIdRef.current !== targetSessionId
+        ) {
+          return 'skipped';
+        }
         syncServerQueuedPrompts(
           result.pendingPrompts.filter(
             (p) => p.state === 'queued' || p.state === 'running',
@@ -300,32 +351,94 @@ export function useQueuedPrompts({
     setQueuedPrompts(next);
   }, []);
 
-  const restoreTextToEditor = useCallback(
-    (text: string, images?: PromptImage[], targetSessionId?: string) => {
+  const restoreQueuedPromptsToEditor = useCallback(
+    (
+      prompts: readonly QueuedPrompt[],
+      targetSessionId?: string,
+      allowUnknown = false,
+      expectedOwnerToken = ownerTokenRef.current,
+    ): boolean => {
       if (
-        targetSessionId !== undefined &&
-        latestSessionIdRef.current !== targetSessionId
+        ownerTokenRef.current !== expectedOwnerToken ||
+        (targetSessionId !== undefined &&
+          latestSessionIdRef.current !== targetSessionId)
       ) {
-        return;
+        return false;
+      }
+      const editor = editorRef.current;
+      if (!editor) return false;
+      const restorable = prompts.filter(
+        (prompt) =>
+          prompt.payloadCompleteness !== 'summary-only' &&
+          (allowUnknown || prompt.admissionOutcome !== 'unknown') &&
+          prompt.payloadAvailable !== false &&
+          !restoredPromptIdsRef.current.has(prompt.id),
+      );
+      if (restorable.length === 0) return false;
+      const currentText = editor.getText();
+      const restoredText = restorable
+        .map((prompt) => prompt.text)
+        .filter(Boolean)
+        .join('\n');
+      let textWasRestored = false;
+      if (restoredText) {
+        const nextText = mergeRestoredPromptText(currentText, restoredText);
+        if (nextText !== currentText) {
+          editor.setText(nextText);
+          textWasRestored = true;
+        }
       }
-      const current = editorRef.current?.getText() ?? '';
-      const next = mergeRestoredPromptText(current, text);
-      if (next !== current) {
-        editorRef.current?.setText(next);
-        // Restore images only alongside a text change: restoreImages appends
-        // to the pasted-image list, so running it on a deduplicated restore
-        // (same prompt restored twice across reconnects/retries) would double
-        // the attachments while the text correctly stays single (#7134
-        // review follow-up).
-        if (images && images.length > 0) {
-          editorRef.current?.restoreImages(images);
+      const attachmentPrompts = restorable.filter(
+        (prompt) => !prompt.text || textWasRestored,
+      );
+      const images = attachmentPrompts.flatMap((prompt) => prompt.images ?? []);
+      if (images.length > 0) editor.restoreImages(images);
+      let annotationOffset = 0;
+      const inputAnnotations: DaemonInputAnnotation[] = [];
+      for (const prompt of attachmentPrompts) {
+        if (!prompt.text) continue;
+        for (const annotation of prompt.inputAnnotations ?? []) {
+          inputAnnotations.push({
+            ...annotation,
+            start: annotation.start + annotationOffset,
+            end: annotation.end + annotationOffset,
+          });
         }
+        annotationOffset += prompt.text.length + 1;
       }
-      editorRef.current?.focus();
+      if (inputAnnotations.length > 0) {
+        editor.restoreInputAnnotations?.(inputAnnotations);
+      }
+      for (const prompt of restorable) {
+        restoredPromptIdsRef.current.add(prompt.id);
+      }
+      editor.focus();
+      return true;
     },
     [editorRef],
   );
 
+  const appendLocalQueuedPrompt = useCallback(
+    (prompt: QueuedPrompt, promptId: string) => {
+      if (
+        displayedServerPromptIdsRef.current.has(promptId) ||
+        prompt.payloadCompleteness === 'summary-only' ||
+        (!prompt.text && (prompt.images?.length ?? 0) === 0)
+      ) {
+        return;
+      }
+      displayedServerPromptIdsRef.current.add(promptId);
+      store.appendLocalUserMessage(
+        prompt.text,
+        toStoreImages(prompt.images),
+        prompt.inputAnnotations?.length
+          ? { inputAnnotations: prompt.inputAnnotations }
+          : undefined,
+      );
+    },
+    [store],
+  );
+
   const pendingPromptVersion = useSyncExternalStore(
     subscribePendingPromptVersion,
     getPendingPromptVersion,
@@ -388,18 +501,26 @@ export function useQueuedPrompts({
               (item) =>
                 !item.serverPromptId &&
                 item.serverState === 'submitting' &&
+                item.admissionOutcome !== 'unknown' &&
+                (item.images?.length ?? 0) === 0 &&
                 item.text === eventText,
             );
-          const text = prompt?.text ?? '';
-          if (text) {
-            displayedServerPromptIdsRef.current.add(promptId);
-            store.appendLocalUserMessage(
-              text,
-              toStoreImages(prompt?.images),
-              prompt?.inputAnnotations?.length
-                ? { inputAnnotations: prompt.inputAnnotations }
-                : undefined,
-            );
+          if (prompt) {
+            appendLocalQueuedPrompt(prompt, promptId);
+            if (!prompt.serverPromptId) {
+              appendedBeforeResponsePromptIdsRef.current.add(promptId);
+            }
+          }
+          if (!prompt?.serverPromptId) {
+            pendingStartedByPromptIdRef.current.set(promptId, eventText);
+            while (pendingStartedByPromptIdRef.current.size > 200) {
+              const oldest = pendingStartedByPromptIdRef.current
+                .keys()
+                .next().value;
+              if (typeof oldest !== 'string') break;
+              pendingStartedByPromptIdRef.current.delete(oldest);
+              appendedBeforeResponsePromptIdsRef.current.delete(oldest);
+            }
           }
         }
         void refreshPendingPrompts();
@@ -409,37 +530,47 @@ export function useQueuedPrompts({
         completionCallbacksRef.current.delete(promptId);
         if (callback) {
           callback();
-        } else {
-          if (!completedPromptIdsRef.current.has(promptId)) {
-            completedPromptIdsRef.current.add(promptId);
-            completedPromptIdOrderRef.current.push(promptId);
-            while (
-              completedPromptIdOrderRef.current.length >
-              MAX_COMPLETED_PROMPT_IDS
-            ) {
-              const expiredPromptId = completedPromptIdOrderRef.current.shift();
-              if (expiredPromptId) {
-                completedPromptIdsRef.current.delete(expiredPromptId);
-              }
-            }
-          }
+        } else if (
+          event.data.stopReason !== 'cancelled' ||
+          pendingStartedByPromptIdRef.current.has(promptId)
+        ) {
+          rememberCompletedPromptId(promptId);
         }
+      } else if (event.type === 'turn_error') {
+        displayedServerPromptIdsRef.current.delete(promptId);
+        const callback = completionCallbacksRef.current.get(promptId);
+        completionCallbacksRef.current.delete(promptId);
+        if (callback) callback();
+        else rememberCompletedPromptId(promptId);
       } else if (
-        event.type === 'turn_error' ||
-        (event.type === 'pending_prompt_completed' &&
-          event.data.state === 'removed')
+        event.type === 'pending_prompt_completed' &&
+        event.data.state === 'removed'
       ) {
         displayedServerPromptIdsRef.current.delete(promptId);
         const callback = completionCallbacksRef.current.get(promptId);
         completionCallbacksRef.current.delete(promptId);
-        callback?.();
-        completedPromptIdsRef.current.delete(promptId);
-        completedPromptIdOrderRef.current =
-          completedPromptIdOrderRef.current.filter((id) => id !== promptId);
+        if (callback) callback();
+        else {
+          removedBeforeResponsePromptIdsRef.current.add(promptId);
+          while (removedBeforeResponsePromptIdsRef.current.size > 200) {
+            const oldest = removedBeforeResponsePromptIdsRef.current
+              .values()
+              .next().value;
+            if (typeof oldest !== 'string') break;
+            removedBeforeResponsePromptIdsRef.current.delete(oldest);
+          }
+        }
       }
     }
     consumePendingPromptEvents(handled);
-  }, [pendingPromptEvents, sessionId, clientId, store, refreshPendingPrompts]);
+  }, [
+    appendLocalQueuedPrompt,
+    pendingPromptEvents,
+    sessionId,
+    clientId,
+    refreshPendingPrompts,
+    rememberCompletedPromptId,
+  ]);
 
   const settleCompletionCallback = useCallback(
     (promptId: string, onComplete: () => void) => {
@@ -457,6 +588,7 @@ export function useQueuedPrompts({
   const submitPendingPrompt = useCallback(
     (prompt: QueuedPrompt) => {
       const { id: localId, sessionId: targetSessionId } = prompt;
+      const ownerToken = ownerTokenRef.current;
       const submitAbort = new AbortController();
       submitAbortControllersRef.current.add(submitAbort);
 
@@ -470,29 +602,73 @@ export function useQueuedPrompts({
         })
         .then((result) => {
           submitAbortControllersRef.current.delete(submitAbort);
-          if (latestSessionIdRef.current !== targetSessionId) {
-            sessionActions
-              .removePendingPrompt(result.promptId, {
-                sessionId: targetSessionId,
-              })
-              .catch((error: unknown) => {
-                console.warn(
-                  '[useQueuedPrompts] cleanup removePendingPrompt failed after session change',
-                  { targetSessionId, promptId: result.promptId, error },
-                );
-              });
+          if (
+            ownerTokenRef.current !== ownerToken ||
+            latestSessionIdRef.current !== targetSessionId
+          ) {
             return;
           }
-          if (latestStreamingStateRef.current === 'idle') {
-            if (!displayedServerPromptIdsRef.current.has(result.promptId)) {
-              displayedServerPromptIdsRef.current.add(result.promptId);
-              store.appendLocalUserMessage(
-                prompt.text,
-                toStoreImages(prompt.images),
-                prompt.inputAnnotations?.length
-                  ? { inputAnnotations: prompt.inputAnnotations }
-                  : undefined,
+          if (result.removedAfterAbort) {
+            pendingStartedByPromptIdRef.current.delete(result.promptId);
+            appendedBeforeResponsePromptIdsRef.current.delete(result.promptId);
+            removedBeforeResponsePromptIdsRef.current.delete(result.promptId);
+            completedPromptIdsRef.current.delete(result.promptId);
+            completedPromptIdOrderRef.current =
+              completedPromptIdOrderRef.current.filter(
+                (promptId) => promptId !== result.promptId,
               );
+            const next = queuedPromptsRef.current.filter(
+              (item) => item.id !== localId,
+            );
+            queuedPromptsRef.current = next;
+            setQueuedPrompts(next);
+            return;
+          }
+          const startedBeforeResponse =
+            pendingStartedByPromptIdRef.current.delete(result.promptId);
+          const appendedBeforeResponse =
+            appendedBeforeResponsePromptIdsRef.current.delete(result.promptId);
+          const removedBeforeResponse =
+            removedBeforeResponsePromptIdsRef.current.delete(result.promptId);
+          const settledBeforeResponse = completedPromptIdsRef.current.delete(
+            result.promptId,
+          );
+          if (settledBeforeResponse) {
+            completedPromptIdOrderRef.current =
+              completedPromptIdOrderRef.current.filter(
+                (promptId) => promptId !== result.promptId,
+              );
+          }
+          if (removedBeforeResponse && !startedBeforeResponse) {
+            const next = queuedPromptsRef.current.filter(
+              (item) => item.id !== localId,
+            );
+            queuedPromptsRef.current = next;
+            setQueuedPrompts(next);
+            return;
+          }
+          let localMessageAppended = appendedBeforeResponse;
+          if (
+            !localMessageAppended &&
+            (startedBeforeResponse || settledBeforeResponse)
+          ) {
+            appendLocalQueuedPrompt(prompt, result.promptId);
+            localMessageAppended = true;
+          }
+          prompt.onAdmitted?.();
+          if (settledBeforeResponse) {
+            const next = queuedPromptsRef.current.filter(
+              (item) => item.id !== localId,
+            );
+            queuedPromptsRef.current = next;
+            setQueuedPrompts(next);
+            prompt.onComplete?.();
+            displayedServerPromptIdsRef.current.delete(result.promptId);
+            return;
+          }
+          if (latestStreamingStateRef.current === 'idle') {
+            if (!localMessageAppended) {
+              appendLocalQueuedPrompt(prompt, result.promptId);
             }
             const next = queuedPromptsRef.current.filter(
               (prompt) => prompt.id !== localId,
@@ -502,6 +678,9 @@ export function useQueuedPrompts({
             if (prompt.onComplete) {
               settleCompletionCallback(result.promptId, prompt.onComplete);
             }
+            if ((prompt.images?.length ?? 0) > 0) {
+              void refreshPendingPrompts(targetSessionId);
+            }
             return;
           }
           const current = queuedPromptsRef.current;
@@ -523,37 +702,69 @@ export function useQueuedPrompts({
             return;
           }
           const updated = [...current];
+          const localPrompt = updated[idx]!;
           updated[idx] = {
-            ...updated[idx]!,
+            ...localPrompt,
             serverPromptId: result.promptId,
             serverState: 'queued',
+            admissionOutcome: undefined,
+            payloadAvailable: undefined,
+            ...(localPrompt.payloadAvailable === false
+              ? { payloadCompleteness: 'summary-only' }
+              : {}),
           };
           queuedPromptsRef.current = updated;
           setQueuedPrompts(updated);
           if (prompt.onComplete) {
             settleCompletionCallback(result.promptId, prompt.onComplete);
           }
+          if ((prompt.images?.length ?? 0) > 0) {
+            void refreshPendingPrompts(targetSessionId);
+          }
         })
         .catch((error: unknown) => {
           submitAbortControllersRef.current.delete(submitAbort);
-          if (latestSessionIdRef.current !== targetSessionId) return;
+          if (
+            ownerTokenRef.current !== ownerToken ||
+            latestSessionIdRef.current !== targetSessionId
+          ) {
+            return;
+          }
           if (!queuedPromptsRef.current.some((p) => p.id === localId)) return;
+          const definitelyRejected = isDefinitelyRejectedPromptAdmission(error);
+          if (!definitelyRejected) {
+            const uncertain = queuedPromptsRef.current.map((item) =>
+              item.id === localId
+                ? {
+                    ...item,
+                    serverState: undefined,
+                    admissionOutcome: 'unknown' as const,
+                    payloadAvailable: true,
+                  }
+                : item,
+            );
+            queuedPromptsRef.current = uncertain;
+            setQueuedPrompts(uncertain);
+            void refreshPendingPrompts(targetSessionId);
+            reportError(error, t('queue.admissionUnknown'));
+            return;
+          }
           const next = queuedPromptsRef.current.filter(
             (prompt) => prompt.id !== localId,
           );
           queuedPromptsRef.current = next;
           setQueuedPrompts(next);
-          restoreTextToEditor(prompt.text, prompt.images, targetSessionId);
+          restoreQueuedPromptsToEditor([prompt], targetSessionId);
           reportError(error, t('queue.queueFailed'));
         });
     },
     [
+      appendLocalQueuedPrompt,
       refreshPendingPrompts,
       reportError,
-      restoreTextToEditor,
+      restoreQueuedPromptsToEditor,
       sessionActions,
       settleCompletionCallback,
-      store,
       t,
     ],
   );
@@ -589,10 +800,12 @@ export function useQueuedPrompts({
       images?: PromptImage[],
       onComplete?: () => void,
       inputAnnotations?: DaemonInputAnnotation[],
+      onAdmitted?: () => void,
     ) => {
       const trimmed = text.trim();
-      if (!trimmed) return true;
+      if (!trimmed && (images?.length ?? 0) === 0) return true;
       const targetSessionId = latestSessionIdRef.current;
+      const ownerToken = ownerTokenRef.current;
       const shouldInsertMidTurn =
         latestStreamingStateRef.current !== 'idle' &&
         (images?.length ?? 0) === 0 &&
@@ -605,6 +818,8 @@ export function useQueuedPrompts({
         images: images ? [...images] : undefined,
         inputAnnotations: inputAnnotations ? [...inputAnnotations] : undefined,
         onComplete,
+        onAdmitted,
+        payloadCompleteness: 'complete',
         ...(shouldInsertMidTurn
           ? { midTurnState: 'submitting' }
           : { serverState: 'submitting' }),
@@ -625,6 +840,7 @@ export function useQueuedPrompts({
       void sessionActions
         .enqueueMidTurnMessage(trimmed, { signal: abort.signal })
         .then((result) => {
+          if (ownerTokenRef.current !== ownerToken) return;
           const current = queuedPromptsRef.current;
           const index = current.findIndex((item) => item.id === prompt.id);
           if (index === -1) return;
@@ -634,6 +850,7 @@ export function useQueuedPrompts({
             fallbackToPendingPrompt(prompt.id);
             return;
           }
+          prompt.onAdmitted?.();
           const next = [...current];
           next[index] = {
             ...current[index]!,
@@ -693,7 +910,7 @@ export function useQueuedPrompts({
         queuedPromptsRef.current = next;
         setQueuedPrompts(next);
         if (prompt.midTurnFailedAction === 'edit') {
-          restoreTextToEditor(prompt.text, prompt.images, prompt.sessionId);
+          restoreQueuedPromptsToEditor([prompt], prompt.sessionId);
         }
       } else if (
         prompt.midTurnState &&
@@ -703,22 +920,26 @@ export function useQueuedPrompts({
         fallbackToPendingPrompt(prompt.id);
       }
     }
-  }, [streamingState, fallbackToPendingPrompt, restoreTextToEditor]);
+  }, [streamingState, fallbackToPendingPrompt, restoreQueuedPromptsToEditor]);
 
-  const popQueuedPromptForEdit = useCallback((id?: number): string | null => {
-    const current = queuedPromptsRef.current;
-    if (current.length === 0) return null;
-    const index =
-      id === undefined
-        ? current.length - 1
-        : current.findIndex((prompt) => prompt.id === id);
-    if (index < 0) return null;
-    const prompt = current[index];
-    const next = current.filter((_, i) => i !== index);
-    queuedPromptsRef.current = next;
-    setQueuedPrompts(next);
-    return prompt?.text ?? null;
-  }, []);
+  const popQueuedPromptForEdit = useCallback(
+    (id?: number): QueuedPrompt | null => {
+      const current = queuedPromptsRef.current;
+      if (current.length === 0) return null;
+      const index =
+        id === undefined
+          ? current.length - 1
+          : current.findIndex((prompt) => prompt.id === id);
+      if (index < 0) return null;
+      const prompt = current[index];
+      if (!prompt) return null;
+      const next = current.filter((_, i) => i !== index);
+      queuedPromptsRef.current = next;
+      setQueuedPrompts(next);
+      return prompt;
+    },
+    [],
+  );
 
   const setQueuedPromptFlags = useCallback(
     (
@@ -743,13 +964,15 @@ export function useQueuedPrompts({
       flags: Partial<Pick<QueuedPrompt, 'isEditing' | 'isRemoving'>>,
       fallback: string,
     ): Promise<boolean> => {
+      const ownerToken = ownerTokenRef.current;
+      const removingPromptIds = removingServerPromptIdsRef.current;
       if (!target.serverPromptId) return true;
       if (target.serverState !== 'queued') return false;
-      if (removingServerPromptIdsRef.current.has(target.serverPromptId)) {
+      if (removingPromptIds.has(target.serverPromptId)) {
         return false;
       }
       const targetSessionId = target.sessionId;
-      removingServerPromptIdsRef.current.add(target.serverPromptId);
+      removingPromptIds.add(target.serverPromptId);
       setQueuedPromptFlags(target.id, flags);
       try {
         const result = await sessionActions.removePendingPrompt(
@@ -758,13 +981,15 @@ export function useQueuedPrompts({
             sessionId: targetSessionId,
           },
         );
-        removingServerPromptIdsRef.current.delete(target.serverPromptId);
+        if (ownerTokenRef.current !== ownerToken) return false;
+        removingPromptIds.delete(target.serverPromptId);
         if (!result.removed) {
           setQueuedPromptFlags(target.id, {
             isEditing: false,
             isRemoving: false,
           });
           await refreshPendingPrompts(targetSessionId);
+          if (ownerTokenRef.current !== ownerToken) return false;
           reportError(
             new Error('Prompt could not be removed from queue'),
             fallback,
@@ -772,7 +997,9 @@ export function useQueuedPrompts({
           return false;
         }
         completionCallbacksRef.current.delete(target.serverPromptId);
-        if ((await refreshPendingPrompts(targetSessionId)) === 'failed') {
+        const refreshResult = await refreshPendingPrompts(targetSessionId);
+        if (ownerTokenRef.current !== ownerToken) return false;
+        if (refreshResult === 'failed') {
           setQueuedPromptFlags(target.id, {
             isEditing: false,
             isRemoving: false,
@@ -784,12 +1011,15 @@ export function useQueuedPrompts({
         }
         return true;
       } catch (error) {
-        removingServerPromptIdsRef.current.delete(target.serverPromptId);
+        if (ownerTokenRef.current !== ownerToken) return false;
+        removingPromptIds.delete(target.serverPromptId);
         setQueuedPromptFlags(target.id, {
           isEditing: false,
           isRemoving: false,
         });
-        if ((await refreshPendingPrompts(targetSessionId)) !== 'refreshed') {
+        const refreshResult = await refreshPendingPrompts(targetSessionId);
+        if (ownerTokenRef.current !== ownerToken) return false;
+        if (refreshResult !== 'refreshed') {
           restoreQueuedPrompts([target]);
         }
         reportError(error, fallback);
@@ -811,6 +1041,7 @@ export function useQueuedPrompts({
       flags: Partial<Pick<QueuedPrompt, 'isEditing' | 'isRemoving'>>,
       fallback: string,
     ): Promise<boolean> => {
+      const ownerToken = ownerTokenRef.current;
       if (
         target.midTurnState !== 'queued' ||
         !target.midTurnMessageId ||
@@ -830,6 +1061,7 @@ export function useQueuedPrompts({
           target.midTurnMessageId,
           { sessionId: target.sessionId },
         );
+        if (ownerTokenRef.current !== ownerToken) return false;
         const current = queuedPromptsRef.current;
         const latest = current.find((prompt) => prompt.id === target.id);
         if (!latest) return result.removed;
@@ -863,6 +1095,7 @@ export function useQueuedPrompts({
         setQueuedPrompts(next);
         return true;
       } catch (error) {
+        if (ownerTokenRef.current !== ownerToken) return false;
         const latest = queuedPromptsRef.current.find(
           (prompt) => prompt.id === target.id,
         );
@@ -893,6 +1126,7 @@ export function useQueuedPrompts({
   const removeQueuedPrompt = useCallback(
     (id: number) => {
       const target = queuedPromptsRef.current.find((p) => p.id === id);
+      if (target?.admissionOutcome === 'unknown') return;
       if (
         target?.serverState === 'submitting' ||
         target?.midTurnState === 'submitting'
@@ -924,10 +1158,67 @@ export function useQueuedPrompts({
     [removeMidTurnPromptForAction, removeServerPromptForAction, t],
   );
 
+  const resolveUnknownQueuedPrompt = useCallback(
+    (id: number, restore: boolean): boolean => {
+      const ownerToken = ownerTokenRef.current;
+      const target = queuedPromptsRef.current.find(
+        (prompt) => prompt.id === id,
+      );
+      if (
+        !target ||
+        target.admissionOutcome !== 'unknown' ||
+        target.payloadCompleteness === 'summary-only' ||
+        target.payloadAvailable === false ||
+        target.sessionId !== latestSessionIdRef.current
+      ) {
+        return false;
+      }
+      if (
+        restore &&
+        !restoreQueuedPromptsToEditor([target], target.sessionId, true)
+      ) {
+        return false;
+      }
+      if (ownerTokenRef.current !== ownerToken) return false;
+      const next = queuedPromptsRef.current.map((prompt) =>
+        prompt.id === id
+          ? {
+              ...prompt,
+              text: '',
+              images: undefined,
+              inputAnnotations: undefined,
+              onComplete: undefined,
+              payloadAvailable: false,
+            }
+          : prompt,
+      );
+      queuedPromptsRef.current = next;
+      setQueuedPrompts(next);
+      return true;
+    },
+    [restoreQueuedPromptsToEditor],
+  );
+
+  const restoreUnknownQueuedPrompt = useCallback(
+    (id: number) => resolveUnknownQueuedPrompt(id, true),
+    [resolveUnknownQueuedPrompt],
+  );
+  const discardUnknownQueuedPrompt = useCallback(
+    (id: number) => resolveUnknownQueuedPrompt(id, false),
+    [resolveUnknownQueuedPrompt],
+  );
+
   const editQueuedPrompt = useCallback(
     async (id: number) => {
+      const editOwnerToken = ownerTokenRef.current;
       const target = queuedPromptsRef.current.find((p) => p.id === id);
       if (!target || target.serverState === 'submitting') return;
+      if (
+        target.payloadCompleteness === 'summary-only' ||
+        target.admissionOutcome === 'unknown'
+      ) {
+        return;
+      }
       if (target.isEditing || target.isRemoving) return;
       if (target.midTurnState) {
         const removed = await removeMidTurnPromptForAction(
@@ -936,7 +1227,12 @@ export function useQueuedPrompts({
           t('queue.editFailed'),
         );
         if (removed) {
-          restoreTextToEditor(target.text, target.images, target.sessionId);
+          restoreQueuedPromptsToEditor(
+            [target],
+            target.sessionId,
+            false,
+            editOwnerToken,
+          );
         }
         return;
       }
@@ -947,18 +1243,23 @@ export function useQueuedPrompts({
           t('queue.editFailed'),
         );
         if (!removed) return;
-        restoreTextToEditor(target.text, target.images, target.sessionId);
+        restoreQueuedPromptsToEditor(
+          [target],
+          target.sessionId,
+          false,
+          editOwnerToken,
+        );
         return;
       }
-      const queuedText = popQueuedPromptForEdit(id);
-      if (!queuedText) return;
-      restoreTextToEditor(queuedText, target.images, target.sessionId);
+      const popped = popQueuedPromptForEdit(id);
+      if (!popped) return;
+      restoreQueuedPromptsToEditor([target], target.sessionId);
     },
     [
       popQueuedPromptForEdit,
       removeMidTurnPromptForAction,
       removeServerPromptForAction,
-      restoreTextToEditor,
+      restoreQueuedPromptsToEditor,
       t,
     ],
   );
@@ -973,7 +1274,9 @@ export function useQueuedPrompts({
       target.midTurnState === 'submitting' ||
       (target.midTurnState === 'queued' && !target.midTurnMessageId) ||
       target.isEditing ||
-      target.isRemoving
+      target.isRemoving ||
+      target.payloadCompleteness === 'summary-only' ||
+      target.admissionOutcome === 'unknown'
     ) {
       return true;
     }
@@ -982,12 +1285,13 @@ export function useQueuedPrompts({
       return true;
     }
     if (!target.serverPromptId) {
-      const queuedText = popQueuedPromptForEdit(target.id);
-      if (!queuedText) return false;
-      restoreTextToEditor(queuedText, target.images, target.sessionId);
+      const popped = popQueuedPromptForEdit(target.id);
+      if (!popped) return false;
+      restoreQueuedPromptsToEditor([target], target.sessionId);
       return true;
     }
     if (target.serverState !== 'queued') return false;
+    const editOwnerToken = ownerTokenRef.current;
     void (async () => {
       const removed = await removeServerPromptForAction(
         target,
@@ -995,7 +1299,12 @@ export function useQueuedPrompts({
         t('queue.editFailed'),
       );
       if (removed) {
-        restoreTextToEditor(target.text, target.images, target.sessionId);
+        restoreQueuedPromptsToEditor(
+          [target],
+          target.sessionId,
+          false,
+          editOwnerToken,
+        );
       }
     })().catch((error: unknown) => {
       reportError(error, t('queue.editFailed'));
@@ -1006,32 +1315,47 @@ export function useQueuedPrompts({
     editQueuedPrompt,
     removeServerPromptForAction,
     reportError,
-    restoreTextToEditor,
+    restoreQueuedPromptsToEditor,
     t,
   ]);
 
   const clearQueuedPrompts = useCallback((): boolean => {
     if (queuedPromptsRef.current.length === 0) return false;
+    const clearOwnerToken = ownerTokenRef.current;
     const clearSessionId = latestSessionIdRef.current;
+    const removingPromptIds = removingServerPromptIdsRef.current;
     const midTurnPrompts = queuedPromptsRef.current.filter(
       (prompt) => prompt.midTurnState !== undefined,
     );
     const submittingPrompts = queuedPromptsRef.current.filter(
       (prompt) =>
         prompt.midTurnState === undefined &&
-        prompt.serverState === 'submitting',
+        prompt.serverState === 'submitting' &&
+        prompt.admissionOutcome !== 'unknown',
     );
     const clearablePrompts = queuedPromptsRef.current.filter(
       (prompt) =>
         prompt.midTurnState === undefined &&
-        prompt.serverState !== 'submitting',
+        prompt.serverState !== 'submitting' &&
+        prompt.admissionOutcome !== 'unknown',
     );
-    for (const prompt of [...submittingPrompts].reverse()) {
-      restoreTextToEditor(prompt.text, prompt.images, prompt.sessionId);
+    if (submittingPrompts.length > 0) {
+      const submittingIds = new Set(
+        submittingPrompts.map((prompt) => prompt.id),
+      );
+      const uncertain = queuedPromptsRef.current.map((prompt) =>
+        submittingIds.has(prompt.id)
+          ? {
+              ...prompt,
+              serverState: undefined,
+              admissionOutcome: 'unknown' as const,
+              payloadAvailable: true,
+            }
+          : prompt,
+      );
+      queuedPromptsRef.current = uncertain;
+      setQueuedPrompts(uncertain);
     }
-    // Restore submitting prompts before aborting their admission requests, then
-    // clear the local ref synchronously so abort catch handlers do not restore
-    // the same text again.
     for (const controller of submitAbortControllersRef.current) {
       controller.abort();
     }
@@ -1039,30 +1363,27 @@ export function useQueuedPrompts({
       (prompt) => prompt.serverPromptId,
     );
     if (serverPrompts.length === 0) {
-      queuedPromptsRef.current = midTurnPrompts;
-      setQueuedPrompts(midTurnPrompts);
-      const cleared =
-        submittingPrompts.length > 0 || clearablePrompts.length > 0;
-      if (cleared) {
+      const retainedIds = new Set(midTurnPrompts.map((prompt) => prompt.id));
+      const retained = queuedPromptsRef.current.filter(
+        (prompt) =>
+          retainedIds.has(prompt.id) || prompt.admissionOutcome === 'unknown',
+      );
+      queuedPromptsRef.current = retained;
+      setQueuedPrompts(retained);
+      if (clearablePrompts.length > 0) {
         store.dispatch([{ type: 'status', text: t('queue.cleared') }]);
       }
-      // A queue holding only mid-turn rows clears nothing: report "not handled"
-      // rather than a no-op `true`.
-      return cleared;
+      return submittingPrompts.length > 0 || clearablePrompts.length > 0;
     }
 
-    const clearIds = new Set(
-      queuedPromptsRef.current
-        .filter((prompt) => prompt.midTurnState === undefined)
-        .map((prompt) => prompt.id),
-    );
+    const clearIds = new Set(clearablePrompts.map((prompt) => prompt.id));
     const serverPromptIds = new Set(
       serverPrompts
         .map((prompt) => prompt.serverPromptId)
         .filter((id): id is string => Boolean(id)),
     );
     for (const promptId of serverPromptIds) {
-      removingServerPromptIdsRef.current.add(promptId);
+      removingPromptIds.add(promptId);
     }
 
     const removingQueue = queuedPromptsRef.current
@@ -1088,12 +1409,17 @@ export function useQueuedPrompts({
           } catch {
             failedPrompts.push(prompt);
           } finally {
-            removingServerPromptIdsRef.current.delete(promptId);
+            removingPromptIds.delete(promptId);
           }
         }),
       );
 
-      if (latestSessionIdRef.current !== clearSessionId) return;
+      if (
+        ownerTokenRef.current !== clearOwnerToken ||
+        latestSessionIdRef.current !== clearSessionId
+      ) {
+        return;
+      }
       const restoredPrompts = failedPrompts.map((prompt) => ({
         ...prompt,
         isRemoving: false,
@@ -1120,14 +1446,7 @@ export function useQueuedPrompts({
       store.dispatch([{ type: 'status', text: t('queue.cleared') }]);
     })();
     return true;
-  }, [
-    refreshPendingPrompts,
-    reportError,
-    restoreTextToEditor,
-    store,
-    t,
-    sessionActions,
-  ]);
+  }, [refreshPendingPrompts, reportError, store, t, sessionActions]);
 
   return {
     queuedPrompts,
@@ -1137,5 +1456,7 @@ export function useQueuedPrompts({
     editQueuedPrompt,
     editLastQueuedPrompt,
     clearQueuedPrompts,
+    restoreUnknownQueuedPrompt,
+    discardUnknownQueuedPrompt,
   };
 }
diff --git a/packages/web-shell/client/i18n.tsx b/packages/web-shell/client/i18n.tsx
index 93991cb8869..7c7f1afb346 100644
--- a/packages/web-shell/client/i18n.tsx
+++ b/packages/web-shell/client/i18n.tsx
@@ -980,6 +980,12 @@ const EN: Messages = {
   'history.retry': 'Retry',
   'editor.shellPlaceholder': 'Enter terminal command',
   'editor.send': 'Send message',
+  'editor.imagesSkipped': (v) =>
+    `${v?.count ?? 0} unsupported image file(s) were skipped.`,
+  'editor.imagesReadFailed': (v) =>
+    `${v?.count ?? 0} image file(s) could not be read.`,
+  'editor.imagesTooLarge': (v) =>
+    `${v?.count ?? 0} image file(s) exceeded the attachment size limit.`,
   'editor.connectionDisconnected':
     'Connection interrupted. Please try again after it reconnects.',
   'editor.sessionLoading': 'Session is still loading. Try again in a moment.',
@@ -1351,6 +1357,18 @@ const EN: Messages = {
   'queue.editing': 'Editing...',
   'queue.removing': 'Updating...',
   'queue.submittingDisabled': 'Submitting queued message...',
+  'queue.summaryEditDisabled':
+    'This restored queue summary cannot recover its original attachments.',
+  'queue.admissionUnknown':
+    'Delivery is uncertain. Check the session before trying again.',
+  'queue.mayCorrespond':
+    'The uncertain local copy and server queue entry may be the same prompt.',
+  'queue.restoreUnknown': 'Restore local copy',
+  'queue.discardUnknown': 'Discard local copy',
+  'queue.continueEditing': 'Continue editing',
+  'queue.continueEditingConfirm':
+    'The prompt may already be running. Continue editing only if you accept the risk of sending it twice.',
+  'queue.localCopyDiscarded': 'Local copy discarded',
   'queue.commandBlocked':
     "Slash commands can't be queued while a turn is running.",
   'queue.shellQueued':
@@ -3752,6 +3770,10 @@ const ZH: Messages = {
   'history.retry': '重试',
   'editor.shellPlaceholder': '请输入终端命令',
   'editor.send': '发送消息',
+  'editor.imagesSkipped': (v) => `已跳过 ${v?.count ?? 0} 个不支持的图片文件。`,
+  'editor.imagesReadFailed': (v) => `${v?.count ?? 0} 个图片文件读取失败。`,
+  'editor.imagesTooLarge': (v) =>
+    `${v?.count ?? 0} 个图片文件超过附件大小限制。`,
   'editor.connectionDisconnected': '连接已中断，请在恢复后重试。',
   'editor.sessionLoading': '会话正在加载，请稍后再发送。',
   'editor.processing': '处理中。新消息会进入队列。',
@@ -4106,6 +4128,16 @@ const ZH: Messages = {
   'queue.editing': '编辑中...',
   'queue.removing': '处理中...',
   'queue.submittingDisabled': '排队消息正在提交中...',
+  'queue.summaryEditDisabled': '恢复的队列摘要无法还原原始附件。',
+  'queue.admissionUnknown': '消息是否送达尚不确定，请先检查会话再重试。',
+  'queue.mayCorrespond':
+    '送达不确定的本地副本与服务器队列项可能对应同一条消息。',
+  'queue.restoreUnknown': '恢复本地副本',
+  'queue.discardUnknown': '丢弃本地副本',
+  'queue.continueEditing': '继续编辑',
+  'queue.continueEditingConfirm':
+    '这条消息可能已经在执行。只有在接受重复发送风险时才继续编辑。',
+  'queue.localCopyDiscarded': '本地副本已丢弃',
   'queue.commandBlocked': '当前回合运行时，Slash 命令不能进入排队。',
   'queue.shellQueued': 'Shell 命令已排队，将在当前回合结束后执行。',
   'queue.shellDropped': (v) =>
diff --git a/packages/web-shell/client/utils/imageIngestion.test.ts b/packages/web-shell/client/utils/imageIngestion.test.ts
new file mode 100644
index 00000000000..36a7cd846a5
--- /dev/null
+++ b/packages/web-shell/client/utils/imageIngestion.test.ts
@@ -0,0 +1,155 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it, vi } from 'vitest';
+import {
+  extractImageTransfer,
+  normalizeImageMediaType,
+  readImageTransfer,
+} from './imageIngestion';
+
+function transfer({
+  files = [],
+  items = [],
+  types = [],
+}: {
+  files?: File[];
+  items?: Array<{
+    kind: string;
+    type: string;
+    getAsFile: () => File | null;
+  }>;
+  types?: string[];
+}): DataTransfer {
+  return { files, items, types } as unknown as DataTransfer;
+}
+
+describe('image ingestion', () => {
+  it.each([
+    ['image/png', 'photo.bin', 'image/png'],
+    ['IMAGE/JPEG', 'photo.bin', 'image/jpeg'],
+    ['image/x-bmp', 'photo.bin', 'image/bmp'],
+    ['image/x-ms-bmp', 'photo.bin', 'image/bmp'],
+    ['', 'photo.BMP', 'image/bmp'],
+    ['application/octet-stream', 'photo.webp', 'image/webp'],
+    ['text/plain', 'photo.png', undefined],
+    ['', 'photo.svg', undefined],
+  ])('normalizes %s and %s', (type, name, expected) => {
+    expect(normalizeImageMediaType(type, name)).toBe(expected);
+  });
+
+  it('uses files as the authoritative source without duplicating item files', () => {
+    const file = new File(['png'], 'photo.png', { type: 'image/png' });
+    const getAsFile = vi.fn(() => file);
+    const result = extractImageTransfer(
+      transfer({
+        files: [file],
+        items: [{ kind: 'file', type: 'image/png', getAsFile }],
+        types: ['Files'],
+      }),
+      'drop',
+    );
+
+    expect(result.claimed).toBe(true);
+    expect(result.candidates).toHaveLength(1);
+    expect(getAsFile).not.toHaveBeenCalled();
+  });
+
+  it('claims unsupported file drops but leaves unsupported file pastes native', () => {
+    const file = new File(['text'], 'notes.txt', { type: 'text/plain' });
+    const dataTransfer = transfer({ files: [file], types: ['Files'] });
+
+    expect(extractImageTransfer(dataTransfer, 'drop')).toMatchObject({
+      claimed: true,
+      candidates: [],
+      rejected: [{ name: 'notes.txt', reason: 'unsupported' }],
+    });
+    expect(extractImageTransfer(dataTransfer, 'paste').claimed).toBe(false);
+  });
+
+  it('claims a supported clipboard item that cannot expose its file', () => {
+    const result = extractImageTransfer(
+      transfer({
+        items: [{ kind: 'file', type: 'image/png', getAsFile: () => null }],
+        types: ['Files'],
+      }),
+      'paste',
+    );
+
+    expect(result).toMatchObject({
+      claimed: true,
+      candidates: [],
+      rejected: [{ reason: 'unavailable' }],
+    });
+  });
+
+  it('reads supported files in selection order and reports lifecycle settlement', async () => {
+    const first = new File(['first'], 'first.png', { type: 'image/png' });
+    const second = new File(['second'], 'second.bmp', { type: 'image/x-bmp' });
+    const extracted = extractImageTransfer(
+      transfer({ files: [first, second], types: ['Files'] }),
+      'drop',
+    );
+    const created: FileReader[] = [];
+    const settled: FileReader[] = [];
+
+    const result = await readImageTransfer(extracted, {
+      onReaderCreated: (reader) => created.push(reader),
+      onReaderSettled: (reader) => settled.push(reader),
+    });
+
+    expect(result.rejected).toEqual([]);
+    expect(result.accepted.map((image) => image.media_type)).toEqual([
+      'image/png',
+      'image/bmp',
+    ]);
+    expect(result.accepted.map((image) => atob(image.data))).toEqual([
+      'first',
+      'second',
+    ]);
+    expect(created).toHaveLength(2);
+    expect(new Set(settled)).toEqual(new Set(created));
+  });
+
+  it('limits concurrent file readers', async () => {
+    const files = Array.from(
+      { length: 10 },
+      (_, index) =>
+        new File([`image-${index}`], `${index}.png`, { type: 'image/png' }),
+    );
+    const extracted = extractImageTransfer(
+      transfer({ files, types: ['Files'] }),
+      'drop',
+    );
+    let activeReaders = 0;
+    let maxActiveReaders = 0;
+
+    const result = await readImageTransfer(extracted, {
+      onReaderCreated: () => {
+        activeReaders += 1;
+        maxActiveReaders = Math.max(maxActiveReaders, activeReaders);
+      },
+      onReaderSettled: () => {
+        activeReaders -= 1;
+      },
+    });
+
+    expect(result.accepted).toHaveLength(10);
+    expect(maxActiveReaders).toBe(4);
+  });
+
+  it('rejects files that exceed the remaining encoded-data budget', async () => {
+    const files = [
+      new File(['one'], 'one.png', { type: 'image/png' }),
+      new File(['two'], 'two.png', { type: 'image/png' }),
+    ];
+    const extracted = extractImageTransfer(
+      transfer({ files, types: ['Files'] }),
+      'drop',
+    );
+
+    const result = await readImageTransfer(extracted, { maxEncodedBytes: 4 });
+
+    expect(result.accepted).toHaveLength(1);
+    expect(result.rejected).toEqual([{ name: 'two.png', reason: 'too-large' }]);
+  });
+});
diff --git a/packages/web-shell/client/utils/imageIngestion.ts b/packages/web-shell/client/utils/imageIngestion.ts
new file mode 100644
index 00000000000..79a8b03f996
--- /dev/null
+++ b/packages/web-shell/client/utils/imageIngestion.ts
@@ -0,0 +1,229 @@
+import type { PromptImage } from '../adapters/promptTypes';
+
+export type ImageIngestionRejectionReason =
+  | 'unsupported'
+  | 'unavailable'
+  | 'too-large'
+  | 'read-failed';
+
+export interface ImageIngestionRejection {
+  name?: string;
+  reason: ImageIngestionRejectionReason;
+}
+
+interface ImageFileCandidate {
+  file: File;
+  mediaType: string;
+}
+
+export interface ExtractedImageTransfer {
+  claimed: boolean;
+  candidates: ImageFileCandidate[];
+  rejected: ImageIngestionRejection[];
+}
+
+export interface ImageIngestionBatchResult {
+  accepted: PromptImage[];
+  rejected: ImageIngestionRejection[];
+}
+
+interface ReaderLifecycle {
+  onReaderCreated?: (reader: FileReader) => void;
+  onReaderSettled?: (reader: FileReader) => void;
+  maxEncodedBytes?: number;
+}
+
+export const MAX_IMAGE_ATTACHMENT_DATA_BYTES = 8 * 1024 * 1024;
+const MAX_CONCURRENT_IMAGE_READERS = 4;
+
+const IMAGE_MIME_BY_EXTENSION: Readonly<Record<string, string>> = {
+  bmp: 'image/bmp',
+  gif: 'image/gif',
+  jpeg: 'image/jpeg',
+  jpg: 'image/jpeg',
+  png: 'image/png',
+  webp: 'image/webp',
+};
+
+const SUPPORTED_IMAGE_MIME_TYPES = new Set(
+  Object.values(IMAGE_MIME_BY_EXTENSION),
+);
+
+export function normalizeImageMediaType(
+  mediaType: string,
+  fileName = '',
+): string | undefined {
+  const normalized = mediaType.trim().toLowerCase();
+  if (normalized === 'image/x-bmp' || normalized === 'image/x-ms-bmp') {
+    return 'image/bmp';
+  }
+  if (SUPPORTED_IMAGE_MIME_TYPES.has(normalized)) return normalized;
+  if (normalized && normalized !== 'application/octet-stream') {
+    return undefined;
+  }
+  const extension = fileName.split('.').pop()?.toLowerCase();
+  return extension ? IMAGE_MIME_BY_EXTENSION[extension] : undefined;
+}
+
+export function hasFileTransferPayload(dataTransfer: DataTransfer): boolean {
+  if (dataTransfer.files.length > 0) return true;
+  if (Array.from(dataTransfer.types).some((type) => type === 'Files')) {
+    return true;
+  }
+  return Array.from(dataTransfer.items).some((item) => item.kind === 'file');
+}
+
+export function extractImageTransfer(
+  dataTransfer: DataTransfer,
+  source: 'paste' | 'drop',
+): ExtractedImageTransfer {
+  const candidates: ImageFileCandidate[] = [];
+  const rejected: ImageIngestionRejection[] = [];
+  let hasSupportedUnavailableItem = false;
+
+  if (dataTransfer.files.length > 0) {
+    for (const file of Array.from(dataTransfer.files)) {
+      const mediaType = normalizeImageMediaType(file.type, file.name);
+      if (mediaType) {
+        candidates.push({ file, mediaType });
+      } else {
+        rejected.push({ name: file.name, reason: 'unsupported' });
+      }
+    }
+  } else {
+    for (const item of Array.from(dataTransfer.items)) {
+      if (item.kind !== 'file') continue;
+      const file = item.getAsFile();
+      if (!file) {
+        if (normalizeImageMediaType(item.type)) {
+          hasSupportedUnavailableItem = true;
+          rejected.push({ reason: 'unavailable' });
+        } else if (source === 'drop') {
+          rejected.push({ reason: 'unavailable' });
+        }
+        continue;
+      }
+      const mediaType = normalizeImageMediaType(
+        file.type || item.type,
+        file.name,
+      );
+      if (mediaType) {
+        candidates.push({ file, mediaType });
+      } else {
+        rejected.push({ name: file.name, reason: 'unsupported' });
+      }
+    }
+  }
+
+  return {
+    claimed:
+      source === 'drop'
+        ? hasFileTransferPayload(dataTransfer)
+        : candidates.length > 0 || hasSupportedUnavailableItem,
+    candidates,
+    rejected,
+  };
+}
+
+function readImage(
+  candidate: ImageFileCandidate,
+  lifecycle: ReaderLifecycle,
+): Promise<PromptImage> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    let settled = false;
+    lifecycle.onReaderCreated?.(reader);
+
+    const settle = (result?: PromptImage) => {
+      if (settled) return;
+      settled = true;
+      lifecycle.onReaderSettled?.(reader);
+      reader.onload = null;
+      reader.onerror = null;
+      reader.onabort = null;
+      if (result) {
+        resolve(result);
+      } else {
+        reject(new Error('Failed to read image file'));
+      }
+    };
+
+    reader.onload = () => {
+      const dataUrl = typeof reader.result === 'string' ? reader.result : '';
+      const commaIndex = dataUrl.indexOf(',');
+      const data = commaIndex >= 0 ? dataUrl.slice(commaIndex + 1) : '';
+      settle(
+        data
+          ? {
+              data,
+              media_type: candidate.mediaType,
+            }
+          : undefined,
+      );
+    };
+    reader.onerror = () => settle();
+    reader.onabort = () => settle();
+
+    try {
+      reader.readAsDataURL(candidate.file);
+    } catch {
+      settle();
+    }
+  });
+}
+
+export async function readImageTransfer(
+  transfer: ExtractedImageTransfer,
+  lifecycle: ReaderLifecycle = {},
+): Promise<ImageIngestionBatchResult> {
+  const candidates: ImageFileCandidate[] = [];
+  const rejected = [...transfer.rejected];
+  let estimatedEncodedBytes = 0;
+  const maxEncodedBytes =
+    lifecycle.maxEncodedBytes ?? MAX_IMAGE_ATTACHMENT_DATA_BYTES;
+  for (const candidate of transfer.candidates) {
+    const candidateBytes = Math.ceil(candidate.file.size / 3) * 4;
+    if (estimatedEncodedBytes + candidateBytes > maxEncodedBytes) {
+      rejected.push({ name: candidate.file.name, reason: 'too-large' });
+      continue;
+    }
+    estimatedEncodedBytes += candidateBytes;
+    candidates.push(candidate);
+  }
+
+  const settled: Array<PromiseSettledResult<PromptImage>> = new Array(
+    candidates.length,
+  );
+  let nextIndex = 0;
+  const readNext = async () => {
+    while (nextIndex < candidates.length) {
+      const index = nextIndex++;
+      try {
+        settled[index] = {
+          status: 'fulfilled',
+          value: await readImage(candidates[index]!, lifecycle),
+        };
+      } catch (reason) {
+        settled[index] = { status: 'rejected', reason };
+      }
+    }
+  };
+  await Promise.all(
+    Array.from(
+      { length: Math.min(MAX_CONCURRENT_IMAGE_READERS, candidates.length) },
+      readNext,
+    ),
+  );
+  const accepted: PromptImage[] = [];
+  settled.forEach((result, index) => {
+    if (result.status === 'fulfilled') {
+      accepted.push(result.value);
+    } else {
+      rejected.push({
+        name: candidates[index]?.file.name,
+        reason: 'read-failed',
+      });
+    }
+  });
+  return { accepted, rejected };
+}
diff --git a/packages/web-shell/client/utils/promptAdmission.test.ts b/packages/web-shell/client/utils/promptAdmission.test.ts
new file mode 100644
index 00000000000..0b107c3340e
--- /dev/null
+++ b/packages/web-shell/client/utils/promptAdmission.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { DaemonHttpError } from '@qwen-code/sdk/daemon';
+import { isDefinitelyRejectedPromptAdmission } from './promptAdmission';
+
+describe('isDefinitelyRejectedPromptAdmission', () => {
+  it.each([413, 501])('classifies HTTP %s as definitely rejected', (status) => {
+    expect(
+      isDefinitelyRejectedPromptAdmission(
+        new DaemonHttpError(status, undefined, 'rejected'),
+      ),
+    ).toBe(true);
+  });
+
+  it.each([400, 408, 429, 499, 500, 502, 503])(
+    'classifies HTTP %s as unknown',
+    (status) => {
+      expect(
+        isDefinitelyRejectedPromptAdmission(
+          new DaemonHttpError(status, undefined, 'unknown'),
+        ),
+      ).toBe(false);
+    },
+  );
+
+  it('does not classify a non-error status as a rejection', () => {
+    expect(
+      isDefinitelyRejectedPromptAdmission(
+        new DaemonHttpError(302, undefined, 'redirect'),
+      ),
+    ).toBe(false);
+  });
+
+  it('classifies transport errors as unknown', () => {
+    expect(
+      isDefinitelyRejectedPromptAdmission(new TypeError('disconnected')),
+    ).toBe(false);
+  });
+});
diff --git a/packages/web-shell/client/utils/promptAdmission.ts b/packages/web-shell/client/utils/promptAdmission.ts
new file mode 100644
index 00000000000..a7172a3a24a
--- /dev/null
+++ b/packages/web-shell/client/utils/promptAdmission.ts
@@ -0,0 +1,8 @@
+import { DaemonHttpError } from '@qwen-code/sdk/daemon';
+
+export function isDefinitelyRejectedPromptAdmission(error: unknown): boolean {
+  return (
+    error instanceof DaemonHttpError &&
+    (error.status === 413 || error.status === 501)
+  );
+}
diff --git a/packages/webui/src/daemon/session/DaemonSessionProvider.test.tsx b/packages/webui/src/daemon/session/DaemonSessionProvider.test.tsx
index dfd1f5a6301..d1f959d9181 100644
--- a/packages/webui/src/daemon/session/DaemonSessionProvider.test.tsx
+++ b/packages/webui/src/daemon/session/DaemonSessionProvider.test.tsx
@@ -1700,7 +1700,10 @@ describe('DaemonSessionProvider', () => {
           signal: controller.signal,
           optimisticUserMessage: false,
         }),
-      ).rejects.toMatchObject({ name: 'AbortError' });
+      ).resolves.toEqual({
+        promptId: 'pending-1',
+        removedAfterAbort: true,
+      });
     });
 
     expect(removePendingPrompt).toHaveBeenCalledWith('pending-1');
@@ -1735,7 +1738,10 @@ describe('DaemonSessionProvider', () => {
           signal: controller.signal,
           optimisticUserMessage: false,
         }),
-      ).rejects.toMatchObject({ name: 'AbortError' });
+      ).resolves.toEqual({
+        promptId: 'pending-1',
+        removedAfterAbort: true,
+      });
     });
 
     expect(removePendingPrompt).toHaveBeenCalledWith('pending-1');
diff --git a/packages/webui/src/daemon/session/actions.test.ts b/packages/webui/src/daemon/session/actions.test.ts
index 5ec4cd0885a..6aac108b17e 100644
--- a/packages/webui/src/daemon/session/actions.test.ts
+++ b/packages/webui/src/daemon/session/actions.test.ts
@@ -738,21 +738,41 @@ describe('createDaemonSessionActions', () => {
 
   it('restarts the event stream after prompt admission', async () => {
     const restartEventStream = vi.fn();
+    const onAdmissionStarted = vi.fn();
     const session = createMockSession('session-a');
     const { actions } = createActionsHarness({
       restartEventStream,
       session,
     });
 
-    const prompt = actions.sendPrompt('hello');
+    const prompt = actions.sendPrompt('hello', { onAdmissionStarted });
 
     await vi.waitFor(() => {
       expect(restartEventStream).toHaveBeenCalledWith('session-a');
     });
+    expect(onAdmissionStarted).toHaveBeenCalledOnce();
     await actions.cancel();
     await expect(prompt).resolves.toEqual({ stopReason: 'cancelled' });
   });
 
+  it('starts admission only after local prompt guards pass', async () => {
+    const onAdmissionStarted = vi.fn();
+    const session = createMockSession('session-a');
+    const { actions } = createActionsHarness({
+      activePrompts: new Map([
+        ['session-a', { controller: new AbortController() } as ActivePrompt],
+      ]),
+      session,
+    });
+
+    await expect(
+      actions.sendPrompt('hello', { onAdmissionStarted }),
+    ).rejects.toThrow('A prompt is already in progress');
+
+    expect(onAdmissionStarted).not.toHaveBeenCalled();
+    expect(session.submitPrompt).not.toHaveBeenCalled();
+  });
+
   it('does not restart the event stream when the admitted prompt is stale', async () => {
     const restartEventStream = vi.fn();
     const session = createMockSession('session-a');
diff --git a/packages/webui/src/daemon/session/actions.ts b/packages/webui/src/daemon/session/actions.ts
index 914e89148e9..61bc53fa43a 100644
--- a/packages/webui/src/daemon/session/actions.ts
+++ b/packages/webui/src/daemon/session/actions.ts
@@ -362,6 +362,7 @@ export function createDaemonSessionActions({
         if (options?.retry) {
           promptRequest['retry'] = true;
         }
+        options?.onAdmissionStarted?.();
         const accepted = await session.submitPrompt(
           promptRequest as Parameters<typeof session.submitPrompt>[0],
           ctrl.signal,
@@ -452,24 +453,27 @@ export function createDaemonSessionActions({
         promptRequest as Parameters<typeof session.submitPrompt>[0],
       );
       if (options?.signal?.aborted) {
-        await session
-          .removePendingPrompt(accepted.promptId)
-          .catch((err: unknown) => {
-            console.warn(
-              '[submitPrompt] removePendingPrompt failed after abort',
-              err,
-            );
-            addNotice({
-              severity: 'error',
-              category: 'user_action',
-              operation: 'send_prompt',
-              code: 'daemon.send_prompt.pending_cleanup_failed',
-              message:
-                'Prompt was accepted after cancellation but could not be removed from the queue.',
-              debugMessage: err instanceof Error ? err.message : String(err),
-              recoverable: true,
-            });
+        try {
+          const removal = await session.removePendingPrompt(accepted.promptId);
+          if (removal.removed) {
+            return { promptId: accepted.promptId, removedAfterAbort: true };
+          }
+        } catch (err) {
+          console.warn(
+            '[submitPrompt] removePendingPrompt failed after abort',
+            err,
+          );
+          addNotice({
+            severity: 'error',
+            category: 'user_action',
+            operation: 'send_prompt',
+            code: 'daemon.send_prompt.pending_cleanup_failed',
+            message:
+              'Prompt was accepted after cancellation but could not be removed from the queue.',
+            debugMessage: err instanceof Error ? err.message : String(err),
+            recoverable: true,
           });
+        }
         throw (
           options.signal.reason ?? new DOMException('Aborted', 'AbortError')
         );
diff --git a/packages/webui/src/daemon/session/promptContent.test.ts b/packages/webui/src/daemon/session/promptContent.test.ts
index 0ce1c593a32..063b8c9ca05 100644
--- a/packages/webui/src/daemon/session/promptContent.test.ts
+++ b/packages/webui/src/daemon/session/promptContent.test.ts
@@ -26,4 +26,13 @@ describe('toDaemonPromptContent', () => {
       { type: 'image', data: 'b', mimeType: 'image/jpeg' },
     ]);
   });
+
+  it('preserves an image-only BMP prompt as canonical daemon content', () => {
+    expect(
+      toDaemonPromptContent('', [{ data: 'Qk0=', mimeType: 'image/bmp' }]),
+    ).toEqual([
+      { type: 'text', text: '' },
+      { type: 'image', data: 'Qk0=', mimeType: 'image/bmp' },
+    ]);
+  });
 });
diff --git a/packages/webui/src/daemon/session/types.ts b/packages/webui/src/daemon/session/types.ts
index 865f37802ff..3568d122b2e 100644
--- a/packages/webui/src/daemon/session/types.ts
+++ b/packages/webui/src/daemon/session/types.ts
@@ -261,6 +261,8 @@ export interface SendPromptOptions {
    * message in the JSONL transcript. Used by Ctrl+Y retry.
    */
   retry?: boolean;
+  /** Fired after local validation, immediately before dispatch to the daemon. */
+  onAdmissionStarted?: () => void;
   /**
    * Fired once the daemon has ACCEPTED the prompt (admission), before the turn
    * runs to completion. Lets a caller act on "the prompt reached the session"
@@ -315,6 +317,7 @@ export interface DaemonTodoList {
 
 export interface SubmitPromptResult {
   promptId: string;
+  removedAfterAbort?: true;
 }
 
 export interface DaemonSessionActions {