修复: aichat 切换/新建对话缺陷(队列串会话/回切丢消息/审批误终态化/删除复活/切换链路)

2026-08-08 14:20:10 +08:00
parent 795e05f42d
commit 9f75db5b15
8 changed files with 511 additions and 325 deletions
@@ -316,3 +316,16 @@ export function clearConvStreamState(convId: string | null | undefined): void {
  if (!convId) return
  convStreamStates.delete(convId)
 }
+
+// ── 切换中缓冲 ──
+//
+// 背景:后台会话(A)生成中,用户点击切换到 A(switchConversation await 往返期间),A 的
+// AiTextDelta 事件因 `convId !== activeConversationId` 被 handleEvent 的 isCurrent 守卫丢弃 →
+// 切换完成后回复缺前缀(切换窗口 token 丢失)。
+//
+// 本集合标记「正在被 switchConversation 拉取的目标 conv」:useAiEvents.handleEvent 对非当前
+// 会话的 AiTextDelta 若命中此集合,则累积到该 conv 的 per-conv 流式态(而非 drop);
+// 切换成功后由 switchConversation 恢复该流式文本续显,失败/过期路径丢弃(防陈旧重复)。
+//
+// 普通 Set(仅事件处理器读,无渲染追踪需求);生命周期由 switchConversation 的 finally 管理。
+export const switchingConvs = new Set<string>()
@@ -10,7 +10,7 @@ import { state } from '@/stores/ai'
 import { notifyConversationChanged } from './useAiEvents'
 import { persistUiState } from './useAiPanel'
 import { setStreaming } from './streamingGuard'
-import { nextMsgId, getConvState, clearConvStreamState, startApprovalTimer, clearAllApprovalTimers } from './aiShared'
+import { nextMsgId, getConvState, clearConvStreamState, startApprovalTimer, clearAllApprovalTimers, switchingConvs, getConvStreamState, setConvCurrentText } from './aiShared'
 import { t } from '@/i18n/i18n-helpers'
 import type { AiConversationDetail, AiMessage, AiToolCallInfo, ConvId } from '@/api/types'

@@ -63,42 +63,60 @@ async function loadConversations() {
  }
 }

+// 新建防抖锁:快速连点「+」/ Ctrl+N 只触发一次(300ms 内重复调用直接 return,
+// 防多个空会话 + 虚拟项堆积)。模块级(跨组件共享,主/分离窗口各自实例由 store 单例统一)。
+let _newConvLock = false
+
 /** 新建空对话并切过去 */
 async function newConversation() {
-  // G3.4:收敛进会话操作族 withConvOp——原裸 await 失败抛 unhandled rejection 用户无感,
-  // 现失败推错误气泡 + 保持当前视图。新建无乐观本地变化(后端生成 id,失败无副作用)。
-  const result = await withConvOp(
-    () => {},
-    () => aiApi.createConversation(),
-    () => {},
-    'newConvFail',
-  )
-  if (!result) return // 失败已推气泡,保持当前视图
-  state.activeConversationId = result.id
-  void appSettings.set('df-ai-active-conv', result.id)
-  // G3.5:新对话无历史,load_more 游标复位
-  loadMoreCursor.hasMore = false
-  loadMoreCursor.earliestSeq = null
-  loadMoreCursor.convId = result.id
-  loadMoreCursor.loading = false
-  state.messages = []
-  state.currentText = ''
-  state.pendingApprovals = []
-  setStreaming(false, { reason: 'newConversation' })
-  // F-09 决策e(真并发):newConversation 对齐 switchConversation 并行语义——旧 conv 后台 loop 继续,
-  // 不清 generatingConvs(保留旧 conv 生成态跟踪,侧栏显双会话生成,AiCompleted/AiError 按
-  // conversation_id 正确收尾旧 conv)。原 state.generatingConvs.clear() 是 A 路线 F-260616-09
-  // 单 loop 软隔离遗留,真并发下致后台生成前端丢失跟踪,废弃。
-  // agentRound 复位 0;searchQuery 清空防新会话侧栏被旧搜索过滤。
-  // queue 保留旧会话排队消息(它们有 conversationId,会在旧会话 AiCompleted 时按 ID 精准 drain)
-  state.agentRound = 0
-  state.searchQuery = ''
-  await loadConversations()
-  notifyConversationChanged()
+  // 新建会话清空所有审批计时器(对齐切换/删除会话——旧 conv 的审批超时到点会误拒后台
+  // 挂起审批 + 错误气泡进新会话视图)。
+  clearAllApprovalTimers()
+  // 防抖(300ms 内重复调用直接 return)
+  if (_newConvLock) return
+  _newConvLock = true
+  try {
+    // G3.4:收敛进会话操作族 withConvOp——原裸 await 失败抛 unhandled rejection 用户无感,
+    // 现失败推错误气泡 + 保持当前视图。新建无乐观本地变化(后端生成 id,失败无副作用)。
+    const result = await withConvOp(
+      () => {},
+      () => aiApi.createConversation(),
+      () => {},
+      'newConvFail',
+    )
+    if (!result) return // 失败已推气泡,保持当前视图
+    state.activeConversationId = result.id
+    void appSettings.set('df-ai-active-conv', result.id)
+    // G3.5:新对话无历史,load_more 游标复位
+    loadMoreCursor.hasMore = false
+    loadMoreCursor.earliestSeq = null
+    loadMoreCursor.convId = result.id
+    loadMoreCursor.loading = false
+    state.messages = []
+    state.currentText = ''
+    state.pendingApprovals = []
+    setStreaming(false, { reason: 'newConversation' })
+    // F-09 决策e(真并发):newConversation 对齐 switchConversation 并行语义——旧 conv 后台 loop 继续,
+    // 不清 generatingConvs(保留旧 conv 生成态跟踪,侧栏显双会话生成,AiCompleted/AiError 按
+    // conversation_id 正确收尾旧 conv)。原 state.generatingConvs.clear() 是 A 路线 F-260616-09
+    // 单 loop 软隔离遗留,真并发下致后台生成前端丢失跟踪,废弃。
+    // agentRound 复位 0;searchQuery 清空防新会话侧栏被旧搜索过滤。
+    // queue 保留旧会话排队消息(它们有 conversationId,会在旧会话 AiCompleted 时按 ID 精准 drain)
+    state.agentRound = 0
+    state.searchQuery = ''
+    await loadConversations()
+    notifyConversationChanged()
+  } finally {
+    // 防抖释放:300ms 后允许再次新建
+    setTimeout(() => { _newConvLock = false }, 300)
+  }
 }

 // 切换 token:快速连点 A→B 时,后返回的 A 响应按 token 丢弃,防 messages 错配(FR-R1)
 let _latestSwitchId = 0
+// 最近一次切换的切换窗口缓冲(成功提交路径恢复续显用;失败/过期路径丢弃,
+// 防陈旧文本在后续切换被误恢复造成内容重复)。由 switchConversation 的 finally 统一填充。
+let _switchBufferedText = ''

 // ============================================================
 // G3.5 load_more 分页(滚顶加载更早历史)
@@ -232,18 +250,27 @@ async function loadMoreHistory(): Promise<boolean> {
  }
 }

-/** 切换到指定会话:加载历史消息(含 tool_calls 回填 + tool_result 映射 + pending 审批恢复) */
-export async function switchConversation(id: string) {
-  // AIC-FIX-17-P0-2:切换会话时清空所有审批计时器(防切走后过期 timer 误拒后台 pending + 错误气泡推错视图)。
-  // 新会话的审批计时器由下文 restore pending 路径的 startApprovalTimer 重新建立。
+/** 切换到指定会话:加载历史消息(含 tool_calls 回填 + tool_result 映射 + pending 审批恢复)
+ *  @param force true=跳过同会话短路(程序化刷新当前会话用:清空/压缩后回刷,如 AiChat.vue
+ *         onCleared/onCompressed 回调);false(默认)=同会话点击直接 return。 */
+export async function switchConversation(id: string, force = false) {
+  // 同会话点击短路:已活跃会话不重拉。原实现无条件走 currentText='' + 全量 parse +
+  // pending 重恢复,流式中点侧栏高亮项会清空流式文本、delta 从空续流 → 回复缺前缀。短路保留
+  // in-flight 流式文本。程序化刷新(force=true)不受影响。
+  if (!force && id === state.activeConversationId) return
+  // 切换会话时清空所有审批计时器(防切走后过期 timer 误拒后台挂起审批 + 错误气泡推错视图)。
+  // 新会话的审批计时器由下文恢复挂起路径的 startApprovalTimer 重新建立。
  clearAllApprovalTimers()
  const mySwitchId = ++_latestSwitchId
  // 允许生成中切换:后台继续生成,事件按 conversation_id 路由不污染当前视图
  let detail: AiConversationDetail
  try {
+    // 标记目标会话切换中(await 往返期间),useAiEvents 对非当前会话的 AiTextDelta
+    // 若命中此集合则累积到其 per-conv 流式态而非丢弃(治切换窗口丢 token)。
+    switchingConvs.add(id)
    detail = await aiApi.switchConversation(id)
  } catch (e) {
-    // G3.3:区分 Err 形态——仅"对话不存在"(已删除/未落库的虚 ID)才 create-new 兜底;
+    // 区分错误形态:仅"对话不存在"(已删除/未落库的虚 ID)才新建会话兜底;
    // 瞬态 IPC 失败(网络抖动/后端异常)保留原视图 + 推错误气泡,不再吞当前视图。
    const errMsg = e instanceof Error ? e.message : String(e)
    if (errMsg.includes('对话不存在')) {
@@ -253,7 +280,7 @@ export async function switchConversation(id: string) {
      void appSettings.set('df-ai-active-conv', created.id)
      // 用新对话 id 重走后续逻辑
      detail = { id: created.id as ConvId, title: null, messages: '[]' }
-      // G3.5:新建对话无历史,load_more 游标复位
+      // 新建对话无历史,load_more 游标复位
      loadMoreCursor.hasMore = false
      loadMoreCursor.earliestSeq = null
      loadMoreCursor.convId = created.id
@@ -263,46 +290,54 @@ export async function switchConversation(id: string) {
      void loadConversations()
      return
    }
-    // 瞬态失败:保留当前视图 + 错误气泡(复用 M30 pushConvOpFail 模式);过期响应丢弃。
+    // 瞬态失败:保留当前视图 + 错误气泡(复用会话操作失败气泡模式);过期响应丢弃。
    // 保留 loadConversations() 刷新:陈旧 id(已被后端删除)在下一次列表刷新中消失。
    console.error('[AI] switchConversation 失败(瞬态),保留当前视图:', e)
    if (mySwitchId !== _latestSwitchId) return
    pushConvOpFail('switchConvFail')
    void loadConversations()
    return
+  } finally {
+    // 切换结束(含失败/过期/新建会话路径)清切换中标记 + 统一收集并清空缓冲。
+    // 成功提交路径在下方用 _switchBufferedText 恢复续显;失败/过期路径缓冲被丢弃,
+    // 防陈旧文本在后续切换被误恢复造成内容重复。
+    switchingConvs.delete(id)
+    _switchBufferedText = getConvStreamState(id)?.currentText ?? ''
+    setConvCurrentText(id, '')
  }
  // 过期响应丢弃(用户已切到别的对话,防 A 后返回覆盖 B)
  if (mySwitchId !== _latestSwitchId) return
-  state.activeConversationId = id
-  // G3.5:透传 has_more/earliest_seq 游标(前端滚顶加载更多历史)。
+  // 透传 has_more/earliest_seq 游标(前端滚顶加载更多历史)。
  // 后端在 generating/空对话等场景返 false/null,此处默认兜底。
  const switchDetailAny = detail as any
  loadMoreCursor.hasMore = switchDetailAny.has_more ?? false
  loadMoreCursor.earliestSeq = switchDetailAny.earliest_seq ?? null
  loadMoreCursor.convId = id
  loadMoreCursor.loading = false
-  void appSettings.set('df-ai-active-conv', id)
-  // P1#6 技术债审查(2026-06-21):streaming 是全局单值,切到非生成会话需按目标 conv 生成态重算,
-  // 否则残留 stop 按钮(ChatInput.vue:88 v-if=streaming)→ 点击 store.stopChat 传 activeConversationId
-  // 发错会话。对齐 newConversation 复位语义;目标在后台生成时保留 true(stop/流式显示正确)。
-  // 根治归 F-09 B 路线:streaming 改 per-conv 态。此处为 A 路线过渡补丁。
-  // 批4 双轨收口:读 getConvState(enum 真相源)派生,替代旧 generatingConvs.has。
-  // 桥接语义:has(id)=true 等价于 conv_state∈{generating,stopping,compressed}(非终止三态)。
+  // streaming 是全局单值,切到非生成会话需按目标会话生成态重算,否则残留停止按钮
+  // (输入区 v-if=streaming)→ 点击停止会传 activeConversationId 发错会话。对齐新建会话的
+  // 复位语义;目标在后台生成时保留 true(停止/流式显示正确)。读会话状态(枚举真相源)派生,
+  // 桥接语义:非终止三态(generating/stopping/compressed)视为生成中。
  const targetCs = getConvState(id)
  const targetGen = targetCs === 'generating' || targetCs === 'stopping' || targetCs === 'compressed'
-  setStreaming(targetGen, { convId: id, reason: 'switchConversation-recompute' })

+  // 先 parse 成功替换 messages,成功后再置 activeConversationId(同一同步块内赋值,
+  // 无 await 间隙 → 无中间态渲染)。原顺序先置 active 后 parse,parse 失败时 active 已是新 id 而
+  // messages 仍是旧视图 + 错误气泡 → active 与 messages 错配(视图显示旧会话却以新会话高亮)。
  try {
    const rawMsgs = typeof detail.messages === 'string'
      ? JSON.parse(detail.messages)
      : detail.messages
-    // G3.5:消息映射收敛进 parseConvMessages(switch + load_more 共用,过滤/映射语义一致)。
+    // 消息映射收敛进 parseConvMessages(切换 + 加载更多共用,过滤/映射语义一致)。
    // 相比原内联逻辑唯一行为变化:id 由 `loaded-${i}` 改为优先后端真实消息 id
    // (DB 主键,prepend 时 v-for key 稳定不重建 DOM),缺失才兜底 `loaded-${i}`。
    state.messages = parseConvMessages(rawMsgs, 'loaded')
+    // parse 成功才置 active(保证 active 与 messages 一致)
+    state.activeConversationId = id
  } catch (e) {
-    // UX-260617-08:历史消息解析/映射失败原仅 state.messages=[] → 切换后空白用户不知原因。
+    // 历史消息解析/映射失败原仅 state.messages=[] → 切换后空白用户不知原因。
    // 改为推错误气泡提示 + 控制台日志(保留 state.messages 不再清空,避免空白无反馈)。
+    // parse 失败不切换(active/messages 保持原状),仅推错误气泡,视图不显错配。
    console.error('[AI] 切换对话历史消息解析失败:', e)
    state.messages.push({
      id: `switch-conv-fail-${nextMsgId()}`,
@@ -311,7 +346,11 @@ export async function switchConversation(id: string) {
      isError: true,
      timestamp: Date.now(),
    } as AiMessage)
+    return
  }
+  // 切换提交完成才持久化活跃会话 + 重算 streaming(active 已指向目标 conv)
+  void appSettings.set('df-ai-active-conv', id)
+  setStreaming(targetGen, { convId: id, reason: 'switchConversation-recompute' })

  // 加载历史对话 token 总量(来自 DB summary);切换对话清空实时值
  const conv = state.conversations.find(c => c.id === id)
@@ -327,16 +366,18 @@ export async function switchConversation(id: string) {
  state.lastTokenUsage = null

  state.currentText = ''
-  // 恢复该对话积压的待审批:重启后后端从审计表重建了 pending_approvals,
-  // 此处查回并把对应 toolCard.status 置 pending_approval,使审批卡片重新可见
-  // 阶段4:按 IPC 返的 kind 渲染——'path' 类显 once/always/deny(tc.kind='path' + 推 path/dir 文案),
-  // 'risk' 类显 approve/reject(tc.kind='risk'/缺省)。对齐阶段3b 统一审批模型(两 kind 都可恢复)。
+  // 恢复切换窗口缓冲的流式文本(切换中累积到该会话 per-conv 态的后端快照之后增量),
+  // 由消息列表续显,避免切换完成时丢可见内容(回复缺前缀)。空缓冲则无操作。
+  if (_switchBufferedText) state.currentText = _switchBufferedText
+  // 恢复该对话积压的待审批:重启后后端从审计表重建了挂起审批,
+  // 此处查回并把对应 toolCard.status 置为待审批,使审批卡片重新可见。
+  // 按 IPC 返的 kind 渲染:'path' 类显 once/always/deny,'risk' 类显 approve/reject。
  try {
    const pending = await aiApi.pendingToolCalls(id)
-    // 第二 await 后二次比对:切换 A→B 期间避免用 A 的 pending 覆写 B 的 pendingApprovals
+    // 第二 await 后二次比对:切换 A→B 期间避免用 A 的挂起覆写 B 的 pendingApprovals
    if (mySwitchId !== _latestSwitchId) return
    if (pending.length) {
-      // kind 索引:tool_call_id → kind('risk'/'path'),供恢复 tc/pendingApprovals 按类型渲染
+      // kind 索引:tool_call_id → kind('risk'/'path'),供恢复工具卡/挂起列表按类型渲染
      const pendingKindMap = new Map(pending.map(p => [p.tool_call_id, p.kind]))
      const pendingIds = new Set(pending.map(p => p.tool_call_id))
      const restored: AiToolCallInfo[] = []
@@ -363,8 +404,7 @@ export async function switchConversation(id: string) {
              path: tc.path,
              dir: tc.dir,
              reason: tc.reason,
-              // A2-B10 conv-scoped 审批收尾:恢复的历史挂起带目标会话 id,
-              // cleanupTerminatedConversation 按此仅清本会话的待审批项(不连累并发会话)。
+              // 恢复的历史挂起带目标会话 id:会话终止收尾按此仅清本会话的待审批项,不连累并发会话。
              conversationId: id,
            })
            // 重新启动审批计时器(APPROVAL_TIMEOUT_MS 默认 15min，0=不限时跳过;
@@ -25,7 +25,7 @@ import { aiApi } from '@/api'
 import { useAppSettingsStore } from '@/stores/appSettings'
 import { state } from '@/stores/ai'
 import { t } from '@/i18n/i18n-helpers'
-import { nextMsgId, findToolCall, startApprovalTimer, clearApprovalTimer, clearAllApprovalTimers, convStates, setConvState } from './aiShared'
+import { nextMsgId, findToolCall, startApprovalTimer, clearApprovalTimer, clearAllApprovalTimers, convStates, setConvState, switchingConvs, getConvStreamState, setConvCurrentText, setConvStreaming } from './aiShared'
 // 批4 双轨收口:getConvState 下沉到 aiShared,本模块 re-export 保持消费方
 // (ChatInput.vue/MaxRoundsCard.vue 等)import 路径不变,组件零改动透明继承。
 export { getConvState } from './aiShared'
@@ -877,15 +877,30 @@ export function handleEvent(event: AiChatEvent) {
  // 不影响其他态(handleUserMessageEvent 去重幂等)。
  if (handleUserMessageEvent(event)) return
  // 事件不属于当前展示对话(生成中切走了)→ 不污染当前视图,仅完成/错误/求助时刷新侧边栏
-  // L1 求助协议(§2.3):AiHelpRequired 同 AiError 后端已 guard.reset 终止 loop,需收敛生成态。
  const isCurrent = !convId || convId === state.activeConversationId
  if (!isCurrent) {
    if (event.type === 'AiCompleted' || event.type === 'AiError' || event.type === 'AiHelpRequired') {
-      // 批4 双轨收口:非当前会话终止事件,收敛 convStates(删 Map 项回 idle/不在生成),
-      // 对齐 :592/:660/:711 当前会话分支语义。非当前会话的 error 态无消费方(MaxRoundsCard/
-      // ChatInput 均读 activeConversationId),回退 null 与停止按钮 streaming 回退行为等价。
+      // 非当前会话终止事件:收敛会话状态(删 Map 项回不在生成)。非当前会话的 error 态无
+      // 消费方(操作卡/输入区均读 activeConversationId),回退 null 与停止按钮回退行为等价。
      convStates.delete(convId || '')
      void loadConversations()
+      // 后台会话终止也触发队列续发/清队(原 isCurrent 守卫拦截导致非当前会话排队消息永不
+      // drain,切回后队列卡死)。完成触发续发;错误终止对齐当前会话分支清该会话队列。
+      if (event.type === 'AiCompleted') {
+        emit('ai-drain-queue', { conversationId: event.conversation_id })
+      } else if (event.type === 'AiError') {
+        if (event.conversation_id) {
+          state.queue = state.queue.filter(q => q.conversationId !== event.conversation_id)
+        } else {
+          state.queue = []
+        }
+      }
+    } else if (event.type === 'AiTextDelta' && convId && switchingConvs.has(convId)) {
+      // 切换中缓冲:目标会话正被 switchConversation 拉取,该会话的 delta 累积到其 per-conv
+      // 流式态(而非丢弃),切换完成后由渲染层续显,避免切换窗口丢可见内容。不做气泡/工具
+      // 副作用(消息视图尚未切到目标会话,避免污染当前视图)。
+      setConvStreaming(convId, true)
+      setConvCurrentText(convId, (getConvStreamState(convId)?.currentText ?? '') + (event.delta ?? ''))
    }
    return
  }
@@ -24,7 +24,7 @@ import { t } from '@/i18n/i18n-helpers'
 import { resetStreamWatchdog, clearStreamWatchdog } from './useAiStream'
 import { setStreaming } from './streamingGuard'
 import { startListener, flushCurrentText } from './useAiEvents'
-import { nextMsgId, startApprovalTimer, clearApprovalTimer, clearAllApprovalTimers, resolveAiLang, convStates } from './aiShared'
+import { nextMsgId, startApprovalTimer, clearApprovalTimer, clearAllApprovalTimers, resolveAiLang, convStates, setConvCurrentText, setConvStreaming } from './aiShared'

 /// 待发送队列上限（超过抛错提示用户）
 const QUEUE_LIMIT = 10
@@ -60,67 +60,75 @@ const modelOverride = ref<string | null>(null)
 // ── 内核发送:推送气泡+调 IPC,被 normal/force 两条路径共用 ──

 /**
- * F-260614-05 Phase 2b: parts 仅影响本地 push 的 user 消息(渲染多模态图)。
+ * 内核发送:推送气泡 + 调 IPC,被 normal/force 两条路径共用。
 *
- * 后端 ai_chat_send IPC 当前不接 parts(Phase 2c 接入);本轮 doSend 仅把 parts 写入本地 push 的
- * user 消息让用户气泡可见图,后端请求仍走 content 文本路径(无图)。
- * Phase 2c 后端接 parts 后,本函数透传给 aiApi.sendMessage/forceSend 即可全链路生效。
- *
- * Input Augmentation: spans 透传给后端 ai_chat_send 的 mention_spans 参数(后端 resolve
- * 投影成 Augmentation 注入)+ 写入本地 push 的 user 消息(MessageList 据此渲染 chip)。
- * undefined/空数组 → 本地 user 消息 mentionSpans 置 undefined(纯文本气泡零回归)+ 后端不传。
+ * @param convId 目标会话 id(显式传入优先,缺省当前活跃会话)。后台会话续发(drainQueue)场景
+ *        目标会话 ≠ 当前活跃视图,此时不 push 本地气泡、不碰当前视图流式态,避免污染当前视图。
 */
-async function doSend(text: string, skill?: string, force = false, parts?: ContentPart[], spans?: MentionSpan[]) {
+async function doSend(text: string, skill?: string, force = false, parts?: ContentPart[], spans?: MentionSpan[], convId?: string | null) {
+  // 目标会话:显式传入优先,缺省当前活跃会话。
+  const targetConvId = convId ?? state.activeConversationId
+  // state.messages 是当前活跃会话的全局视图;后台会话续发不 push 本地气泡,
+  // 切回目标会话时由切换加载从 DB/事件恢复完整历史,避免把 A 的消息污染 B 的视图。
+  const isViewTarget = !targetConvId || targetConvId === state.activeConversationId
  // 防御:先 flush 残留 currentText(正常情况已是空,flushCurrentText 直接 return;
-  // 异常时序下可防止上一轮文本被 state.currentText='' 误清)
-  flushCurrentText()
+  // 异常时序下可防止上一轮文本被清空误伤)。仅当前视图会话发送才 flush,后台续发不碰当前视图流式文本。
+  if (isViewTarget) flushCurrentText()

  const userMsgId = `user-${nextMsgId()}`
-  state.messages.push({
-    id: userMsgId as MessageId,
-    role: 'user',
-    content: text.trim(),
-    // 仅在非空时挂 parts(纯文本消息保持 undefined,渲染走原 content 路径零回归)
-    parts: parts && parts.length > 0 ? parts : undefined,
-    // Input Augmentation: 仅在非空时挂 mentionSpans(供 MessageList chip 渲染;空则 undefined 零回归)
-    mentionSpans: spans && spans.length > 0 ? spans : undefined,
-    timestamp: Date.now(),
-  })
-
  const aiMsgId = `ai-${nextMsgId()}`
-  state.messages.push({
-    id: aiMsgId as MessageId,
-    role: 'assistant',
-    content: '',
-    timestamp: Date.now(),
-  })
-  setStreaming(true, { convId: state.activeConversationId, reason: 'doSend' })
-  state.currentText = ''
-  resetStreamWatchdog() // 启动流式看门狗,无数据超时兜底
+  if (isViewTarget) {
+    state.messages.push({
+      id: userMsgId as MessageId,
+      role: 'user',
+      content: text.trim(),
+      // 仅在非空时挂 parts(纯文本消息保持 undefined,渲染走原 content 路径零回归)
+      parts: parts && parts.length > 0 ? parts : undefined,
+      // Input Augmentation: 仅在非空时挂 mentionSpans(供消息列表 chip 渲染;空则 undefined 零回归)
+      mentionSpans: spans && spans.length > 0 ? spans : undefined,
+      timestamp: Date.now(),
+    })
+
+    state.messages.push({
+      id: aiMsgId as MessageId,
+      role: 'assistant',
+      content: '',
+      timestamp: Date.now(),
+    })
+    setStreaming(true, { convId: targetConvId, reason: 'doSend' })
+    state.currentText = ''
+    // 启动流式看门狗(per-conv,无数据超时兜底)
+    resetStreamWatchdog(targetConvId || undefined)
+  } else {
+    // 后台会话续发:直接写其 per-conv 流式态(setStreaming 写当前活跃视图,后台场景会写错会话);
+    // 不 arm 看门狗(目标会话流式态暂由切换加载时按会话状态重算,后台不干扰当前视图)。
+    setConvStreaming(targetConvId, true)
+    setConvCurrentText(targetConvId, '')
+  }

  await startListener()
  const lang = resolveAiLang()
  try {
    // force=true 走 force_send IPC(复位残留 generating),否则走正常 send
-    // F-01 阶段6: 透传 modelOverride(主对话专用,后端兜底校验池内才用)
    const override = modelOverride.value
    if (force) {
-      // F-05 Phase 2c: 透传 parts(图片)给后端 ai_chat_force_send,多模态全链生效
-      // F-260616-09 B 批4(决策 e):传 activeConversationId,操作指定 conv 的 per_conv。
-      // Input Augmentation: 透传 mentionSpans(spans 非空时后端 resolve_and_inject 注入)。
-      await aiApi.forceSend(text.trim(), lang, skill, override, parts, state.activeConversationId, spans)
+      // 透传 parts(图片) + mentionSpans + 目标会话 id
+      await aiApi.forceSend(text.trim(), lang, skill, override, parts, targetConvId, spans)
    } else {
-      await aiApi.sendMessage(text.trim(), lang, skill, override, parts, state.activeConversationId, spans)
+      await aiApi.sendMessage(text.trim(), lang, skill, override, parts, targetConvId, spans)
    }
  } catch (e) {
-    // IPC 失败(spawn 前/provider 配置错等):回滚 streaming 防光标卡死 + 移除 user 消息与空气泡占位;
-    // 重新抛出由 handleSend 回填输入框,用户可重试
-    // BUG-2026-07-17:彻底清理 convStates,避免按钮永久红色
-    const convId = state.activeConversationId
-    setStreaming(false, { convId, reason: 'doSend-ipc-fail' })
-    clearStreamWatchdog(convId || undefined)
-    if (convId) convStates.delete(convId)
-    state.messages = state.messages.filter(m => m.id !== aiMsgId && m.id !== userMsgId)
+    // IPC 失败(spawn 前/provider 配置错等):回滚目标会话 streaming 防光标卡死 + 移除本地气泡占位;
+    // 重新抛出由调用方回填输入框,用户可重试。彻底清理会话状态,避免按钮永久红色。
+    const failConvId = targetConvId
+    if (isViewTarget) {
+      setStreaming(false, { convId: failConvId, reason: 'doSend-ipc-fail' })
+      state.messages = state.messages.filter(m => m.id !== aiMsgId && m.id !== userMsgId)
+    } else {
+      setConvStreaming(failConvId, false)
+    }
+    clearStreamWatchdog(failConvId || undefined)
+    if (failConvId) convStates.delete(failConvId)
    throw e
  }
 }
@@ -255,44 +263,51 @@ async function editMessage(newMessage: string) {
 /**
 * 取出队首并发送（AiCompleted 触发，此时 streaming 已 false）。
 *
- * B-260617-02: 原 void sendMessage(...) fire-and-forget 吞没了 doSend IPC 失败 throw,
- * 既无 AiCompleted 触发下次 drain(队列永久卡死),也无任何用户反馈。
- * 现显式 catch:复位 streaming + 推错误气泡(复用 AiError 的 isError 气泡模式) +
- * 回填失败消息到队首并停 drain(不静默丢用户输入,保留剩余队列供手动重试/编辑/取消)。
- * 成功路径不受影响——doSend 成功后端会再 emit AiCompleted 续 drain 链路。
+ * 原 fire-and-forget 吞没了 doSend IPC 失败 throw,既无 AiCompleted 触发下次 drain(队列永久
+ * 卡死),也无任何用户反馈。现显式 catch:复位 streaming + 推错误气泡(后台会话不推,避免污染
+ * 当前视图)+ 回填失败消息到该会话队首并停 drain(不静默丢用户输入,保留剩余队列供手动重试/
+ * 编辑/取消)。成功路径不受影响——doSend 成功后端会再 emit AiCompleted 续 drain 链路。
 */
 export function drainQueue(convId?: string | null) {
  if (state.queue.length === 0) return
-  // 找队首属于目标 conv 的消息;若穿越(非当前 conv 的项堵在队首)则跳过整条队列
+  // 找队首属于目标会话的消息;若穿越(非目标会话的项堵在队首)则跳过整条队列
  const targetId = convId ?? state.activeConversationId
+  if (!targetId) return
  const idx = state.queue.findIndex(q => q.conversationId === targetId)
  if (idx === -1) return
  const next = state.queue.splice(idx, 1)[0]!
-  const activeConvId = state.activeConversationId
  void (async () => {
    try {
-      await sendMessage(next.text, next.skill, false, next.parts)
+      // 用目标会话 id 发送(而非当前活跃会话)——若已切到别的会话,原实现会把 A 的队首消息
+      // 误发到当前活跃会话 B。队列项无 mentionSpans 字段,传 undefined。
+      await sendMessage(next.text, next.skill, false, next.parts, undefined, targetId)
    } catch (e) {
-      // BUG-2026-07-17: 失败时彻底收尾,带 convId 精准清理 per-conv watchdog + convStates
-      setStreaming(false, { convId: activeConvId, reason: 'drainQueue-fail' })
-      clearStreamWatchdog(activeConvId || undefined)
-      if (activeConvId) convStates.delete(activeConvId)
+      // 失败时彻底收尾:带目标会话 id 精准清理 per-conv 看门狗 + 会话状态
+      setConvStreaming(targetId, false)
+      clearStreamWatchdog(targetId || undefined)
+      if (targetId) convStates.delete(targetId)
      const errMsg = e instanceof Error ? e.message : String(e)
-      state.queue.unshift(next) // 回填失败消息到队首,保留剩余队列(不静默丢用户输入)
-      state.messages.push({
-        id: `err-${nextMsgId()}`,
-        role: 'assistant',
-        content: t('ai.queuedSendFailed', { error: errMsg }),
-        isError: true,
-        timestamp: Date.now(),
-      } as AiMessage)
+      // 回填失败消息到该会话队首,保留剩余队列(不静默丢用户输入)
+      const reIdx = state.queue.findIndex(q => q.conversationId === targetId)
+      state.queue.splice(reIdx === -1 ? state.queue.length : reIdx, 0, next)
+      // 仅目标会话为当前视图才推错误气泡(后台会话续发失败不污染当前视图;错误消息留在队列
+      // 供切回后编辑/重试/取消)
+      if (targetId === state.activeConversationId) {
+        state.messages.push({
+          id: `err-${nextMsgId()}`,
+          role: 'assistant',
+          content: t('ai.queuedSendFailed', { error: errMsg }),
+          isError: true,
+          timestamp: Date.now(),
+        } as AiMessage)
+      }
      console.error('[AI] drainQueue 续发失败:', e)
    }
  })()
 }

 /**
- * 发送消息 — 三级降级(B-260616-02 L2 发送韧性):
+ * 发送消息 — 三级降级(L0 直接发 / L1 入队 / L2 强制):
 *
 * L0 normal:  后端 idle → 直接 doSend()
 * L1 queued:  后端 busy → 入队等 AiCompleted 续发
@@ -301,25 +316,27 @@ export function drainQueue(convId?: string | null) {
 *
 * forceMode=true 时跳过入队,直接走 ai_chat_force_send。
 *
+ * @param convId 目标会话 id(显式传入优先,缺省当前活跃会话)。后台会话续发(drainQueue)必须
+ *        显式传目标会话,否则切走后会用当前活跃会话发错消息。
+ *
 * 注:入队条件仅用 backendGenerating(IPC 查后端真实态),不再检查 state.streaming。
 * streaming 是渲染态(文本是否在屏幕上输出),不能作为「后端能否接收消息」的代理。
- * 文本显示完但后端在落库时,streaming 仍 true——此时按钮已白(基于 delta 时间戳),
- * 用户点击发送,若后端还在忙则入队短暂等待(~1s),AiCompleted 后自动续发。
 */
-async function sendMessage(text: string, skill?: string, forceMode = false, parts?: ContentPart[], spans?: MentionSpan[]) {
+async function sendMessage(text: string, skill?: string, forceMode = false, parts?: ContentPart[], spans?: MentionSpan[], convId?: string | null) {
  if (!text.trim() && !(parts && parts.length)) return
+  // 目标会话:显式传入优先(后台会话续发场景),缺省当前活跃会话
+  const targetConvId = convId ?? state.activeConversationId

  // ── L2 强制模式:跳过所有预检,直接 force_send ──
  if (forceMode) {
-    await doSend(text, skill, true, parts, spans)
+    await doSend(text, skill, true, parts, spans, targetConvId)
    return
  }

-  // B-260615-22(方案 A):发送前 IPC 查后端真实 generating。
-  // F-260616-09 B 批4(决策 e):传 activeConversationId 精确查当前 conv(不读全局单值)。
+  // 发送前 IPC 查后端真实 generating(精确查目标会话,不读全局单值)。
  let backendGenerating = false
  try {
-    backendGenerating = await invoke<boolean>('ai_is_generating', { conversationId: state.activeConversationId || null })
+    backendGenerating = await invoke<boolean>('ai_is_generating', { conversationId: targetConvId || null })
  } catch {
    backendGenerating = false
  }
@@ -335,51 +352,55 @@ async function sendMessage(text: string, skill?: string, forceMode = false, part
      skill: skill || undefined,
      enqueuedAt: Date.now(),
      parts: parts && parts.length > 0 ? parts : undefined,
-      conversationId: state.activeConversationId,
+      conversationId: targetConvId,
    })
    return
  }

  // ── L0:normal 直接发送 ──
-  await doSend(text, skill, false, parts, spans)
+  await doSend(text, skill, false, parts, spans, targetConvId)
 }

-/** 排队是否已超时(任一条超即算,因队首阻塞导致后续全堵) */
-export function isQueueTimedOut(): boolean {
-  const first = state.queue[0]
+/** 排队是否已超时(任一条超即算,因队首阻塞导致后续全堵;未传 convId 时仅看当前活跃会话队列) */
+export function isQueueTimedOut(convId?: string | null): boolean {
+  const targetConv = convId ?? state.activeConversationId
+  const q = targetConv ? state.queue.filter(x => x.conversationId === targetConv) : state.queue
+  const first = q[0]
  return first !== undefined && (Date.now() - first.enqueuedAt > QUEUE_TIMEOUT_MS)
 }

 /**
- * 超时时弹 confirm,用户确认后以 force_mode 重发队首消息;取消则保持排队。
+ * 超时时弹 confirm,用户确认后以 force_mode 重发目标会话队首消息;取消则保持排队。
 *
- * B-260617-04: force_send 失败时,原实现队首已 shift 致消息静默丢失。
- * 现失败把队首 unshift 回队列(保留 UI 队列可见,用户可改普通发送/编辑/取消),
- * 并复位 streaming/clearStreamWatchdog(对齐 doSend 失败回填模式)让 UI 脱卡死态。
- * 不自动重试 force(避免循环),交用户决定下一步。
+ * force_send 失败时,队首已移除,此处回填到该会话队首(原全局 unshift 在跨会话队列下会错位),
+ * 并复位目标会话 streaming / 清看门狗,让 UI 脱卡死态。不自动重试 force(避免循环),交用户决定。
 */
-export async function tryForceSend(confirmFn: (msg: string) => Promise<boolean>): Promise<boolean> {
-  const first = state.queue[0]
+export async function tryForceSend(confirmFn: (msg: string) => Promise<boolean>, convId?: string | null): Promise<boolean> {
+  const targetConv = convId ?? state.activeConversationId
+  const idx = targetConv ? state.queue.findIndex(q => q.conversationId === targetConv) : 0
+  const first = idx === -1 ? undefined : state.queue[idx]
  if (!first) return false
  const confirmed = await confirmFn(t('ai.forceSendConfirm'))
  if (!confirmed) return false
-  // 从队列移除队首,以 force_mode 发送
-  state.queue.shift()
-  // 清看门狗:doSend 内 force_send 路径会重设 streaming=true 并重启 watchdog,
-  // 此处无需前置 false(前置 false 会触发 AiChat watch 清流式块再重建,产生瞬态抖动)
+  // 从队列移除该会话队首,以 force_mode 发送
+  state.queue.splice(idx, 1)
+  // 清看门狗:doSend 内 force_send 路径会重设 streaming=true 并重启看门狗,
+  // 此处无需前置 false(前置 false 会触发消息列表 watch 清流式块再重建,产生瞬态抖动)
  clearStreamWatchdog()
  try {
-    await sendMessage(first.text, first.skill, true, first.parts)
+    await sendMessage(first.text, first.skill, true, first.parts, undefined, first.conversationId)
    return true
  } catch (e) {
-    // force_send 也失败:回填队首保消息不丢,复位 streaming 让 UI 可继续操作
-    state.queue.unshift({
+    // force_send 也失败:回填该会话队首保消息不丢,复位 streaming 让 UI 可继续操作
+    const reIdx = targetConv ? state.queue.findIndex(q => q.conversationId === targetConv) : 0
+    state.queue.splice(reIdx === -1 ? state.queue.length : reIdx, 0, {
      text: first.text,
      skill: first.skill,
      enqueuedAt: first.enqueuedAt,
      parts: first.parts,
+      conversationId: first.conversationId,
    })
-    setStreaming(false, { convId: state.activeConversationId, reason: 'tryForceSend-fail' })
+    setStreaming(false, { convId: targetConv ?? state.activeConversationId, reason: 'tryForceSend-fail' })
    clearStreamWatchdog()
    console.error('[AI] tryForceSend force_send 失败,消息已回填队首:', e)
    return false
@@ -388,52 +409,79 @@ export async function tryForceSend(confirmFn: (msg: string) => Promise<boolean>)

 /** 批量审批已拆分到 useAiApproval.ts(fe-arch P0-1) */

-/** 取消队列中指定位置的消息 */
-function cancelQueued(index: number) {
-  state.queue.splice(index, 1)
+/**
+ * 把「当前活跃会话视图内的队列下标」映射到全局队列真实下标。
+ *
+ * 队列区在 AiChat.vue 按 activeConversationId 过滤渲染(activeQueue),UI 上的编辑/删除/立即发送
+ * 传的是过滤视图内的 idx。此处按当前活跃会话在全局队列中定位真实下标;越界(项已被并发 drain
+ * 移除等)返 -1,调用方据此 no-op。
+ */
+function activeQueueRealIndex(idx: number): number {
+  const targetConv = state.activeConversationId
+  if (!targetConv) return -1
+  let seen = -1
+  for (let i = 0; i < state.queue.length; i++) {
+    if (state.queue[i].conversationId === targetConv) {
+      seen++
+      if (seen === idx) return i
+    }
+  }
+  return -1
 }

-/** 清空整个待发送队列 */
-function clearQueue() {
-  state.queue = []
+/** 取消队列中指定位置的消息(仅当前活跃会话视图内的队列项) */
+function cancelQueued(index: number) {
+  const realIdx = activeQueueRealIndex(index)
+  if (realIdx === -1) return
+  state.queue.splice(realIdx, 1)
+}
+
+/** 清空待发送队列(未传 convId 时仅清当前活跃会话;空 active 则全清兜底) */
+function clearQueue(convId?: string | null) {
+  const targetConv = convId ?? state.activeConversationId
+  if (targetConv) {
+    state.queue = state.queue.filter(q => q.conversationId !== targetConv)
+  } else {
+    state.queue = []
+  }
 }

 /**
- * UX-260616-06: 编辑队列项的 text(决策只编 text)。
+ * 编辑队列项的 text(决策只编 text)。
 *
 * 设计:
 * - 只改 text,skill 编辑态不暴露(skill 来自发送时技能联想,编辑态改 skill 复杂化交互无收益)。
 * - 边界:index 越界 / newText 空白 → 直接忽略(no-op),不抛错(UI 不会触发,防御)。
- * - queue item 类型 { text, skill?, enqueuedAt } 不改。
 */
 function editQueued(index: number, newText: string) {
-  if (index < 0 || index >= state.queue.length) return
+  const realIdx = activeQueueRealIndex(index)
+  if (realIdx === -1) return
  const trimmed = newText.trim()
  if (!trimmed) return
-  state.queue[index].text = trimmed
+  state.queue[realIdx].text = trimmed
 }

 /**
- * UX-260616-07: 队列项立即发送(决策 a:插队=打断当前+发本条,复用 UX-05 stop 链路)。
+ * 队列项立即发送(插队=打断当前+发本条,复用停止链路)。
 *
- * 流程(顺序关键):
- * 1. 先 splice 出该项(记下 {text, skill})——必须在 stopChat 之前,
- *    否则 stopChat→AiCompleted→drainQueue 续发时该项还在队列致重复发。
- * 2. 调 stopChat() 打断当前生成(stopChat UX-05 后已不清队列,故 splice 步骤前置必要)。
- * 3. 直接 sendMessage(splicedItem.text, skill) 立即发这条(不等 drainQueue 轮到)。
- *    当前未完成回复已由 stop 截断保留(agentic/mod.rs save_conversation),无需额外处理。
+ * 顺序关键:
+ * 1. 先 splice 出该项——必须在 stopChat 之前,否则 stopChat→AiCompleted→drainQueue 续发时
+ *    该项还在队列致重复发。
+ * 2. 调 stopChat() 打断当前生成(停止后已不清队列,故 splice 步骤前置必要)。
+ * 3. 直接 sendMessage(..., forceMode=true) 立即发这条(不等 drainQueue 轮到)。
+ *    当前未完成回复已由停止截断保留,无需额外处理。
 */
 async function sendQueuedNow(index: number) {
-  if (index < 0 || index >= state.queue.length) return
-  const spliced = state.queue.splice(index, 1)[0]
+  const realIdx = activeQueueRealIndex(index)
+  if (realIdx === -1) return
+  const spliced = state.queue.splice(realIdx, 1)[0]
  await stopChat()
-  // B-260617-01: forceMode=true 跳过 L1 预检(ai_is_generating)直走 force_send。
-  // stopChat() 仅 await stop IPC 发出(置 stop_flag=true),不等后端 loop 跑到
-  // agentic/mod.rs guard 检测点+guard.reset()(generating 才复位)。紧接 sendMessage
-  // 命中 L1 的 backendGenerating(后端真值仍 true)→ spliced 被入队而非立即发,
-  // 与"立即发送"语义不符。force_send(commands/chat.rs ai_chat_force_send)原子复位 generating=false
-  // 再发,无竞态窗口;stopChat 的 stop_flag 让旧 loop 在下个检测点退出,不冲突。
-  await sendMessage(spliced.text, spliced.skill, true, spliced.parts)
+  // forceMode=true 跳过 L1 预检(后端 generating 判定)直走 force_send:stopChat 仅发出停止信号
+  // (置 stop_flag),不等后端 loop 跑到检测点复位 generating,紧接的普通发送会命中 L1 的
+  // backendGenerating(后端真值仍 true)→ spliced 被入队而非立即发,与"立即发送"语义不符。
+  // force_send 原子复位 generating=false 再发,无竞态窗口;stop_flag 让旧 loop 在下个检测点退出。
+  // 显式传 spliced 所属会话 id(当前活跃视图内操作,即当前会话)。
+  await sendMessage(spliced.text, spliced.skill, true, spliced.parts, undefined, spliced.conversationId)
 }

 /** 停止当前生成：本地先复位 streaming，再发停止信号。