magic-agent 2.1.5 → 2.3.2

package/client-ui/shared/conversation.js

@@ -19,6 +19,9 @@
  *                                              h: {onOpen?, onEvent, onSnapshot?, onEnd?, onError?}
  *      upload(file)                         -> Promise<{path, name, size, mime, url?}>  （可选）
  *      mediaUrl(path)                       -> string  （可选）附件回读地址；有它历史气泡才画得出缩略图
+ *      suggest({user, reply, engine, model})-> Promise<{suggestions:[string]}>  （可选）
+ *                                              一轮收尾后生成「用户下一句」的快捷回复；
+ *                                              没有这条通道就不画建议（诚实降级，不造假按钮）
  *    掌天瓶走 IPC → CLI；别的对接方可能走 HTTP —— 组件对此一无所知。
  *    现成的 HTTP 实现见同目录 transport-http.js。
  *
@@ -28,6 +31,10 @@
  *      transport:     必填，见上
  *      session:       可选。传了就从这段会话开始（会拉历史），不传 = 新会话
  *      engine, model, permission: 可选初始值（空 = 不传，由 core 用自己的默认）
+ *      suggestEngine:  可选。生成「下一轮建议」用哪个引擎；**不传 / 空 = 关闭建议功能**
+ *                     （默认）：不发 /desk/suggest、不画建议、不补历史建议、托管也不自动执行。
+ *                     宿主在「我的 → 建议引擎 / 模型」里配置后传进来；改配置走 setSuggestEngine()。
+ *      suggestModel:   可选。建议引擎下指定的模型；空 = 引擎默认（core 对 llm 会自动挑最快变体）。
  *      engines:       可选。给了就用这份清单，不给则调 transport.listEngines()
  *      titleEl:       可选。宿主显示会话标题的元素（组件会写「新会话 · <引擎>」这类文案）
  *      showPermission: 可选。false 则不显示输入框下的「授权」选择器（权限仍可用 openPermissionPicker 打开）
@@ -59,9 +66,29 @@
  *                     **由宿主持有**（引擎/模型是宿主的偏好，不是这一轮对话的状态）：
  *                     组件只在每轮下发时读一次。不传 = 只传 `team:{}`，路由全走 core 默认。
  *                     组件不判断「有没有配置图像引擎」这类事 —— 那是 core 的裁决（缺了就明确失败）。
+ *      onQueuePush:   可选。(info) => void。运行中提交的追问进队时回调，宿主据此落库
+ *                     （info = {id, prompt, attachments, atts, session, workspace, engine,
+ *                              model, permission, team}）。给了它，组件重建后宿主就能用
+ *                     conv.adoptQueue(…) 把还没轮到的条目还给新实例 —— 这是「重进会话
+ *                     排队气泡消失」的正解（组件内存队列活不过 destroy）。
+ *      onQueueTake:   可选。(id) => void。轮到这条了，正要真正下发（宿主删掉落库那条）。
+ *      onQueueDrop:   可选。(id) => void。用户取消了（宿主把它从磁盘删掉）。
+ *      hosting:       可选。初始是否开启「会话托管」（默认 false）。开启后，每个成功收尾的
+ *                     轮次会把第一条建议**自动发出去**（最多连续 hostingMax 轮）。
+ *                     开关的权威值在宿主，且**按会话**：移动端落在会话页「任务运行设置」，
+ *                     子会话没有自己的记录时沿父链继承（`magic.hosting.sessions.v1`）。
+ *                     自动发出的那条会标成「托管发送」（机器人头像 + 小标），并随 ask
+ *                     带 `hosted:true`；core 写进历史后重开会话也保持同一标识。
+ *      hostingDelay:  可选。建议画出来后等多少毫秒再自动发（默认 1200，测试可调小）。
+ *      hostingMax:    可选。连续自动执行的上限（默认 12）；到顶自动暂停并回调宿主。
+ *      onHostingChange: 可选。(on, reason) => void。**组件自己暂停**托管时回调
+ *                     （失败 / 被停 / 到上限 / 用户点「托管中」标记）；宿主据此把关掉开关、
+ *                     同步界面并给一句原因。宿主自己调 setHosting 不触发它（避免绕圈）。
  *    });
  *    conv.send('…');  conv.interrupt();  conv.stop();  conv.answer('…');
  *    conv.setSession(sid) / conv.newSession() / conv.refreshEngines() / conv.destroy();
+ *    conv.setHosting(on) / conv.hostingOn()   // 会话托管开关（组件只执行，权威值由宿主存）
+ *    conv.adoptQueue([{id, prompt, attachments, atts}])   // 把宿主落库的排队条目接回画布
  *
  *  ── 边界 ──
  *    组件**只管对话区**：会话列表、工作区切换、引擎探测的展示、业务视图都由对接方
@@ -371,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,
@@ -433,12 +467,49 @@
       awaitingAnswer: false,
       /* 内核「重试」走 MagicHost.send(…, {echo:false})：那条气泡已经在画布上了，别再画一遍 */
       noEcho: false,
+      /* 下一轮建议（2026-10-23）：收尾后向桌面端要 0-3 条「用户下一句」，点一下即发。
+         suggestSeq = 这一轮请求的序号（响应回来时对不上就丢弃，见 requestSuggestions）；
+         suggestAbort = 在途请求的取消钩子（开新轮 / 换会话 / 销毁时立刻断掉）；
+         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 = 等待「让用户看见建议」的那一小段延时（可被任何用户动作取消）。
+         ⚠️ 托管开关的**权威值在宿主**，且按会话（移动端落在 `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，然后自动选第一项（优先「继续/下一步」措辞）交卷；
+         用户点卡上任何地方 / 关掉卡 / 自己作答 → 取消这次自动答，不抢人的操作。 */
+      hostingAskTimer: 0, hostingAskCard: null, hostingAskAnswered: false,
       /* 最近一条**已画到画布上**的提问（签名 = 正文）。同一条提问会从三处再走一遍：
          发送时的本地回声 / 历史日志回放 / 网关在 ask 缓冲头合成的 `type:"user"`（seq 固定 0）。
          没有这道签名，一次提问可能画出两三个一模一样的气泡（2026-10-20 用户报「出来三个」）。 */
       lastUserSig: ''
     };
 
+  /* 托管的两条护栏（都可被宿主覆盖，主要给测试用）：
+     · hostingDelay —— 建议画出来后等一小会儿再自动发，让用户看见「要发哪句」并有机会暂停；
+     · hostingMax   —— 连续自动执行的上限。没有这条，一个「继续」接「继续」的循环能烧一整夜；
+       到顶就暂停并通知宿主，不静默停。 */
+  var hostingDelay = 1200, hostingMax = 12;
+  if (opts && typeof opts.hostingDelay === 'number' && isFinite(opts.hostingDelay)) {
+    hostingDelay = Math.max(0, Math.min(5000, opts.hostingDelay));
+  }
+  if (opts && typeof opts.hostingMax === 'number' && isFinite(opts.hostingMax)) {
+    hostingMax = Math.max(1, Math.min(50, Math.floor(opts.hostingMax)));
+  }
+
   /* ══════════ markdown 渲染（**栈归内核**）══════════
      2026-10-16 阶段三：本文件以前自带一套手写解析（inlineMd / readTable / readList /
      codePanelHtml / mdToHtml，约 200 行）—— 只覆盖「agent 回复里实际会出现」的子集，
@@ -577,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/*`）——
@@ -626,6 +700,9 @@
        「一条事件流 → 对话」的映射收归对话内核一份（`shared/conv/09-stream-apply.js`），
        组件这边只递事件、递画布、把回调接回自己的状态。见下面 kernelApply。 */
     kernelApply(ev);
+    /* 提问卡一出现就排托管自动答（卡是 kernelApply 里同步挂到停靠位的）。
+       每个事件都问一次是廉价的：没有未答的卡就什么都不做，有卡且已有计时器就直接返回。 */
+    if (state.hosting && !state.replay) scheduleHostingAsk();
   }
 
   /* ══════════ 事件 → 画面：走内核那一份实现 ══════════
@@ -690,7 +767,10 @@
   function turnHasContent(h) {
     var el = h && h.el;
     if (!el) return false;
-    return !!el.querySelector('.qa-t, .qa-think, .qa-tools, .qa-tool, .qa-ask, .qa-agent, .qa-mk, .qa-sep, .qa-img');
+    /* ⚠️ `.qa-mk` = 标记行（notice / system / turn_failed 都画成它）。漏掉它的话，
+       一轮只有过程提示（团队模式的心跳、计划播报）而没有正文时，整条消息会被
+       dropEmptyAnswer 当「空块」撤掉 —— 历史回放里那些提示就凭空消失了。 */
+    return !!el.querySelector('.qa-t, .qa-think, .qa-tools, .qa-tool, .qa-ask, .qa-agent, .qa-mk, .qa-sep, .qa-img, .qa-todo-panel');
   }
   /** 只有「引擎抬头」的助手块就撤掉（否则收尾行上方留一块空白，2026-10-20 用户截图）。 */
   function dropEmptyAnswer(h) {
@@ -717,7 +797,7 @@
       if (e.model) state.model = String(e.model);
       syncPickers();
     }
-    if (t === 'ask') state.awaitingAnswer = true;       // 引擎在等这一问的答案（见 MagicHost.send）
+    if (t === 'ask') { state.awaitingAnswer = true; state.qaHadAsk = true; }   // 引擎在等这一问的答案（见 MagicHost.send）
     /* 画布上已经有东西了 → 撤掉那句空态说明（它只在一条都还没画时该在） */
     var em = document.getElementById('qa-stream');
     var empty = em && em.querySelector('.conv__empty');
@@ -747,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 注释）。
@@ -843,10 +924,421 @@
       onDone: function (e) { kernelDone(true, (e && e.stopped) ? '已停止' : '已完成'); },
     };
   }
+  /* ══════════ 下一轮建议（2026-10-23）══════════
+     用户：「在回复结束后 ai 自动生成下一轮的建议，点击即可发送」。
+     生成在**桌面端**做（core 的 --suggest-followups，见 internal/suggest）：提示词与解析口径
+     只有一份，手机只拿结果。这一层只负责「什么时候问、画在哪、点了怎么发」。
+
+     · 只在**成功收尾**且没有提问卡的那一轮问（失败 / 被停 / 历史回放都不问：
+       那些轮没有「下一步」可言，问了也只会拿到过期的建议）；
+     · 一次只有一个在途请求：开新轮 / 换会话 / 销毁立刻 abort（core 侧随之杀进程），
+       响应回来时用 suggestSeq 对号，对不上就丢 —— 否则上一轮的建议会画到下一轮上；
+     · 点击 = **直接发送**（走 MagicHost.send，与用户打字同一条路径：内核画用户气泡、
+       忙时自动排队、附件闸门一致）。不做「填进输入框」两极分化 —— 用户说的是点击即发；
+     · 拿不到建议（接口 4xx/5xx、超时、模型给了空数组）就**什么都不画**，不拿模板凑。 */
+
+  /* 建议行属于**哪一次建议**：{ sid, seq }。
+     2026-10-23（用户：「排队的和自动建议发送串会话了」）：这之前建议行只按「DOM 里还有没有
+     这枚按钮」存在，托管那条路径（scheduleHostingSend）的延时窗口里也只复核了 busy /
+     输入框 / 附件 —— 没有一条核对「还是不是原来那条会话、还是不是同一批建议」。
+     于是切会话后那 1.2s 一到，上一条会话的建议就发进了新会话（画布、session 续接一起串）。
+     现在每次请求 / 渲染都把身份记在这里，自动发送前逐条核对。 */
+  var sugId = { sid: '', seq: -1 };
+
+  /** 清空建议行 + 断掉在途请求（序号 +1 让迟到的响应失效）。 */
+  function clearSuggest() {
+    clearHostingTimer();                         // 建议行都没了，等待中的自动发送也必须作废
+    clearHostingAsk();                           // 提问卡的自动作答同理
+    state.suggestSeq++;                          // 迟到响应的作废标记（见 requestSuggestions）
+    state.suggestHistory = false;
+    sugId = { sid: '', seq: -1 };                // 建议行都没了：托管那条也不再有任何可发的身份
+    var ac = state.suggestAbort;
+    state.suggestAbort = null;
+    if (ac) { try { ac.abort(); } catch (e) {} }
+    if (ctx.sugBar) { ctx.sugBar.innerHTML = ''; ctx.sugBar.hidden = true; }
+  }
+
+  /* 历史会话的“最后一轮建议”（2026-10-23 用户：「任何历史会话现在点进去都看不到建议」）：
+     只在打开会话、回放完最后一轮之后请求一次；结果按 (sid, 最后一条 user 的 at/seq)
+     缓存在 localStorage，30 分钟内重开不重复调模型。历史建议**只展示**，绝不交给托管
+     自动发 —— 否则一打开旧会话，托管会立刻把几天前的一句建议发进去。 */
+  var HISTORY_SUGGEST_TTL = 30 * 60 * 1000;
+
+  function historySuggestKey(sid, u) {
+    if (!sid || !u) return '';
+    var at = String(u.at || ''), seq = String(u.seq == null ? '' : u.seq);
+    /* `at` 是这一轮的唯一锚：老日志没有 at 时宁可不缓存，也不拿每轮都从 1 开始的
+       seq 当键 —— 那会把上一轮的旧建议画到新的一轮上。 */
+    if (!at) return '';
+    return 'magic.suggest.v1.' + sid + '.' + encodeURIComponent(at) + '.' + seq
+      + '.' + encodeURIComponent(state.suggestEngine || '')
+      + '.' + encodeURIComponent(state.suggestModel || '');
+  }
+
+  function readHistorySuggest(key) {
+    if (!key) return null;
+    try {
+      var raw = window.localStorage.getItem(key);
+      if (!raw) return null;
+      var o = JSON.parse(raw);
+      if (!o || !Array.isArray(o.items) || !o.at) return null;
+      if (Date.now() - Number(o.at) > HISTORY_SUGGEST_TTL) {
+        window.localStorage.removeItem(key);
+        return null;
+      }
+      return o.items.filter(function (x) { return typeof x === 'string' && x.trim(); });
+    } catch (e) { return null; }
+  }
+
+  function writeHistorySuggest(key, items) {
+    if (!key) return;
+    try {
+      window.localStorage.setItem(key, JSON.stringify({ at: Date.now(), items: items || [] }));
+    } catch (e) { /* 隐私模式 / 配额满：不缓存，下次重算，不打扰用户 */ }
+  }
+
+  /** 收尾后要一次建议。失败静默（控制台留一行，便于排障）。
+   *  o.history = 打开历史会话时补的“最后一轮”建议；只展示，不排托管计时器。 */
+  function requestSuggestions(userText, replyText, o) {
+    var history = !!(o && o.history);
+    var cacheKey = (o && o.cacheKey) || '';
+    clearSuggest();
+    /* 默认不配置 = 建议功能关闭：连模型都不碰（历史缓存也不读，见 maybeHistorySuggest 的前置判断）。 */
+    if (!state.suggestEngine) return;
+    if (state.replay) return;
+    /* 提问卡出现过的轮次：以前一律不请求（卡还在等人答，建议会抢注意力）。
+       托管开着且这一问**已经由托管自动答掉**时例外 —— 用户要的就是答完继续，
+       下一轮的正常建议必须照常生成。手动答的卡由 fireTurn 把 qaHadAsk 清掉，不会走到这里。 */
+    if (state.qaHadAsk && !(state.hosting && state.hostingAskAnswered)) return;
+    /* 宿主没接这条通道（老驱动 / 测试桩）→ 如实不做，不假装有建议。 */
+    if (!transport || typeof transport.suggest !== 'function') return;
+    var reply = String(replyText == null ? '' : replyText).trim();
+    if (reply.length < 12) return;               // 一句「好的 / 已完成」没有下一步可提炼，省一次模型调用
+    var sid = state.session || '';
+    var seq = state.suggestSeq;
+    state.suggestHistory = history;
+    var ac = null;
+    try { ac = new AbortController(); } catch (e) { ac = null; }
+    state.suggestAbort = ac;
+    /* 界面侧 20s 放弃：core 侧是 22s / 插件 25s，留出余量让服务端先把进程收掉。 */
+    var timer = setTimeout(function () { if (ac) { try { ac.abort(); } catch (e) {} } }, 20000);
+    Promise.resolve(transport.suggest({
+      user: String(userText == null ? '' : userText).slice(0, 4000),
+      reply: reply.slice(-16000),
+      /* 用户在「我的 → 建议引擎 / 模型」里选的那组；空值在上面已经提前 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;     // 已经开新轮 / 换会话 / 又收尾了
+        if (state.replay || state.busy) return;
+        if ((state.session || '') !== sid) return;
+        /* 身份记在**渲染之前**：renderSuggestions 里会把托管计时器排上，它要读这个身份。 */
+        sugId = { sid: sid, seq: seq };
+        state.suggestHistory = history;
+        var items = (res && Array.isArray(res.suggestions)) ? res.suggestions : [];
+        renderSuggestions(items, history);
+        if (cacheKey) writeHistorySuggest(cacheKey, items);
+      })
+      .catch(function (e) {
+        if (seq !== state.suggestSeq) return;
+        /* 超时 / abort 是常态（用户已经发了下一句），不打扰；其它失败也只在控制台说一声。 */
+        if (e && e.name === 'AbortError') return;
+        console.info('[conv] 建议生成失败：' + ((e && e.message) || e));
+      })
+      .then(function () {
+        clearTimeout(timer);
+        if (state.suggestAbort === ac) state.suggestAbort = null;
+      });
+  }
+
+  /** 画建议行（最多 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(); })
+      .slice(0, 3);
+    state.suggestHistory = hist;
+    bar.classList.toggle('sugbar--history', hist);
+    bar.innerHTML = '';
+    if (!items.length) { bar.hidden = true; return; }
+    /* 托管态先落一枚「托管中」标记：用户一眼看到「接下来会自动发」，
+       点它当场暂停（与运行设置里的按会话开关是同一个状态，只差一个更近的入口）。 */
+    if (state.hosting && !hist) {
+      var tag = el('button', 'sugtag');
+      tag.type = 'button';
+      tag.textContent = '托管中';
+      tag.title = '会话托管：' + Math.round(hostingDelay / 100) / 10 + ' 秒后自动发送第一条建议；点击暂停';
+      tag.addEventListener('click', function () { pauseHosting(''); });
+      bar.appendChild(tag);
+    }
+    items.forEach(function (text, i) {
+      var b = el('button', 'sugchip');
+      b.type = 'button';
+      b.textContent = text;
+      b.title = text;
+      if (state.hosting && !hist && i === 0) b.classList.add('sugchip--next');
+      b.addEventListener('click', function () { pickSuggestion(text); });
+      bar.appendChild(b);
+    });
+    bar.hidden = false;
+    if (state.hosting && !hist) scheduleHostingSend(items[0]);
+  }
+
+  /** 点了建议 = 用户明确要发这句：清掉建议行，走与打字完全相同的发送路径。 */
+  function pickSuggestion(text) {
+    var t = String(text == null ? '' : text).trim();
+    if (!t) return;
+    state.hostingRounds = 0;                     // 用户亲手点的：托管计数重新起算
+    clearSuggest();
+    if (window.MagicHost && typeof window.MagicHost.send === 'function') window.MagicHost.send(t);
+  }
+
+  /* ══════════ 会话托管（2026-10-23）══════════
+     用户：「托管模式下自动按照最佳建议提交到会话中执行」。同日再定：「跟团队模式一样
+     改成挂在会话上，子会话继承，不再是全局」。
+
+     这里只做**执行**，开关的权威值在宿主，且**按会话**（移动端会话页 → 任务运行设置；
+     子会话没有自己的记录时由宿主沿父链继承）。
+     一次托管轮次的完整路径：
+       成功收尾 → 生成建议 → 画出来（含「托管中」标记）→ 等 hostingDelay
+       → 复核「还该发吗」→ 第一条建议直接走 fireTurn（用户气泡、beforeAsk、权限、排队全部照旧）。
+
+     复核不是形式：延时期间用户可能已经开始打字、贴了附件、点了别的建议、
+     切了会话、或者干脆把托管关了 —— 任何一条命中都必须放弃这次自动发送。
+     自动暂停（失败 / 被停 / 到上限 / 用户暂停）都回调 onHostingChange，
+     让宿主把**这条会话**的开关同步关掉，不留下「界面显示开着、其实已经不跑了」的错觉。 */
+
+  function clearHostingTimer() {
+    if (state.hostingTimer) { clearTimeout(state.hostingTimer); state.hostingTimer = 0; }
+  }
+
+  /** 撤掉提问卡的自动作答：清计时器 + 把卡头那枚「托管中」标签摘掉。
+   *  不重置 hostingAskAnswered —— kernelDone 还要靠它决定「这一问是托管答的，可以继续出建议」。 */
+  function clearHostingAsk() {
+    if (state.hostingAskTimer) { clearTimeout(state.hostingAskTimer); state.hostingAskTimer = 0; }
+    var card = state.hostingAskCard;
+    state.hostingAskCard = null;
+    if (card) {
+      var tag = card.querySelector('.qa-ask-hosting');
+      if (tag && tag.parentNode) tag.parentNode.removeChild(tag);
+    }
+  }
+
+  /** 「最佳」= 优先挑措辞像继续的选项；没有就第一项（模型给的顺序本来就是推荐序）。 */
+  function bestAskOption(qb) {
+    var opts = [].slice.call(qb.querySelectorAll('.qa-ask-opt'));
+    if (!opts.length) return null;
+    var good = /继续|下一步|开始|执行|确认|是|好/;
+    var bad = /取消|停止|拒绝|不用|否|关闭/;
+    for (var i = 0; i < opts.length; i++) {
+      var lb = String(opts[i].dataset.label || opts[i].textContent || '');
+      if (good.test(lb) && !bad.test(lb)) return opts[i];
+    }
+    return opts[0];
+  }
+
+  /** 真正的交卷：把每一问的第一项点中，再让内核的 qaAskMark 落定。
+   *  全单选时点最后一项内核会自己发；带多选时它要等 1.5s，这里 80ms 后直接收笔。 */
+  function fireHostingAsk() {
+    state.hostingAskTimer = 0;
+    var card = state.hostingAskCard;
+    if (!state.hosting || !card || !card.isConnected || card.dataset.answered === '1' || card.dataset.hostingSkip === '1') {
+      clearHostingAsk();
+      return;
+    }
+    if (state.hostingRounds >= hostingMax) {
+      pauseHosting('已连续自动执行 ' + hostingMax + ' 轮，先停下来确认结果');
+      return;
+    }
+    var qbs = [].slice.call(card.querySelectorAll('.qa-ask-qb'));
+    if (!qbs.length) { clearHostingAsk(); return; }
+    var picks = [];
+    for (var i = 0; i < qbs.length; i++) {
+      var opt = bestAskOption(qbs[i]);
+      if (!opt) { clearHostingAsk(); return; }       // 有一问没有选项 → 不替用户猜，留给人工
+      picks.push(opt);
+    }
+    state.hostingRounds++;
+    state.hostingAskAnswered = true;
+    picks.forEach(function (opt) { try { opt.click(); } catch (e) {} });
+    setTimeout(function () {
+      if (state.hostingAskCard === card && card.isConnected && card.dataset.answered !== '1'
+          && typeof qaAskMark === 'function' && typeof qaAskText === 'function') {
+        try { qaAskMark(card, qaAskText(card)); } catch (e) {}
+      }
+      if (state.hostingAskCard === card) clearHostingAsk();
+    }, 80);
+  }
+
+  /** 卡一出现就排一次自动答；只在**当前会话的停靠位**里找，后台会话的卡不动。 */
+  function scheduleHostingAsk() {
+    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');
+    var card = null;
+    for (var i = cards.length - 1; i >= 0; i--) {
+      var c = cards[i];
+      if (c.dataset.answered === '1' || c.dataset.hostingSkip === '1' || !c.isConnected) continue;
+      card = c; break;
+    }
+    if (!card) return;
+    state.hostingAskAnswered = false;             // 新的一张卡：还没自动答过
+    if (state.hostingRounds >= hostingMax) {
+      pauseHosting('已连续自动执行 ' + hostingMax + ' 轮，先停下来确认结果');
+      return;
+    }
+    state.hostingAskCard = card;
+    var hd = card.querySelector('.qa-ask-hd');
+    if (hd) {
+      var tag = document.createElement('button');
+      tag.type = 'button';
+      tag.className = 'sugtag qa-ask-hosting';
+      tag.textContent = '托管中';
+      tag.title = '会话托管：' + (Math.round(hostingDelay / 100) / 10) + ' 秒后自动选第一项继续；点击暂停';
+      tag.addEventListener('click', function (e) {
+        e.preventDefault(); e.stopPropagation();
+        pauseHosting('');
+      });
+      hd.insertBefore(tag, hd.querySelector('.qa-ask-x') || null);
+    }
+    /* 用户只要碰了卡（选项 / 其他输入 / 关闭）就取消自动答，不跟人抢。 */
+    card.addEventListener('pointerdown', function (e) {
+      if (e.target && e.target.closest && e.target.closest('.qa-ask-hosting')) return;
+      card.dataset.hostingSkip = '1';
+      clearHostingAsk();
+    }, { once: true });
+    card.addEventListener('focusin', function () {
+      card.dataset.hostingSkip = '1';
+      clearHostingAsk();
+    }, { once: true });
+    state.hostingAskTimer = setTimeout(fireHostingAsk, hostingDelay);
+  }
+
+  /** 暂停托管（组件内部发起）：改状态 + 通知宿主 + 留下原因。 */
+  function pauseHosting(reason) {
+    clearHostingTimer();
+    clearHostingAsk();
+    state.hostingAskAnswered = false;
+    var was = state.hosting;
+    state.hosting = false;
+    state.hostingRounds = 0;
+    if (!was) return;
+    if (typeof opts.onHostingChange === 'function') {
+      try { opts.onHostingChange(false, String(reason || '')); } catch (e) {}
+    }
+  }
+
+  /** 宿主设置托管开关（用户点会话页「任务运行设置」里的开关，或切换会话时同步初值）。
+   *  ⚠️ 刻意不回调 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;
+    state.hostingAskAnswered = false;
+    clearHostingTimer();
+    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 || !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 = ''; }
+    if (typed) { pauseHosting('输入框里有没发出去的内容'); return; }
+    if ((state.attachments || []).length) { pauseHosting('输入框里还有附件'); return; }
+    if (state.plugin) { pauseHosting('输入框里还选着插件'); return; }
+    if (state.hostingRounds >= hostingMax) {
+      pauseHosting('已连续自动执行 ' + hostingMax + ' 轮，先停下来确认结果');
+      return;
+    }
+    var ident = { sid: sugId.sid, seq: sugId.seq };
+    state.hostingTimer = setTimeout(function () {
+      state.hostingTimer = 0;
+      if (!state.hosting) return;
+      /* ① 归属不复核就等于跨会话发送：建议是**某条会话**那一轮的下一步，
+         不是「这个组件此刻挂着的那条」的。会话变了（或建议已换代）→ 直接放弃。 */
+      if (ident.sid !== sugId.sid || ident.seq !== sugId.seq) return;
+      if (ident.sid && (state.session || '') !== ident.sid) return;
+      /* 延时期间世界可能变了：逐条复核，任何一条命中都放弃本次发送。 */
+      if (state.busy || state.queue.length) return;
+      var nowTyped = '';
+      try { nowTyped = String(ctx.input.value || '').trim(); } catch (e) { nowTyped = ''; }
+      if (nowTyped) { pauseHosting('输入框里有没发出去的内容'); return; }
+      if ((state.attachments || []).length) { pauseHosting('输入框里还有附件'); return; }
+      if (state.plugin) { pauseHosting('输入框里还选着插件'); return; }
+      if (state.hostingRounds >= hostingMax) {
+        pauseHosting('已连续自动执行 ' + hostingMax + ' 轮，先停下来确认结果');
+        return;
+      }
+      /* 只发「此刻真的画在建议行里」的第一条：如果空建议 / 已被新响应替换 /
+         行被藏起来，宁可这次不发，也不能拿一个用户看不见的旧句子自动开一轮。
+         （2026-10-23 用户报「明明没有建议，托管却发出又写一篇」的兜底闸门。） */
+      var sugbar = ctx.sugBar;
+      if (!sugbar || sugbar.hidden) return;
+      var live = sugbar.querySelectorAll('.sugchip');
+      if (!live.length || String(live[0].textContent || '').trim() !== String(text).trim()) return;
+      state.hostingRounds++;
+      clearSuggest();                                    // 建议行收起（含本条的「托管中」标记）
+      /* 直接走 fireTurn：不经过输入框，不把这句话闪进 textarea；用户气泡、串行门、
+         权限与排队语义仍由同一条路负责（与点建议、打字发送完全一致）。
+         meta.hosted = 画成「托管发送」而不是「我」，并让 history 也带这个标识。 */
+      Promise.resolve(fireTurn(String(text), [], [], null, { hosted: true })).catch(function (e) {
+        pauseHosting('自动发送失败：' + ((e && e.message) || e));
+      });
+    }, hostingDelay);
+  }
+
   /** 一轮收尾（成功 / 失败 / 被停）：内核的收尾动作已经做完（收思考区 / 工具卡 / 运行胶囊），
    *  这一层只补**收尾行**（状态语 + 总耗时，取墙上时钟 —— 与掌天瓶那边同一口径）。 */
   function kernelDone(ok, label) {
+    /* 销毁后迟到的终态：这一轮已经不属于任何画面了 —— 收尾行、托管判定、建议请求
+       一条都不该再跑（它们会写进新实例的画布，或替新实例发下一句）。 */
+    if (destroyed) return;
+    /* 失败 / 被用户停：托管立刻暂停。这两类收尾没有「下一步」可自动执行，
+       继续挂着只会在下一轮突然又动起来 —— 用户很难把因果对上。 */
+    /* ⚠️ 回放（看历史）里的失败 / 中止不算：那可能是几天前的一条旧轮次，
+       翻到它就把托管关掉，用户会以为托管自己坏了。只看**这一次真的在跑**的轮次。 */
+    if (!state.replay && (!ok || label === '已停止')) {
+      pauseHosting(!ok ? '这一轮失败了' : '这一轮被停止');
+    }
     var q = state.qa; if (!q) return;                  // 幂等：终态可能来两条（turn_end 之后还有 end）
+    /* 上一轮的建议随这一轮结束一起作废；新的那批在下面按结果决定要不要求。 */
+    clearSuggest();
     state.qa = null;
     state.qaClosed = true;                             // 迟到事件不再开新一笔（见 state.qaClosed）
     state.awaitingAnswer = false;
@@ -862,6 +1354,9 @@
        不在这条消息块里，所以撤掉不丢收尾行。 */
     dropEmptyAnswer(q.h);
     qaRenderDone(ok, label, thread(), ms);
+    /* 只有「真的跑完了」才有下一步可取：失败 / 被停 / 回放的轮次都不问。
+       请求异步进行，界面不等待 —— 结果回来再画（见 requestSuggestions）。 */
+    if (ok && label !== '已停止' && !state.replay) requestSuggestions(state.lastPrompt, state.agentRaw);
     if (opts.onBusy) { try { opts.onBusy(false); } catch (err) {} }
     /* 收掉运行态（2026-10-20 用户：「进行中已经变了 结束的时候图没变」）。
        这里是「这一轮真的结束了」的**唯一收口**（turn_end / error / end 都落到这里），
@@ -887,6 +1382,7 @@
   }
 
   function clearThread() {
+    clearSuggest();                              // 换会话 / 清屏：上一轮的建议不能留给下一段画面
     histSid = null;                              // 画布清空 = 历史不在场了（见 setSession 的短路）
     /* 换会话先停掉上一轮的断线续传轮询：否则补拉回来的事件会落进新会话的画面。 */
     if (state.resumeStop) { var rs = state.resumeStop; state.resumeStop = null; try { rs(); } catch (e) {} }
@@ -916,6 +1412,9 @@
     state.replayT0 = 0; state.replayLastAt = 0;
     state.resumeT0 = 0;
     state.awaitingAnswer = false;
+    state.qaHadAsk = false;
+    clearHostingAsk();
+    state.hostingAskAnswered = false;
     clearWorking();                              // 递带停掉秒表（只置 null 会让定时器空转）
     state.autoFollow = true;
     if (mdTimer) { clearTimeout(mdTimer); mdTimer = 0; }
@@ -1006,6 +1505,11 @@
     }
 
     async function send() {
+      if (destroyed) return;                     // 销毁后的实例不许再发（见 destroyed 的注释）
+      /* 用户亲手发了一句：托管计数重新起算（手动接管意味着「我还想继续」）；
+         正在等的那次自动发送也立刻作废 —— 用户已经自己发了，不能再补一条。 */
+      state.hostingRounds = 0;
+      clearHostingTimer();
       /* 插件胶囊在场时，用户写的只是「做什么」；**真正下发的提示词**由这一层补上
          「用哪个 CLI 做」（见 buildPluginPrompt）。所以这里读的是原文，
          两个都空才拦（只有插件、没写要求时用插件的模板兜住）。 */
@@ -1042,21 +1546,18 @@
       /* `state.queue.length` 也算「忙」：flush 已经在路上的那一小段窗口里，
          新提交的必须排到队尾，不能插到前一条排队追问的前面。 */
       if (state.busy || state.queue.length) {
-        /* ⚠️ 气泡**当场就画**，不等轮到它
-           （2026-10-21 用户：「确实合并了 但是追问的内容没在对话内容区域显示」）。
-           以前这里只往排队条里塞一条 chip：用户写完一抬头，对话区里空空的，
-           自己那句话只在输入框上方那行小字里 —— 看上去就像没发出去。
-           串行门那条路径（beforeAsk 挂起）反而是先画气泡再等，两边观感不一致。
-           现在两条路一致：**发出去的那一刻就落进画布**，排队状态由气泡自己标。 */
-        var qb = qaRenderMine(text, sentAtts || []);
-        if (qb) qb.classList.add('is-queued');
-        var item = { id: qid(), text: text, atts: sentAtts, attPaths: attPaths, bubble: qb };
+        /* 2026-10-22 用户定稿：「排队的列表应该显示在对话框上面不进对话区域」，
+           同日再收一句「排队的任务列表是挂在对话框外面不是里面」。
+           排队的那条**还没跑**，画成用户气泡会让人以为已经发出去了；它只进输入框
+           **外面**上沿的 queuebar（见 renderQueue），轮到它时再由 fireTurn 正常落进画布。
+           （前一天曾在画布上先画气泡，用户已明确改回这个口径。） */
+        var item = { id: qid(), text: text, atts: sentAtts, attPaths: attPaths, bubble: null,
+                     /* 2026-10-23：条目**当场钉死归属会话**（提交这一刻的 state.session）。
+                        新会话的首句排进来的那一刻 state.session 还是空串，等 core 回 session_id
+                        才填上 —— 落库时再读就成了空串，接回时按空串匹配等于「谁都可能是它」。
+                        见 notifyQueue / flushQueue 里按它做的核对。 */
+                     sid: state.session || '' };
         state.queue.push(item);
-        /* 取消入口做在**气泡上**（排队条那边不再重复列一遍，见 renderQueue）：
-           用户要撤的就是这一句话，按钮贴在它身上最直接。 */
-        if (qb) item.unmountCancel = mountQueueCancel(qb, item);
-        /* 气泡已经画过了，轮到它时别再画一遍。 */
-        state.noEcho = false;
         renderQueue();
         /* 这条队列只在内存里，刷新/关 App 就整条消失（2026-10-21 用户：
            「非团队的串行排队也没落库」）。交给宿主记进它那套持久化队列
@@ -1085,8 +1586,19 @@
     /* 真正开跑一轮：本地用户气泡（内核的 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;
+      state.hostingAskAnswered = false;
       state.lastPrompt = text;
       state.lastAttPaths = attPaths || [];      // 记住本轮附件，重试时一起重发
       /* 用户那条气泡由**内核**画（qaRenderMine）—— 与另外两端逐字同一份实现；
@@ -1096,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 });
     }
 
     /* ── 排队追问：渲染 / 取消 / 收尾后自动提交 ──
@@ -1132,47 +1644,56 @@
            （少了 session 追问会变成新会话，少了 team 会静默降级成单任务）。 */
         payload = {
           id: it.id, prompt: it.text, attachments: (it.attPaths || []).slice(),
-          session: state.session || '', workspace: state.workspace || '',
+          /* atts = 气泡缩略图的快照（{name, remoteUrl}）。落库时必须一起带上：
+             宿主重新打开会话时用 adoptQueue 把排队气泡画回来，只存本地路径的话
+             恢复出来的气泡会丢图（用户看到的是一句没有截图的话）。 */
+          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) {}
     }
 
-  /* 排队条：**只在气泡画不出来时**兜底。
-     正常路径下排队的那句已经作为气泡落在画布上了（见 send 的排队分支），
-     再在输入框上方原样列一遍就是同一句话出现两次 —— 用户还得在两处找「取消在哪」。
-     所以现在的分工是：
-       · 气泡（首选）：一句「排队中 · 上一轮结束后自动发送」+ 一个「取消排队」按钮；
-       · 排队条（兜底）：只有 bubble 没画成（老内核没有 qaRenderMine 返回值、
-         或画布当时不在）的条目才在这里列一行，保证它们仍然可见、仍然能撤。 */
+  /* 排队条 = **排队条目的唯一可见处**（2026-10-22 用户：「排队的列表应该显示在
+     对话框上面不进对话区域」；同日再定稿「排队的任务列表是挂在对话框外面不是里面」）。
+     位置在输入框**外面**的上沿（composer__box 之外的 queuebar，见 DOM 那段注释），
+     每条一行文本 + ✕；轮到它时由 flushQueue 从队列取走，fireTurn 再把气泡画进画布。
+     所以同一句话**只会在一个地方出现**：排队时在上方列表，发出后才进对话区。 */
   function renderQueue() {
+    if (destroyed) return;
     var bar = ctx.queueBar;
     if (!bar) return;
     bar.innerHTML = '';
-    var orphan = state.queue.filter(function (it) { return !it.bubble || !it.bubble.parentNode; });
-    bar.hidden = !orphan.length;
-    if (!orphan.length) return;
-    bar.appendChild(el('div', 'queuebar__cap', '排队中 · 本轮结束后自动发送'));
-    orphan.forEach(function (it) {
-      var idx = state.queue.indexOf(it);
-      var row = el('div', 'queuechip');
-      row.appendChild(box('queuechip__ico', 'i-clock', 13));
-      var t = el('span', 'queuechip__t', it.text);
-      t.title = it.text;
-      row.appendChild(t);
-      var x = el('button', 'queuechip__x', '✕');
-      x.type = 'button';
-      x.setAttribute('aria-label', '取消这条排队');
-      x.onclick = function () { dropQueued(idx); };
-      row.appendChild(x);
-      bar.appendChild(row);
-    });
+    var list = state.queue;
+    bar.hidden = !list.length;
+    if (list.length) {
+      bar.appendChild(el('div', 'queuebar__cap', '排队中 · 本轮结束后自动发送'));
+      list.forEach(function (it, idx) {
+        var row = el('div', 'queuechip');
+        row.appendChild(box('queuechip__ico', 'i-clock', 13));
+        var t = el('span', 'queuechip__t', it.text);
+        t.title = it.text;
+        row.appendChild(t);
+        var x = el('button', 'queuechip__x', '✕');
+        x.type = 'button';
+        x.setAttribute('aria-label', '取消这条排队');
+        x.onclick = function () { dropQueued(idx); };
+        row.appendChild(x);
+        bar.appendChild(row);
+      });
+    }
+    /* 挂到框外后，排队条占的高度是从**画布**那边让出来的（框的尺寸不变）：
+       本来贴着底看的人，条子一出现最后一行就会被挤掉半截；撤掉（收尾自动发出）时同理。
+       autoFollow 时贴一次底 —— 必须在**填完内容之后**量（先量后填，撑高的那截又会被裁掉）。 */
+    if (state.autoFollow) scrollBottom();
   }
 
-  /* 从队列里撤掉一条：气泡（画过的）与排队条（兜底项）都要清掉，
-     否则画布上留着一句永远不会被回答的话。 */
+  /* 从队列里撤掉一条：排队条与（历史遗留的）画布气泡都清掉，并通知宿主删掉落库记录。 */
   function dropQueued(idx) {
     if (idx < 0 || idx >= state.queue.length) return false;
     var gone = state.queue.splice(idx, 1)[0];
@@ -1182,39 +1703,14 @@
     renderQueue();
     return true;
   }
-  /* 在排队气泡上挂一个「取消排队」：撤这一条，并把气泡一起摘掉。
-     状态说明（「排队中 · 上一轮结束后自动发送」）由 CSS 的 ::after 画，
-     这里只负责那颗按钮 —— 文案只有一处，改的时候不会两边不一致。 */
-  function mountQueueCancel(bubble, item) {
-    var acts = bubble.querySelector('.qa-acts');
-    if (!acts) return null;
-    var wasHidden = acts.hidden;
-    var b = el('button', 'qa-act qa-act--cancel', '取消排队');
-    b.type = 'button';
-    b.onclick = function (e) {
-      if (e) { e.preventDefault(); e.stopPropagation(); }
-      var i = state.queue.indexOf(item);
-      if (i >= 0) dropQueued(i);
-      noticeItem('已取消这条排队');
-    };
-    acts.hidden = false;
-    acts.appendChild(b);
-    /* 轮到这一条（flushQueue 把它从队列里取走）时必须把这颗按钮摘掉：
-       它已经不在队列里了，还挂着「取消排队」会让人以为按了能撤，
-       按下去只会弹一句「已取消这条排队」，其实什么都没撤。 */
-    return function () {
-      if (b.parentNode) b.parentNode.removeChild(b);
-      if (wasHidden) acts.hidden = true;
-    };
-  }
 
     /* 换会话 / 新建会话：排队条目属于**上一条会话**，不能落到新会话的画布里。
        返回取消的条数，由调用方决定怎么如实告知用户（静默丢用户刚写的东西最难查）。 */
     function clearQueue() {
       var n = state.queue.length;
       if (!n) return 0;
-      /* 排队时气泡已经画在画布上了（见 send 的排队分支）：换会话就得一并撤掉，
-         否则那几句话跟着进了新会话的画布，看着像「我在这个会话里问过」。 */
+      /* 排队条目只在上方 queuebar（不再画进画布）；换会话时一并撤掉，
+         再通知宿主删掉对应的落库记录，否则它会跟着新会话冒出来。 */
       state.queue.forEach(function (it) {
         if (it.bubble && it.bubble.parentNode) it.bubble.parentNode.removeChild(it.bubble);
         notifyQueue('drop', it);
@@ -1226,28 +1722,81 @@
 
     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;
-      var it = state.queue.shift();
-      /* 轮到它了：摘掉「取消排队」与气泡上的排队标记（这一轮已经开跑，
-         再不摘就会留下一个按了没用的按钮、和一句与实际状态不符的「排队中」）。 */
-      if (it.unmountCancel) { try { it.unmountCancel(); } catch (e) {} it.unmountCancel = null; }
-      if (it.bubble && it.bubble.classList) it.bubble.classList.remove('is-queued');
+      /* 销毁后别再动队列：取走 / 发出去 / 通知宿主 take，任意一步都会让新实例那条
+         排队 chip 变成「已发出还在显示」（见 destroyed 的注释）。 */
+      if (destroyed || flushing || state.busy || state.replay || !state.queue.length) return;
+      var it = state.queue[0];
+      /* ⚠️ 2026-10-23（用户：「排队的和自动建议发送串会话了」）：这条**不是当前会话排的**就整队作废，
+         一条都不发 —— 队列跟会话走，实例被复用到别的会话后，把上一条会话的追问发出去就是
+         张冠李戴（不仅气泡画错，`session` 续接也跟着串）。正常情况下 setSession/newSession
+         已经 clearQueue 过；这里是第二道闸：接回（adoptQueue）与运行时落定的 session_id
+         之间有时间差，闸门必须自己判，不能只靠调用方记得清。 */
+      if (it.sid && state.session && it.sid !== state.session) {
+        var n = clearQueue();
+        if (n) noticeItem('排队追问属于另一条会话，已取消 ' + n + ' 条');
+        return;
+      }
+      state.queue.shift();
+      /* 轮到它了：先把它从上方排队列表里摘掉（renderQueue 重画），再由 fireTurn
+         正常画进画布 —— 同一句话不会在列表和对话区各出现一次。 */
       renderQueue();
       /* 轮到它了：宿主那条「等待中」该换成真正跑起来的会话（见 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();
     }
 
-    async function runTurn(prompt, attPaths, bubble) {
+    /* ── 把宿主落库的排队条目接回**输入框上方的排队列表**（2026-10-22）──
+       需求演进：排队条目**不进对话区**（用户当天定稿「排队的列表应该显示在
+       对话框上面不进对话区域」）；重进会话时也要在这里看到它。
+       根因：排队条目原先只有组件内存里的 state.queue。组件被销毁重建（返回列表
+       后再进来 / 切过别的会话 / WebView 被系统回收）内存队列就没了；历史回放读的是
+       **已落盘**日志，这条还没发出去，日志里当然没有 —— 于是凭空消失，宿主那条
+       持久化记录还躺在 PENDING 里没人认领。
+       现在宿主在历史画完之后把属于这条会话的条目喂回来：列进 queuebar、接回队列，
+       这一轮收尾时照常 flush。id 沿用宿主的持久化 id —— 轮到 / 取消时宿主据此对账
+       （onQueueTake / onQueueDrop），不会删错行。
+       items: [{id, prompt, session?, attachments:[core 路径], atts:[{name,remoteUrl}]}]
+       2026-10-23：`session` = 宿主核对过归属的那条会话（adoptPendingFor 按它筛过），
+       条目把它记进自己的 sid —— flushQueue 发之前按它核对，不属于当前会话就整队作废。
+       （这之前只按「宿主筛过了」信任，而宿主那一侧的匹配在 session 为空时是放行的。） */
+    function adoptQueue(items) {
+      /* 销毁后的实例不许再接管：条目归宿主，等下一个活实例来认领（否则它会挂在
+         一块已经不在页面上的排队条里，谁都发不出去）。 */
+      if (destroyed || !Array.isArray(items) || !items.length) return 0;
+      var n = 0;
+      items.forEach(function (it) {
+        if (!it || !it.id || !it.prompt) return;
+        if (state.queue.some(function (x) { return x.id === it.id; })) return;
+        var atts = (it.atts || []).slice();
+        var attPaths = (it.attachments || []).slice();
+        /* 只入队 + 列表：不画进画布（还没发出去，画成用户气泡会让人以为已发送）。 */
+        var item = { id: it.id, text: it.prompt, atts: atts, attPaths: attPaths, bubble: null,
+                     sid: it.session || state.session || '', hosted: !!it.hosted };
+        state.queue.push(item);
+        n++;
+      });
+      if (n) {
+        renderQueue();
+        /* 这一刻组件刚回放完历史：如果那一轮已经收尾（busy=false）就立刻发，
+           还在跑（follow 已接管 busy）则由 followEnd 的 scheduleFlush 接手。 */
+        scheduleFlush();
+      }
+      return n;
+    }
+
+    async function runTurn(prompt, attPaths, bubble, meta) {
+      if (destroyed) return;                       // 见 destroyed 的注释：销毁后不许开轮
+      var hosted = !!(meta && meta.hosted);
       /* 本页原本在尾随别的进程跑的那一轮（follow）：现在自己要发新一轮 →
          先把旧尾随掐掉。**不能等收尾再掐** —— 旧会话的增量会继续 render，
          而新一轮的事件也在同一张画布上，正文就重复了。也不走 stopFollow：
@@ -1286,6 +1835,9 @@
             /* team：团队开关也是这一轮的**下发参数**。宿主排队落库后重发时必须还原它，
                否则「开了团队模式的任务」在串行队列里会被静默降级成单任务。 */
             team: state.team ? teamPayload() : null,
+            /* hosted：托管自动发出的那一轮，串行门落库 / 重发时要原样还原 ——
+               否则重启后补发的那条在历史里会变回「用户亲手发的」。 */
+            hosted: hosted,
             prompt: prompt, attachments: (attPaths || []).slice(),
             /* queued(on)：宿主**确认这一轮要等**时调它，把「排队中」标到气泡上；
                放行时调 queued(false)（或不调，runTurn 收口时会摘）。
@@ -1339,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 () {
@@ -1369,7 +1924,13 @@
                 if (el && !el.querySelector('.qa-t, .qa-think, .qa-tools, .qa-tool, .qa-ask, .qa-agent, .qa-mk, .qa-sep, .qa-img')) {
                   if (el.parentNode) el.parentNode.removeChild(el);
                 }
-                kernelDone(false, label || (failed ? '没有收到回复 · core 异常退出' : '没有收到回复 · 连接中断'));
+                /* ⚠️ 兜底收尾也要分成功/失败（2026-10-23 实测）：
+                   有些引擎（如 llm）只发 result 不发 turn_end，走的就是这条 hardFinish。
+                   以前无条件传 false，于是「已完成」的轮次在建议门 / 托管暂停里被当成失败：
+                   建议永远不请求、托管第一轮就被暂停。判据只看**明确的成功措辞**；
+                   「连接中断 / core 异常退出」一律仍算失败。 */
+                var good = !failed && !!label && label.indexOf('已完成') === 0;
+                kernelDone(good, label || (failed ? '没有收到回复 · core 异常退出' : '没有收到回复 · 连接中断'));
               } else {
                 noticeItem('本轮没有收到任何输出（连接可能已断开），请重试');
               }
@@ -1428,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;
@@ -1851,6 +2414,55 @@
       return { index: idx, terminal: terminal, at: idx >= 0 ? replayAt(events[idx]) : 0 };
     }
 
+    /* 历史最后一轮能不能补建议：必须是**成功收尾**、没有待答提问卡、正文够长。
+       `lastTurnInfo` 只回答“有没有终态”，这里再判“终态是不是成功 + 正文在哪”。 */
+    function historyTurnReply(events, idx) {
+      if (idx < 0) return null;
+      var end = null, result = null, failed = false, pendingAsk = false, texts = [];
+      for (var i = idx + 1; i < events.length; i++) {
+        var e = events[i] || {};
+        var k = e.kind || e.type;
+        if (k === 'ask' || k === 'permission') pendingAsk = true;
+        if (k === 'turn_failed' || k === 'error') failed = true;
+        if (k === 'turn_end') end = e;
+        if (k === 'result') result = e;
+        if (k === 'text' && e.text) texts.push(String(e.text));
+      }
+      if (failed || pendingAsk) return null;
+      var term = end || result;
+      if (!term) return null;
+      var st = String(term.status || '').toLowerCase();
+      if (/fail|error|stop|cancel|abort/.test(st)) return null;
+      var reply = String(term.text || '').trim();
+      if (reply.length < 12) reply = texts.join('').trim();
+      if (reply.length < 12) return null;
+      return reply;
+    }
+
+    /* 打开历史会话时，只给**最后一轮**补一次建议：
+       · 还在跑 / 刚接上实时流 → 不补（live / partial，收尾后走实时那条）；
+       · 最后一轮失败 / 被停 / 有提问卡 → 不补；
+       · 先读缓存（按 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;
+      var reply = historyTurnReply(events, idx);
+      if (!reply) return;
+      var u = events[idx] || {};
+      var key = historySuggestKey(sid, u);
+      if (key) {
+        var cached = readHistorySuggest(key);
+        if (cached) {
+          if (cached.length) renderSuggestions(cached, true);
+          return;
+        }
+      }
+      requestSuggestions(String(u.text || ''), reply, { history: true, cacheKey: key });
+    }
+
     /* 补拉路径的收口：内核的统一收尾（qaRunEnd = finish + 摘「生成中」胶囊）之后
        再补收尾行。为什么不能只调 kernelDone：内核的 `result` 分支**不收尾**
        （实时流靠网关的 SSE `end` 帧收尾），而 ask 缓冲里只有 core 的 stdout 行 ——
@@ -2022,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;
@@ -2040,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' }); }
       });
@@ -2210,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
@@ -2317,6 +2951,11 @@
         /* 首载结束：骨架屏撤下。一条都没画出来（空会话）→ 把空态那句还回去。
            ⚠️ 期间用户可能已经切走（迟到的这一份不许撤新会话的骨架屏）。 */
         if (after == null && sid === state.session) endHistLoading(true);
+        /* 历史会话：回放完、确认真的是“已收尾且不在跑”的最后一轮 → 补一次建议。
+           只在首载做；分页拉更早 / 接续实时流都不做。 */
+        if (after == null && sid === state.session && !live && !partial && info.terminal) {
+          maybeHistorySuggest(sid, events, info.index);
+        }
         return events.length;
       });
       /* 读失败也要撤骨架屏（否则它会一直挂着，看着像永远读不完）。 */
@@ -2437,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 重画一遍。 */
@@ -2512,17 +3153,28 @@
     ctx.bottomBtn = el('span', 'tobottom');
 
     var form = el('form', 'composer');
+    /* 下一轮建议的停靠位（2026-10-23）：收尾后由 /desk/suggest 生成、贴在这条输入框**正上方**。
+       默认藏起来 —— 没有建议时它一个像素都不占（不预留空行，也不让输入框跳位）。 */
+    var sugBar = el('div', 'sugbar'); sugBar.hidden = true;
+    sugBar.setAttribute('role', 'group');
+    sugBar.setAttribute('aria-label', '建议追问');
+    ctx.sugBar = sugBar;
+    form.appendChild(sugBar);
     var cbox = el('div', 'composer__box');
     /* 提问卡的**停靠位**：内核按固定 id 找它（`home-askdock`，见 shared/conv/06-ask-answer.js），
        引擎提问 / 待授权时卡钉在输入框上方。显隐与进出全由内核管，这里只给一块地。 */
     var askDock = el('div', 'qa-askdock'); askDock.id = 'home-askdock'; askDock.hidden = true;
     cbox.appendChild(askDock);
-    /* 排队追问的停靠位（2026-10-21）：运行中提交的那几条排在这里，不进画布 ——
-       它们**还没跑**，画成用户气泡会让人以为已经发出去了。位置贴着输入框上沿
-       （与 PC 的 qaMsgList 同一意图：「新需求排列在会话框上面」）。 */
+    /* 排队追问的停靠位（2026-10-21；2026-10-22 挪到框外）：运行中提交的那几条排在这里，
+       不进画布 —— 它们**还没跑**，画成用户气泡会让人以为已经发出去了。
+       ⚠️ 挂在 `.composer__box` **外面**（框上沿之上，见下面 form 的 append 顺序），
+          不放进框里：用户 2026-10-22 定稿「排队的任务列表是挂在对话框外面不是里面」——
+          塞进圆角框会跟正在写的正文混成一条，看着像「已经写进这一句了」。
+          PC 的 `.ag-queue` 也是同一个挂法（.ag-box 之外）。 */
     var queueBar = el('div', 'queuebar'); queueBar.hidden = true;
+    queueBar.setAttribute('role', 'group');
+    queueBar.setAttribute('aria-label', '排队中');
     ctx.queueBar = queueBar;
-    cbox.appendChild(queueBar);
     /* 选中的插件胶囊的**停靠位**：在附件条上方、输入框之外。
        ⚠️ 不塞进 .attachbar 里：那是附件的地盘，混在一起后 clearAttachments
           （每轮必跑）会把胶囊一起清掉，而插件是「本轮怎么干」不是附件。 */
@@ -2578,6 +3230,9 @@
     crow.appendChild(cleft); crow.appendChild(ctx.sendBtn);
     cbox.appendChild(crow);
     form.appendChild(trow);
+    /* 排队条在**框外**、紧贴框的上沿（见上面 queueBar 的注释）：排在参数行之后，
+       出现时把参数行往上顶，而不是把输入框撑高 —— 框的尺寸只由输入内容决定。 */
+    form.appendChild(queueBar);
     form.appendChild(cbox);
     wrap.appendChild(form);
     root.appendChild(wrap);
@@ -2691,6 +3346,9 @@
       /* 附件也算「有内容」：忙时贴了图再点发送 = 排队，不能把它当成「停止」（同 send 的闸门）。 */
       if (typed || state.plugin || (state.attachments || []).length) return;
       e.preventDefault();
+      /* 用户按了「停止」：托管当场暂停，不等收尾行 —— 否则它可能在这一轮结束的
+         同一秒自动发出下一条，看起来像「点了停止还在自己跑」。 */
+      pauseHosting('这一轮被停止');
       control('interrupt');
     });
 
@@ -2721,6 +3379,10 @@
          引擎那边还在等，这一问就断了。 */
       if (state.awaitingAnswer) { control('answer', t); return; }
       state.noEcho = !!(o && o.echo === false);     // 内核的重试路径：那条气泡已经在画布上了
+      /* ⚠️ 显式指定会话（`o.sid`）而此刻挂着的**不是它** → 一律不发。
+         调用方（内核的重试 / 追问）给出的是「这条消息属于哪条会话」；
+         组件实例被复用到别的会话后，照旧落进当前会话就是串会话。 */
+      if (o && o.sid && String(o.sid) !== String(state.session || '')) return;
       ctx.input.value = t;
       send();
     };
@@ -3205,13 +3867,19 @@
       syncNewTitle();
       setTimeout(function () { ctx.input.focus(); }, 0);
     }
-    function setSession(sid, s) {
+    function setSession(sid, s, o) {
       /* 同一条会话重入（移动端「返回列表 → 再点进来」的高频路径）：画面就在眼前，
          别清屏重放整段历史 —— 宿主复用的是同一个组件实例（见 client-ui-mobile 的
          mountConversation），历史与实时流都还在内存里。判据除了「同一条会话」还要
          `histSid === sid`（历史真的在这块画布里，见 loadHistory / clearThread）。
-         这里只同步外壳状态：会话标题可能在列表里被改过，引擎 / 模型要跟着清单行走。 */
-      if (sid && sid === state.session && histSid === sid) {
+         这里只同步外壳状态：会话标题可能在列表里被改过，引擎 / 模型要跟着清单行走。
+         ⚠️ o.same：宿主**已经确认是同一屏会话**（run_id ↔ session_id 别名，组件自己
+            不知道这层映射）。此时按字面判会落到下面的「换会话」分支 ——
+            clearQueue() 把排队追问整队删掉，正是「重新进来就看不到」的病根。
+            所以宿主传 same 就只同步外壳，绝不换代。 */
+      var same = !!(o && o.same);
+      if (sid && ((sid === state.session && histSid === sid) || same)) {
+        if (sid) state.session = sid;
         if (s) {
           /* 清单行的 state / alive 是「要不要尾随实时进度」的判据（见 sessionLive）：
              重入时它可能刚从 running 变 done，必须跟着更新，否则会去尾随一条已收尾的会话。 */
@@ -3255,10 +3923,15 @@
         startWatch();
         /* watchInflight：这次首载期间别让 watcher 再插一次 loadHistory（大日志可能超过 5s）。 */
         watchInflight = true;
-        loadHistory(sid)
+        /* 返回「历史真的画完」的那个 Promise：宿主据此决定什么时候把落库的排队条目
+           adoptQueue 回来（抢在回放之前插气泡，会被 clearThread 一起清掉 —— 那正是
+           「重新进来就看不到」的另一半）。复用同一屏（上面那个分支）时它已经是 0 了，
+           宿主同样不必等。 */
+        return loadHistory(sid)
           .catch(function (e) { noticeItem('历史加载失败：' + (e.message || e)); })
           .then(function () { if (sid === state.session) watchInflight = false; });
       }
+      return Promise.resolve(0);
       /* 打开一条已有的回话（看历史 / 接着聊）时**不**自动把焦点塞进输入框：
          移动端上这一下会直接顶起软键盘，刚回放出来的历史被键盘挡掉大半。
          要打字时用户自己点输入框即可；newSession（用户主动「新建」）仍保留聚焦。 */
@@ -3288,7 +3961,27 @@
       });
     }
     function destroy() {
-      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);
     }
@@ -3305,8 +3998,8 @@
       el: root,
       state: state,
       send: send,
-      interrupt: function () { return control('interrupt'); },
-      stop: function () { return control('stop'); },
+      interrupt: function () { pauseHosting('这一轮被停止'); return control('interrupt'); },
+      stop: function () { pauseHosting('这一轮被停止'); return control('stop'); },
       answer: function (text) { return control('answer', text); },
       setEngine: function (n) { state.engine = n; syncPickers(); },
       setModel: function (n) { state.model = n; syncPickers(); },
@@ -3325,10 +4018,16 @@
       openTeamPicker: openTeamPicker,
       featureOn: featureOn,
       setEngines: function (list) { state.engines = list || []; syncPickers(); },
+      /* 会话托管：宿主按会话的开关调它（运行设置页）；hostingOn() 给宿主做开关态回读。 */
+      setHosting: setHosting,
+      hostingOn: function () { return !!state.hosting; },
+      /* 建议引擎：宿主「我的」里改配置时调它；空 = 关闭建议功能。 */
+      setSuggestEngine: setSuggestEngine,
       refreshEngines: refreshEngines,
       setSession: setSession,
       newSession: newSession,
       loadHistory: loadHistory,
+      adoptQueue: adoptQueue,
       render: function (ev) { render(ev); },
       syncPickers: syncPickers,
       destroy: destroy