magic-agent 1.0.3 → 1.0.49

package/client-ui/shared/conv/06-ask-answer.js

@@ -0,0 +1,377 @@
+/* ---------- 提问卡 → 回答（AskUserQuestion 的落笔）----------
+   2026-09-18 用户：「返回了 askuserquestion，需要 ui 在对话框中增加选择显示 而不是显示这个 json」。
+   卡落在对话框里，答案也要回到对话框：点选项 = 把这一问的回答作为**追问**发给同一个会话
+   （走 qaSend 的 followup 语义、沿用 sessionId 续接，不在左栏另开一条会话）。
+
+   ⚠️ 发送时机 —— **不打断在跑的那一轮**（用户 2026-09-18 定稿「对话中不允许上一条没结束
+   直接输入下1个」；这条会话的撰写区在它自己生成中锁死）：这一轮还在跑就先把答案排进
+   qaAskQueue，等它收尾（onDone / onError / 用户点停止）或用户切回该会话时由 qaAskFlush
+   自动发出。
+   空闲时（引擎早就不等回答了 —— 非交互模式下很常见）点一下立即发出，不排队。
+   排队态在卡上已经是「已答」（选中项高亮 + 标题变「已回答」），不会让用户以为点了没反应。
+
+   ⚠️ 2026-09-30（用户：「确认框不应该显示在消息中 需要显示在对话框上」）：卡**画在哪**改了 ——
+   原来由 03-chat-message.js 的 askCard 插进**对话流**（`bd.insertBefore`），跟着消息一起滚、
+   也一起进快照；现在一律挂到 `#qa-askdock`（输入框正上方那一条）。见下面「提问卡停靠位」一节。
+   本文件上半部分（收答案 → 发回会话）**一个字没改**：停靠位只换画布位置，不动答题语义。 */
+const qaAskQueue = new Map();                  // taskId → [等着发出去的答案]（一轮里可能问好几次）
+
+/* ---------- 提问卡停靠位（2026-09-30）----------
+   用户：「确认框不应该显示在消息中 需要显示在对话框上」。
+   改前：AskUserQuestion 的卡是**对话流里的一张消息**（跟着滚动、跟着快照）；可它其实是在
+   「等用户回答」的交互件 —— 用户读到一半往下滚，卡就滑出视野了，回答入口跟着消失。
+   改后：卡一律挂 `#home-askdock` —— 对话框组件（18-askbox.js 的 askBoxMarkup）里那一条，
+   位置紧挨在 `.ag-box` 之上，**不进对话流、不进 `t.snapshot`**。
+   为什么卡要跟着会话走：卡表达的是「**这条会话**正在等回答」，切到别的会话不该看见它 ——
+   所以每张卡记自己的 taskId：当前显示的这条挂进停靠位，其余挂进**离屏缓冲**（节点不销毁，
+   切回来直接搬回去，事件委托与已勾选状态都还在，见 07-chat-stream-render.js 的委托）。
+   ⚠️ 待回答的卡**只活在内存**里：它不进快照（快照是对话流的画面），也不进 SQLite 消息表
+      （提问题本来就不是一条消息）。所以应用重启后不会残留「待回答」——这正是要的效果：
+      非交互模式下引擎问完就自己往下跑了，重启后再弹一张旧问题反而是幽灵。
+   ⚠️ 收答案的唯一出口仍是本文件上半部分的 `qaAskMark → qaAskDeliver → qaAskSend`
+      （点选项 = 把 `【用户选择】…` 作为**追问**发回这条会话）。停靠位不掺和这件事。 */
+const qaAskDockCards = new Map();     // taskId → [card,…]（按到达顺序；当前会话那批就在停靠位里）
+const qaAskDockParked = new Map();    // taskId → 离屏缓冲容器（该会话不显示时，它的卡挂这儿）
+const QA_ASKDOCK_ID = "home-askdock";  // = 会话框实例（QA_QUEUE_INSTANCE = "home"）的 `${p}-askdock`
+const qaAskDockEl = ()=> $("#" + QA_ASKDOCK_ID);
+/** 这张卡属于哪条会话：由**渲染宿主**反推（可见画布 = 当前显示的这条；后台 run 的 holder =
+ *  那条 run 的 taskId）。取不到就落到当前会话 —— 停靠位宁可挂错一条，也不能把卡丢掉。 */
+function qaAskDockTaskOf(host){
+  if(host && host.id !== "qa-stream" && typeof qaRuns !== "undefined"){
+    for(const r of qaRuns.values()) if(r.holder === host) return r.taskId || "";
+  }
+  return qaActiveId || "";
+}
+function qaAskDockBuffer(taskId){
+  let b = qaAskDockParked.get(taskId);
+  if(!b){ b = document.createElement("div"); b.hidden = true; qaAskDockParked.set(taskId, b); }
+  return b;
+}
+/** 搬移的**唯一**出口：当前这条的卡全部在停靠位，其余收回各自的离屏缓冲，顺手按有无卡切显隐。
+ *  新卡到达 / 切会话 / 删会话都走它 —— 三处各写一份搬移逻辑必然会漂移。 */
+function qaAskDockSync(taskId){
+  const id = taskId == null ? (qaActiveId || "") : taskId;
+  const dock = qaAskDockEl();
+  qaAskDockCards.forEach((list, tid)=>{
+    const host = (dock && tid === id) ? dock : qaAskDockBuffer(tid);
+    list.forEach(c=>{ if(c.parentNode !== host) host.appendChild(c); });
+  });
+  if(dock) dock.hidden = !((qaAskDockCards.get(id) || []).length);
+}
+/** 新卡落位（askCard 调）。 */
+function qaAskDockAdd(card, taskId){
+  if(!card) return;
+  const id = taskId == null ? (qaActiveId || "") : taskId;
+  const list = qaAskDockCards.get(id) || [];
+  if(!list.includes(card)) list.push(card);
+  qaAskDockCards.set(id, list);
+  qaAskDockSync(id);
+}
+/** 撤下一张卡（答完自动撤 / 用户点 × 主动撤）：摘 DOM + 出登记表，空了就清掉这条会话的座位。 */
+function qaAskDockDrop(card){
+  if(!card) return;
+  qaAskAutoCancel(card);        // 卡都要撤了 → 挂在这张卡上的「答满即走」计时一并作废
+  /* ⚠️ 认领标志用 **null** 而不是空串：`qaActiveId` 可能还没有（新会话 / 预览态没点过任何会话），
+     那时 taskId 就是 ""，用 `if(!touched) return` 判「没认领」会把这种卡的收尾整条吞掉 ——
+     卡摘了、停靠位却还亮着（空一条白框钉在输入框上方）。2026-09-30 由 verify-chat-flush 实测咬出来。 */
+  let touched = null;
+  qaAskDockCards.forEach((list, tid)=>{
+    const i = list.indexOf(card);
+    if(i >= 0){ list.splice(i, 1); touched = tid; }
+  });
+  if(card.parentNode) card.parentNode.removeChild(card);
+  if(touched === null) return;
+  if(!(qaAskDockCards.get(touched) || []).length){
+    qaAskDockCards.delete(touched);
+    qaAskDockParked.delete(touched);           // 卡都没了，离屏缓冲也别留着
+  }
+  qaAskDockSync(qaActiveId || "");
+}
+/** 答完**稍后**再撤：留一拍让「已回答 + 你选了哪条」看得见 —— 点一下卡立刻消失会像没点上。
+ *  ⚠️ 排队态（这一轮还在跑）**不在此列**：那要等 qaAskFlush 真发出去才撤（见那两个调用点），
+ *     否则用户会以为答案没送出去。
+ *  ⚠️ 2026-10-10 用户：「回答完应该自动关闭并提交答案继续对话」——
+ *     老快照里那种「画在对话流里」的卡（停靠位机制之前存下的画面，恢复后仍由 #qa-stream 的
+ *     委托点得到）**一起撤**：答完的卡留在原地只把标题改成「已回答」，正是「不自动关闭」的样子。
+ *     撤下只动**画面**、不动对话内容 —— 答案本身早就以 `【用户选择】…` 那条消息回了会话，
+ *     历史里留下的是「用户那条消息」，不是这张提问卡（与停靠位上的卡同一口径）。
+ *     实现上不需要分叉：qaAskDockDrop 对不在名册里的卡就是「摘节点 + 直接返回」。 */
+function qaAskDockRetire(card){
+  if(!card) return;
+  if(card.dataset.retiring === "1") return;
+  card.dataset.retiring = "1";
+  setTimeout(()=>qaAskDockDrop(card), 1100);
+}
+/** 会话删了 → 它的卡一起清（不留一张永远等不到回答的幽灵卡）。 */
+function qaAskDockClear(taskId){
+  const id = taskId || ""; if(!id) return;
+  (qaAskDockCards.get(id) || []).forEach(c=>{ qaAskAutoCancel(c); if(c.parentNode) c.parentNode.removeChild(c); });
+  qaAskDockCards.delete(id);
+  qaAskDockParked.delete(id);
+  qaAskDockSync(qaActiveId || "");
+}
+
+function qaAskAnswered(card){ return !!card && card.dataset.answered === "1"; }
+/** 收这一张卡上的答案，形状与 magic-agent 的 `EncodeAskFollowUp` **逐字对齐**：
+ *      【用户选择】
+ *      - <问题原文> → <答案>
+ *  多选多个 label 用 `", "` 连接（Go 侧 askMultiSelectSep）。
+ *  为什么必须有这个前缀：答案是以**新的一条 user 消息**追加进会话的（见 agent-cli.cjs 那一节），
+ *  没有前缀模型会把它读成一条新需求；两端文案漂移就等于白答。
+ *  单问单选也不再只回一个裸标签（原先回的就是「推送到远程」四个字，模型只能靠猜）。 */
+function qaAskText(card){
+  const qbs = [...card.querySelectorAll(".qa-ask-qb")];
+  const lines = qbs.map(qb=>{
+    const labels = [...qb.querySelectorAll(".qa-ask-opt.sel")]
+      .map(o=>o.dataset.label || "").filter(Boolean);
+    if(!labels.length) return "";
+    return "- " + (qb.dataset.q || "") + " → " + labels.join(", ");
+  }).filter(Boolean);
+  return lines.length ? "【用户选择】\n" + lines.join("\n") + "\n" : "";
+}
+function qaAskAllDone(card){
+  const qbs = [...card.querySelectorAll(".qa-ask-qb")];
+  return qbs.length > 0 && qbs.every(qb=>qb.querySelector(".qa-ask-opt.sel"));
+}
+function qaAskSyncSub(card){
+  const b = card.querySelector(".qa-ask-sub");
+  if(b) b.disabled = !qaAskAllDone(card);
+  card.querySelectorAll(".qa-ask-opt").forEach(o=>
+    o.setAttribute("aria-checked", o.classList.contains("sel") ? "true" : "false"));
+}
+/* ---------- 答满即走（2026-10-10）----------
+   用户：「回答完应该自动关闭并提交答案继续对话」。
+   改前：**全是单选**的卡在最后一问落定那一刻已经会自己发（qaAskPick 里那条 qaAskAllDone 判定），
+   但**带可多选**的卡必须由用户点一下「提交」—— 用户把每一项都勾完之后，卡还杵在输入框上方
+   （只把标题改成「已回答」），看着像「点了没反应」，得自己去找那枚钮才能让对话往下走。
+   改后：卡一旦「**每一问都有选择**」就自己提交（qaAskMark → 答案走 `【用户选择】…` 回会话），
+   随后照旧自动撤下（qaAskDockRetire，留一拍让用户看见选了哪条）——「提交」不再是必经的一步。
+   ⚠️ **可多选的问留一拍**（QA_ASK_AUTO_MS）：勾第一项就发等于把第二项堵死（多选本来就允许勾好几条），
+      所以这种卡改走**计时器** —— 卡上再来任何一次点选就重新计时（用户还在挑就绝不发），
+      停手 1.5s 才把答案发出去。全是单选没有任何歧义，不等待、立即发。
+   ⚠️ 计时器挂**卡**上（WeakMap）：卡被撤下 / 被标已答 / 选择被取消 → 一律先取消计时，
+      绝不出现「卡都没了、答案还在半路」的幽灵提交。
+   ⚠️ 老快照里画在对话流里的卡走的是**同一个**出口（它是同一个 qaAskPick），不必另写一套。 */
+const QA_ASK_AUTO_MS = 1500;
+const qaAskAutoTimers = new WeakMap();
+function qaAskAutoCancel(card){
+  const t = card && qaAskAutoTimers.get(card);
+  if(t){ clearTimeout(t); qaAskAutoTimers.delete(card); }
+}
+/** 选择变了就调它：答满 → 提交（可多选的卡延后 QA_ASK_AUTO_MS，给用户接着勾的时间）。 */
+function qaAskAutoArm(card){
+  if(!card) return;
+  qaAskAutoCancel(card);
+  if(qaAskAnswered(card) || !qaAskAllDone(card)) return;
+  const fire = ()=>{
+    qaAskAutoTimers.delete(card);
+    if(!qaAskAnswered(card) && qaAskAllDone(card)) qaAskMark(card, qaAskText(card));
+  };
+  const multi = [...card.querySelectorAll(".qa-ask-qb")].some(qb=>qb.dataset.multi === "1");
+  if(!multi){ fire(); return; }                 // 全单选：最后一问落定 = 答完，立即发
+  qaAskAutoTimers.set(card, setTimeout(fire, QA_ASK_AUTO_MS));
+}
+/** 标记「这一问已答」并把答案发出去。
+ *  text = 真正发出去的内容（`【用户选择】…` 信封，见 qaAskText）；
+ *  display = 卡上「你的回答」那一行显示什么（只有「其他」自由输入需要它：
+ *  信封里的题面不适合当展示文案；不传就不显示这行，选项高亮本身已经是答案）。 */
+function qaAskMark(card, text, display){
+  const t = String(text || "").trim(); if(!card || !t) return;
+  qaAskAutoCancel(card);                    // 已答 → 任何「答满即走」的计时都作废（人工点「提交」也走这里）
+  card.dataset.answered = "1";
+  const ttl = card.querySelector(".qa-ask-ttl"); if(ttl) ttl.textContent = "提问 · 已回答";
+  const shown = String(display == null ? "" : display).trim();
+  if(shown){
+    const ans = card.querySelector(".qa-ask-ans");
+    if(ans){ ans.hidden = false; ans.querySelector(".v").textContent = shown; }
+  }
+  qaAskSyncSub(card);
+  /* sid / rid 从**卡自己**身上取（dataset，见 askCard）：这样快照恢复出来的历史卡也答得回去。
+     卡本身也一起交给投递口（`card`）—— 它决定「什么时候把停靠位上的这张卡撤下来」：
+     立即发出去 → 留一拍就撤；排队等这轮结束 → 等真发出去那一刻才撤（见 qaAskDeliver / qaAskFlush）。 */
+  qaAskDeliver(qaActiveId, t, { sid: card.dataset.sid || "", rid: card.dataset.rid || "", card });
+}
+/** 把答案交给会话：**这条会话**空闲立即发；它自己的那一轮还在跑就排队（收尾/切回时由
+ *  qaAskFlush 发出）。别的会话在跑**不拦它**（2026-09-18 晚定稿：锁只跟会话走，跨会话不互锁）。
+ *  一轮里被问了多次（多张卡）→ 按先后顺序逐条发：前一条发出后新一轮又跑起来，
+ *  后一条继续排队，等那一轮收尾再发（同一把闸门，不绕开「生成中不发下一条」）。 */
+function qaAskDeliver(taskId, text, opts){
+  const id = taskId || qaActiveId || "";
+  const o = opts || {};
+  if(qaTaskRunning(id)){
+    const q = qaAskQueue.get(id) || [];
+    q.push({ text, sid: o.sid || "", rid: o.rid || "", card: o.card || null });
+    qaAskQueue.set(id, q);
+    /* 2026-10-10 用户：「回答完应该自动关闭并提交答案继续对话」——
+       改前：排队态**故意不撤卡**（怕用户以为没点上）。可用户看到的是「每一项都答完了，
+       框子还杵在输入框上方」，于是再来点一次「提交」、或者干脆把这一轮停掉 —— 那才是真的误会。
+       改后：**答完就撤**（与空闲时同一拍），排队的痕迹改由**待发队列行**承担
+       （`已选答案 · 这一轮结束后自动发出`，见 qaMsgQueueRender）——「还没发出去」这件事
+       照样看得见，但不再占着输入框上方那块地方。 */
+    if(typeof qaMsgQueueRender === "function") qaMsgQueueRender(id);
+    toast("已选：<b>" + escHtml(qaAskQueueLine(text)) + "</b><br>这一轮结束后自动发出", true);
+    qaAskDockRetire(o.card);
+    return;
+  }
+  toast("已选：<b>" + escHtml(qaAskQueueLine(text)) + "</b>", true);
+  qaAskSend(text, o);
+  qaAskDockRetire(o.card);          // 2026-09-30：停靠位上的这张卡答完就撤（留一拍可读）
+}
+
+/** 答案的统一出口：**能追加就追加**（答案落进那条还活着的会话、引擎当下一轮处理），
+ *  追加不了就新起一轮 + `--session` 续接（老版 CLI / 会话已结束 / 没有会话 id）。
+ *  判据是「拿到 sid 且拿到 rid」：sid 来自统一 ask 事件（tool_use 那条老路没有它）——
+ *  所以老引擎自动走回落路径，行为与改造前完全一致。 */
+function qaAskSend(text, opts){
+  const o = opts || {};
+  const sid = String(o.sid || "").trim();
+  /* ⚠️ rid 从 dataset 读回来是**字符串**，而事件路由（qaRuns / bindHomeAsk 的 `qaRuns.get(ev.rid)`）
+     用的是**数字** —— 不归一化就会「qaRuns.get(1) 查不到 '1'」，追加回来的那一轮整轮被当过期
+     事件丢掉（界面表现：追加成功、却永远看不到引擎的回答）。 */
+  const ridNum = (o.rid == null || o.rid === "") ? NaN : Number(o.rid);
+  if(sid && Number.isFinite(ridNum) && window.desk && typeof window.desk.askAppend === "function"){
+    qaSend(text, { followup: true, from: "home", append: { sid, rid: ridNum } });
+    return;
+  }
+  qaSend(text, { followup: true, from: "home" });
+}
+/** 排队的答案该不该现在发：**这条会话**没有一轮在跑 + 用户正看着这条会话
+ *  （qaSend 是按 qaActiveId 落笔的，不能在别的会话的画布里替它发）。
+ *  别的会话还在跑**不拦** —— 答案发给的是空闲的这条，并行是会话之间的事。 */
+function qaAskFlush(taskId){
+  const id = taskId || "";
+  const q = qaAskQueue.get(id);
+  if(!q || !q.length || qaTaskRunning(id)) return;
+  if(id !== (qaActiveId || "")) return;
+  const item = q.shift();
+  if(!q.length) qaAskQueue.delete(id);
+  qaAskSend(item.text, { sid: item.sid, rid: item.rid });
+  qaAskDockRetire(item.card);   // 2026-09-30：排队的那张卡，等真发出去的这一刻才撤
+  /* 2026-10-10：答案发走了 → 待发队列里那一行「已选答案」同步消失（见 qaMsgQueueRender）。 */
+  if(typeof qaMsgQueueRender === "function") qaMsgQueueRender(id);
+}
+
+/* ---------- 会话排队：处理中提交的下一条 ----------
+   用户 2026-09-18：「会话处理中时 改成支持输入 但是新需求排列在会话框上面默认等待上一个
+   结束后自动提交」。
+   改前：这一轮没跑完，撰写区整块锁死（输入域 disabled + 提交钮变停止钮）—— 想追问只能干等。
+   改后：输入域照常可写（qaBusyEx 不再 disabled 它），处理中点发送 = **排进队列**：
+     · 条目渲染在**会话框上方**（#home-queue，与附件条同在 .home-entry 里），标「等待中」；
+     · 这一轮收尾（onDone / onError / 用户点停止）或用户切回这条会话时，由 qaMsgFlush
+       **自动提交队首那一条** —— 这就是用户说的「默认等待上一个结束后自动提交」。
+   ⚠️ 一次只放一条出去：每条消息都会起**新的一轮**，一次放多条 = 后一条把前一条杀掉
+      （主进程 `desk:ask` 是单会话槽）。剩下的等那一轮收尾再放 —— 队列自己就串起来了。
+   ⚠️ 提问卡答案优先：qaAskQueue 里还有没发出去的答案时先不发队列消息（那是引擎正等着的
+      回答，抢在它前面发会把这一问的上下文冲掉）。
+   ⚠️ 只在**用户正看着这条会话**时发：qaSend 是按 qaActiveId 落笔的（画布只有一份），
+      在别的会话的画布里替它发就是张冠李戴 —— 与 qaAskFlush 同一条判据。切回来即发。
+   ⚠️ 队列条目只存正文（`{ text }`）：处理中贴的图留在**附件条**上（2026-10-19 起处理中
+      贴图不再被拦，见 19-attachments 的 askAttBind），收尾后 qaMsgFlush 走 qaSend
+      （from = 本实例）时才被取走 —— 贴图与排队的那条一起发出。 */
+const qaMsgQueue = new Map();                  // taskId → [{ text }]
+/** 队列条目画在**哪只实例**上：队列跟会话走，而「会话框」= home 实例。
+ *  home2 是新建对话入口 —— 它提交的永远是**新会话**，不排队，也不该显示别人的队列。 */
+const QA_QUEUE_INSTANCE = "home";
+function qaMsgQueueRender(taskId){
+  const el = $("#" + QA_QUEUE_INSTANCE + "-queue");
+  if(!el) return;
+  const id = taskId == null ? (qaActiveId || "") : taskId;
+  // 只画「当前显示的这条会话」的队列：切到别的会话时不该看见上一条会话的待发条目
+  const showing = !!id && id === (qaActiveId || "");
+  const asks = showing ? (qaAskQueue.get(id) || []) : [];
+  const list = showing ? (qaMsgQueue.get(id) || []) : [];
+  el.hidden = !(asks.length || list.length);
+  el.innerHTML = "";
+  /* 2026-10-10：**已回答但还没发出去的答案**也画在这里（用户：「回答完应该自动关闭并提交
+     答案继续对话」）。卡答完就撤了，排队的痕迹必须另有出处 —— 就是这一行：
+     「答」字圆牌 + 「题 → 答案」摘要 + 如实写「这一轮结束后自动发出」。
+     ⚠️ 不给它 × ：这一行是那个答案**唯一的痕迹**，点掉就等于让用户把答案悄悄丢了；
+        要取消就等这一轮收尾（或停掉这一轮，答案会立刻发出）。 */
+  asks.forEach((it)=>{
+    const row = document.createElement("div");
+    row.className = "ag-q ag-q-ask";
+    row.innerHTML = `<span class="no"></span><span class="tx"></span>`
+      + `<span class="st">已选答案 · 这一轮结束后自动发出</span>`;
+    row.querySelector(".no").textContent = "答";
+    row.querySelector(".tx").textContent = qaAskQueueLine(it.text);
+    el.appendChild(row);
+  });
+  list.forEach((it, i)=>{
+    const row = document.createElement("div");
+    row.className = "ag-q";
+    row.dataset.i = String(i);
+    row.innerHTML = `<span class="no"></span><span class="tx"></span>`
+      + `<span class="st">等待中 · 上一条结束后自动发送</span>`
+      + `<button class="x" type="button" aria-label="取消这条待发消息">×</button>`;
+    row.querySelector(".no").textContent = String(i + 1);
+    row.querySelector(".tx").textContent = it.text || "";
+    /* 直接绑监听（不走 #qa-stream 事件委托）：这一行在画布**之外**，不参与快照重建，
+       每次渲染都是新节点 —— 与附件条的 × 同一套做法。 */
+    row.querySelector(".x").addEventListener("click", (e)=>{ e.stopPropagation(); qaMsgQueueDrop(id, i); });
+    el.appendChild(row);
+  });
+}
+/** 待发队列里那一行答案摘要：把 `【用户选择】\n- 题 → 答\n` 信封压成一行（那一串给引擎看的前缀
+ *  在界面上是噪声；题面 + 答案本身才是用户要核对的）。 */
+function qaAskQueueLine(text){
+  const body = String(text || "").replace(/^【用户选择】\s*/, "").trim();
+  return body.split("\n").map((s)=>s.replace(/^-\s*/, "").trim()).filter(Boolean).join(" · ");
+}
+/** 取消一条待发消息（点条目尾的 ×）：列表空了就把这条会话的队列键删掉，不留空数组。 */
+function qaMsgQueueDrop(taskId, idx){
+  const id = taskId || ""; if(!id) return;
+  const q = qaMsgQueue.get(id); if(!q || idx < 0 || idx >= q.length) return;
+  q.splice(idx, 1);
+  if(!q.length) qaMsgQueue.delete(id);
+  qaMsgQueueRender(id);
+  toast("已取消这条待发消息");
+}
+/** 处理中提交 → 入队（**不打断**在跑的那一轮）。 */
+function qaMsgEnqueue(taskId, item){
+  const id = taskId || ""; if(!id) return;
+  const q = qaMsgQueue.get(id) || [];
+  q.push({ text: String((item && item.text) || "") });
+  qaMsgQueue.set(id, q);
+  qaMsgQueueRender(id);
+  toast("已排队 · 这一轮结束后自动发送<br><b>" + escHtml((item && item.text) || "") + "</b>", true);
+}
+/** 排队的下一条该不该现在发：这条会话没有一轮在跑 + 用户正看着它 + 没有待发的提问卡答案
+ *  （见上面三条 ⚠️）。发一条即返回 —— 剩下的等这一轮收尾再来。 */
+function qaMsgFlush(taskId){
+  const id = taskId || "";
+  const q = qaMsgQueue.get(id);
+  if(!q || !q.length || qaTaskRunning(id)) return;
+  if(id !== (qaActiveId || "")) return;
+  if((qaAskQueue.get(id) || []).length) return;
+  const item = q.shift();
+  if(!q.length) qaMsgQueue.delete(id);
+  qaMsgQueueRender(id);
+  qaSend(item.text, { followup: true, from: QA_QUEUE_INSTANCE });
+}
+/** 会话删了 → 它排的队也没意义了（不留悬挂条目）。 */
+function qaMsgQueueDropFor(taskId){ qaMsgQueue.delete(taskId || ""); qaMsgQueueRender(); }
+/** 点选项：多选只勾（每勾一下都重新计时 —— 答满即走，见 qaAskAutoArm）；单选点一下即定 */
+function qaAskPick(card, optEl){
+  if(!card || !optEl || qaAskAnswered(card)) return;
+  const qb = optEl.closest(".qa-ask-qb"); if(!qb) return;
+  if(qb.dataset.multi === "1") optEl.classList.toggle("sel");
+  else {
+    qb.querySelectorAll(".qa-ask-opt").forEach(o=>o.classList.remove("sel"));
+    optEl.classList.add("sel");
+  }
+  qaAskSyncSub(card);
+  /* 2026-10-10 用户：「回答完应该自动关闭并提交答案继续对话」——答满即走（全单选立即发；
+     带可多选的卡延后一拍，给用户接着勾的时间）。撤下由 qaAskMark → qaAskDockRetire 接手。 */
+  qaAskAutoArm(card);
+}
+/** 「其他」自由输入：不在清单里的答案直接写（回车 / 点确认都走这里）。
+ *  发出去的是**同一份信封**（引擎只认 `【用户选择】` 前缀，见 qaAskText）；卡上「你的回答」
+ *  那一行显示用户写的原文（信封里的题面当展示文案太啰嗦）。 */
+function qaAskFree(card, val){
+  const t = String(val || "").trim();
+  if(!card || !t || qaAskAnswered(card)) return;
+  const qbs = [...card.querySelectorAll(".qa-ask-qb")];
+  const q = qbs.length === 1 ? (qbs[0].dataset.q || "") : "";
+  qaAskMark(card, "【用户选择】\n" + (q ? "- " + q + " → " + t : "- " + t) + "\n", t);
+}
+

package/client-ui/shared/conv/07-stream-delegation.js

@@ -0,0 +1,158 @@
+/* ---------- #qa-stream 事件委托：工具卡 / 思考条的开合 / 提问卡点选 ----------
+   为什么必须委托：快照恢复（qaTaskSwitch / qaDbLoad / 启动恢复）走的是
+   `s.innerHTML = t.snapshot` —— DOM 节点被整份重建，绑在卡片上的监听随旧节点消失。
+   表现就是「点侧栏历史任务后，WebSearch 这类工具卡点了没反应」（2026-09-16 用户报障）。
+   委托挂在容器 #qa-stream 上（它从不被替换，只换 innerHTML），历史卡片照样可开合。
+   ⚠️ 提问卡（⑤ .qa-ask）同理：恢复出来的历史提问卡也要能点选 —— 它比工具卡更怕丢监听。
+   ⚠️ 2026-09-30：提问卡**不在** #qa-stream 里了（改挂输入框上方的停靠位 #qa-askdock，
+      见 06-ask-answer.js「提问卡停靠位」）—— 所以同一份处理器**两个根都挂**：
+      #qa-stream 管对话流里的卡（工具卡 / 思考条 / 老快照恢复出来的提问卡），
+      #qa-askdock 管停靠位上那批。只挂一边的话，提问卡换了个爹就地变哑巴。
+   ⚠️ **幂等标记必须挂在根自己身上，不能用模块级变量**（2026-10-20 用户报「组内工具调用
+      点击也无法展开」）：移动端每打开一条会话都是 `destroy()` + 重新 `create()`（宿主页的
+      mountConversation），而 `#qa-stream` 是**每次新建的节点** —— 模块级 `qaStreamDelegated`
+      第一次就置真，之后每个新画布都因「已绑过」被跳过 → 那块画布上零监听，
+      组里的工具 / 思考条 / 复制按钮 / 折叠组全都点不动。 */
+function bindQaStreamDelegation(){
+  const s = $("#qa-stream");
+  if(!s) return;
+  const onAskClick = e=>{
+    /* ⑤ 提问卡右上角的 ×（2026-09-30）：卡现在停在输入框上方、会一直占着那块地方 ——
+       得给用户一个「我不回答，收起来」的出口（点 × 只撤下卡，等于放弃这一问）。 */
+    const askX = e.target.closest && e.target.closest(".qa-ask-x");
+    if(askX){
+      const c = askX.closest(".qa-ask");
+      if(c && typeof qaAskDockDrop === "function"){ qaAskDockDrop(c); toast("已收起这个确认框"); }
+      return;
+    }
+    // ⑤ 提问卡：选项 / 提交 / 「其他」确认（先于工具卡判定 —— 卡里没有 .qa-tool-head，互不干扰）
+    const askOpt = e.target.closest && e.target.closest(".qa-ask-opt");
+    if(askOpt){ const c = askOpt.closest(".qa-ask"); if(c) qaAskPick(c, askOpt); return; }
+    const askSub = e.target.closest && e.target.closest(".qa-ask-sub");
+    if(askSub){
+      const c = askSub.closest(".qa-ask");
+      if(c && !qaAskAnswered(c) && qaAskAllDone(c)) qaAskMark(c, qaAskText(c));
+      return;
+    }
+    const askGo = e.target.closest && e.target.closest(".qa-ask-go");
+    if(askGo){
+      const c = askGo.closest(".qa-ask");
+      const inp = c && c.querySelector(".qa-ask-other input");
+      if(c) qaAskFree(c, inp && inp.value);
+      return;
+    }
+    /* ③ 折叠组的开合（所有 `<details>`：段行 / 收尾大组 `.qa-turn`、回放条 `.qa-hist-step`）。
+       ⚠️ 这里**本来指望原生**：点 `<summary>` 自己就翻（03-chat-message 特意用原生 details，
+       零脚本、键盘可达、开合态写进 HTML 不怕快照重建）。
+       但 2026-10-18 用户报「工具无法点击展开」—— 手机上点了没反应。
+       排查：桌面上（新 Chromium）程序点击、鼠标、触摸都正常翻；皮肤里这些 `summary` 都设了
+       `display:flex`，而 **老 WebView / 老 Chromium 对 details/summary 上的 `display` 支持不完整**
+       （Chrome 131 才正式支持在 details/summary 上用 display，见 Chrome 官方博客
+       「More options for styling <details>」）—— 于是那台机器上原生那一下不发生了。
+       现在**自己翻**：`preventDefault()` 掉原生那一下，再手动切 `open` ——
+       原生能翻的机器上也只翻一次（先掐掉原生，再自己翻），不会翻两下回到原状。
+       选择器故意写宽（`#qa-stream` 里的 `<summary>` 都是我们自己的 disclosures；
+       正文里若出现 markdown 的 `<details>`，接管后同样「只翻一次」，不会更坏）。 */
+    const sum = e.target.closest && e.target.closest("summary");
+    if(sum && s.contains(sum)){
+      const d = sum.closest("details");
+      if(d){ e.preventDefault(); d.open = !d.open; }
+      return;
+    }
+    const toolHead = e.target.closest && e.target.closest(".qa-tool-head");
+    if(toolHead){
+      const card = toolHead.closest(".qa-tool"); if(!card) return;
+      card.dataset.touched = "1";               // 记「用户手动开合过」，自动收起让位
+      card.classList.toggle("open");
+      return;
+    }
+    /* ②③ 复制按钮（代码面板帧 / 工具明细段，2026-09-28）：
+       要复制的原文落位是**固定的** —— 面板里是 `.qa-cf-bd pre`，明细段里是 `.qa-tool-sec pre`
+       （见 29-msg-variants 的 qaCodeFrameNode / QA_COPY_BTN）。按这个约定取文本，
+       所以按钮本身不带任何 data-*，快照重建后照样能复制。
+       点完切成对勾 1.2s：原来没有反馈，用户会怀疑没复制上、连点好几次。 */
+    const cpBtn = e.target.closest && e.target.closest(".qa-cf-copy");
+    if(cpBtn){
+      const host = cpBtn.closest(".qa-cf, .qa-tool-sec");
+      const pre = host && host.querySelector("pre");
+      if(typeof qaCopyText === "function") qaCopyText(pre ? pre.textContent : "");
+      cpBtn.classList.add("copied");
+      setTimeout(()=>cpBtn.classList.remove("copied"), 1200);
+      return;
+    }
+    /* 消息操作行：复制 / 重试（2026-10-09 用户：「消息要加上复制和重试」）。
+       落位约定与代码面板复制按钮同源 —— 要复制的正文固定在 `.qa-t`（用户那条与引擎那条都是它，
+       见 03-chat-message 的两个渲染入口），所以按钮不带任何 data-*，快照重建后照样能用。
+       ⚠️ 时间轴下一条消息可能有**多块正文**（写一段 → 跑工具 → 再写一段，见 03 的块说明）——
+          复制要取**全部块**、按 DOM 顺序拼接，只取第一块会漏掉后半篇。
+       重试的判定与回退逻辑收在 qaMsgRetry（03-chat-message）里一处，这里只做转发。 */
+    const actBtn = e.target.closest && e.target.closest(".qa-act");
+    if(actBtn){
+      const msg = actBtn.closest(".qa-msg");
+      if(msg){
+        if(actBtn.classList.contains("qa-act-copy")){
+          const parts = [...msg.querySelectorAll(".qa-t")].map(el=>el.textContent || "");
+          if(typeof qaCopyText === "function") qaCopyText(parts.join("\n\n").trim());
+          actBtn.classList.add("copied");
+          setTimeout(()=>actBtn.classList.remove("copied"), 1200);
+        }else if(actBtn.classList.contains("qa-act-retry")){
+          if(typeof qaMsgRetry === "function") qaMsgRetry(msg);
+        }
+      }
+      return;
+    }
+    /* ② 单行标记行开合（图标 + 人话标题 + 状态徽章 + 可展开明细）。
+       ⚠️ 没有明细（data-tog="0"）时不可点 —— 否则点了一下什么都没有，像坏了。 */
+    const mkRow = e.target.closest && e.target.closest(".qa-mk-row");
+    if(mkRow){
+      if(mkRow.dataset.tog !== "1") return;
+      const mk = mkRow.closest(".qa-mk"); if(!mk) return;
+      mk.dataset.touched = "1";
+      mk.classList.toggle("open");
+      return;
+    }
+    const thinkTg = e.target.closest && e.target.closest(".qa-think-toggle");
+    if(thinkTg){
+      const th = thinkTg.closest(".qa-think"); if(!th) return;
+      th.dataset.touched = "1";
+      th.classList.toggle("open");
+      return;
+    }
+    const toolsTg = e.target.closest && e.target.closest(".qa-tools-toggle");
+    if(toolsTg){
+      const ts = toolsTg.closest(".qa-tools"); if(!ts) return;
+      ts.dataset.touched = "1";
+      ts.classList.toggle("open");
+      return;
+    }
+    /* ⑥ 任务列表开合：面板是应答里的一块**常驻**节点（一条应答只有一块，每次 TodoWrite
+       原地更新它的内容，见 03-chat-message 的 todoList）—— 开合态只切类，点击必须走委托，
+       理由与工具卡 / 思考条同：快照恢复（`s.innerHTML = t.snapshot`）会把节点整个重建，
+       直接绑的监听随旧节点消失（点了没反应）。 */
+    const todoTg = e.target.closest && e.target.closest(".qa-todo-toggle");
+    if(todoTg){
+      const panel = todoTg.closest(".qa-todo-panel"); if(!panel) return;
+      panel.classList.toggle("open");
+    }
+  };
+  // 「其他」行的回车确认（input 的 Enter 不会走 click；同样挂在容器上才不怕快照重建）
+  // ⚠️ 合成中（输入法选词那一敲）不算确认，见 qaImeComposing —— 这行输入框同样要吃中文。
+  const onAskKeydown = e=>{
+    if(qaImeComposing(e)) return;
+    if(e.key !== "Enter") return;
+    const inp = e.target.closest && e.target.closest(".qa-ask-other input");
+    if(!inp) return;
+    e.preventDefault();
+    const c = inp.closest(".qa-ask"); if(c) qaAskFree(c, inp.value);
+  };
+  /* 两个根都挂（见文件头 2026-09-30）：停靠位上的卡不在 #qa-stream 里，只挂一个根等于
+     让提问卡在换位置之后变成哑巴（点击无反应、回车不确认）。
+     ⚠️ 幂等按**每个根自己**判（`__qaDelegated`）：宿主每重建一次组件就是一批新节点，
+        按模块级变量判会把后来的画布整批漏掉（见文件头那条报障）。 */
+  [s, $("#" + QA_ASKDOCK_ID)].forEach(root=>{
+    if(!root || root.__qaDelegated) return;
+    root.__qaDelegated = true;
+    root.addEventListener("click", onAskClick);
+    root.addEventListener("keydown", onAskKeydown);
+  });
+}