magic-agent 2.4.2 → 2.6.0

package/client-ui/shared/conv/03-chat-message.js

@@ -59,17 +59,70 @@ function qaNearBottom(s){ return !!s && (s.scrollHeight - s.scrollTop - s.client
  *     下一帧才滚），那一刻判 nearBottom 恒为真 → 手势永远关不掉闸，手机上还是会被拽回。
  *     反过来也不能不判：内容不足一屏时（没得滚）若把手势当真，一次误触就再也不跟随新内容了。 */
 function qaCanScroll(s){ return !!s && s.scrollHeight > s.clientHeight + 4; }
+/** 贴底（「跟着新内容下移到最新」）的**唯一出口** —— 本文件每一处落笔后都调它。
+ *  三道闸，逐条理由：
+ *   ① `qaPaintBg` —— 后台 run 在画它自己的 holder（不在屏幕上），不许拽动可见画布；
+ *   ② `qaUserAway` —— 用户上滚看历史了（qaScrollGateBind 维护），别抢他的滚动位置；
+ *   ③ rAF 合并 —— 见下。
+ *  ⚠️ 为什么必须合并（2026-10-25 实测）：流式增量是**每事件**一贴，而 `scrollHeight` 读一次
+ *     就是一次强制布局 —— 画布长起来之后每笔约 2ms：回放 5000 条文本事件实测 **11.8s**，
+ *     同一批不贴底只要 1.4s。长会话（实测有 95k 事件的）会把「加载慢」放大成分钟级卡死，
+ *     正是用户 2026-10-20 报过的「移动端加载也很慢」那一类。合并之后：
+ *       · 同步循环（历史回放 / 前插翻页）里 rAF 根本不会触发 → 只注册一帧一次，
+ *         中间成本归零，循环结束那一帧补一次贴底，终态与逐条贴完全一致；
+ *       · 直播路径最多「下一帧贴底」（≤16ms），肉眼无差，突发批量也不会每笔都重排。
+ *  ⚠️ 执行前再查一次 `qaUserAway`：安排之后、帧到来之前用户滚上去了 → 这次作废
+ *     （他的意图比这一笔增量新）。 */
+let qaScrollRaf = 0;
 function qaScrollIntoView(){
-  if(qaPaintBg) return;                          // 后台 run 的增量不许拽动前台画布（见 qaPaintBg）
-  if(qaUserAway) return;                         // 用户跳上去看历史了，别抢他的滚动位置
+  if(qaPaintBg) return;                          // ① 后台 run 的增量不许拽动前台画布（见 qaPaintBg）
+  if(qaUserAway) return;                         // ② 用户跳上去看历史了，别抢他的滚动位置
   const s = $("#qa-stream"); if(!s) return;
-  s.scrollTop = s.scrollHeight;   // 卡片固定撑满、自身即滚动容器（滚动条已隐藏），永远贴底
+  if(qaScrollRaf) return;                        // ③ 本帧已安排过一次（同步循环里后续调用全走这条）
+  qaScrollRaf = requestAnimationFrame(()=>{
+    qaScrollRaf = 0;
+    if(qaUserAway) return;                       // 安排后用户滚上去看历史了 → 作废
+    const el = $("#qa-stream"); if(!el) return;
+    el.scrollTop = el.scrollHeight;   // 卡片固定撑满、自身即滚动容器（滚动条已隐藏），永远贴底
+  });
 }
 /** 切会话时把「用户离开底部」复位（2026-10-20）：`qaUserAway` 是**画布级**状态，而画布只有一份。
  *  在 A 里滚上去看历史，再切到 B，若不复位，B 打开时就停在顶部（看的是旧内容中间），
  *  而不是它最新的那条消息。宿主切换会话时调用（见 qaTaskSwitch）。 */
 function qaScrollReset(){ qaUserAway = false; }
 
+/** 打开历史会话后的「兜底贴底」（2026-10-25 用户：「历史会话也应该默认到最底部」）。
+ *  各宿主回放结束那次同步贴底（loadHistory / qaRailReplay 里的 scrollTop=scrollHeight）
+ *  发生在**布局完成之前**：回放里的截图缩略图、markdown 字体在贴底之后才加载完，
+ *  把 scrollHeight 撑大 → 画布停在半空。手机上图片加载慢，几乎必现（同一张图
+ *  PC 网页有缓存所以看着正常）。
+ *  三重兜底，全部尊重 `qaUserAway`（用户已经自己往上翻了就别拽回来）：
+ *    ① rAF 下一帧 —— 同步回放结束后布局刚稳的那一刻；
+ *    ② 300ms 定时 —— 缩略图大多在这前后到位；
+ *    ③ 1.5s 窗口内的 img load 各再贴一次（慢图；窗口过期后顺手摘监听）。
+ *  ⚠️ 重复调用先摘上一个 img 监听（#qa-stream 节点常驻不替换、只换 innerHTML，
+ *     不摘会随切换次数累积）；置 qaUserAway=false 已含 qaScrollReset 的语义。 */
+let qaHistStickLsn = null;
+function qaHistoryStickBottom(){
+  qaUserAway = false;
+  const once = ()=>{
+    if(qaUserAway) return;
+    const s = $("#qa-stream"); if(!s) return;
+    s.scrollTop = s.scrollHeight;
+  };
+  requestAnimationFrame(once);
+  setTimeout(once, 300);
+  const s = $("#qa-stream"); if(!s) return;
+  if(qaHistStickLsn) s.removeEventListener("load", qaHistStickLsn, true);
+  const until = Date.now() + 1500;
+  qaHistStickLsn = function(e){
+    if(!e.target || e.target.tagName !== "IMG") return;
+    if(Date.now() > until){ s.removeEventListener("load", qaHistStickLsn, true); qaHistStickLsn = null; return; }
+    once();
+  };
+  s.addEventListener("load", qaHistStickLsn, true);
+}
+
 /* ---------- 快速回话跳转（2026-10-12 用户：「增加一个快速跳转回话的功能 用户1个问题1个圆点」）----------
    对话流左侧一条竖排圆点轨：**一个用户提问一枚圆点** —— 数的就是流里那些 `.qa-msg.qa-mine`
    （自己说的话），引擎回答 / 机器侧 trace / 收尾行都不算，所以圆点数 = 你问过几轮。
@@ -348,9 +401,23 @@ function qaBotAvatarHtml(){
    前缀只是 App / CLI 内部区分自定义端点的约定，对用户是噪点；`--engines` 的清单早就
    剥过了（agent.StripCustomLocalPrefix），但**会话登记表 / start 事件 / 引擎 result 行**
    里仍是完整 id —— 那些是传给 `-m` 与落库的值，不能改，只能在渲染这一层剥。
-   ⚠️ 只用于显示：`-m`、任务落库、payload 一律仍用完整 id（见 codebuddyCore.modelArg）。 */
-function qaModelText(id){
-  return String(id == null ? "" : id).trim().replace(/^custom-local:/, "");
+   ⚠️ 只用于显示：`-m`、任务落库、payload 一律仍用完整 id（见 codebuddyCore.modelArg）。
+   dsh 的 id 是 `route/model`（路由前缀只在 dsh 配置内部有区分意义），显示时只留后面的
+   模型名 —— `-m` 仍用完整 id（见 dsh.go::dshResolveRoute）。engine 省略时不做这一步，
+   因为调用方可能拿它当查表键（倍率 / 标签表都用完整 id）。 */
+function qaModelText(id, engine){
+  const s = String(id == null ? "" : id).trim().replace(/^custom-local:/, "");
+  if(String(engine == null ? "" : engine).trim().toLowerCase() === "dsh") return s.replace(/^[^/]+\//, "");
+  return s;
+}
+/* 模型 id → 归属路由（dsh 的 `route/model` 里那段 route；其它引擎 / 不带斜杠 → 空串）。
+   只给**选择器**做两层显示用：同名模型可能挂在多条路由下（modelverse 与 volcengine
+   都有 deepseek-v4.1-flash-1017），单看末段分不出是哪一个。消息里的小标仍只显示模型名。 */
+function qaModelRoute(id, engine){
+  if(String(engine == null ? "" : engine).trim().toLowerCase() !== "dsh") return "";
+  const s = String(id == null ? "" : id).trim();
+  const i = s.indexOf("/");
+  return i > 0 ? s.slice(0, i) : "";
 }
 /* 模型 → **展示用倍率**（`"×0.34"`）；没有倍率（引擎不给数据 / 该模型不计费）→ `""`。
    数据来自 `--engines` 的 `model_credits`（见 internal/cli/root.go）：键与 `models[]` 同形，
@@ -377,6 +444,86 @@ function qaModelCredit(engines, engine, id){
   for(const e of list){ const c = read(e); if(c) return c; }
   return "";
 }
+/* 模型 → **供应商展示名**（如 `"Volcengine"`）；没有数据 → `""`。
+   数据来自 `--engines` 的 `model_vendors`（见 internal/cli/root.go，目前只有 codebuddy 系：
+   取自它自己 models.json 的 vendor 字段）。只用于**选择器第二行**（与 dsh 的路由同一位置、
+   同一视觉），不参与 -m / 落库。键与 models[] 同形（已剥 custom-local:）。
+   PC 宿主可能归一成 camelCase，两种拼写都认。
+   ⚠️ 只给 models.json 里登记了 vendor 的自定义模型显示；codebuddy 官方模型没有厂商字段
+   （缓存里只有内部路由码），按用户要求不推断、不显示第二行。 */
+function qaModelVendor(engines, engine, id){
+  const key = qaModelText(id);
+  if(!key) return "";
+  const list = Array.isArray(engines) ? engines : [];
+  const read = (e)=>{
+    const map = (e && (e.model_vendors || e.modelVendors)) || null;
+    if(!map || typeof map !== "object") return "";
+    return String(map[key] == null ? "" : map[key]).trim();
+  };
+  if(engine){
+    for(const e of list) if(e && e.engine === engine) return read(e);
+    return "";
+  }
+  for(const e of list){ const v = read(e); if(v) return v; }
+  return "";
+}
+/* 选择器里的模型顺序（**仅展示层**）：
+   ① `auto` 固定第一；
+   ② 官方模型在前、自定义模型（有 model_vendors 的）整体在后；
+   ③ 组内按积分倍率升序（便宜的在前），没有倍率的排在组尾；同倍率保持原顺序。 */
+function qaModelsOrdered(engines, engine, models){
+  const list = Array.isArray(models) ? models.slice() : [];
+  if(list.length < 2) return list;
+  const idx = new Map();
+  list.forEach(function(m, i){ idx.set(m, i); });
+  const creditOf = function(id){
+    const raw = qaModelCredit(engines, engine, id).replace(/^×/, "");
+    const n = parseFloat(raw);
+    return isNaN(n) ? Infinity : n;
+  };
+  list.sort(function(a, b){
+    if(a === "auto") return -1;
+    if(b === "auto") return 1;
+    const ca = !!qaModelVendor(engines, engine, a);
+    const cb = !!qaModelVendor(engines, engine, b);
+    if(ca !== cb) return ca ? 1 : -1;
+    const x = creditOf(a), y = creditOf(b);
+    if(x !== y){
+      if(x === Infinity) return 1;
+      if(y === Infinity) return -1;
+      return x - y;
+    }
+    return idx.get(a) - idx.get(b);
+  });
+  return list;
+}
+/* 模型 → **套餐额度快照**（如 `"5h 98% · 周 53%"`）；没有数据 → `""`。
+   数据来自 `--engines` 的 `model_quota`（model id → `{interval_left, weekly_left}`，
+   键与 `models[]` 同形）+ `credit_suffix`（单位，缺省 `%`）。目前只有 llm 的 MiniMax
+   模型有：同一账号一份快照，core 把它挂到每个走该端点的模型上；别的供应商模型没有。
+   PC 宿主的 glue 可能把字段归一成 camelCase，两种拼写这里都认。 */
+function qaModelQuota(engines, engine, id){
+  const key = qaModelText(id);
+  if(!key) return "";
+  const list = Array.isArray(engines) ? engines : [];
+  for(const e of list){
+    if(!e || (engine && e.engine !== engine)) continue;
+    const map = e.model_quota || e.modelQuota || null;
+    if(!map || typeof map !== "object") continue;
+    const q = map[key];
+    if(!q || typeof q !== "object") continue;
+    const read = (a, b)=>String((a != null ? a : (b == null ? "" : b))).trim();
+    const iv = read(q.interval_left, q.intervalLeft);
+    const wk = read(q.weekly_left, q.weeklyLeft);
+    if(!iv && !wk) continue;
+    const unit = e.credit_suffix || e.creditSuffix || "%";
+    const parts = [];
+    if(iv) parts.push("5h " + iv + unit);
+    if(wk) parts.push("周 " + wk + unit);
+    return parts.join(" · ");
+  }
+  return "";
+}
 /* **引擎名小标**（2026-09-22 用户：「头像旁边显示引擎名字」；同日追加「名字显示的大一点
    再加上模型显示」→ 文案 = 「引擎 · 模型」，字号见 app.css M8）：左侧消息头像独占一行（见文末 M7）
    之后，头像那一行右侧空着 —— 把「这一条是哪个引擎、哪个模型说的」挂在头像右边。
@@ -394,7 +541,7 @@ function qaWhoLabel(engine, model, modelOnly){
   const nm = String(engine == null ? "" : engine).trim();
   if(!nm) return "";
   const md = String(model == null ? "" : model).trim();
-  const mName = md ? qaModelName(qaModelText(md), nm) : "";
+  const mName = md ? qaModelName(qaModelText(md, nm), nm) : "";
   if(modelOnly) return mName || nm;
   return mName ? `${nm} · ${mName}` : nm;
 }
@@ -505,9 +652,16 @@ function qaRenderMine(text, atts, opts){
     const row = document.createElement("div");
     row.className = "qa-atts";
     atts.forEach((a)=>{
-      const u = attThumbUrl(a);
+      /* 实时附件（remoteUrl/objectUrl 在）走 attThumbUrl，行为与以前逐像素一致；
+         历史附件只有 {path, mime} —— 走 attHistUrl / attHistName 这条取址链
+         （见 19-attachments 的「历史附件」段），否则点开历史会话参考图整排消失。 */
+      const live = !!(a && (a.remoteUrl || a.objectUrl));
+      const u = live ? attThumbUrl(a) : attHistUrl(a);
       if(!u) return;
-      row.appendChild(qaThumbNode(u, (a.name || "截图") + " · " + attSize(a.size), a.name || "截图"));
+      if(!live && !attHistIsImage(a)) return;   // 历史档的非图附件没有缩略形态，不画破图
+      const nm = attHistName(a);
+      const sz = Number(a && a.size) > 0 ? " · " + attSize(Number(a.size)) : "";
+      row.appendChild(qaThumbNode(u, nm + sz, nm));
     });
     if(row.children.length) host.appendChild(row);
   }
@@ -598,6 +752,8 @@ function qaRenderAnswer(host){
      否则这一轮里后起的机器块会落错地方（旧实现预置了空的思考块/工具组，恰好掩盖了这点）。 */
   const machineHost = ()=> (div.__traceWrap && div.__traceWrap.querySelector(".qa-bd")) || bd;
   let curThink = null, curGroup = null, curText = null;   // 当前「打开」的三类块
+  /* 本回合**最后一次**建出的思考块（含已定格的那些）——「交替推理」要往里续，见 ensureThink。 */
+  let lastThink = null;
   /* 本条消息里**建过的所有**工具组（不只当前那个）——收尾兜底要能封到「被 endToolRun 摘掉
      引用、之后又被卡片落定重新点亮」的那种组（见 settleGroups 的说明）。 */
   const groups = [];
@@ -727,7 +883,15 @@ function qaRenderAnswer(host){
         （2026-09-16 用户报障：WebSearch 点击无法展开）。用户手动开合过 → 记 data-touched。 */
   function ensureThink(){
     if(curThink) return curThink;
-    endToolRun(); sealText();                          // 换块：正文与这一段工具到此为止
+    /* ⚠️ **交替推理不能封正文**（2026-10-25 用户报障「乱显示了」）：
+       codebuddy + glm-5.3-flash 实测把思考与正文**逐字交替**吐（thinking → text →
+       thinking → text…，同一 message id、见会话日志）。原实现无条件 `sealText()`，
+       于是每个几字的 text 增量都被封成一块 → 画布上就是
+       「半句话 / 任务耗时 1 项过程 / 半句话」一路铺下来。
+       正文正在进行时思考只**旁挂**（思考块为收起态，正文继续在同一块里追加）。 */
+    if(!curText){
+      endToolRun(); sealText();                        // 换块：正文与这一段工具到此为止
+    }
     const el = document.createElement("div");
     el.className = "qa-think";
     el.hidden = true;
@@ -736,6 +900,7 @@ function qaRenderAnswer(host){
     curThink = { el, tt: el.querySelector(".tt"), dur: el.querySelector(".qa-think-dur"),
                  body: el.querySelector(".qa-think-bd"), start: 0, timer: null,
                  touched: ()=> el.dataset.touched === "1" };
+    lastThink = curThink;
     return curThink;
   }
   function thinkBegin(c){
@@ -865,7 +1030,7 @@ function qaRenderAnswer(host){
 
   const run = document.createElement("div");
   run.className = "qa-run";
-  run.innerHTML = qaRunPillHtml(`${qaEngine}${qaModel ? " · " + qaModelName(qaModelText(qaModel), qaEngine) : ""} · 生成中`);
+  run.innerHTML = qaRunPillHtml(`${qaEngine}${qaModel ? " · " + qaModelName(qaModelText(qaModel, qaEngine), qaEngine) : ""} · 生成中`);
   s.appendChild(run);
   /* ⚠️ 落笔即贴底（2026-09-23，与 qaRenderMine / qaRenderDone 同一约定）。
      为什么必须在**这一行之后**：这条应答的立身有两块 —— 气泡节点（上面那个 div）+ 这枚
@@ -1184,6 +1349,11 @@ function qaRenderAnswer(host){
   function askCard(name, qs, opts){
     const list = Array.isArray(qs) ? qs : [];
     const o = opts || {};
+    /* 待授权（kind=permission，2026-10-25）：与提问共用同一张卡，只换措辞与作答出口
+       （允许 / 拒绝 → control 的 ask_answer；见 06-ask-answer 的 qaAskMark）。
+       计划审批 ExitPlanMode 以前在界面上**什么都没有**（用户：「没看到审批」），
+       而那一轮其实正卡在 CLI 里等 control_response。 */
+    const isPerm = o.kind === "permission";
     const multi = list.length > 1 || list.some(q=>q.multiSelect);
     /* 收笔那枚「提交」钮**只在卡里有可多选的问时才画**（2026-10-10）：单选是明确的落笔，
        答满即走（见 06-ask-answer.js::qaAskAutoArm），摆一枚用不上的钮只会让人以为还差一步；
@@ -1194,26 +1364,35 @@ function qaRenderAnswer(host){
     card.title = String(o.title || "").slice(0, 600);
     /* 答案要回到哪条会话 —— 落在 **dataset** 上而不是闭包里：
        快照恢复走 `innerHTML = snapshot`，闭包随旧节点一起丢，dataset 跟着 HTML 活下来，
-       所以恢复出来的历史提问卡照样答得回去（REQ-22 锁的就是「已答态随快照恢复」）。 */
+       所以恢复出来的历史提问卡照样答得回去（REQ-22 锁的就是「已答态随快照恢复」）。
+       待授权还多两样：引擎 control_request 的 request_id（回 control_response 必须原样带回）
+       与工具名（只用于回执/排障）。 */
     if(o.sid) card.dataset.sid = String(o.sid);
     if(o.rid != null && o.rid !== "") card.dataset.rid = String(o.rid);
+    if(isPerm){
+      card.dataset.askkind = "permission";
+      if(o.requestId) card.dataset.requestId = String(o.requestId);
+      if(o.toolName) card.dataset.toolName = String(o.toolName);
+    }
     card.innerHTML = `
       <div class="qa-ask-hd">
         <span class="qa-ask-ico">${QA_ICONS.ask}</span>
         <span class="qa-ask-tag"></span>
-        <span class="qa-ask-ttl">提问 · 待回答</span>
+        <span class="qa-ask-ttl">${isPerm ? "审批 · 待确认" : "提问 · 待回答"}</span>
         <button type="button" class="qa-ask-x" title="收起这个确认框（不回答）" aria-label="收起这个确认框">×</button>
       </div>
       <div class="qa-ask-list"></div>
       <div class="qa-ask-other">
-        <input type="text" placeholder="其他：不在上面选项里就直接写，回车确认">
-        <button type="button" class="qa-ask-go">确认</button>
+        <input type="text" placeholder="${isPerm ? "不同意就说说要改什么，回车 = 拒绝并提交意见" : "其他：不在上面选项里就直接写，回车确认"}">
+        <button type="button" class="qa-ask-go">${isPerm ? "拒绝并说明" : "确认"}</button>
       </div>
       <div class="qa-ask-ft"${multi ? "" : " hidden"}>
         ${needSubmit ? '<button type="button" class="qa-ask-sub" disabled>提交</button>' : ""}
-        <span class="qa-ask-hint">${needSubmit
-          ? (list.length > 1 ? "共 " + list.length + " 问 · 可多选，勾完自动提交（也可点提交）" : "可多选，勾完自动提交（也可点提交）")
-          : "共 " + list.length + " 问，都选完自动提交"}</span>
+        <span class="qa-ask-hint">${isPerm
+          ? "点「允许」或「拒绝」，选完自动提交"
+          : (needSubmit
+            ? (list.length > 1 ? "共 " + list.length + " 问 · 可多选，勾完自动提交（也可点提交）" : "可多选，勾完自动提交（也可点提交）")
+            : "共 " + list.length + " 问，都选完自动提交")}</span>
       </div>
       <div class="qa-ask-ans" hidden><span class="k">你的回答</span><span class="v"></span></div>`;
     /* ⚠️ 2026-09-22 审美修订：这枚标签原来**直接把引擎的工具名画在卡头上**
@@ -1222,8 +1401,17 @@ function qaRenderAnswer(host){
        工具名降级进 title（排障时鼠标一悬停仍能看到是哪个工具）。 */
     const tagEl = card.querySelector(".qa-ask-tag");
     if(tagEl){
-      tagEl.textContent = "需要你确认";
-      tagEl.title = "引擎提问工具：" + String(name || "AskUserQuestion");
+      tagEl.textContent = isPerm ? "需要你审批" : "需要你确认";
+      tagEl.title = (isPerm ? "引擎审批工具：" : "引擎提问工具：") + String(name || "AskUserQuestion");
+    }
+    /* 待授权的 × 要如实说清后果：引擎正阻塞等这一裁决，收起卡 = 这一轮会一直等到超时
+       （或用户点停止）。提问卡没这个语义（模型问完通常自己往下走了）。 */
+    if(isPerm){
+      const x = card.querySelector(".qa-ask-x");
+      if(x){
+        x.title = "收起（不回答：这一轮会继续等，直到你点停止或超时）";
+        x.setAttribute("aria-label", "收起这个审批卡（不回答）");
+      }
     }
     const listEl = card.querySelector(".qa-ask-list");
     list.forEach((q, qi)=>{
@@ -1276,7 +1464,7 @@ function qaRenderAnswer(host){
       done(){
         if(!qaAskAnswered(card)){
           const ttl = card.querySelector(".qa-ask-ttl");
-          if(ttl) ttl.textContent = "提问 · 待回答";
+          if(ttl) ttl.textContent = isPerm ? "审批 · 待确认" : "提问 · 待回答";
         }
         settled = true;
       qaScrollIntoView();
@@ -1571,12 +1759,35 @@ function qaRenderAnswer(host){
     endThinking(){ thinkEnd(); },
     beginTools(){ groupBegin(); },
     endTools(){ groupEnd(); },
-    appendThinking(t){ const c = thinkBegin(); c.body.textContent += t; },
+    /* ⚠️ 这两个流式追加出口**必须贴底**（2026-10-25 用户报障：「会话运行中显示不会自动跟着
+       消息返回下移到底端」）：本文件其余落笔处（工具卡 / 思考块开关 / 标记行 / 收尾行…）
+       每一处都跟着一句 qaScrollIntoView，唯独流式增量这两条没有 —— 组件宿主（移动端 /
+       PC 网页）的 render → kernelApply → qaStreamApply → appendText 全程就没有别的地方
+       再滚了。PC 宿主靠 qaStreamBind 在 qaStreamApply 之后自己补了一次（92-composer.js），
+       所以只有组件宿主坏掉；根因是渲染收敛进内核时，旧组件渲染器 pushItem 里那句
+       `if (state.autoFollow) scrollBottom()` 没有对应物。补在这里 = 三端一份实现都恢复。
+       「用户上滚看历史时停止下移」由 qaScrollIntoView 里的 qaUserAway 闸门负责
+       （qaScrollGateBind 维护，宿主 create / qaComposerInit 已绑）—— 闸开着才贴，
+       用户滚上去看历史时每一笔增量都直接 return，不抢他的滚动位置。 */
+    appendThinking(t){
+      /* 交替推理（见 ensureThink）：正文正在进行时，思考**续写同一枚**思考块，
+         不再每来一跳就新起一块 —— 否则收起态下会堆出一串「已深度思考」。 */
+      if(curText && lastThink && !curThink){
+        lastThink.body.textContent += t;
+        qaScrollIntoView();
+        return;
+      }
+      const c = thinkBegin(); c.body.textContent += t; qaScrollIntoView();
+    },
     appendText(t){
+      /* 正文回来了 → 正亮着的思考到此定格（不然「思考中 · 12.3s」会一直转到收尾，
+         与下面不断增长的正文同框）。块不搬走、正文块也不新起，见 ensureThink。 */
+      if(curThink) thinkEnd(curThink);
       ensureText();                            // 没有当前正文块就按到达顺序新起一块
       pending += t;
       flushClosed();
       renderTail();
+      qaScrollIntoView();                     // 流式增量贴底（闸门见上面的说明）
     },
     /** 图片块：KindImage / 原生 image 块 → data URI 直接上正文区。
      *  图算**正文的一部分**（不是过程块）：归到当前正文块、插在打字预览（.qa-tail）之前 ——
@@ -1727,11 +1938,18 @@ function qaDurText(ms){
  *  给了就在状态语后面拼一段「· 总耗时 7m 14s」；不给（拿不到起点 / 老调用方）只写状态语。
  *  ⚠️ 与引擎自报的 `latency_ms` 不是一回事：那个只算引擎自己那一跑，不含排队与冷启动，
  *     而且引擎不给就没有 —— 收尾行要的是「这一轮一共花了多久」，所以用墙上时钟自己算。 */
-function qaRenderDone(ok, label, host, elapsedMs){
+function qaRenderDone(ok, label, host, elapsedMs, detail){
   // host = 这一轮的落笔处（见 qaRunHost）：后台跑的收尾行要落进它自己的画布，
   // 不能写死 #qa-stream —— 否则「切走那条跑完了」会在**当前显示的**会话里凭空多出一行收尾。
   const s = host || $("#qa-stream"); if(!s) return;
   const t = qaDurText(elapsedMs);
+  // 失败终态：落成一张**设计过的错误卡**（见 29-msg-variants 的 qaErrorCardNode），
+  // 而不是原来那行等宽灰字。成功 / 被停仍走下面那行轻量收尾（它们不需要卡片）。
+  if(ok === false){
+    s.appendChild(qaErrorCardNode({ label: label, detail: detail, elapsedMs: t }));
+    qaScrollIntoView();
+    return;
+  }
   const d = document.createElement("div");
   d.className = "qa-done" + (ok ? "" : " err") + " qa-pin";
   d.innerHTML = `<span class="d"></span><span></span>`;

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

@@ -171,15 +171,77 @@ function qaAskAutoArm(card){
   if(!multi){ fire(); return; }                 // 全单选：最后一问落定 = 答完，立即发
   qaAskAutoTimers.set(card, setTimeout(fire, QA_ASK_AUTO_MS));
 }
+/** 待授权的裁决出口（宿主桥 `window.desk.askApprove`，见 90-glue.js / conversation.js）。
+ *  返回 Promise<boolean>；返回 **null** = 这个宿主没有审批桥（调用方回落文本追问）。
+ *  payload：{id(会话 id), rid(本轮渲染 id), request_id, tool_name, allowed, message}。 */
+function qaAskApproveSend(card, allowed, message){
+  const reqId = String((card && card.dataset.requestId) || "");
+  if(!reqId) return null;
+  const d = (typeof window !== "undefined") ? window.desk : null;
+  const extra = (typeof window !== "undefined") ? window.__qaDeskExtra : null;
+  const fn = (d && typeof d.askApprove === "function") ? d.askApprove
+    : (extra && typeof extra.askApprove === "function") ? extra.askApprove : null;
+  if(!fn) return null;
+  const ridNum = (card.dataset.rid == null || card.dataset.rid === "") ? NaN : Number(card.dataset.rid);
+  const payload = {
+    id: card.dataset.sid || "",
+    rid: Number.isFinite(ridNum) ? ridNum : null,
+    request_id: reqId,
+    tool_name: card.dataset.toolName || "",
+    allowed: !!allowed,
+    message: String(message || ""),
+  };
+  try{
+    return Promise.resolve(fn(payload)).then((r)=> !!(r && (r.ok === undefined ? r : r.ok)), ()=> false);
+  }catch(e){
+    return Promise.resolve(false);
+  }
+}
+
 /** 标记「这一问已答」并把答案发出去。
  *  text = 真正发出去的内容（`【用户选择】…` 信封，见 qaAskText）；
  *  display = 卡上「你的回答」那一行显示什么（只有「其他」自由输入需要它：
  *  信封里的题面不适合当展示文案；不传就不显示这行，选项高亮本身已经是答案）。 */
 function qaAskMark(card, text, display){
   const t = String(text || "").trim(); if(!card || !t) return;
+  /* 待授权（kind=permission，2026-10-25）的答案不是「一段话」，而是 allowed/denied ——
+     必须走 control 的 ask_answer **原地**写回 CLI 的 control_response
+     （见 internal/cli/control.go）。当成 user 消息发进去它不会读，整轮继续挂着。
+     宿主没有审批桥（老壳 / 老服务端）时如实回落成下面的文本追问，不假装送达。 */
+  if(card.dataset.askkind === "permission"){
+    const labels = [...card.querySelectorAll(".qa-ask-opt.sel")].map(o=>o.dataset.label || "");
+    const allowed = labels.indexOf("允许") >= 0;
+    const reason = allowed ? "" : String(card.dataset.denyMessage || display || "").trim();
+    const sent = qaAskApproveSend(card, allowed, reason);
+    if(sent){
+      qaAskAutoCancel(card);
+      card.dataset.answered = "1";
+      const ttl = card.querySelector(".qa-ask-ttl");
+      if(ttl) ttl.textContent = allowed ? "审批 · 已允许" : "审批 · 已拒绝";
+      const ans = card.querySelector(".qa-ask-ans");
+      const shown = String(display == null ? (allowed ? "允许" : "拒绝") : display).trim();
+      if(ans && shown){ ans.hidden = false; ans.querySelector(".v").textContent = shown; }
+      qaAskSyncSub(card);
+      /* ⚠️ 撤卡要等「真的送到」：送不回去（本轮已结束 / 老 core 不认 ask_answer）时
+         把卡退回「待确认」让用户重试，绝不假装批准成功（AGENTS.md 的硬规则）。 */
+      sent.then((ok)=>{
+        if(!ok){
+          delete card.dataset.answered;
+          if(ttl) ttl.textContent = "审批 · 待确认";
+          qaAskSyncSub(card);
+          toast("审批没有送到引擎（这一轮可能已经结束），可以重试或点停止", true);
+          return;
+        }
+        toast(allowed ? "已提交：<b>允许</b>" : "已提交：<b>拒绝</b>", true);
+        qaAskDockRetire(card);
+      });
+      return;
+    }
+  }
   qaAskAutoCancel(card);                    // 已答 → 任何「答满即走」的计时都作废（人工点「提交」也走这里）
   card.dataset.answered = "1";
-  const ttl = card.querySelector(".qa-ask-ttl"); if(ttl) ttl.textContent = "提问 · 已回答";
+  const ttl = card.querySelector(".qa-ask-ttl");
+  if(ttl) ttl.textContent = card.dataset.askkind === "permission" ? "审批 · 已回答" : "提问 · 已回答";
   const shown = String(display == null ? "" : display).trim();
   if(shown){
     const ans = card.querySelector(".qa-ask-ans");
@@ -393,6 +455,18 @@ function qaAskPick(card, optEl){
 function qaAskFree(card, val){
   const t = String(val || "").trim();
   if(!card || !t || qaAskAnswered(card)) return;
+  /* 待授权：自由输入 = 拒绝并附上意见（「允许」就走选项，不可能靠打字表达）。
+     把「拒绝」选中，把这段文字当 reason 交给 control 的 ask_answer。 */
+  if(card.dataset.askkind === "permission"){
+    card.dataset.denyMessage = t;
+    const opts = [...card.querySelectorAll(".qa-ask-opt")];
+    opts.forEach(o=> o.classList.toggle("sel", (o.dataset.label || "") === "拒绝"));
+    qaAskSyncSub(card);
+    const qb = card.querySelector(".qa-ask-qb");
+    const q = (qb && qb.dataset.q) || "审批";
+    qaAskMark(card, "【用户选择】\n- " + q + " → 拒绝：" + t + "\n", t);
+    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/09-stream-apply.js

@@ -7,7 +7,14 @@
    ask 后到 → 由 qaStreamApplyOne 去重，不会画两张卡）。 */
 function qaAskFromEvent(ask){
   if(!ask || typeof ask !== "object") return null;
-  if(ask.kind && ask.kind !== "question") return null;     // 待授权（permission）暂不走提问卡
+  /* 待授权（kind=permission，2026-10-25）：引擎发的是
+       {"kind":"permission","tool_name":"ExitPlanMode","request_id":"perm_…","tool_input":{…}}
+     ——**没有 questions**，是一句「要不要放行」。以前这里直接 return null，
+     于是计划审批 / manual 档的工具授权在界面上**完全看不到**（用户报障原话：
+     「没看到审批」，而那一轮其实正卡在 CLI 里等 control_response）。
+     现在合成一张和提问卡同构的两选一（允许 / 拒绝），作答走 control 的 ask_answer。 */
+  if(ask.kind === "permission") return [qaAskPermissionQuestion(ask)];
+  if(ask.kind && ask.kind !== "question") return null;     // 未知 kind：不冒充提问
   const qs = Array.isArray(ask.questions) ? ask.questions : [];
   const out = qs.map(q=>({
     header: String(q.header || ""),
@@ -20,6 +27,31 @@ function qaAskFromEvent(ask){
   return out.length ? out : null;
 }
 
+/* 待授权 → 一张两选一的问题卡（结构沿用提问卡，视觉/交互零分叉）。
+   ⚠️ 选项 label 必须是「允许 / 拒绝」这两个字：06-ask-answer 的 qaAskMark 靠它决定
+   allowed，换文案（「批准」「同意」）就会被判成拒绝 —— 差别只写在 description 里。 */
+function qaAskPermissionQuestion(ask){
+  const tool = String((ask && ask.tool_name) || "");
+  if(/exitplanmode/i.test(tool)) return {
+    header: "计划审批",
+    question: "计划已写好，批准后开始执行？",
+    multiSelect: false,
+    options: [
+      { label: "允许", description: "批准这份计划，模型开始动手" },
+      { label: "拒绝", description: "先不执行，让模型继续完善计划" },
+    ],
+  };
+  return {
+    header: "工具授权",
+    question: "允许执行「" + (tool || "这个工具") + "」吗？",
+    multiSelect: false,
+    options: [
+      { label: "允许", description: "放行这一次调用" },
+      { label: "拒绝", description: "不执行，把结果告诉模型" },
+    ],
+  };
+}
+
 /* ---------- 工具结果在**画布上**的显示上限（2026-10-20）----------
    用户报「读取历史太慢」。实测一条会话的 404 条 tool_result 共 28.1MB，
    其中 30 条 >12KB 就占了 27.7MB（最大单条 1.6MB）。这些全量字串既进 `<pre>`，
@@ -108,7 +140,7 @@ function qaStreamApplyOne(ev, ctx){
       const mdl = String(ev.model || "");
       const retry = Number(ev.attempt || 0) > 0;
       if(typeof h.setRunLabel === "function"){
-        h.setRunLabel(`${eng}${mdl ? " · " + qaModelName(qaModelText(mdl), eng) : ""} · 生成中`);
+        h.setRunLabel(`${eng}${mdl ? " · " + qaModelName(qaModelText(mdl, eng), eng) : ""} · 生成中`);
       }
       /* 头像右边的「引擎 · 模型」小标同一时机跟成实际值（与胶囊同一条口径：
          界面说 A、实际跑 B 不行）。机器侧 `.qa-trace`（审查轮 / 数字分身的活动行）
@@ -167,9 +199,12 @@ function qaStreamApplyOne(ev, ctx){
          会话锚点也不会丢（README「会话 id 闭环」那条要求）。 */
       if(sid && typeof ctx.onSession === "function") ctx.onSession(sid);
       const tid = (ev.ask && ev.ask.tool_use_id) ? String(ev.ask.tool_use_id) : "";
-      /* 同一问会走两条路各报一次（tool_use 事件先到、这条后到）→ 已经画过卡的只**补寻址信息**，
-         不再画第二张。补的是卡上的 dataset.sid/rid：快照恢复后照样答得回去（见 askCard）。 */
-      const prev = tid ? ctx.tools.get(tid) : null;
+      const askKind = (ev.ask && ev.ask.kind) ? String(ev.ask.kind) : "question";
+      /* 同一问会走两条路各报一次（tool_use 事件先到、这条后到）→ 已经画过卡只**补寻址信息**，
+         不再画第二张。补的是卡上的 dataset.sid/rid：快照恢复后照样答得回去（见 askCard）。
+         ⚠️ 只对提问（question）成立：待授权（permission）前面那张工具卡是**普通工具卡**
+            （没有 bindAsk），审批必须另画一张 —— 见 qaAskFromEvent 的注释。 */
+      const prev = (askKind !== "permission" && tid) ? ctx.tools.get(tid) : null;
       if(prev && typeof prev.bindAsk === "function"){
         prev.bindAsk({ sid, rid: ctx.rid });
         break;
@@ -177,8 +212,14 @@ function qaStreamApplyOne(ev, ctx){
       const qs = qaAskFromEvent(ev.ask);
       if(qs && typeof h.askCard === "function"){
         const tc = h.askCard((ev.ask && ev.ask.tool_name) || "AskUserQuestion", qs,
-          { title: ev.text || "", sid, rid: ctx.rid });
-        if(tid) ctx.tools.set(tid, tc);
+          { title: ev.text || "", sid, rid: ctx.rid,
+            kind: askKind,
+            requestId: (ev.ask && ev.ask.request_id) ? String(ev.ask.request_id) : "",
+            toolName: (ev.ask && ev.ask.tool_name) ? String(ev.ask.tool_name) : "" });
+        /* ⚠️ 待授权**不登记**进 ctx.tools：那个 id 属于原本的 ExitPlanMode 工具卡，
+           工具结果要落到它头上（审批卡只负责「回答」，不参与结果配对）；
+           登记进来会把原卡的结果抢走，界面上多一张永远转圈的工具卡。 */
+        if(tid && askKind !== "permission") ctx.tools.set(tid, tc);
       }
       break;
     }
@@ -407,6 +448,21 @@ function qaStreamApplyOne(ev, ctx){
                    detail: Object.assign({}, ev, { kind: "notice" }), status: ev.status || "" });
       else if(typeof h.note === "function") h.note(String(ev.text || ev.notice || ""));
       break;
+    /* 主备降级（KindFallback，2026-10-26）：这一轮的主引擎失败了，下面的回答是**备用**给的。
+       与 notice 同形态（标记行 + 可展开载荷），但用 sep 图标 + 「备用引擎」字样 ——
+       用户配主备就是为了「额度用尽时还能接着答」，这一行是他确认「生效了」的唯一证据。
+       `ev.fallback` 带 from/to 两端（core 的 internal/agent/fallback.go）；
+       老 core 不发这条时，这种轮次根本不会降级，不会有缺失。 */
+    case "fallback": {
+      const fb = ev.fallback || {};
+      const to = [fb.to_engine, fb.to_model].filter(Boolean).join(" · ");
+      const title = String(ev.text || ("已由备用引擎" + (to ? "「" + to + "」" : "") + "接上"));
+      if(typeof h.marker === "function")
+        h.marker({ icon: QA_V_ICONS.sep, title,
+                   detail: Object.assign({}, ev, { kind: "fallback" }), status: "备用引擎" });
+      else if(typeof h.note === "function") h.note(title);
+      break;
+    }
     /* 团队模式的任务列表（KindTasks，见 internal/team/board.go）：一条团队会话里**唯一**那张任务卡。
        快照语义 —— core 每次任务状态变化都把整份清单重发一次（`text` = {"tasks":[…]}），
        这里只做「整块换内容」：h.todoList 原地更新同一块面板（见 03-chat-message），