magic-agent 2.3.0 → 2.3.2

package/client-ui/shared/conversation.js

@@ -31,6 +31,10 @@
  *      transport:     必填，见上
  *      session:       可选。传了就从这段会话开始（会拉历史），不传 = 新会话
  *      engine, model, permission: 可选初始值（空 = 不传，由 core 用自己的默认）
+ *      suggestEngine:  可选。生成「下一轮建议」用哪个引擎；**不传 / 空 = 关闭建议功能**
+ *                     （默认）：不发 /desk/suggest、不画建议、不补历史建议、托管也不自动执行。
+ *                     宿主在「我的 → 建议引擎 / 模型」里配置后传进来；改配置走 setSuggestEngine()。
+ *      suggestModel:   可选。建议引擎下指定的模型；空 = 引擎默认（core 对 llm 会自动挑最快变体）。
  *      engines:       可选。给了就用这份清单，不给则调 transport.listEngines()
  *      titleEl:       可选。宿主显示会话标题的元素（组件会写「新会话 · <引擎>」这类文案）
  *      showPermission: 可选。false 则不显示输入框下的「授权」选择器（权限仍可用 openPermissionPicker 打开）
@@ -71,7 +75,10 @@
  *      onQueueDrop:   可选。(id) => void。用户取消了（宿主把它从磁盘删掉）。
  *      hosting:       可选。初始是否开启「会话托管」（默认 false）。开启后，每个成功收尾的
  *                     轮次会把第一条建议**自动发出去**（最多连续 hostingMax 轮）。
- *                     开关的权威值在宿主（移动端「我的」→ 会话托管，落 localStorage）。
+ *                     开关的权威值在宿主，且**按会话**：移动端落在会话页「任务运行设置」，
+ *                     子会话没有自己的记录时沿父链继承（`magic.hosting.sessions.v1`）。
+ *                     自动发出的那条会标成「托管发送」（机器人头像 + 小标），并随 ask
+ *                     带 `hosted:true`；core 写进历史后重开会话也保持同一标识。
  *      hostingDelay:  可选。建议画出来后等多少毫秒再自动发（默认 1200，测试可调小）。
  *      hostingMax:    可选。连续自动执行的上限（默认 12）；到顶自动暂停并回调宿主。
  *      onHostingChange: 可选。(on, reason) => void。**组件自己暂停**托管时回调
@@ -391,6 +398,13 @@
       return d;
     }
 
+    /* 实例是否已被宿主销毁（2026-10-22）。
+       ⚠️ 必须有一个显式标记：画布是**全局唯一**的 `#qa-stream`（内核按固定 id 找），
+          销毁只摘掉本实例的 wrap，**在飞的 ask / 排队 flush / 定时器并不会自己停**。
+          它们一旦跑到下一拍，就会把这一轮的气泡画进**新实例**的画布、把排队那条
+          替新实例发出去（新实例随后还留着那条 chip，看起来就是「已发出还在排队」）。
+          所以所有「会写画面 / 会下发 / 会动队列」的入口都先看它一眼。 */
+    var destroyed = false;
     var state = {
       engines: opts.engines || [], engine: opts.engine || '', model: opts.model || '',
       permission: opts.permission || '', workspace: opts.workspace || '', attachments: [], session: opts.session || '', busy: false, askId: null,
@@ -459,13 +473,21 @@
          qaHadAsk = 本轮出现过提问卡（那种情况输入区已经有一张卡在等作答，
          再给「建议下一句」只会与它抢注意力 —— 跳过这一轮）。 */
       suggestSeq: 0, suggestAbort: null, suggestHistory: false, qaHadAsk: false,
+      /* 建议引擎 / 模型（2026-10-23 用户：在「我的」里像默认引擎那样选引擎 + 模型；
+         默认不配置 = 关闭：不请求 / 不画 / 历史不补 / 托管不自动跑）。 */
+      suggestEngine: String(opts.suggestEngine || '').trim(),
+      suggestModel: String(opts.suggestEngine ? (opts.suggestModel || '') : '').trim(),
       /* 会话托管（2026-10-23 用户：「托管模式下自动按照最佳建议提交到会话中执行」）：
          开着时每个成功收尾的轮次会把第一条（模型排序里的最佳）建议**自动发出去**。
          hostingRounds = 本次开启以来连续自动发了几轮（上限见 hostingMax，防跑飞）；
          hostingTimer = 等待「让用户看见建议」的那一小段延时（可被任何用户动作取消）。
-         ⚠️ 托管开关的**权威值在宿主**（移动端「我的」tab 落 localStorage），
-            组件只执行；自动暂停时通过 onHostingChange 通知宿主把开关也关掉。 */
-      hosting: !!opts.hosting, hostingRounds: 0, hostingTimer: 0,
+         ⚠️ 托管开关的**权威值在宿主**，且按会话（移动端落在 `magic.hosting.sessions.v1`，
+            子会话没记录就沿父链继承）；组件只执行 —— 自动暂停时通过 onHostingChange
+            通知宿主把**这条会话**的开关也关掉。 */
+      /* 没有建议引擎时即使宿主传了 hosting=true 也不进入托管：没有「最佳建议」可发，
+         提问卡的自动答也一并关掉（用户 2026-10-23：默认不配置就不开启建议功能）。 */
+      hosting: !!opts.hosting && !!String(opts.suggestEngine || '').trim(),
+      hostingRounds: 0, hostingTimer: 0,
       /* 提问卡的托管（2026-10-23 用户：「托管碰到提问卡也一样发最佳建议继续」）：
          卡一出现就等 hostingDelay，然后自动选第一项（优先「继续/下一步」措辞）交卷；
          用户点卡上任何地方 / 关掉卡 / 自己作答 → 取消这次自动答，不抢人的操作。 */
@@ -626,6 +648,9 @@
     d.appendChild(box('notice__ico', 'i-alert', 20));
     d.appendChild(el('div', 'notice__t', text));
     pushItem(d, true);
+    /* 返回节点：断线重连要在**同一行**上把「正在重连」改成「已恢复」，
+       而不是再补一条（2026-10-24「断连时要有重试机制」—— 状态得看得见、也收得回）。 */
+    return d;
   }
 
   /* ⚠️ 2026-10-16（块③ 三端瘦身）：**「事件 → 画面」整层已交给对话内核**（`shared/conv/*`）——
@@ -802,7 +827,8 @@
       if (state.replay) {
         state.replayT0 = replayAt(e); state.replayLastAt = state.replayT0;
       }
-      qaRenderMine(String(e.text || ''), Array.isArray(e.attachments) ? e.attachments : []);
+      qaRenderMine(String(e.text || ''), Array.isArray(e.attachments) ? e.attachments : [],
+        { hosted: !!e.hosted });
       return;
     }
     /* 产物收集：这一轮的工具参数 / 工具输出 / notice 里出现的落盘路径（见 turnArts 注释）。
@@ -944,7 +970,9 @@
     /* `at` 是这一轮的唯一锚：老日志没有 at 时宁可不缓存，也不拿每轮都从 1 开始的
        seq 当键 —— 那会把上一轮的旧建议画到新的一轮上。 */
     if (!at) return '';
-    return 'magic.suggest.v1.' + sid + '.' + encodeURIComponent(at) + '.' + seq;
+    return 'magic.suggest.v1.' + sid + '.' + encodeURIComponent(at) + '.' + seq
+      + '.' + encodeURIComponent(state.suggestEngine || '')
+      + '.' + encodeURIComponent(state.suggestModel || '');
   }
 
   function readHistorySuggest(key) {
@@ -975,6 +1003,8 @@
     var history = !!(o && o.history);
     var cacheKey = (o && o.cacheKey) || '';
     clearSuggest();
+    /* 默认不配置 = 建议功能关闭：连模型都不碰（历史缓存也不读，见 maybeHistorySuggest 的前置判断）。 */
+    if (!state.suggestEngine) return;
     if (state.replay) return;
     /* 提问卡出现过的轮次：以前一律不请求（卡还在等人答，建议会抢注意力）。
        托管开着且这一问**已经由托管自动答掉**时例外 —— 用户要的就是答完继续，
@@ -995,12 +1025,11 @@
     Promise.resolve(transport.suggest({
       user: String(userText == null ? '' : userText).slice(0, 4000),
       reply: reply.slice(-16000),
-      /* 旁路用 core 的默认 llm（与标题归纳同一档）：建议只是纯文本，不该排进
-         当前编码引擎的队列 —— codebuddy 这类 CLI 一轮没退干净时，/desk/suggest
-         会跟着它超时（2026-10-23 实测 22s 后 502，界面 20s 先放弃 = 永远没有建议）。
-         不传 engine，由 core 用 DefaultEngine=llm。 */
-      engine: '',
-      model: ''
+      /* 用户在「我的 → 建议引擎 / 模型」里选的那组；空值在上面已经提前 return。
+         engine 有值、model 为空 = 引擎默认（llm 会挑不思考变体，约 1-2s）；选 dsh/codebuddy
+         则是它们自己的无工具 JSON 通道（实测 6-10s，用户自己承担）。 */
+      engine: state.suggestEngine,
+      model: state.suggestModel
     }, { signal: ac ? ac.signal : undefined }))
       .then(function (res) {
         if (seq !== state.suggestSeq) return;     // 已经开新轮 / 换会话 / 又收尾了
@@ -1028,6 +1057,12 @@
   /** 画建议行（最多 3 枚；空数组 = 收起，一个像素都不占）。 */
   function renderSuggestions(list, history) {
     var bar = ctx.sugBar; if (!bar) return;
+    /* 建议功能关闭：任何迟到的响应都不许再画（requestSuggestions 已经挡了一次）。 */
+    if (!state.suggestEngine) {
+      bar.innerHTML = '';
+      bar.hidden = true;
+      return;
+    }
     var hist = !!history;
     var items = (Array.isArray(list) ? list : [])
       .filter(function (s) { return typeof s === 'string' && s.trim(); })
@@ -1037,7 +1072,7 @@
     bar.innerHTML = '';
     if (!items.length) { bar.hidden = true; return; }
     /* 托管态先落一枚「托管中」标记：用户一眼看到「接下来会自动发」，
-       点它当场暂停（与「我的」里的开关是同一个状态，只差一个更近的入口）。 */
+       点它当场暂停（与运行设置里的按会话开关是同一个状态，只差一个更近的入口）。 */
     if (state.hosting && !hist) {
       var tag = el('button', 'sugtag');
       tag.type = 'button';
@@ -1069,9 +1104,11 @@
   }
 
   /* ══════════ 会话托管（2026-10-23）══════════
-     用户：「托管模式下自动按照最佳建议提交到会话中执行，是否开启在我的 tab 中可配置」。
+     用户：「托管模式下自动按照最佳建议提交到会话中执行」。同日再定：「跟团队模式一样
+     改成挂在会话上，子会话继承，不再是全局」。
 
-     这里只做**执行**，开关的权威值在宿主（移动端「我的」→ 会话托管）。
+     这里只做**执行**，开关的权威值在宿主，且**按会话**（移动端会话页 → 任务运行设置；
+     子会话没有自己的记录时由宿主沿父链继承）。
      一次托管轮次的完整路径：
        成功收尾 → 生成建议 → 画出来（含「托管中」标记）→ 等 hostingDelay
        → 复核「还该发吗」→ 第一条建议直接走 fireTurn（用户气泡、beforeAsk、权限、排队全部照旧）。
@@ -1079,7 +1116,7 @@
      复核不是形式：延时期间用户可能已经开始打字、贴了附件、点了别的建议、
      切了会话、或者干脆把托管关了 —— 任何一条命中都必须放弃这次自动发送。
      自动暂停（失败 / 被停 / 到上限 / 用户暂停）都回调 onHostingChange，
-     让宿主把「我的」里那枚开关同步关掉，不留下「界面显示开着、其实已经不跑了」的错觉。 */
+     让宿主把**这条会话**的开关同步关掉，不留下「界面显示开着、其实已经不跑了」的错觉。 */
 
   function clearHostingTimer() {
     if (state.hostingTimer) { clearTimeout(state.hostingTimer); state.hostingTimer = 0; }
@@ -1145,7 +1182,7 @@
 
   /** 卡一出现就排一次自动答；只在**当前会话的停靠位**里找，后台会话的卡不动。 */
   function scheduleHostingAsk() {
-    if (!state.hosting || state.replay || state.hostingAskTimer || state.hostingAskCard) return;
+    if (!state.hosting || !state.suggestEngine || state.replay || state.hostingAskTimer || state.hostingAskCard) return;
     var dock = root.querySelector('#home-askdock');
     if (!dock || dock.hidden) return;
     var cards = dock.querySelectorAll('.qa-ask');
@@ -1202,11 +1239,14 @@
     }
   }
 
-  /** 宿主设置托管开关（用户点「我的」里的开关，或新建会话时同步初值）。
+  /** 宿主设置托管开关（用户点会话页「任务运行设置」里的开关，或切换会话时同步初值）。
    *  ⚠️ 刻意不回调 onHostingChange：那是「组件自己暂停了」的回传口，
    *     宿主自己改完再收到自己的回调只会绕圈（与 setTeam 同一约定）。 */
   function setHosting(on) {
     var next = !!on;
+    /* 没有配置建议引擎 = 建议功能关闭：托管没有「最佳建议」可发，也没有提问卡自动答的入口。
+       宿主应先在「我的」里配引擎；这里再兜一道，避免旧状态/脚本直接打开。 */
+    if (next && !state.suggestEngine) { pauseHosting('未配置建议引擎'); return; }
     if (next === state.hosting) return;
     state.hosting = next;
     state.hostingRounds = 0;
@@ -1215,13 +1255,27 @@
     clearHostingAsk();
   }
 
+  /** 宿主改「建议引擎」：空 = 关闭建议功能。
+   *  关闭时立刻清掉建议行 / 在途请求 / 托管计时器，并暂停托管（回调宿主落盘）。
+   *  开启后从**下一轮**收尾开始生成；不追着已经画过的旧轮补请求。 */
+  function setSuggestEngine(engine, model) {
+    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;
+    state.suggestEngine = next;
+    state.suggestModel = nextModel;
+    clearSuggest();
+    if (!next) pauseHosting('未配置建议引擎');
+  }
+
   /** 自动发送前的复核 + 延时。text = 第一条建议（模型排序即优先级）。
    *  2026-10-23（用户：「排队的和自动建议发送串会话了」）：这一条**只服务当前这次建议**。
    *  排计时器时把 sugId（会话 + 建议序号）一起拷进闭包，到点后逐条核对 ——
    *  会话换了 / 建议换代了 / 建议行已经没了 → **放弃这次自动发送**，绝不替别的会话开一轮。 */
   function scheduleHostingSend(text) {
     clearHostingTimer();
-    if (!state.hosting || !text || state.suggestHistory) return;
+    if (!state.hosting || !state.suggestEngine || !text || state.suggestHistory) return;
     if (state.busy || state.queue.length) return;          // 已经有活要干：不插队
     var typed = '';
     try { typed = String(ctx.input.value || '').trim(); } catch (e) { typed = ''; }
@@ -1261,8 +1315,9 @@
       state.hostingRounds++;
       clearSuggest();                                    // 建议行收起（含本条的「托管中」标记）
       /* 直接走 fireTurn：不经过输入框，不把这句话闪进 textarea；用户气泡、串行门、
-         权限与排队语义仍由同一条路负责（与点建议、打字发送完全一致）。 */
-      Promise.resolve(fireTurn(String(text), [], [])).catch(function (e) {
+         权限与排队语义仍由同一条路负责（与点建议、打字发送完全一致）。
+         meta.hosted = 画成「托管发送」而不是「我」，并让 history 也带这个标识。 */
+      Promise.resolve(fireTurn(String(text), [], [], null, { hosted: true })).catch(function (e) {
         pauseHosting('自动发送失败：' + ((e && e.message) || e));
       });
     }, hostingDelay);
@@ -1271,6 +1326,9 @@
   /** 一轮收尾（成功 / 失败 / 被停）：内核的收尾动作已经做完（收思考区 / 工具卡 / 运行胶囊），
    *  这一层只补**收尾行**（状态语 + 总耗时，取墙上时钟 —— 与掌天瓶那边同一口径）。 */
   function kernelDone(ok, label) {
+    /* 销毁后迟到的终态：这一轮已经不属于任何画面了 —— 收尾行、托管判定、建议请求
+       一条都不该再跑（它们会写进新实例的画布，或替新实例发下一句）。 */
+    if (destroyed) return;
     /* 失败 / 被用户停：托管立刻暂停。这两类收尾没有「下一步」可自动执行，
        继续挂着只会在下一轮突然又动起来 —— 用户很难把因果对上。 */
     /* ⚠️ 回放（看历史）里的失败 / 中止不算：那可能是几天前的一条旧轮次，
@@ -1447,6 +1505,7 @@
     }
 
     async function send() {
+      if (destroyed) return;                     // 销毁后的实例不许再发（见 destroyed 的注释）
       /* 用户亲手发了一句：托管计数重新起算（手动接管意味着「我还想继续」）；
          正在等的那次自动发送也立刻作废 —— 用户已经自己发了，不能再补一条。 */
       state.hostingRounds = 0;
@@ -1527,8 +1586,15 @@
     /* 真正开跑一轮：本地用户气泡（内核的 qaRenderMine）+ 附件快照 + runTurn。
        运行中排队的那条（flushQueue）也走这里 —— 两条路径画出来必须一模一样。
        preBubble：这条气泡**已经画过**（排队时当场画的，见 send 的排队分支）——
-                  传进来的话就只把它从「等待中」恢复成正常态，不再重画。 */
-    async function fireTurn(text, sentAtts, attPaths, preBubble) {
+                  传进来的话就只把它从「等待中」恢复成正常态，不再重画。
+       meta.hosted：本轮由会话托管自动发出（2026-10-23 用户：「是托管发送的要标识
+                   显示时区别于“我”发送」）。传给内核画成机器人头像 + 「托管发送」小标，
+                   并随 ask 下发 hosted=true，core 写进历史后回放也能认出来。
+                   托管发送前已经挡掉 busy / 排队，所以这里不会与 preBubble 同时出现。 */
+    async function fireTurn(text, sentAtts, attPaths, preBubble, meta) {
+      /* 销毁后不许再开轮：这一笔会画进**新实例**的全局画布（见 destroyed 的注释）。 */
+      if (destroyed) return;
+      var hosted = !!(meta && meta.hosted);
       /* 新的一轮开始 = 上一轮的建议作废（它们描述的是上一轮的下一步）。 */
       clearSuggest();
       state.qaHadAsk = false;
@@ -1542,12 +1608,12 @@
       var bubble = preBubble || null;
       if (preBubble) {
         try { preBubble.classList.remove('is-queued'); } catch (e) {}
-      } else if (!state.noEcho) bubble = qaRenderMine(text, sentAtts || []) || null;
+      } else if (!state.noEcho) bubble = qaRenderMine(text, sentAtts || [], { hosted: hosted }) || null;
       state.noEcho = false;
       /* 本地回声也登记签名：同一条提问随后若从补拉缓冲（网关合成的 `type:"user"`）再来一遍，
          或者看门狗清屏重放，就不再画出第二个一样的气泡（见 state.lastUserSig）。 */
       state.lastUserSig = text;
-      await runTurn(text, attPaths, bubble);
+      await runTurn(text, attPaths, bubble, { hosted: hosted });
     }
 
     /* ── 排队追问：渲染 / 取消 / 收尾后自动提交 ──
@@ -1584,7 +1650,10 @@
           atts: (it.atts || []).slice(),
           session: it.sid || state.session || '', workspace: state.workspace || '',
           engine: state.engine, model: state.model, permission: state.permission,
-          team: state.team ? teamPayload() : null
+          team: state.team ? teamPayload() : null,
+          /* 队列里一般不会有托管条目（托管在 busy / 有队列时根本不发），
+             但真被串行门挡住时这条标记要能落库、重发时还原。 */
+          hosted: !!it.hosted
         };
       }
       try { fn(payload); } catch (e) {}
@@ -1596,6 +1665,7 @@
      每条一行文本 + ✕；轮到它时由 flushQueue 从队列取走，fireTurn 再把气泡画进画布。
      所以同一句话**只会在一个地方出现**：排队时在上方列表，发出后才进对话区。 */
   function renderQueue() {
+    if (destroyed) return;
     var bar = ctx.queueBar;
     if (!bar) return;
     bar.innerHTML = '';
@@ -1652,12 +1722,15 @@
 
     function scheduleFlush() {
       setTimeout(function () {
+        if (destroyed) return;
         if (!state.busy && !state.replay) flushQueue();
       }, 0);
     }
 
     async function flushQueue() {
-      if (flushing || state.busy || state.replay || !state.queue.length) return;
+      /* 销毁后别再动队列：取走 / 发出去 / 通知宿主 take，任意一步都会让新实例那条
+         排队 chip 变成「已发出还在显示」（见 destroyed 的注释）。 */
+      if (destroyed || flushing || state.busy || state.replay || !state.queue.length) return;
       var it = state.queue[0];
       /* ⚠️ 2026-10-23（用户：「排队的和自动建议发送串会话了」）：这条**不是当前会话排的**就整队作废，
          一条都不发 —— 队列跟会话走，实例被复用到别的会话后，把上一条会话的追问发出去就是
@@ -1676,7 +1749,7 @@
       /* 轮到它了：宿主那条「等待中」该换成真正跑起来的会话（见 notifyQueue）。 */
       notifyQueue('take', it);
       flushing = true;
-      try { await fireTurn(it.text, it.atts, it.attPaths, it.bubble); }
+      try { await fireTurn(it.text, it.atts, it.attPaths, it.bubble, { hosted: !!it.hosted }); }
       finally { flushing = false; }
       /* 连排了多条：这一条也收尾之后再发下一条（让用户看得清是哪条在跑）。 */
       if (state.queue.length) scheduleFlush();
@@ -1697,7 +1770,9 @@
        条目把它记进自己的 sid —— flushQueue 发之前按它核对，不属于当前会话就整队作废。
        （这之前只按「宿主筛过了」信任，而宿主那一侧的匹配在 session 为空时是放行的。） */
     function adoptQueue(items) {
-      if (!Array.isArray(items) || !items.length) return 0;
+      /* 销毁后的实例不许再接管：条目归宿主，等下一个活实例来认领（否则它会挂在
+         一块已经不在页面上的排队条里，谁都发不出去）。 */
+      if (destroyed || !Array.isArray(items) || !items.length) return 0;
       var n = 0;
       items.forEach(function (it) {
         if (!it || !it.id || !it.prompt) return;
@@ -1706,7 +1781,7 @@
         var attPaths = (it.attachments || []).slice();
         /* 只入队 + 列表：不画进画布（还没发出去，画成用户气泡会让人以为已发送）。 */
         var item = { id: it.id, text: it.prompt, atts: atts, attPaths: attPaths, bubble: null,
-                     sid: it.session || state.session || '' };
+                     sid: it.session || state.session || '', hosted: !!it.hosted };
         state.queue.push(item);
         n++;
       });
@@ -1719,7 +1794,9 @@
       return n;
     }
 
-    async function runTurn(prompt, attPaths, bubble) {
+    async function runTurn(prompt, attPaths, bubble, meta) {
+      if (destroyed) return;                       // 见 destroyed 的注释：销毁后不许开轮
+      var hosted = !!(meta && meta.hosted);
       /* 本页原本在尾随别的进程跑的那一轮（follow）：现在自己要发新一轮 →
          先把旧尾随掐掉。**不能等收尾再掐** —— 旧会话的增量会继续 render，
          而新一轮的事件也在同一张画布上，正文就重复了。也不走 stopFollow：
@@ -1758,6 +1835,9 @@
             /* team：团队开关也是这一轮的**下发参数**。宿主排队落库后重发时必须还原它，
                否则「开了团队模式的任务」在串行队列里会被静默降级成单任务。 */
             team: state.team ? teamPayload() : null,
+            /* hosted：托管自动发出的那一轮，串行门落库 / 重发时要原样还原 ——
+               否则重启后补发的那条在历史里会变回「用户亲手发的」。 */
+            hosted: hosted,
             prompt: prompt, attachments: (attPaths || []).slice(),
             /* queued(on)：宿主**确认这一轮要等**时调它，把「排队中」标到气泡上；
                放行时调 queued(false)（或不调，runTurn 收口时会摘）。
@@ -1811,6 +1891,9 @@
            路由配置每次下发都现读宿主的配置 —— 用户在「我的」里改了图像引擎，
            下一条消息就该用上，不必重新挂载组件。 */
         if (state.team) payload.team = teamPayload();
+        /* 托管自动发送：只用于历史标识（core 的 user 事件带 hosted），不改执行语义。
+           老 core 不认这个字段 / 插件没开这个能力位时会忽略，实时气泡不受影响。 */
+        if (hosted) payload.hosted = true;
         await new Promise(function (resolve) {
           var resolved = false;
           var deliver = function () {
@@ -1906,9 +1989,11 @@
           };
           try {
             askHandle = transport.ask(payload, {
-              onOpen: function (runID) { state.askId = runID || state.askId; },
-              onEvent: function (ev) { try { render(ev); } catch (e) {} },
-              onEnd: finish
+              /* 销毁后迟到的回调一律丢弃：`render` 写的是全局 #qa-stream（新实例的画布），
+                 `finish → hardFinish → kernelDone` 还会补收尾行、排 flush。 */
+              onOpen: function (runID) { if (destroyed) return; state.askId = runID || state.askId; },
+              onEvent: function (ev) { if (destroyed) return; try { render(ev); } catch (e) {} },
+              onEnd: function (code) { if (destroyed) return; finish(code); }
             });
             /* 存下取消钩子：kernelDone 在 turn_end 收尾时用它掐断这条流（见那里的注释） */
             state.askHandle = askHandle;
@@ -2360,6 +2445,7 @@
        · 先读缓存（按 sid + 最后一条 user 的 at/seq），有就画，没有才请求；
        · 画出来的建议**不排托管**（renderSuggestions 的 history 模式）。 */
     function maybeHistorySuggest(sid, events, idx) {
+      if (!state.suggestEngine) return;             // 默认关闭：历史会话也不补建议
       if (!sid || idx < 0 || state.busy || state.replay || state.suggestAbort) return;
       /* 已经有实时建议画着（刚跑完那条会话）→ 不重复请求。 */
       if (ctx.sugBar && !ctx.sugBar.hidden && ctx.sugBar.querySelector('.sugchip')) return;
@@ -2548,7 +2634,9 @@
     function startFollow(sid, after, askID) {
       stopFollow();
       if (!sid || typeof transport.followSession !== 'function') return false;
-      var tok = { sid: sid, cancel: null, askId: askID || null };
+      /* retryNotice = 这一轮断线时插在画布上的那行状态；重连成功后**就地把文案改掉**，
+         让它读起来是一次「已恢复」，而不是把「正在重连」永远留在历史里。 */
+      var tok = { sid: sid, cancel: null, askId: askID || null, retryNotice: null };
       var h = transport.followSession(String(sid), after || 0, {
         onEvent: function (ev) {
           if (state.follow !== tok || sid !== state.session) return;
@@ -2566,6 +2654,23 @@
           state.qaClosed = false;
           loadHistory(sid).catch(function () { /* 下一拍由用户重开 */ });
         },
+        /* 传输层负责重试（指数退避 + 断点游标）；这里只负责**让用户看见**。
+           只在第一次退避时插一行，后续几次不重复刷屏 —— 否则一次地铁过隧道
+           能在画布里留下七八条「正在重连」。 */
+        onRetry: function (info) {
+          if (state.follow !== tok || sid !== state.session || tok.retryNotice) return;
+          /* max_duration 是服务端主动轮换，不是「连接中断」：安静续上，别吓用户。 */
+          if (info && info.reason === 'max_duration') return;
+          tok.retryNotice = noticeItem('连接中断，正在自动重连…');
+        },
+        onResume: function () {
+          if (state.follow !== tok || sid !== state.session || !tok.retryNotice) return;
+          var n = tok.retryNotice;
+          tok.retryNotice = null;
+          var t = n && n.querySelector ? n.querySelector('.notice__t') : null;
+          if (t) t.textContent = '已重新连接，继续同步';
+        },
+        /* 终态 / 重试用尽 / 4xx 才收摊；普通网络抖动不会走到这里（传输层在重连）。 */
         onEnd: function (info) { if (state.follow === tok) followEnd(info); },
         onError: function () { if (state.follow === tok) followEnd({ reason: 'error' }); }
       });
@@ -2736,6 +2841,9 @@
         ? histFirstPage(sid)
         : Promise.resolve(transport.readSession(sid, { after: after }));
       var done = Promise.all([firstP, asksP]).then(function (rs) {
+        /* 读取期间实例被销毁（切走 / 重建）：这份历史属于**上一块画布**，不能落进新实例的
+           #qa-stream（全局唯一）。上一个实现只挡住了「换会话」，挡不住 destroy。 */
+        if (destroyed) return 0;
         var r = rs[0];
         var events = (r && r.events) || [];
         /* ⚠️ **不按 seq 排序**（2026-10-16）：日志是跨轮追加的，老日志里每轮的 seq
@@ -2968,13 +3076,15 @@
       stopFollow();
     }
     function watchTick() {
+      if (destroyed) return;                       // 销毁后不再碰画布（见 destroyed 的注释）
       var sid = state.session;
       if (!sid || state.busy || watchInflight) return;
       if (typeof document !== 'undefined' && document.visibilityState && document.visibilityState !== 'visible') return;
       if (typeof transport.listAsks !== 'function') return;
       watchInflight = true;
       Promise.resolve().then(function () { return transport.listAsks(); }).then(function (asks) {
-        /* 期间换了会话：这一拍作废（新会话有自己的加载与轮询）。 */
+        /* 期间换了会话 / 实例被销毁：这一拍作废（否则 clearThread 会清掉新实例的画布）。 */
+        if (destroyed) return;
         if (sid !== state.session || state.busy) return;
         var run = runningAskOf(asks, sid);
         /* 同一条 run 只刷一次：接不上（旧网关缺 askEvents）时别每 5s 重画一遍。 */
@@ -3851,8 +3961,27 @@
       });
     }
     function destroy() {
-      clearSuggest();
-      stopWatch();
+      /* 先把实例钉死，再收资源：顺序反了的话，收资源过程中触发的下一拍
+         （流被 cancel 的收尾、flush 定时器）仍会写进全局画布 / 动队列。 */
+      if (destroyed) return;
+      destroyed = true;
+      clearSuggest();                              // 顺手 abort 在途的建议请求
+      clearHostingTimer();
+      clearHostingAsk();
+      stopWatch();                                 // 巡检 + follow 一起停
+      /* 掐掉本轮在飞的流：服务端拿 WithoutCancel 继续跑 core，断连只表示「这边不看了」，
+         任务照常落盘 —— 但这边**必须**断开，否则迟到的事件会画进新实例的画布。 */
+      var ah = state.askHandle;
+      state.askHandle = null;
+      if (ah && typeof ah.cancel === 'function') { try { ah.cancel(); } catch (e) {} }
+      var rs = state.resumeStop;
+      state.resumeStop = null;
+      if (typeof rs === 'function') { try { rs(); } catch (e) {} }
+      /* 队列条目**不通知宿主 drop**：它们属于宿主的持久化队列（magic.serial.queue.v1），
+         还等着下一个活实例 adoptQueue / enqueueDispatch 接管。这里只松开本实例的引用，
+         免得一块已经不在页面上的排队条继续替自己发车。 */
+      state.queue = [];
+      state.busy = false;
       Sheet.close();
       if (wrap.parentNode) wrap.parentNode.removeChild(wrap);
     }
@@ -3889,9 +4018,11 @@
       openTeamPicker: openTeamPicker,
       featureOn: featureOn,
       setEngines: function (list) { state.engines = list || []; syncPickers(); },
-      /* 会话托管：宿主「我的」里的开关调它；hostingOn() 给宿主做开关态回读。 */
+      /* 会话托管：宿主按会话的开关调它（运行设置页）；hostingOn() 给宿主做开关态回读。 */
       setHosting: setHosting,
       hostingOn: function () { return !!state.hosting; },
+      /* 建议引擎：宿主「我的」里改配置时调它；空 = 关闭建议功能。 */
+      setSuggestEngine: setSuggestEngine,
       refreshEngines: refreshEngines,
       setSession: setSession,
       newSession: newSession,