magic-agent 2.4.3 → 2.6.3

package/client-ui/shared/conversation.js

@@ -176,6 +176,38 @@
      ⚠️ 轮廓是用 Catmull-Rom 由 15 个右半控制点算出来的三次贝塞尔（见 BOTTLE_PROFILE），
         不是手写路径 —— 手调控制点必然在肩/腹出现折角，看着像塑料件。改形去改那串点，
         别去改 BOTTLE_CAVITY 的 d。 */
+  /* 进选择器 / 参与「首个可用」判定的引擎：探测成功、**已登录**且能列出模型。
+     没登录或取不到模型清单的（如 trae、登出后的 codebuddy-ai）不出现
+     （2026-10-25 用户要求：「登录了几个账号就显示几个」）。
+     ⚠️ 「取不到模型清单」必须分两种（core --engines 的 models_source）：
+       · none   —— 引擎**本身不提供**模型选择（arkclaw 按 claw_id 绑死模型、
+                   codebuddy-gateway 用网关进程的模型）。这不是故障，引擎完全可用，
+                   右列显示「引擎默认」即可 —— 以前按 models_note 一刀切，把它一起藏了。
+       · failed —— 有动态来源但探测失败（CLI 非 0 退出等），继续隐藏。
+     老 core 没有 models_source 时，按 ErrNoModelSource 的固定文案前缀兜底。 */
+  function modelsSourceOf(en) {
+    return en.models_source || en.modelsSource || '';
+  }
+  /* 「没有模型可选」的原因，翻成人话（core 的 models_note 是英文诊断串）。
+     arkclaw / MagicAI 的模型绑在网关的 claw_id 上，codebuddy-gateway 的绑在网关进程上 ——
+     两者都不是"选不了模型就不可用"，只是模型不在这台机器上选。 */
+  function noModelChoiceHint(en) {
+    var note = String(en.models_note || en.modelsNote || '');
+    if (/claw_id/i.test(note)) return '模型由网关的 claw_id 决定';
+    if (/gateway/i.test(note)) return '模型由网关进程决定';
+    return '不指定模型，由引擎自己挑';
+  }
+  function pickableEngines(list) {
+    return (list || []).filter(function (en) {
+      if (!en || !en.ok) return false;
+      if (en.logged_in === false || en.loggedIn === false) return false;
+      var src = modelsSourceOf(en);
+      if (src === 'none') return true;
+      if (src === 'failed') return false;
+      if (/^no dynamic model source/.test(en.models_note || en.modelsNote || '')) return true;
+      return (en.models || []).length > 0 || !(en.models_note || en.modelsNote);
+    });
+  }
   var BOTTLE_VB = { w: 64, h: 104, x: 16, y: 4 };
   /* 右半轮廓（x 以 48 为中轴）：颈口 → 颈 → 肩 → 腹 → 足 → 底心 */
   var BOTTLE_PROFILE = [
@@ -376,12 +408,20 @@
     }
     /* 选择器里的「一行模型」：左名字、右倍率（`×0.34`）。
        两列布局用 CSS 的 `.pick__cr` 定宽靠右，名字过长只自己省略 —— 倍率列不跟着抖。
-       倍率为空（引擎不给数据）时只画名字，不占位、不显示「×1」这类编出来的值。 */
-    function modelRow(id, credit) {
+       倍率为空（引擎不给数据）时只画名字，不占位、不显示「×1」这类编出来的值。
+       dsh 再补第二层：路由名（同名模型可能挂在多条路由下，只给末段分不出来）。 */
+    function modelRow(id, credit, engine, quota) {
+      var frag = document.createDocumentFragment();
       var row = el('span', 'pick__crow');
-      row.appendChild(el('span', 'pick__cl', qaModelText(id)));
+      row.appendChild(el('span', 'pick__cl', qaModelText(id, engine)));
       if (credit) row.appendChild(el('span', 'pick__cr', credit));
-      return row;
+      frag.appendChild(row);
+      /* 第二行：供应商（dsh = 路由名，其余引擎 = model_vendors）与套餐额度合在一行：
+         「MiniMax · 5h 100% · 周 0%」（用户口径：和供应商在一行即可）。 */
+      var sub = qaModelRoute(id, engine) || qaModelVendor(state.engines, engine, id);
+      var extra = [sub, quota].filter(Boolean).join(" · ");
+      if (extra) frag.appendChild(el("span", "pick__cd" + (quota ? " pick__cd--credit" : ""), extra));
+      return frag;
     }
     function svgIcon(id, size) {
       var s = document.createElementNS(SVG_NS, 'svg');
@@ -407,7 +447,21 @@
     var destroyed = false;
     var state = {
       engines: opts.engines || [], engine: opts.engine || '', model: opts.model || '',
+      /* 主备（2026-10-24）：主引擎失败（额度用尽 / 单模型故障）且零产出时，core 自动
+         降级到这一对。空 = 不降级；模型为空 = 备用引擎自己的默认模型。 */
+      fallbackEngine: String(opts.fallbackEngine || '').trim(),
+      fallbackModel: String(opts.fallbackEngine ? (opts.fallbackModel || '') : '').trim(),
       permission: opts.permission || '', workspace: opts.workspace || '', attachments: [], session: opts.session || '', busy: false, askId: null,
+      /* 执行阶段（2026-10-24 用户：「状态已经显示黄色的是不是算停止了 按钮应该变回提交状态，
+         只有真的运行中状态才是停止」）—— 与 busy 是**两件事**：
+           busy  = 这条会话**占着一轮**（追问要排队、收尾要等它）；
+           phase = 这一轮**现在在干什么**：
+             idle    空闲（没有在跑，也没有在等）
+             running 引擎**真的在执行**（红色停止键 / 绿液瓶 / 绿光边框只属于它）
+             waiting 引擎停下来等用户（waiting_approval：提问 / 工具待授权 —— 黄色）
+         以前两者混在一个 busy 里，等审批时按钮也是红的「中断」—— 可引擎根本没在跑，
+         点下去只会把正等着你的一轮直接打断。 */
+      phase: 'idle',
       /* 这一轮选中的插件（2026-10-21 用户：「选择插件后 对话框中要出现一个胶囊
          然后发送后就是提示词变成要使用这个插件做什么」）。
          存的是 GET /desk/plugins 那一行**原样**（id/name/cli/usePrompt…），
@@ -477,6 +531,9 @@
          默认不配置 = 关闭：不请求 / 不画 / 历史不补 / 托管不自动跑）。 */
       suggestEngine: String(opts.suggestEngine || '').trim(),
       suggestModel: String(opts.suggestEngine ? (opts.suggestModel || '') : '').trim(),
+      /* 建议引擎的主备（2026-10-24）：主建议引擎失败时先试它，再落到 core 内置的 llm。 */
+      suggestFallbackEngine: String(opts.suggestFallbackEngine || '').trim(),
+      suggestFallbackModel: String(opts.suggestFallbackEngine ? (opts.suggestFallbackModel || '') : '').trim(),
       /* 会话托管（2026-10-23 用户：「托管模式下自动按照最佳建议提交到会话中执行」）：
          开着时每个成功收尾的轮次会把第一条（模型排序里的最佳）建议**自动发出去**。
          hostingRounds = 本次开启以来连续自动发了几轮（上限见 hostingMax，防跑飞）；
@@ -755,6 +812,18 @@
       ? function (p) { return transport.fileUrl(p); } : null);
     put('pathRead', typeof transport.pathRead === 'function'
       ? function (req) { return transport.pathRead(req); } : null);
+    /* 待授权（计划审批 / 工具授权）的裁决出口（2026-10-25）：
+       内核的审批卡点「允许 / 拒绝」时调它，必须走 control 的 ask_answer ——
+       引擎正阻塞在 control_response 上，当成新消息发进去它不读（见 internal/cli/control.go）。 */
+    put('askApprove', function (p) {
+      var req = p || {};
+      return control('ask_answer', null, {
+        request_id: req.request_id || '',
+        allowed: !!req.allowed,
+        message: req.message || '',
+        tool_name: req.tool_name || '',
+      });
+    });
   })();
 
   /* 本轮产物：与 PC 工作台 / magic-test 用**同一套**（内核 qaTurnArtsTrack，见 19-attachments.js）——
@@ -779,6 +848,15 @@
     if (el.parentNode) el.parentNode.removeChild(el);
   }
 
+  /* 事件类型两份清单（执行阶段与日志末尾定档共用，见 lastTurnInfo）：
+     · 终态 —— 这一轮到此结束。与 internal/client/service.go 的 isTerminalEvent 同口径，
+       另加 interrupted / stopped（打断 / 收工：事件流上它们先到，之后不一定再有终帧）。
+     · 执行 —— 引擎真的在吐增量；停在等（waiting）的时候由它们翻回 running。 */
+  var TERMINAL_KINDS = { turn_end: 1, turn_failed: 1, result: 1, error: 1, end: 1, interrupted: 1, stopped: 1 };
+  var EXEC_KINDS = { text: 1, thinking: 1, tool_use: 1, tool_call: 1, tool_result: 1,
+                     image: 1, notice: 1, command: 1, tasks: 1, start: 1, user: 1,
+                     answered: 1, answer_queued: 1 };
+
   function kernelApply(ev) {
     if (!ev || typeof ev !== 'object') return;
     var t = ev.type || ev.kind;
@@ -791,13 +869,32 @@
        进程退出时的 `end` 那条兜底收尾。 */
     if (t === 'turn_end' && !String(ev.text == null ? '' : ev.text).trim() && !ev.item_id && !turnHasContent(state.qa && state.qa.h)) return;
     var e = ev.type ? ev : Object.assign({}, ev, { type: t });
+    /* 待授权（计划审批 / 工具授权）是**现场**裁决：回放时那一轮 CLI 早就不等了，
+       再画一张「允许 / 拒绝」只会给用户一个点了必然失败的按钮
+       （ask_answer 找不到对应的 control_request）。提问卡不受此限 ——
+       历史里的提问点一下仍能把答案作为追问发进那条会话。 */
+    if (state.replay && t === 'ask' && e.ask && e.ask.kind === 'permission') return;
     if (t === 'start') {
-      /* 一轮真正用的引擎 / 模型（配置里的模型链会自动降级）→ 选择器跟着改口 */
-      if (e.engine) state.engine = String(e.engine);
+      /* 一轮真正用的引擎 / 模型（配置里的模型链会自动降级）→ 选择器跟着改口。
+         历史会话锁：start 里的 engine 不得改写归属（模型链降级会带新 engine），
+         锁定态只采纳 model。 */
+      if (e.engine && !engineLockReason()) state.engine = String(e.engine);
       if (e.model) state.model = String(e.model);
       syncPickers();
     }
     if (t === 'ask') { state.awaitingAnswer = true; state.qaHadAsk = true; }   // 引擎在等这一问的答案（见 MagicHost.send）
+    /* 执行阶段推进（口径与 core 自己的状态机一致：internal/cli/ask.go ——
+       ask → waiting_approval；其后任何非终帧 → 又在跑）。
+       ⚠️ 回放（state.replay）不在这里翻：回放的档位由 loadHistory 末尾按
+       lastTurnInfo().waiting 一次定死。
+       ⚠️ 终态翻 idle 后再来的迟到 EXEC 帧（收尾后才到的 tool_result / notice）
+       不会点亮任何东西：is-running 的判据是 busy && phase==='running'（见 setSendMode），
+       终态已把 busy 放开，setPhase 重画时走的是 idle 模式 —— 相位值脏一点无害。 */
+    if (!state.replay) {
+      if (t === 'ask') setPhase('waiting');
+      else if (TERMINAL_KINDS[t]) setPhase('idle');
+      else if (EXEC_KINDS[t]) setPhase('running');
+    }
     /* 画布上已经有东西了 → 撤掉那句空态说明（它只在一条都还没画时该在） */
     var em = document.getElementById('qa-stream');
     var empty = em && em.querySelector('.conv__empty');
@@ -917,9 +1014,11 @@
       whoModelOnly: true,
       onError: function (e) {
         /* 显示「根因」优先：`reason` 是 CLI 给的最内层原因（429 / 额度 / 认证），
-           `error` 是带引擎包装的完整链 —— 前 80 字常被包装词吃掉。 */
+           `error` 是带引擎包装的完整链 —— 前 80 字常被包装词吃掉。
+           把整份错误信封（e）作为 detail 传给收尾卡，卡片会取 reason 做根因、
+           取 error 做可展开的完整链。 */
         var why = String((e && e.reason) || '').trim();
-        kernelDone(false, '调用失败 · ' + (why ? why.slice(0, 200) : String((e && e.error) || '未知错误').slice(0, 80)));
+        kernelDone(false, '调用失败 · ' + (why ? why.slice(0, 200) : String((e && e.error) || '未知错误').slice(0, 80)), e);
       },
       onDone: function (e) { kernelDone(true, (e && e.stopped) ? '已停止' : '已完成'); },
     };
@@ -1029,7 +1128,10 @@
          engine 有值、model 为空 = 引擎默认（llm 会挑不思考变体，约 1-2s）；选 dsh/codebuddy
          则是它们自己的无工具 JSON 通道（实测 6-10s，用户自己承担）。 */
       engine: state.suggestEngine,
-      model: state.suggestModel
+      model: state.suggestModel,
+      /* 建议引擎的主备：core 先试这一对，再落到内置 llm。 */
+      fallbackEngine: state.suggestFallbackEngine || undefined,
+      fallbackModel: state.suggestFallbackModel || undefined
     }, { signal: ac ? ac.signal : undefined }))
       .then(function (res) {
         if (seq !== state.suggestSeq) return;     // 已经开新轮 / 换会话 / 又收尾了
@@ -1258,13 +1360,19 @@
   /** 宿主改「建议引擎」：空 = 关闭建议功能。
    *  关闭时立刻清掉建议行 / 在途请求 / 托管计时器，并暂停托管（回调宿主落盘）。
    *  开启后从**下一轮**收尾开始生成；不追着已经画过的旧轮补请求。 */
-  function setSuggestEngine(engine, model) {
+  function setSuggestEngine(engine, model, fallbackEngine, fallbackModel) {
     var next = String(engine == null ? '' : engine).trim();
     var nextModel = String(model == null ? '' : model).trim();
     if (!next) nextModel = '';            // 引擎关了就不留孤儿模型
-    if (next === state.suggestEngine && nextModel === state.suggestModel) return;
+    var nextFb = String(fallbackEngine == null ? '' : fallbackEngine).trim();
+    var nextFbModel = String(fallbackModel == null ? '' : fallbackModel).trim();
+    if (!nextFb) nextFbModel = '';
+    if (next === state.suggestEngine && nextModel === state.suggestModel
+      && nextFb === state.suggestFallbackEngine && nextFbModel === state.suggestFallbackModel) return;
     state.suggestEngine = next;
     state.suggestModel = nextModel;
+    state.suggestFallbackEngine = nextFb;
+    state.suggestFallbackModel = nextFbModel;
     clearSuggest();
     if (!next) pauseHosting('未配置建议引擎');
   }
@@ -1325,7 +1433,7 @@
 
   /** 一轮收尾（成功 / 失败 / 被停）：内核的收尾动作已经做完（收思考区 / 工具卡 / 运行胶囊），
    *  这一层只补**收尾行**（状态语 + 总耗时，取墙上时钟 —— 与掌天瓶那边同一口径）。 */
-  function kernelDone(ok, label) {
+  function kernelDone(ok, label, detail) {
     /* 销毁后迟到的终态：这一轮已经不属于任何画面了 —— 收尾行、托管判定、建议请求
        一条都不该再跑（它们会写进新实例的画布，或替新实例发下一句）。 */
     if (destroyed) return;
@@ -1353,7 +1461,7 @@
        （2026-10-20 用户截图：空块 + 「已完成 · 总耗时 1.8s」）。收尾行本身挂在线程容器上，
        不在这条消息块里，所以撤掉不丢收尾行。 */
     dropEmptyAnswer(q.h);
-    qaRenderDone(ok, label, thread(), ms);
+    qaRenderDone(ok, label, thread(), ms, detail);
     /* 只有「真的跑完了」才有下一步可取：失败 / 被停 / 回放的轮次都不问。
        请求异步进行，界面不等待 —— 结果回来再画（见 requestSuggestions）。 */
     if (ok && label !== '已停止' && !state.replay) requestSuggestions(state.lastPrompt, state.agentRaw);
@@ -1369,6 +1477,7 @@
     if (!state.replay) {
       clearWorking();
       state.busy = false;
+      state.phase = 'idle';
       state.askId = null;
       setSendMode('idle');
       /* 顺手把还挂着的那条流掐掉：让 runTurn 的 Promise 收口（否则它会一直等 end 帧）。
@@ -1431,7 +1540,7 @@
      ⚠️ 例外：这一轮**还在宿主那里排队**（beforeAsk 没 resolve）时本来就没有 askId，
         此时打断的真实含义是「别发这一轮了」。宿主用 opts.onInterrupt 认领这层语义：
         返回 true = 它已经把排队撤掉，组件不再往下走 control。 */
-  async function control(op, text) {
+  async function control(op, text, extra) {
     if (!state.askId) {
       if (op === 'interrupt' && typeof opts.onInterrupt === 'function') {
         var owned = false;
@@ -1485,8 +1594,16 @@
     try {
       var payload = { op: op, id: state.askId };
       if (text != null) payload.text = text;
+      /* 附加字段（2026-10-25）：ask_answer 要带 request_id / allowed / message / tool_name ——
+         与 core `--control` 的命令形状一致，别在这里丢字段。 */
+      if (extra && typeof extra === 'object') {
+        Object.keys(extra).forEach(function (k) {
+          if (extra[k] !== undefined && extra[k] !== null) payload[k] = extra[k];
+        });
+      }
       await transport.control(payload);
-      if (op !== 'answer') noticeItem(op === 'interrupt' ? '已请求打断' : '已请求收工');
+      if (op === 'interrupt') noticeItem('已请求打断');
+      else if (op === 'stop') noticeItem('已请求收工');
       return true;
     } catch (e) {
       noticeItem('控制失败：' + (e.message || e));
@@ -1841,7 +1958,9 @@
          而新一轮的事件也在同一张画布上，正文就重复了。也不走 stopFollow：
          它会把 busy 放开，而这里马上就要置 busy。 */
       cancelFollowQuiet();
-      state.busy = true; setSendMode('busy');
+      /* 直接赋值而不走 setPhase：上一轮迟到的 EXEC 帧可能把 phase 留在 'running'，
+         setPhase 的幂等挡板会吞掉这次重画 —— 这里必须无条件切到 busy 运行态。 */
+      state.busy = true; state.phase = 'running'; setSendMode('busy');
       var askHandle = null;                        // 本轮 transport.ask 的返回值（收尾时取消用）
       /* 串行门（beforeAsk）真正把这一轮挡住时，画布上必须看得见「排队中」——
          2026-10-21 用户：「其实在串行排队 但是没显示出来任何标识」：气泡已经画出来了，
@@ -1889,7 +2008,7 @@
         markQueued(false);
         if (gate === false) {
           clearWorking();
-          state.busy = false; state.askId = null; setSendMode('idle');
+          state.busy = false; state.phase = 'idle'; state.askId = null; setSendMode('idle');
           /* 气泡已经画在画布上了（fireTurn 先画再等门）：这一轮不会有人回答它，
              标成「已取消」比留一句悬空的话强 —— 用户至少知道它被撤了、不是还在等。 */
           markLastMineCancelled();
@@ -1921,6 +2040,11 @@
       try {
         var payload = { engine: state.engine, prompt: prompt };
         if (state.model) payload.model = state.model;
+        /* 主备：只配了备用也要带上（主引擎仍是 state.engine）。 */
+        if (state.fallbackEngine) {
+          payload.fallbackEngine = state.fallbackEngine;
+          if (state.fallbackModel) payload.fallbackModel = state.fallbackModel;
+        }
         if (state.workspace) payload.workspace = state.workspace;
         if (attPaths && attPaths.length) payload.attachments = attPaths;
         /* 空值就不传：让 core 用它自己的默认档，不替用户预设（安全语义）。 */
@@ -2048,7 +2172,7 @@
            这里只摘掉本壳自己的「运行中」指示并把状态放开 —— 别再补「完成」这类行，
            内核那条收尾行已经写了，补一条会变成画布上多一行重复的「完成」。 */
         clearWorking();
-        state.busy = false; state.askId = null; setSendMode('idle');
+        state.busy = false; state.phase = 'idle'; state.askId = null; setSendMode('idle');
         /* 只收自己那条流：收尾后用户可能已经发了新一轮，别把新一轮的钩子抹掉 */
         if (state.askHandle === askHandle) state.askHandle = null;
         if (opts.onBusy) { try { opts.onBusy(false); } catch (e) {} }
@@ -2058,6 +2182,15 @@
       }
     }
 
+    /* 执行阶段归一 + 唯一出口：phase 一变就把按钮/胶囊重画一遍。
+       busy 不动 —— 占着一轮（排队/收尾）是占着一轮，现在在跑还是在等是另一件事。 */
+    function setPhase(p) {
+      var v = p === 'running' ? 'running' : (p === 'waiting' ? 'waiting' : 'idle');
+      if (state.phase === v) return;
+      state.phase = v;
+      setSendMode(state.busy ? 'busy' : 'idle');
+    }
+
     function setSendMode(mode) {
       var b = ctx.sendBtn;
       var busy = mode === 'busy';
@@ -2067,7 +2200,12 @@
          输入框里的字一敲一删都会回调这里（见下面 input 监听）。 */
       var typed = '';
       try { typed = String(ctx.input.value || '').trim(); } catch (e) { typed = ''; }
-      var stop = busy && !typed && !state.plugin;
+      /* 2026-10-24 用户：「状态已经显示黄色的是不是算停止了 按钮应该变回提交状态，
+         只有真的运行中状态才是停止」—— 停止键只属于 phase==='running'。
+         waiting（waiting_approval：引擎停下来等确认）时按钮回到「发送」，
+         但仍占着一轮 → 有字照样排队，由 send() 的 busy 守卫拦重复。 */
+      var running = busy && state.phase === 'running';
+      var stop = running && !typed && !state.plugin;
       /* ⚠️ busy 时**不能**把它 disabled：那样点它不会派发 click，
          它就从「中断」退化成一枚按不动的图标。改指中断后，
          重复发送由 send() 自己的 state.busy 守卫拦住，不需要靠 disabled 防。 */
@@ -2076,17 +2214,19 @@
       b.innerHTML = '';
       /* 停止用方块、且比发送箭头略小（方块本身比箭头「重」，同尺寸会显得头重脚轻） */
       b.appendChild(svgIcon(stop ? 'i-stop' : 'i-up', stop ? 14 : 17));
-      b.setAttribute('aria-label', !busy ? '发送' : (stop ? '中断' : '排队发送'));
+      b.setAttribute('aria-label', !busy ? '发送' : (stop ? '中断' : (running ? '排队发送' : '发送')));
       b.title = !busy ? '发送'
-        : (stop ? '中断这一轮' : '排队发送 · 上一条处理中，结束后自动提交');
+        : (stop ? '中断这一轮'
+          : (running ? '排队发送 · 上一条处理中，结束后自动提交'
+            : '发送 · 上一轮在等你确认，现在发出的消息会先排队'));
       /* 运行态并进引擎 · 模型那枚胶囊（2026-10-20 用户：「两个胶囊合并成1个」
          →「是图中胶囊下方的生成中 应该跟胶囊合并」→「不需要文字了 用其他动画效果代替」）——
          运行态时这枚胶囊**自己**变成运行态：前面的小图标换成绿液瓶（会涨落）。
-         ⚠️ 跟着 busy 走（setSendMode 是 busy 的唯一出口：发一轮 / 收一轮 / 续传轮
-         都经过它），所以不需要另开一个状态位。
-         ⚠️ 引擎·模型的真值仍在胶囊里：降级换模型时 'start' 事件会改写它
+         ⚠️ 跟着 **phase** 走而不是 busy：等审批（黄色）时引擎没在跑，
+         绿液瓶 / 绿光边框必须熄掉，只有真执行才亮（见 state.phase 注释）。
+         引擎·模型的真值仍在胶囊里：降级换模型时 'start' 事件会改写它
          （见 kernelApply 的 'start' 分支 → syncPickers），所以不丢信息。 */
-      if (ctx.casc) ctx.casc.classList.toggle('is-running', mode === 'busy');
+      if (ctx.casc) ctx.casc.classList.toggle('is-running', running);
     }
 
     /* ══════════ 底部抽屉组件 Sheet（引擎 / 模型 / 授权共用）══════════
@@ -2096,6 +2236,8 @@
        和叠加元素盖住；现在收成一个组件：层级拉高、高度用 dvh 贴合真实可视区。 */
     var Sheet = (function () {
       var scrim = null, panel = null, bodyEl = null, titleEl = null, curAnchor = null;
+      /* 每次 open 递增：异步回调据此判断「这次打开是否还在」 */
+      var gen = 0;
       function onKey(e) { if (e.key === 'Escape') { e.preventDefault(); close(); } }
       function build() {
         scrim = el('div', 'pick-scrim');
@@ -2156,11 +2298,19 @@
       }
       function open(anchor, fn) {
         /* 同一按钮再点一次 = 收起 */
-        if (panel && curAnchor === anchor) { close(); return; }
+        if (panel && curAnchor === anchor) { close(); return null; }
         close();
+        gen++;
+        var my = gen;
         curAnchor = anchor;
         build();
         render(fn);
+        /* 返回这一次打开的手柄：异步拿到新数据时用来判断「抽屉还是同一次打开」
+           （用户可能已经关掉或换了别的抽屉，那就不该再往里画）。 */
+        return {
+          alive: function () { return panel != null && my === gen; },
+          render: function (next) { if (panel != null && my === gen) render(next); }
+        };
       }
       return { open: open, close: close, render: render };
     })();
@@ -2168,7 +2318,16 @@
     /* 引擎 · 模型：**省市联动**（左列引擎 · 右列该引擎的模型，选中实时联动切换）。
        —— 不是「下钻二级」那种一列换一列；两列同屏，像省市选择器。 */
     function openEnginePicker(anchor) {
-      Sheet.open(anchor, function (M) { engineModelCascade(M); });
+      var h = Sheet.open(anchor, function (M) { engineModelCascade(M); });
+      if (!h) return;
+      /* 额度 / 签到**不跟缓存走**：模型清单可以缓存 5 分钟（要起引擎 CLI），
+         额度不行 —— 它随用量和 key 变化（core --quotas 只读票据 + 一两条 HTTP）。
+         打开选择器时后台再取一次；数据真变了且抽屉还开着，就地重画。 */
+      var before = JSON.stringify(state.engines);
+      refreshEngines(true).then(function () {
+        if (!h.alive() || JSON.stringify(state.engines) === before) return;
+        h.render(function (M) { engineModelCascade(M); });
+      }, function () { /* 取不到就继续用旧值，不打扰用户 */ });
     }
     /* 引擎/模型**落定**（点了具体模型或「默认模型」）时通知宿主。
        宿主据此把它记成下次新建任务的默认值（移动端「我的 → 默认引擎/模型」）；
@@ -2178,10 +2337,28 @@
       if (!opts.onPick) return;
       try { opts.onPick(state.engine, state.model); } catch (e) {}
     }
+    /* 历史会话锁：会话已有归属（state.session 非空）时引擎不可换，模型照旧可换。
+       会话 id 是引擎命名空间的 —— codebuddy 开的会话拿 dsh 去续，dsh 直接报
+       「session does not exist」。state.engine 为空时不锁（无可锁对象，锁了发送
+       就没有引擎可带）。返回锁定原因文案（供 title / desc 复用），未锁返回 ''。 */
+    function engineLockReason() {
+      if (state.session && state.engine) return '这条会话由 ' + state.engine + ' 开的 · 引擎不能换，模型可以换';
+      return '';
+    }
     function engineModelCascade(M) {
       var all = state.engines || [];
-      var available = all.filter(function (x) { return x.ok; });
-      M.title('选择引擎 / 模型（' + available.length + ' / ' + all.length + '）');
+      var available = pickableEngines(all);
+      var locked = engineLockReason();
+      if (locked) {
+        /* 锁定态左列只画当前引擎这一项（置灰不可点）。当前引擎不在可用清单里
+           （探测失败等）也要画 —— 会话归属不随探测结果变。 */
+        var own = null;
+        all.forEach(function (x) { if (x.engine === state.engine) own = x; });
+        if (!own) own = { engine: state.engine, ok: true, models: [] };
+        available = [own];
+      }
+      M.title(locked ? '这条会话的引擎不能换（模型可以换）'
+        : '选择引擎 / 模型（' + available.length + ' / ' + all.length + '）');
       if (!available.length) {
         M.row({ label: '没有可用引擎', desc: 'magic-agent --engines 会给每个引擎的一键安装命令' });
         return;
@@ -2197,6 +2374,7 @@
       if (!cur) cur = available[0];
 
       function chooseEngine(en) {
+        if (engineLockReason()) return;   // 历史会话：引擎归属锁死，堵死一切绕过路径
         cur = en;
         var models = en.models || [];
         state.engine = en.engine;
@@ -2205,30 +2383,94 @@
         syncPickers();
         paint();
       }
+      /* 引擎行副标题：没模型时说清「取不到（未登录等）」还是「用引擎默认」——
+         之前一律写「引擎默认」，会把 trae 这类没登录、models 为空的引擎误写成默认可用。
+         多账号引擎（codebuddy 系）把登录的账号昵称放在最前面，一眼看出是哪个号。 */
+      function engineSubLine(en) {
+        var n = (en.models || []).length;
+        var head = n ? (n + ' 个模型') : '引擎默认';
+        return en.account ? (en.account + ' · ' + head) : head;
+      }
+      /* 每日积分领取（codebuddy 系）：点「领取」只领积分，不切换引擎。
+         成功后就地更新这一行的状态并重画，不重新探测整份引擎清单（太慢）。
+         领取结果**不弹任何提示**（2026-10-25 用户要求）：领完「领取」直接消失，
+         失败静默恢复按钮。 */
+      function claimCheckin(en) {
+        if (!transport.claimCheckin || en._claimBusy) return;
+        en._claimBusy = true;
+        paint();
+        transport.claimCheckin(en.engine).then(function (res) {
+          en._claimBusy = false;
+          if (res && res.ok) {
+            en.checkin_today = true;
+            en.checkin_credit = '';
+            if (res.credit_left) en.credit_left = res.credit_left;
+          } else if (res && res.checked_today) {
+            en.checkin_today = true;
+            en.checkin_credit = '';
+          }
+          paint();
+        }, function () {
+          en._claimBusy = false;
+          paint();
+        });
+      }
       function paint() {
         left.innerHTML = ''; right.innerHTML = '';
         available.forEach(function (en) {
           var n = (en.models || []).length;
           var b = el('button', 'pick__citem' + (en.engine === cur.engine ? ' is-on' : ''));
           b.type = 'button';
+          if (locked) b.disabled = true;   // 历史会话：引擎项置灰不可点
           b.appendChild(el('span', 'pick__cl', en.engine));
-          b.appendChild(el('span', 'pick__cd', n ? (n + ' 个模型') : '引擎默认'));
+          b.appendChild(el('span', 'pick__cd', engineSubLine(en)));
+          if (locked) b.appendChild(el('span', 'pick__cd', engineLockReason()));
+          /* 账号剩余积分（codebuddy 系才有 credit_left，见 core --engines）。
+             只显示「剩余」，总量随套餐变化、对选引擎没判据价值。
+             ⚠️ PC 宿主的 glue 会归一成 camelCase，两种拼写都认。 */
+          var creditLeft = en.credit_left || en.creditLeft;
+          var creditSuffix = en.credit_suffix || en.creditSuffix || ' 积分';
+          if (creditLeft) {
+            b.appendChild(el('span', 'pick__cd pick__cd--credit', '剩余 ' + creditLeft + creditSuffix));
+          }
+          /* 每日积分：今天没领就画「领取」；已领显示状态。点 chip 只领取，不切引擎。 */
+          var checkedToday = (typeof en.checkin_today === 'boolean') ? en.checkin_today : en.checkinToday;
+          if (checkedToday === false) {
+            var checkinCredit = en.checkin_credit || en.checkinCredit || '';
+            var chip = el('span', 'pick__cd pick__cd--credit pick__claim',
+              en._claimBusy ? '领取中…' : ('领取 ' + checkinCredit + ' 积分'));
+            chip.onclick = function (ev) {
+              if (ev) { ev.preventDefault(); ev.stopPropagation(); }
+              claimCheckin(en);
+            };
+            b.appendChild(chip);
+          }
           b.onclick = function () { chooseEngine(en); };
           left.appendChild(b);
         });
-        var models = cur.models || [];
-        var d = el('button', 'pick__citem' + (state.engine === cur.engine && !state.model ? ' is-on' : ''));
-        d.type = 'button';
-        d.appendChild(el('span', 'pick__cl', '默认模型'));
-        d.appendChild(el('span', 'pick__cd', '不传 -m，由引擎自己挑'));
-        d.onclick = function () { state.engine = cur.engine; state.model = ''; syncPickers(); notifyPick(); Sheet.close(); };
-        right.appendChild(d);
+        var models = qaModelsOrdered(state.engines, cur.engine, cur.models || []);
+        if (!models.length) {
+          /* 引擎不提供模型清单（models_source = none：arkclaw 按 claw_id 绑模型、
+             codebuddy-gateway 用网关进程的模型）。必须给一个「引擎默认」落定项 ——
+             否则左列能选中、右列却是空的，用户无从"确定"，notifyPick 也永远不触发。 */
+          var d = el('button', 'pick__citem' + (state.engine === cur.engine && !state.model ? ' is-on' : ''));
+          d.type = 'button';
+          d.appendChild(el('span', 'pick__cl', '引擎默认'));
+          d.appendChild(el('span', 'pick__cd',
+            modelsSourceOf(cur) === 'none' ? noModelChoiceHint(cur) : '不指定模型，由引擎自己挑'));
+          d.onclick = function () {
+            state.engine = cur.engine; state.model = '';
+            syncPickers(); notifyPick(); Sheet.close();
+          };
+          right.appendChild(d);
+        }
         models.forEach(function (mm) {
           var b = el('button', 'pick__citem' + (state.engine === cur.engine && state.model === mm ? ' is-on' : ''));
           b.type = 'button';
           /* 清单项显示剥离前缀后的名字（`mm` 本身是 CLI 认的完整 id，选它时原样写回）。
              倍率（`model_credits`）靠右挂在同一行：模型名再长也只挤自己，倍率列不会错位。 */
-          b.appendChild(modelRow(mm, qaModelCredit(state.engines, cur.engine, mm)));
+          b.appendChild(modelRow(mm, qaModelCredit(state.engines, cur.engine, mm), cur.engine,
+            qaModelQuota(state.engines, cur.engine, mm)));
           b.onclick = function () { state.engine = cur.engine; state.model = mm; syncPickers(); notifyPick(); Sheet.close(); };
           right.appendChild(b);
         });
@@ -2257,10 +2499,18 @@
         Object.keys(routes).forEach(function (k) {
           var r = routes[k] || {};
           var engine = String(r.engine || '').trim();
-          if (!engine) return;             // 没选引擎 = 这一类跟随主引擎（不传空对象，core 会当成显式指定）
-          var item = { engine: engine };
+          var fe = String(r.fallbackEngine || '').trim();
+          /* 主/备任一非空都要下发：只配了备用 = 主引擎跟随主引擎 + 这一路的备。 */
+          if (!engine && !fe) return;
+          var item = {};
+          if (engine) item.engine = engine;
           var model = String(r.model || '').trim();
           if (model) item.model = model;
+          if (fe) {
+            item.fallbackEngine = fe;
+            var fm = String(r.fallbackModel || '').trim();
+            if (fm) item.fallbackModel = fm;
+          }
           clean[k] = item;
         });
         if (Object.keys(clean).length) out.routes = clean;
@@ -2445,12 +2695,16 @@
         var k = events[i] && (events[i].kind || events[i].type);
         if (k === 'user') idx = i;
       }
-      var terminal = false;
+      var terminal = false, waiting = false;
       for (var j = idx + 1; j < events.length; j++) {
         var k2 = events[j] && (events[j].kind || events[j].type);
-        if (k2 === 'turn_end' || k2 === 'turn_failed' || k2 === 'result' || k2 === 'error' || k2 === 'end') { terminal = true; break; }
+        /* waiting：最后一轮停在等用户（ask：提问 / 工具待授权）。其后若又有执行帧
+           （answered 之后引擎继续跑），清掉 —— 口径与 core 的 ask.go 状态机一致。 */
+        if (k2 === 'ask') waiting = true;
+        else if (EXEC_KINDS[k2]) waiting = false;
+        if (TERMINAL_KINDS[k2]) { terminal = true; waiting = false; break; }
       }
-      return { index: idx, terminal: terminal, at: idx >= 0 ? replayAt(events[idx]) : 0 };
+      return { index: idx, terminal: terminal, waiting: waiting, at: idx >= 0 ? replayAt(events[idx]) : 0 };
     }
 
     /* 历史最后一轮能不能补建议：必须是**成功收尾**、没有待答提问卡、正文够长。
@@ -2555,6 +2809,7 @@
           if (state.askId && state.askId !== runID) return;
           clearWorking();
           state.busy = false;
+          state.phase = 'idle';
           state.askId = null;
           state.resumeT0 = 0;
           setSendMode('idle');
@@ -2625,6 +2880,7 @@
       if (!state.askId) {
         clearWorking();
         state.busy = false;
+        state.phase = 'idle';
         setSendMode('idle');
         if (opts.onBusy) { try { opts.onBusy(false); } catch (e) {} }
       }
@@ -2647,6 +2903,7 @@
       var st = String((info && info.state) || '');
       clearWorking();
       state.busy = false;
+      state.phase = 'idle';
       state.askId = null;
       state.resumeT0 = 0;
       setSendMode('idle');
@@ -2708,6 +2965,11 @@
           tok.retryNotice = null;
           var t = n && n.querySelector ? n.querySelector('.notice__t') : null;
           if (t) t.textContent = '已重新连接，继续同步';
+          /* 「已恢复」是一次过去式的确认，不是这一轮的历史：短暂提示后收走，
+             别让这行红条一直挂在画布里（2026-10-24 用户：「重连成功了不要一直还显示提示」）。 */
+          setTimeout(function () {
+            if (n && n.parentNode) n.parentNode.removeChild(n);
+          }, 1800);
         },
         /* 终态 / 重试用尽 / 4xx 才收摊；普通网络抖动不会走到这里（传输层在重连）。 */
         onEnd: function (info) { if (state.follow === tok) followEnd(info); },
@@ -2952,9 +3214,20 @@
              续传中的那一轮（partial）**不封**：它的收尾由后面接上的实时通道落定。 */
           if (!partial) finishReplayRound();
         } finally { state.replay = false; }
+        /* 回放的档位在这里一次定死（回放期间 kernelApply 不翻相位）：
+           最后一轮停在等用户（日志里有 ask、其后没有终帧）→ waiting；
+           有终态 → idle；还在跑（partial，马上接实时流）→ running。 */
+        var lti = lastTurnInfo(replayList || []);
+        if (partial) setPhase('running');
+        else if (lti.waiting && !lti.terminal) setPhase('waiting');
+        else setPhase('idle');
         var t = thread(); t.scrollTop = t.scrollHeight;
         /* 打开 / 切换会话 = 从底部开始看：把内核的「用户离开底部」闸复位（见 qaScrollReset）。 */
         if (typeof qaScrollReset === 'function') { try { qaScrollReset(); } catch (e) {} }
+        /* 兜底贴底（2026-10-25 用户：「历史会话也应该默认到最底部」）：上面那次同步贴底
+           在缩略图 / 字体加载完成**之前**执行，图一到位画布就被撑高、停在半空（手机上几乎必现）。
+           rAF + 300ms + 慢图 load 三重补贴，见内核 qaHistoryStickBottom。 */
+        if (typeof qaHistoryStickBottom === 'function') { try { qaHistoryStickBottom(); } catch (e) {} }
         state.autoFollow = true;
         /* 分页游标落定后才显示入口（旧服务端 hist = null → 不显示，行为与改动前一致）。 */
         state.hist = after == null ? hist : state.hist;
@@ -3029,6 +3302,20 @@
       Array.prototype.slice.call(t.childNodes).forEach(function (n) {
         if (n !== moreBtn) frag.appendChild(n);
       });
+      /* ⚠️ 翻页可能发生在**一轮还在跑**的时候（2026-10-24 用户：「点击向上滚动没反应」）。
+         前插走的是回放那条管线，而回放会「遇到 user 就把当前这一笔封口」、产物也挂到
+         「当前这一笔」上 —— 不隔离就会把正在流式增长的那张实时卡当历史轮封掉，
+         后续增量只能另起一张（同一轮变两卡）。所以把实时那一轮属于宿主的状态整体摘下来，
+         回放完原样接回去。回放是同步的（detach → 画 → 接回都在同一段 JS 里），实时事件插不进来。 */
+      var live = {
+        qa: state.qa, qaClosed: state.qaClosed, lastUserSig: state.lastUserSig,
+        agentRaw: state.agentRaw, working: state.working,
+        awaitingAnswer: state.awaitingAnswer, qaHadAsk: state.qaHadAsk,
+        engine: state.engine, model: state.model, arts: turnArts,
+      };
+      state.qa = null;
+      state.working = null;                       // 不回放里抢「运行中」那一行（mountWorking 就没得搬）
+      if (typeof qaTurnArtsTrack === 'function') turnArts = qaTurnArtsTrack();   // 这一页的产物自己收，别和实时混账
       state.replay = true;
       state.replayT0 = 0; state.replayLastAt = 0;
       state.qaClosed = false;      // 历史轮次要先能开新的一笔
@@ -3039,7 +3326,22 @@
         /* 页尾通常切在同一轮中间（页首才是 user，见 histCursor）→ 封口，
            否则最后一笔会一直挂着「生成中」胶囊；整轮完整时这里已是空操作。 */
         finishReplayRound();
-      } finally { state.replay = false; }
+      } finally {
+        state.replay = false;
+        turnArts = live.arts;
+        state.qa = live.qa;
+        state.working = live.working;
+        state.qaClosed = live.qaClosed;
+        state.lastUserSig = live.lastUserSig;
+        state.agentRaw = live.agentRaw;
+        state.awaitingAnswer = live.awaitingAnswer;
+        state.qaHadAsk = live.qaHadAsk;
+        /* 旧轮次里的 start 事件会把选择器改口成那一轮的引擎 / 模型 —— 翻页不该改现在这一轮 */
+        if (state.engine !== live.engine || state.model !== live.model) {
+          state.engine = live.engine; state.model = live.model;
+          syncPickers();
+        }
+      }
       t.appendChild(frag);
       /* 别让内核把这个动作当成「有新内容」把画面拽回底部（qaUserAway 是它的滚动闸）。 */
       if (typeof qaUserAway !== 'undefined') { try { qaUserAway = true; } catch (e) {} }
@@ -3053,8 +3355,9 @@
       var h = state.hist;
       var sid = state.session;
       if (!sid || !h || h.loading || !h.more) return Promise.resolve(false);
-      /* 正在看一条运行中的轮次：前插会打乱实时事件的落笔位置，等它收尾再翻。 */
-      if (state.busy) return Promise.resolve(false);
+      /* ⚠️ 不再因为「这一轮还在跑」就拒绝翻页（2026-10-24 用户：「点击向上滚动没反应」）：
+         此前 busy 直接 return，按钮看着能点、点了一点动静都没有。回放与实时那一轮的状态
+         隔离在 prependPage 里做（见那里的注释）。 */
       h.loading = true;
       syncMore();
       /* 一页装不下一整轮时（实测一条会话有 5000 条思考/工具的分页上限），服务端只能给出
@@ -3152,8 +3455,15 @@
       if (casc) {
         casc.querySelector('.casc__p').textContent = state.engine || '选择引擎';
         /* 展示走 qaModelText：剥掉 codebuddy 系自定义模型的 `custom-local:` 前缀
-           （`state.model` 本身仍是完整 id，`-m` 要用它）。 */
-        casc.querySelector('.casc__s').textContent = qaModelText(state.model) || '默认模型';
+           （`state.model` 本身仍是完整 id，`-m` 要用它）。
+           dsh 的 id 是 `route/model`：同名模型可能挂在多条路由下（modelverse 与
+           volcengine 都有 deepseek-v4.1-flash-1017），胶囊只显示末段就分不清选的是
+           哪条 —— 2026-10-25 报障里「我明明选了另一条」就是这么来的，故 dsh 带上路由。 */
+        var modelLabel = qaModelText(state.model, state.engine) || '默认模型';
+        var modelRoute = qaModelRoute(state.model, state.engine);
+        if (modelRoute) modelLabel = modelRoute + '/' + modelLabel;
+        casc.querySelector('.casc__s').textContent = modelLabel;
+        casc.title = engineLockReason();   // 置灰胶囊的悬停说明（历史会话锁）
       }
       var chip = ctx.permBtn;
       if (chip) {
@@ -3384,6 +3694,11 @@
       try { typed = String(ctx.input.value || '').trim(); } catch (e0) { typed = ''; }
       /* 附件也算「有内容」：忙时贴了图再点发送 = 排队，不能把它当成「停止」（同 send 的闸门）。 */
       if (typed || state.plugin || (state.attachments || []).length) return;
+      /* 2026-10-24 用户：「状态已经显示黄色的是不是算停止了 按钮应该变回提交状态，
+         只有真的运行中状态才是停止」—— waiting（等审批）时按钮是「发送」，空输入点它
+         不是中断：不许把正等着你确认的那一轮打断。不 preventDefault，让表单照常走
+         send()（空输入它自己 no-op）。 */
+      if (state.phase !== 'running') return;
       e.preventDefault();
       /* 用户按了「停止」：托管当场暂停，不等收尾行 —— 否则它可能在这一轮结束的
          同一秒自动发出下一条，看起来像「点了停止还在自己跑」。 */
@@ -3430,7 +3745,7 @@
       /* 内核的角色行 / 「生成中」胶囊都走这里取显示名。**必须剥掉 `custom-local:`**
          —— 本壳没有 modelLabels，宿主回不出可读名时内核会退回 id，前缀就露出来了
          （移动端尤其明显：它没有 PC 那份 qaModelName 标签表，见 04-task-list.js）。 */
-      name: function (id) { return qaModelText(id) || qaModelText(state.model); },
+      name: function (id) { return qaModelText(id, state.engine) || qaModelText(state.model, state.engine); },
       set: function (id) { state.model = id ? String(id) : ''; syncPickers(); return true; },
     };
     window.MagicHost.toast = function (msg) { console.info('[conv] ' + String(msg == null ? '' : msg)); };
@@ -3944,6 +4259,8 @@
          `t.model = s.model || ""`）：空值 = 让 core 用默认档，不替用户预设。 */
       state.model = (s && s.model) || '';
       clearThread();
+      /* 新开 / 换到空会话：相位归零（有历史的会话由 loadHistory 末尾按日志定档）。 */
+      if (!state.busy) setPhase('idle');
       /* 换到另一条会话：上一条留下的插件胶囊不跟过来（它是「这一轮用哪个 CLI」，
          属于未发出的那一句，换了会话就该作废）。 */
       setPlugin(null);
@@ -3982,7 +4299,7 @@
            不做这步的话，带着一个跑不起来的引擎发任务，报错指向 core 而不是
            「这个引擎没了」；宿主记的默认值也会一直卡在死引擎上。
            （清单为空 = 探测失败，保持原引擎不动，别把用户的默认值清掉。） */
-        var okRows = state.engines.filter(function (x) { return x.ok; });
+        var okRows = pickableEngines(state.engines);
         if (!state.engine) {
           var firstOk = okRows[0];
           if (firstOk) state.engine = firstOk.engine;   // 「自动」档：静默取首个可用，不回写宿主
@@ -4021,6 +4338,7 @@
          免得一块已经不在页面上的排队条继续替自己发车。 */
       state.queue = [];
       state.busy = false;
+      state.phase = 'idle';                        // 销毁即归零：新实例从干净相位起步
       Sheet.close();
       if (wrap.parentNode) wrap.parentNode.removeChild(wrap);
     }
@@ -4042,6 +4360,11 @@
       answer: function (text) { return control('answer', text); },
       setEngine: function (n) { state.engine = n; syncPickers(); },
       setModel: function (n) { state.model = n; syncPickers(); },
+      /* 主备（2026-10-24）：宿主改「我的 → 备用引擎」时同步进来（新会话立即生效）。 */
+      setFallback: function (engine, model) {
+        state.fallbackEngine = String(engine || '').trim();
+        state.fallbackModel = state.fallbackEngine ? String(model || '').trim() : '';
+      },
       setPermission: function (v) { state.permission = v; syncPickers(); },
       setWorkspace: function (v) { state.workspace = v || ''; },
       permissionLabel: function () { return tierOf(state.permission || '').label; },