From f953029c5cb6a0617f082427ecdb5612d06162a7 Mon Sep 17 00:00:00 2001
From: A1pha-bit <542016855@qq.com>
Date: Mon, 19 Jan 2026 12:58:48 +0800
Subject: [PATCH] Optimize message sending logic and add a waitlist to handle
 message submissions while waiting for a response.

---
 frontend/src/App.vue                          |   2 +-
 frontend/src/components/input/InputArea.vue   | 128 ++++++++++++-
 frontend/src/components/input/SendButton.vue  |  49 ++---
 .../src/stores/chat/conversationActions.ts    |   6 +
 frontend/src/stores/chat/state.ts             |  17 +-
 .../src/stores/chat/streamChunkHandlers.ts    |  48 ++++-
 frontend/src/stores/chat/toolActions.ts       |  11 ++
 frontend/src/stores/chat/types.ts             |  26 ++-
 frontend/src/stores/chatStore.ts              | 170 +++++++++++++++++-
 webview/stream/StreamAbortManager.ts          |  25 ++-
 webview/stream/StreamRequestHandler.ts        |  12 +-
 11 files changed, 453 insertions(+), 41 deletions(-)

diff --git a/frontend/src/App.vue b/frontend/src/App.vue
index fb2c68c..9937f62 100644
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -60,7 +60,7 @@ async function handleSend(content: string, messageAttachments: Attachment[]) {
     }
 
     // 正常发送消息（传递附件）
-    await chatStore.sendMessage(content, messageAttachments)
+    await chatStore.submitMessage(content, messageAttachments)
   } catch (err) {
     console.error('发送失败:', err)
   }
diff --git a/frontend/src/components/input/InputArea.vue b/frontend/src/components/input/InputArea.vue
index 96f745f..539a448 100644
--- a/frontend/src/components/input/InputArea.vue
+++ b/frontend/src/components/input/InputArea.vue
@@ -189,20 +189,41 @@ const hasAttachments = computed(() =>
   props.attachments && props.attachments.length > 0
 )
 
-// 是否可以发送 - 只在等待响应或上传时禁用发送
-// 例外：当有待确认工具时允许发送（用于带批注拒绝）
+// 是否可以发送
+// - 上传中禁用
+// - 等待响应期间允许"发送"（会进入候补队列）
+// - 例外：当有待确认工具时，发送用于带批注拒绝
 const canSend = computed(() => {
   const hasContent = inputValue.value.trim().length > 0 ||
     (props.attachments && props.attachments.length > 0)
 
+  if (!hasContent) return false
+  if (props.uploading) return false
+
   // 如果有待确认的工具，允许发送（作为批注拒绝）
-  if (chatStore.hasPendingToolConfirmation && hasContent) {
+  if (chatStore.hasPendingToolConfirmation) {
     return true
   }
 
-  return hasContent && !chatStore.isWaitingForResponse && !props.uploading
+  // 等待响应期间也允许发送（会进入候补队列）
+  return true
 })
 
+// 格式化候补队列消息预览
+function formatQueuedPreview(item: any): string {
+  const text = String(item?.content || '').trim()
+  if (text) {
+    return text.length > 60 ? text.slice(0, 60) + '…' : text
+  }
+
+  const count = Array.isArray(item?.attachments) ? item.attachments.length : 0
+  if (count > 0) {
+    return `附件(${count})`
+  }
+
+  return ''
+}
+
 // 处理发送
 function handleSend() {
   if (!canSend.value) return
@@ -899,6 +920,33 @@ watch(() => settingsStore.promptModesVersion, () => {
       </div>
     </div>
 
+    <!-- 候补队列：等待响应期间提交的消息会先进入队列 -->
+    <div
+      v-if="chatStore.queuedMessages && chatStore.queuedMessages.length > 0"
+      class="queued-messages"
+      :class="{ paused: !!chatStore.error }"
+    >
+      <div
+        v-for="item in chatStore.queuedMessages"
+        :key="item.id"
+        class="queued-message-chip"
+        :class="{ paused: !!chatStore.error }"
+        :title="item.content || formatQueuedPreview(item)"
+      >
+        <i class="codicon codicon-clock queued-icon"></i>
+        <span class="queued-text">{{ formatQueuedPreview(item) }}</span>
+        <span v-if="chatStore.error" class="queued-paused-badge">暂停中</span>
+        <button
+          class="queued-remove"
+          type="button"
+          :title="t('common.remove')"
+          @click="chatStore.removeQueuedMessage(item.id)"
+        >
+          <i class="codicon codicon-close"></i>
+        </button>
+      </div>
+    </div>
+
     <!-- 输入框容器（包含文件选择器） -->
     <div class="input-box-container">
       <!-- @ 文件选择面板 -->
@@ -1262,6 +1310,78 @@ watch(() => settingsStore.promptModesVersion, () => {
   position: relative;
 }
 
+/* 候补队列 */
+.queued-messages {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-xs, 4px);
+}
+
+.queued-message-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  max-width: 100%;
+  padding: 2px 6px;
+  border-radius: 999px;
+  background: var(--vscode-textBlockQuote-background, rgba(127, 127, 127, 0.1));
+  border: 1px solid var(--vscode-panel-border, rgba(127, 127, 127, 0.25));
+  font-size: 12px;
+  line-height: 18px;
+}
+
+/* error 状态下：队列暂停，气泡高亮 */
+.queued-message-chip.paused {
+  background: var(--vscode-inputValidation-errorBackground);
+  border-color: var(--vscode-inputValidation-errorBorder);
+}
+
+.queued-message-chip.paused .queued-icon,
+.queued-message-chip.paused .queued-text,
+.queued-message-chip.paused .queued-remove {
+  color: var(--vscode-inputValidation-errorForeground);
+}
+
+.queued-paused-badge {
+  padding: 0 6px;
+  border-radius: 999px;
+  font-size: 11px;
+  line-height: 16px;
+  border: 1px solid var(--vscode-inputValidation-errorBorder);
+  color: var(--vscode-inputValidation-errorForeground);
+}
+
+.queued-icon {
+  font-size: 12px;
+  opacity: 0.8;
+}
+
+.queued-text {
+  max-width: 360px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.queued-remove {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  height: 18px;
+  border: none;
+  background: transparent;
+  color: var(--vscode-foreground);
+  opacity: 0.75;
+  cursor: pointer;
+  border-radius: 4px;
+}
+
+.queued-remove:hover {
+  opacity: 1;
+  background: var(--vscode-toolbar-hoverBackground);
+}
+
 /* 附件列表 */
 .attachments-list {
   display: flex;
diff --git a/frontend/src/components/input/SendButton.vue b/frontend/src/components/input/SendButton.vue
index 65d2716..7f32d5d 100644
--- a/frontend/src/components/input/SendButton.vue
+++ b/frontend/src/components/input/SendButton.vue
@@ -31,29 +31,38 @@ function handleCancel() {
 </script>
 
 <template>
-  <!-- 取消按钮 - loading 状态下显示 -->
-  <button
-    v-if="loading"
-    class="send-button"
-    :title="t('components.input.stopGenerating')"
-    @click="handleCancel"
-  >
-    <i class="codicon codicon-primitive-square stop-icon"></i>
-  </button>
-  
-  <!-- 发送按钮 - 正常状态下显示 -->
-  <button
-    v-else
-    class="send-button"
-    :disabled="disabled"
-    :title="t('components.input.send')"
-    @click="handleClick"
-  >
-    <i class="codicon codicon-send send-icon"></i>
-  </button>
+  <div class="send-button-group">
+    <!-- 取消按钮 - loading 状态下显示 -->
+    <button
+      v-if="loading"
+      type="button"
+      class="send-button"
+      :title="t('components.input.stopGenerating')"
+      @click="handleCancel"
+    >
+      <i class="codicon codicon-primitive-square stop-icon"></i>
+    </button>
+
+    <!-- 发送按钮 - 始终显示（等待响应时用于加入候补队列） -->
+    <button
+      type="button"
+      class="send-button"
+      :disabled="disabled"
+      :title="t('components.input.send')"
+      @click="handleClick"
+    >
+      <i class="codicon codicon-send send-icon"></i>
+    </button>
+  </div>
 </template>
 
 <style scoped>
+.send-button-group {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
 .send-button {
   display: inline-flex;
   align-items: center;
diff --git a/frontend/src/stores/chat/conversationActions.ts b/frontend/src/stores/chat/conversationActions.ts
index a76c795..973e882 100644
--- a/frontend/src/stores/chat/conversationActions.ts
+++ b/frontend/src/stores/chat/conversationActions.ts
@@ -38,6 +38,9 @@ export async function createNewConversation(
   state.isStreaming.value = false
   state.streamingMessageId.value = null
   state.isWaitingForResponse.value = false
+
+  // 清空待发送队列（切换/新建对话时不保留队列）
+  state.queuedMessages.value = []
 }
 
 /**
@@ -215,6 +218,9 @@ export async function switchConversation(
   state.isStreaming.value = false
   state.streamingMessageId.value = null
   state.isWaitingForResponse.value = false
+
+  // 清空待发送队列（切换对话时不保留队列）
+  state.queuedMessages.value = []
   
   // 如果是已持久化的对话，从后端加载历史和检查点
   if (conv.isPersisted) {
diff --git a/frontend/src/stores/chat/state.ts b/frontend/src/stores/chat/state.ts
index b17fcd1..3a17fa0 100644
--- a/frontend/src/stores/chat/state.ts
+++ b/frontend/src/stores/chat/state.ts
@@ -10,7 +10,8 @@ import type {
   WorkspaceFilter,
   RetryStatus,
   ConfigInfo,
-  ChatStoreState
+  ChatStoreState,
+  QueuedMessage
 } from './types'
 
 /**
@@ -50,6 +51,13 @@ export function createChatState(): ChatStoreState {
   
   /** 当前流式消息ID */
   const streamingMessageId = ref<string | null>(null)
+
+  /**
+   * 最近一次发起取消时对应的 assistant 消息 ID。
+   *
+   * 用途：解决“旧流 cancelled chunk 在新流开始后到达，误取消新流”的竞态。
+   */
+  const pendingCancelledMessageId = ref<string | null>(null)
   
   /** 等待AI响应状态 - 用于显示等待动画 */
   const isWaitingForResponse = ref(false)
@@ -81,6 +89,9 @@ export function createChatState(): ChatStoreState {
   /** 工作区筛选模式（默认当前工作区） */
   const workspaceFilter = ref<WorkspaceFilter>('current')
 
+  /** 待发送消息队列 */
+  const queuedMessages = ref<QueuedMessage[]>([])
+
   return {
     conversations,
     currentConversationId,
@@ -92,6 +103,7 @@ export function createChatState(): ChatStoreState {
     isLoadingConversations,
     error,
     streamingMessageId,
+    pendingCancelledMessageId,
     isWaitingForResponse,
     retryStatus,
     toolCallBuffer,
@@ -101,6 +113,7 @@ export function createChatState(): ChatStoreState {
     deletingConversationIds,
     currentWorkspaceUri,
     inputValue,
-    workspaceFilter
+    workspaceFilter,
+    queuedMessages
   }
 }
diff --git a/frontend/src/stores/chat/streamChunkHandlers.ts b/frontend/src/stores/chat/streamChunkHandlers.ts
index c3a5bc1..6257bc5 100644
--- a/frontend/src/stores/chat/streamChunkHandlers.ts
+++ b/frontend/src/stores/chat/streamChunkHandlers.ts
@@ -420,11 +420,36 @@ export function handleCheckpoints(
  */
 export function handleCancelled(chunk: StreamChunk, state: ChatStoreState): void {
   // 用户取消了请求
-  // 尝试获取目标消息：优先使用 streamingMessageId，如果已清除则尝试寻找最后一条助手消息
+  // 重要：在“取消旧流并立即开启新流”的场景下，旧流的 cancelled chunk 可能在新流开始后到达。
+  // 若直接用当前 streamingMessageId 处理，会误伤新流（删除占位消息/重置 isWaitingForResponse）。
+
+  const activeStreamingId = state.streamingMessageId.value
+  const pendingCancelledId = state.pendingCancelledMessageId.value
+
+  // 1) 优先使用 pendingCancelledMessageId（若它与当前 activeStreamingId 不同，说明 cancelled chunk 很可能属于旧流）
+  let targetMessageId: string | null = null
+
+  if (pendingCancelledId && pendingCancelledId !== activeStreamingId) {
+    targetMessageId = pendingCancelledId
+  } else if (activeStreamingId) {
+    targetMessageId = activeStreamingId
+  } else if (pendingCancelledId) {
+    targetMessageId = pendingCancelledId
+  }
+
+  // 2) 计算 target messageIndex
   let messageIndex = -1
-  if (state.streamingMessageId.value) {
-    messageIndex = state.allMessages.value.findIndex(m => m.id === state.streamingMessageId.value)
-  } else {
+  if (targetMessageId) {
+    messageIndex = state.allMessages.value.findIndex(m => m.id === targetMessageId)
+
+    // 如果 cancelled chunk 指向的是“旧流”，但旧消息已不存在：忽略本次 cancelled，避免误伤新流
+    if (messageIndex === -1 && pendingCancelledId && pendingCancelledId !== activeStreamingId) {
+      state.pendingCancelledMessageId.value = null
+      return
+    }
+  }
+
+  if (messageIndex === -1) {
     // 兼容性处理：如果 streamingMessageId 已被 cancelStream 清除，则寻找最后一条助手消息
     // 仅当最后一条助手消息处于非流式状态（说明刚被 cancelStream 处理过）时才尝试更新其元数据
     const lastMsgIndex = state.allMessages.value.length - 1
@@ -489,9 +514,18 @@ export function handleCancelled(chunk: StreamChunk, state: ChatStoreState): void
       ]
     }
   }
-  state.streamingMessageId.value = null
-  state.isStreaming.value = false
-  state.isWaitingForResponse.value = false
+  // 本次 cancelled chunk 已处理，清除 pendingCancelledMessageId
+  if (state.pendingCancelledMessageId.value) {
+    state.pendingCancelledMessageId.value = null
+  }
+
+  // 仅当 cancelled chunk 作用于“当前活跃流”时，才重置全局流状态
+  // 如果此时已经有新流在进行（activeStreamingId 与 targetMessageId 不同），则不要误伤新流。
+  if (activeStreamingId && targetMessageId === activeStreamingId) {
+    state.streamingMessageId.value = null
+    state.isStreaming.value = false
+    state.isWaitingForResponse.value = false
+  }
 }
 
 /**
diff --git a/frontend/src/stores/chat/toolActions.ts b/frontend/src/stores/chat/toolActions.ts
index 7035266..8f7180c 100644
--- a/frontend/src/stores/chat/toolActions.ts
+++ b/frontend/src/stores/chat/toolActions.ts
@@ -200,6 +200,11 @@ export async function cancelStreamAndRejectTools(
   _computed: ChatStoreComputed
 ): Promise<void> {
   if (!state.currentConversationId.value) return
+
+  // 记录本次取消针对的消息，避免 cancelled chunk 在新流开始后误取消新流
+  if (state.isStreaming.value) {
+    state.pendingCancelledMessageId.value = state.streamingMessageId.value
+  }
   
   if (state.retryStatus.value) {
     state.retryStatus.value = null
@@ -268,6 +273,9 @@ export async function cancelStream(
   
   // 等待工具确认状态（包括 diff 工具等待用户操作）
   if (!state.isStreaming.value) {
+    // awaitingConfirmation 场景通常已无活跃流，不会再收到 cancelled chunk
+    state.pendingCancelledMessageId.value = null
+
     // 先调用后端 cancelStream 来关闭 diff 编辑器并拒绝工具
     try {
       await sendToExtension('cancelStream', {
@@ -292,6 +300,9 @@ export async function cancelStream(
   // 先保存当前 streaming 消息 ID，因为 await 期间可能被其他事件清除
   const currentStreamingId = state.streamingMessageId.value
 
+  // 记录本次取消针对的消息，避免 cancelled chunk 在新流开始后误取消新流
+  state.pendingCancelledMessageId.value = currentStreamingId
+
   try {
     await sendToExtension('cancelStream', {
       conversationId: state.currentConversationId.value
diff --git a/frontend/src/stores/chat/types.ts b/frontend/src/stores/chat/types.ts
index 39cf432..214719a 100644
--- a/frontend/src/stores/chat/types.ts
+++ b/frontend/src/stores/chat/types.ts
@@ -3,7 +3,7 @@
  */
 
 import type { Ref, ComputedRef } from 'vue'
-import type { Message, ErrorInfo, CheckpointRecord } from '../../types'
+import type { Message, ErrorInfo, CheckpointRecord, Attachment } from '../../types'
 
 // 重新导出类型以供其他模块使用
 export type { CheckpointRecord } from '../../types'
@@ -42,6 +42,20 @@ export interface AttachmentData {
   thumbnail?: string
 }
 
+/**
+ * 待发送消息（候补队列）
+ */
+export interface QueuedMessage {
+  /** 队列消息 ID */
+  id: string
+  /** 文本内容（允许为空：仅附件消息） */
+  content: string
+  /** 附件（可选） */
+  attachments?: Attachment[]
+  /** 入队时间 */
+  createdAt: number
+}
+
 /**
  * 重试状态
  */
@@ -89,6 +103,14 @@ export interface ChatStoreState {
   error: Ref<ErrorInfo | null>
   /** 当前流式消息ID */
   streamingMessageId: Ref<string | null>
+  
+  /**
+   * 最近一次发起取消时对应的 assistant 消息 ID。
+   *
+   * 用途：解决“旧流 cancelled chunk 在新流开始后到达，误取消新流”的竞态。
+   */
+  pendingCancelledMessageId: Ref<string | null>
+
   /** 等待AI响应状态 */
   isWaitingForResponse: Ref<boolean>
   /** 重试状态 */
@@ -109,6 +131,8 @@ export interface ChatStoreState {
   inputValue: Ref<string>
   /** 工作区筛选模式 */
   workspaceFilter: Ref<WorkspaceFilter>
+  /** 待发送消息队列 */
+  queuedMessages: Ref<QueuedMessage[]>
 }
 
 /**
diff --git a/frontend/src/stores/chatStore.ts b/frontend/src/stores/chatStore.ts
index ae95ae3..9a14dcc 100644
--- a/frontend/src/stores/chatStore.ts
+++ b/frontend/src/stores/chatStore.ts
@@ -26,8 +26,10 @@
  */
 
 import { defineStore } from 'pinia'
+import { ref as vueRef, watch } from 'vue'
 import type { Attachment, StreamChunk } from '../types'
 import { sendToExtension, onMessageFromExtension } from '../utils/vscode'
+import { generateId } from '../utils/format'
 
 // 导入模块
 import { createChatState } from './chat/state'
@@ -115,6 +117,157 @@ export const useChatStore = defineStore('chat', () => {
   
   const sendMessage = (messageText: string, attachments?: Attachment[]) =>
     sendMessageFn(state, computed, messageText, attachments)
+
+  // ============ 待发送队列（候补发送） ============
+
+  /** 是否正在自动发送队列（防止并发 drain） */
+  const isDrainingQueue = vueRef(false)
+
+  /**
+   * 当前 Webview 中是否存在待确认的 Diff（apply_diff / write_file / search_in_files replace）。
+   *
+   * 用途：当用户正处于 Diff 审阅阶段时，允许用户发送“即时消息”来中断当前流程，
+   * 让 LLM 根据新需求重新审阅并给出新的修改方案。
+   */
+  const pendingDiffToolIds = vueRef<Set<string>>(new Set())
+
+  function hasPendingDiffInCurrentConversation(): boolean {
+    if (pendingDiffToolIds.value.size === 0) return false
+
+    // 当前对话中出现过的工具调用 ID
+    for (const msg of state.allMessages.value) {
+      const tools = (msg as any).tools as Array<{ id: string; status?: string }> | undefined
+      if (!tools || tools.length === 0) continue
+
+      for (const tool of tools) {
+        // 仅当该 toolId 仍未产生 functionResponse 时，才认为在 Diff 审阅阶段
+        //（避免 tool.status 被错误标记、或 diff.statusChanged 同步延迟导致误判）
+        if (tool?.id && pendingDiffToolIds.value.has(tool.id) && !hasToolResponse(tool.id)) {
+          return true
+        }
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * 入队：等待响应期间用户提交的消息不会立刻发给后端，而是先进入候补队列。
+   */
+  function enqueueMessage(messageText: string, attachments?: Attachment[]): void {
+    state.queuedMessages.value.push({
+      id: generateId(),
+      content: messageText,
+      attachments: attachments && attachments.length > 0 ? attachments : undefined,
+      createdAt: Date.now()
+    })
+  }
+
+  /** 取消队列中的某条消息 */
+  function removeQueuedMessage(id: string): void {
+    state.queuedMessages.value = state.queuedMessages.value.filter(m => m.id !== id)
+  }
+
+  /** 清空队列 */
+  function clearQueuedMessages(): void {
+    state.queuedMessages.value = []
+  }
+
+  /**
+   * 对外统一入口：用户点击发送/按 Enter 时调用。
+   * - 空闲：直接 sendMessage
+   * - 忙碌（等待响应）：入队
+   */
+  async function submitMessage(messageText: string, attachments?: Attachment[]): Promise<void> {
+    const hasText = messageText.trim().length > 0
+    const hasAttachments = !!(attachments && attachments.length > 0)
+    if (!hasText && !hasAttachments) return
+
+    // Diff 审阅阶段：允许即时发送
+    // 说明：diff 审阅本质上是“工具执行流程暂停等待用户确认”，
+    // 若用户此时提出新需求，应立即中断当前流程并发送新消息，让 LLM 重新调整。
+    if (hasPendingDiffInCurrentConversation()) {
+      // 防止 cancelStream 导致队列自动 drain 抢跑
+      isDrainingQueue.value = true
+      try {
+        if (state.isWaitingForResponse.value) {
+          await cancelStream()
+        }
+
+        await sendMessage(messageText, attachments)
+      } finally {
+        isDrainingQueue.value = false
+      }
+      return
+    }
+
+    // 若正在等待响应，或队列中已有消息，则入队
+    // 这样可以确保候补队列严格 FIFO：不会出现新提交的消息“插队”到队列前面。
+    if (state.isWaitingForResponse.value || state.queuedMessages.value.length > 0 || isDrainingQueue.value) {
+      enqueueMessage(messageText, attachments)
+
+      // 如果当前空闲且无错误，确保队列会被及时发送（避免极端情况下卡住）
+      if (!state.isWaitingForResponse.value && !state.error.value) {
+        setTimeout(() => {
+          void tryDrainQueuedMessages()
+        }, 0)
+      }
+
+      return
+    }
+
+    await sendMessage(messageText, attachments)
+  }
+
+  /**
+   * 尝试自动发送队列中的下一条消息。
+   *
+   * 约束：
+   * - 仅在空闲（isWaitingForResponse=false）时发送
+   * - 若存在错误（state.error!=null），不自动发送，等待用户手动处理错误
+   */
+  async function tryDrainQueuedMessages(): Promise<void> {
+    if (isDrainingQueue.value) return
+    if (state.isWaitingForResponse.value) return
+    if (state.error.value) return
+    if (state.queuedMessages.value.length === 0) return
+
+    isDrainingQueue.value = true
+
+    try {
+      const next = state.queuedMessages.value[0]
+      // 先出队，避免并发重复发送
+      state.queuedMessages.value = state.queuedMessages.value.slice(1)
+      await sendMessage(next.content, next.attachments)
+    } finally {
+      isDrainingQueue.value = false
+    }
+  }
+
+  // 监听等待状态：一轮结束后尝试自动发送队列
+  watch(
+    () => state.isWaitingForResponse.value,
+    (waiting, prevWaiting) => {
+      if (prevWaiting && !waiting) {
+        // 延迟到下一轮事件循环，避免与流式状态切换产生竞态
+        setTimeout(() => {
+          void tryDrainQueuedMessages()
+        }, 0)
+      }
+    }
+  )
+
+  // 监听错误清除：用户手动处理错误后，若当前空闲则继续发送队列
+  watch(
+    () => state.error.value,
+    (err, prevErr) => {
+      if (prevErr && !err) {
+        setTimeout(() => {
+          void tryDrainQueuedMessages()
+        }, 0)
+      }
+    }
+  )
   
   const retryLastMessage = () => retryLastMessageFn(state, computed, cancelStream)
   const retryFromMessage = (messageIndex: number) => 
@@ -175,13 +328,21 @@ export const useChatStore = defineStore('chat', () => {
   // ============ 初始化 ============
   
   async function initialize(): Promise<void> {
-    onMessageFromExtension((message) => {
+    onMessageFromExtension((message: any) => {
       if (message.type === 'streamChunk') {
         handleStreamChunkWrapper(message.data)
       } else if (message.type === 'workspaceUri') {
         setCurrentWorkspaceUri(state, message.data)
       } else if (message.type === 'retryStatus') {
         handleRetryStatus(state, message.data)
+      } else if (message.type === 'command' && message.command === 'diff.statusChanged') {
+        // 记录当前待确认 diff 对应的 toolId 集合（用于 Diff 审阅阶段“即时发送”）
+        const pending = Array.isArray(message.data?.pendingDiffs) ? message.data.pendingDiffs : []
+        const ids = new Set<string>()
+        for (const d of pending) {
+          if (d?.toolId) ids.add(d.toolId)
+        }
+        pendingDiffToolIds.value = ids
       }
     })
     
@@ -199,6 +360,7 @@ export const useChatStore = defineStore('chat', () => {
     
     state.currentConversationId.value = null
     state.allMessages.value = []
+    state.queuedMessages.value = []
   }
 
   // ============ 返回 ============
@@ -242,6 +404,7 @@ export const useChatStore = defineStore('chat', () => {
     // 消息管理
     loadHistory: () => loadHistory(state),
     sendMessage,
+    submitMessage,
     retryLastMessage,
     retryFromMessage,
     retryAfterError,
@@ -286,6 +449,11 @@ export const useChatStore = defineStore('chat', () => {
     inputValue: state.inputValue,
     setInputValue,
     clearInputValue,
+
+    // 候补队列（待发送消息）
+    queuedMessages: state.queuedMessages,
+    removeQueuedMessage,
+    clearQueuedMessages,
     
     // 上下文总结
     summarizeContext,
diff --git a/webview/stream/StreamAbortManager.ts b/webview/stream/StreamAbortManager.ts
index 8d7d886..5340742 100644
--- a/webview/stream/StreamAbortManager.ts
+++ b/webview/stream/StreamAbortManager.ts
@@ -14,8 +14,20 @@ export class StreamAbortManager {
 
   /**
    * 创建并存储新的 AbortController
+   *
+   * 注意：同一 conversationId 同时只能有一个“活跃的流”。
+   * 若已有旧的 controller，则先 abort，避免并发流导致状态错乱。
    */
   create(conversationId: string): AbortController {
+    const existing = this.controllers.get(conversationId)
+    if (existing) {
+      try {
+        existing.abort()
+      } catch {
+        // ignore
+      }
+    }
+
     const controller = new AbortController();
     this.controllers.set(conversationId, controller);
     return controller;
@@ -43,8 +55,19 @@ export class StreamAbortManager {
 
   /**
    * 删除指定对话的 AbortController
+   *
+   * 为避免“旧流 finally 清理时误删新流 controller”的竞态，
+   * 允许传入 controller：仅当当前 map 中仍指向该 controller 时才删除。
    */
-  delete(conversationId: string): void {
+  delete(conversationId: string, controller?: AbortController): void {
+    if (controller) {
+      const current = this.controllers.get(conversationId)
+      if (current === controller) {
+        this.controllers.delete(conversationId)
+      }
+      return
+    }
+
     this.controllers.delete(conversationId);
   }
 
diff --git a/webview/stream/StreamRequestHandler.ts b/webview/stream/StreamRequestHandler.ts
index 2d6895d..e559e9b 100644
--- a/webview/stream/StreamRequestHandler.ts
+++ b/webview/stream/StreamRequestHandler.ts
@@ -55,7 +55,8 @@ export class StreamRequestHandler {
     } catch (error: any) {
       this.handleStreamError(error, processor, requestId);
     } finally {
-      this.deps.abortManager.delete(conversationId);
+      // 仅清理当前这次请求创建的 controller，避免竞态误删新请求 controller
+      this.deps.abortManager.delete(conversationId, controller);
     }
   }
 
@@ -85,7 +86,8 @@ export class StreamRequestHandler {
     } catch (error: any) {
       this.handleStreamError(error, processor, requestId);
     } finally {
-      this.deps.abortManager.delete(conversationId);
+      // 仅清理当前这次请求创建的 controller，避免竞态误删新请求 controller
+      this.deps.abortManager.delete(conversationId, controller);
     }
   }
 
@@ -118,7 +120,8 @@ export class StreamRequestHandler {
     } catch (error: any) {
       this.handleStreamError(error, processor, requestId);
     } finally {
-      this.deps.abortManager.delete(conversationId);
+      // 仅清理当前这次请求创建的 controller，避免竞态误删新请求 controller
+      this.deps.abortManager.delete(conversationId, controller);
     }
   }
 
@@ -150,7 +153,8 @@ export class StreamRequestHandler {
     } catch (error: any) {
       this.handleStreamError(error, processor, requestId);
     } finally {
-      this.deps.abortManager.delete(conversationId);
+      // 仅清理当前这次请求创建的 controller，避免竞态误删新请求 controller
+      this.deps.abortManager.delete(conversationId, controller);
     }
   }