magic-agent 1.0.49 → 1.0.109

package/client-ui/shared/conversation.js

@@ -13,7 +13,10 @@
  *      control({id, op, text?})             -> Promise   （op: interrupt | stop | answer）
  *      readSession(id, {after?})            -> Promise<{events, lastSeq?, snapshotRequired?}>
  *      listAsks()                           -> Promise<[{id, engine, started, session?, run?}]>  （可选）
- *                                              打开还在跑的会话时用它续上实时流（见 attachRunningAsk）
+ *                                              网关没有 followSession 时，用它 + askEvents 兜底续流
+ *      followSession(id, after, h)           -> {cancel}  （可选，**首选**）
+ *                                              打开还在跑的会话时尾随磁盘日志的增量（SSE）；
+ *                                              h: {onOpen?, onEvent, onSnapshot?, onEnd?, onError?}
  *      upload(file)                         -> Promise<{path, name, size, mime, url?}>  （可选）
  *      mediaUrl(path)                       -> string  （可选）附件回读地址；有它历史气泡才画得出缩略图
  *    掌天瓶走 IPC → CLI；别的对接方可能走 HTTP —— 组件对此一无所知。
@@ -30,9 +33,32 @@
  *      showPermission: 可选。false 则不显示输入框下的「授权」选择器（权限仍可用 openPermissionPicker 打开）
  *      onEvent:       可选。每个 core 事件透传一份给宿主（只读）
  *      onBusy:        可选。一轮开始/结束时回调 (busy:boolean)
+ *      beforeAsk:     可选。**每一轮下发前**的闸门 async (info) => boolean|undefined。
+ *                     info = {isNew, session, workspace, engine, model, permission, prompt,
+ *                             attachments, team, queued(on)}。
+ *                     返回 false = 宿主判定这一轮不必再发（移动端串行模式里用户取消排队就是这条），
+ *                     组件会清掉「进行中」态并留一条提示；返回其它任何值（含 undefined）= 照常下发。
+ *                     宿主在自己的 Promise 里慢慢等（比如排队等前一条跑完）即可，组件不设超时。
+ *                     `queued(true)` = 宿主**确认这一轮要等**，把「排队中」标到气泡上；
+ *                     `queued(false)` 放行时摘掉。组件**不按时间猜**排队态 —— 空闲时的一个请求
+ *                     往返不该闪一下假的「排队中」（2026-10-22 用户报的就是这个）。
+ *      onInterrupt:   可选。(prompt) => boolean。用户在这一轮**还没拿到 askId**（还在宿主那边排队）
+ *                     时点了打断：宿主认领就返回 true（撤掉排队），组件不再发 control。
+ *                     prompt 是刚发出去的那句，宿主据此认出是哪一条在排队。
  *      onPick:        可选。用户在选择器里**落定**引擎/模型时回调 (engine, model)。
  *                     宿主可据此把它记成下次新建任务的默认值（移动端「我的 → 默认引擎/模型」）；
  *                     只点左列引擎浏览模型不回调。引擎清单探测到记住的引擎已不可用而回退时也回调。
+ *      team:          可选。初始是否开启团队模式（默认 false）。
+ *      onTeamChange:  可选。(on) => void。用户在**组件自己的**团队面板里改了开关时回调。
+ *                     为什么需要它：开关的权威状态在宿主（移动端**按会话**落 localStorage，
+ *                     一进一出要还原），而面板是组件画的 —— 不回传的话只有组件知道
+ *                     用户开过，宿主那侧一重挂载就丢（实测：开了、跑完、重新打开会话又变回关）。
+ *                     初始值仍由 `team` 给，两边不会互相纠正。
+ *      features:      可选。core 能力位清单（`feature.*`），数组或 () => 数组。缺 = 当作不支持。
+ *      teamConfig:    可选。() => {routes:{plan|text|code|image|video|game:{engine,model}}, parallel}。
+ *                     **由宿主持有**（引擎/模型是宿主的偏好，不是这一轮对话的状态）：
+ *                     组件只在每轮下发时读一次。不传 = 只传 `team:{}`，路由全走 core 默认。
+ *                     组件不判断「有没有配置图像引擎」这类事 —— 那是 core 的裁决（缺了就明确失败）。
  *    });
  *    conv.send('…');  conv.interrupt();  conv.stop();  conv.answer('…');
  *    conv.setSession(sid) / conv.newSession() / conv.refreshEngines() / conv.destroy();
@@ -68,6 +94,9 @@
     '<symbol id="i-mcp" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M9 3.5v3.8M15 3.5v3.8"/><path d="M6.4 7.3h11.2v3.2a5.6 5.6 0 0 1-11.2 0z"/><path d="M12 16.1v4.4"/></symbol>' +
     '<symbol id="i-listcheck" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M4.4 7.4 6 9l2.6-2.6M4.4 16.4 6 18l2.6-2.6"/><path d="M11.4 8h8.2M11.4 17h8.2"/></symbol>' +
     '<symbol id="i-up" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 19.5V5M5.8 11.2 12 5l6.2 6.2"/></symbol>' +
+    /* 「停止」用实心圆角方块，不用时钟：时钟读起来是「定时 / 等待」，
+       而这一枚按下去是**立刻掐断**（用户 2026-10-22：「提交后按钮需要变成停止样式」）。 */
+    '<symbol id="i-stop" viewBox="0 0 24 24" fill="currentColor"><rect x="7" y="7" width="10" height="10" rx="2.6"/></symbol>' +
     '<symbol id="i-cpu" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><rect x="7" y="7" width="10" height="10" rx="2"/><path d="M10 4v3M14 4v3M10 17v3M14 17v3M4 10h3M4 14h3M17 10h3M17 14h3"/></symbol>' +
     '<symbol id="i-set" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><circle cx="12" cy="12" r="3"/><path d="M12 3.5v2.2M12 18.3v2.2M20.5 12h-2.2M5.7 12H3.5M18 6l-1.6 1.6M7.6 16.4 6 18M18 18l-1.6-1.6M7.6 7.6 6 6"/></symbol>' +
     '<symbol id="i-plus" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M12 5.5v13M5.5 12h13"/></symbol>' +
@@ -95,90 +124,179 @@
      三处用同一份图形：读历史的居中 loading、App 启动闪屏、以后别的等待态。
      ⚠️ 只在这里画一次瓶身，别在宿主页里另抄一份 —— 抄了就会像历史上那三份对话实现一样漂移。
      实现要点：
-       · 瓶型取**瓷瓶**（细颈 · 丰腹 · 小圈足），不是烧瓶：这是「掌天瓶」这个名字的形，
-         圆烧瓶那种造型一眼读成化学实验，创意就落到了错的地方。
-       · 用 SVG 而不是 div/CSS：液面要做**波浪**，CSS 做不了曲线；viewBox 固定 96×120，
-         调用方给 width/height 就能任意缩放，瓶身不会变形。
+       · 用 SVG 而不是 div/CSS：液面要做**曲线**（凹液面），CSS 做不了；viewBox 固定 64×104，
+         调用方给 width/height 任意缩放，瓶身不会变形。
        · 绿液用 `<clipPath>` 剪在**瓶腔以内** —— 液面涨到瓶颈时自然收窄，
          这是「往瓶里灌」而不是「给瓶子刷绿漆」的分界。
-       · 所有动效只动 transform / opacity：回放大日志会占死主线程（见 histLoading 那段注释）。 */
-  var BOTTLE_VB = { w: 96, h: 120 };
-  /* 瓶腔：梅瓶形 —— 长颈 · 广肩 · 最宽在上腹（y≈68）· 下腹圆润回收 · 平底圈足（x31..65）。
-     液面靠这个路径裁剪。
-     ⚠️ 为什么最宽点必须在**上腹**而不是正中：最宽点一半高度、底部再收成一个半圆，那是
-        圆烧瓶（一眼读成化学实验）。最宽上移 + 底部收成平足，才读得出「坛/瓶」。
-     ⚠️ 下腹的弧度要**缓**：收得太急会变成沙漏（试过 x68.5@94.5 → 61.5@102.5，就是那个效果）。
-     关键尺寸（改形时一起对）：瓶口 x43..53 @y11 · 最宽 x13.5..82.5 @y68 · 足 x31..65 @y106。 */
-  var BOTTLE_CAVITY = 'M48 11C50.8 11 53 12.6 53 15.4V22'
-    + 'C53 34 53 40 53 45'
-    + 'C59 47 72 50 78 56C81.6 60 82.5 64 82.5 68'
-    + 'C82.5 78 79 88 72 95C68 98.8 65 101 65 103.6'
-    + 'C65 105.4 63.8 106 61.8 106H34.2C32.2 106 31 105.4 31 103.6'
-    + 'C31 101 28 98.8 24 95C17 88 13.5 78 13.5 68'
-    + 'C13.5 64 14.4 60 18 56C24 50 37 47 43 45'
-    + 'C43 40 43 34 43 22V15.4C43 12.6 45.2 11 48 11Z';
+       · 所有动效只动 transform / opacity：回放大日志会占死主线程（见 histLoading 那段注释）。
+
+     ── 形制：参照《凡人修仙传》的小绿瓶（掌天瓶的原型）──
+     2026-10-21 用户：「瓶子太大 参考一下凡人修仙传的小绿瓶」。这次不只是改比例，是**换材质**：
+       ① 小口 · 短颈 · 溜肩 · 饱腹 · 圆底。腹宽/全高 ≈ 0.63（上一版 0.72 偏瘦长，像药水瓶）。
+       ② 它是**玉**，不是玻璃。玉「自己就有颜色」—— 所以不能画成「透明壳 + 绿汤」，
+          那样看着像化学烧瓶。做法：瓶体整体是淡翠玉色（**空处也是绿的**，只是薄、透），
+          液位以下才是浓翠（玉被灵液浸透 → 透光率掉下来，颜色沉下去）。
+       ③ 液位那条线是全图最亮的一道：玉/液的折射率差在界面上最明显，不画这条就没有「装了东西」。
+       ④ 尺寸要**小**：loading 里 88×143、闪屏里 104×169（原来 132×175 / 150×199）。
+          它是「一枚小瓶」，不是一尊摆件；占满一屏反而不像掌天瓶了。
+
+     ── 前几版的教训（别再往回走）──
+       · 长颈 + 凹肩 + 尖底 = 化学烧瓶。颈占全高 >1/6 就完了（现在是 14.6..23.4，占 8.5%）。
+       · 肩必须**凸**（凹肩是漏斗和试管的分界）；腹要接近正圆；底不能收成半圆（那是烧瓶）。
+       · 别画外翻的撇口：1.15px 描边下翻唇只会变成颈侧两个小耳朵（试过）。
+       · 亮/暗两套底都要试：玉体的 alpha 在浅底上会被冲成白瓷（实测 .42 白、.62 才读得出翠）。
+         所以玉体浓度走 `--q-bottle-jade*` 令牌，宿主按主题给。
+     ⚠️ 轮廓是用 Catmull-Rom 由 15 个右半控制点算出来的三次贝塞尔（见 BOTTLE_PROFILE），
+        不是手写路径 —— 手调控制点必然在肩/腹出现折角，看着像塑料件。改形去改那串点，
+        别去改 BOTTLE_CAVITY 的 d。 */
+  var BOTTLE_VB = { w: 64, h: 104, x: 16, y: 4 };
+  /* 右半轮廓（x 以 48 为中轴）：颈口 → 颈 → 肩 → 腹 → 足 → 底心 */
+  var BOTTLE_PROFILE = [
+    [52.4, 14.6], [52.4, 19.4], [53, 23.4], [56, 27.4],
+    [61.5, 33.6], [67.6, 41.4], [72.6, 50.6], [75.8, 60],
+    [77.4, 69.4], [76.6, 78.4], [73.2, 87], [67.6, 93.8],
+    [60.6, 98.8], [53.4, 101.8], [48, 102.6]
+  ];
+  /* 镜像 + 拼成闭合瓶腔。左右两半用**同一串点**，所以形状天然对称 —— 手写 d 做不到。 */
+  var BOTTLE_CAVITY = (function () {
+    var r2 = function (n) { return Math.round(n * 100) / 100; };
+    /* 端点外推一个虚拟点，首尾那两段才不会打卷 */
+    function segs(pts) {
+      var p = [pts[0]].concat(pts, [pts[pts.length - 1]]);
+      var out = [];
+      for (var i = 1; i < p.length - 2; i++) {
+        var a = p[i - 1], b = p[i], c = p[i + 1], d = p[i + 2];
+        out.push([b[0] + (c[0] - a[0]) / 6, b[1] + (c[1] - a[1]) / 6,
+                  c[0] - (d[0] - a[0]) / 6, c[1] - (d[1] - a[1]) / 6, c[0], c[1]]);
+      }
+      return out;
+    }
+    function run(pts) {
+      var d = '';
+      segs(pts).forEach(function (s) {
+        d += ' C' + r2(s[0]) + ' ' + r2(s[1]) + ' ' + r2(s[2]) + ' ' + r2(s[3])
+          + ' ' + r2(s[4]) + ' ' + r2(s[5]);
+      });
+      return d;
+    }
+    var right = BOTTLE_PROFILE;
+    /* 左半：从底心往回走，x 翻成 96-x */
+    var left = [right[right.length - 1]].concat(
+      right.slice(0, -1).reverse().map(function (p) { return [96 - p[0], p[1]]; }));
+    return 'M' + right[0][0] + ' ' + right[0][1] + run(right) + run(left) + ' Z';
+  })();
+  /* 液面：中间低、贴壁微高 = 玉瓶里的**凹液面**（meniscus）。
+     落差的两个拐点压在瓶壁内（x20 / x76），两端超出的部分由 clipPath 裁掉 ——
+     剩下的正是「液体沿壁爬升」那一段。画成直线就成了「一块绿色积木」，这是早先最丑的地方。
+     ⚠️ 拐点不能放到 ±160：那样瓶内那 60px 只是曲线的平底段，看上去仍是一条直线（试过）。 */
+  function bottleSurf(y, amp, close) {
+    return 'M-120 ' + y + ' L20 ' + y
+      + ' C32 ' + y + ' 36 ' + (y + amp) + ' 48 ' + (y + amp)
+      + ' C60 ' + (y + amp) + ' 64 ' + y + ' 76 ' + y
+      + ' L216 ' + y + (close ? ' L216 150 L-120 150 Z' : '');
+  }
   /** 造一枚掌天瓶。`opts.fill` = 液面停在哪（0 = 空瓶 / 1 = 满），`opts.anim` = 'hist'（涨落循环）| 'rise'（一次灌满）。
    *  @returns {SVGElement} 直接 appendChild 用。 */
   function bottleSVG(opts) {
     opts = opts || {};
     var uid = 'btl' + (bottleSeq++);
-    var f = Math.max(0, Math.min(1, opts.fill == null ? 0.55 : opts.fill));
-    /* 液面顶边：在「y45（满到颈根下沿）→ y100（贴瓶底）」之间按 fill 移动。
-       上限取 45 而不是颈口 15：满瓶也要在颈里留一截空气，否则读成「塞住了」；
-       而下腹最宽点在上腹（y69），液面停在 45 时正好盖住整个腹部 —— 视觉上「装了大半瓶」。 */
-    var topY = 100 - 55 * f;
+    var f = Math.max(0, Math.min(1, opts.fill == null ? 0.62 : opts.fill));
+    /* 液面中心：f=1 → y47（肩下，颈里留一截空玉，否则读成「塞满了」）· f=0 → y95（几乎见底）。
+       上限取 47 而不是颈口 15：满瓶也要能看见瓶颈与肩，不然那只瓶子就读成一个绿球。 */
+    var y = 95 - 48 * f;
+    /* 越满凹得越浅：满瓶时液面在肩下，那儿的瓶腔已经窄了，凹太深会像液面塌下去 */
+    var amp = 2.2 - 0.7 * f;
+    /* 气泡只在液层够厚时才画（f 小的时候只是瓶底一层薄液，冒泡会浮出液面） */
+    var bub = f > 0.42
+      ? '<circle class="qbottle__bubble" cx="41" cy="92" r="1.9"/>'
+        + '<circle class="qbottle__bubble qbottle__bubble--b" cx="55" cy="95.5" r="1.4"/>'
+        + '<circle class="qbottle__bubble qbottle__bubble--c" cx="47" cy="97.5" r="1.1"/>'
+      : '';
     var svg = document.createElementNS(SVG_NS, 'svg');
-    svg.setAttribute('viewBox', '0 0 ' + BOTTLE_VB.w + ' ' + BOTTLE_VB.h);
+    svg.setAttribute('viewBox', BOTTLE_VB.x + ' ' + BOTTLE_VB.y + ' ' + BOTTLE_VB.w + ' ' + BOTTLE_VB.h);
     svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');
     svg.setAttribute('aria-hidden', 'true');
     svg.setAttribute('class', 'qbottle' + (opts.cls ? ' ' + opts.cls : '')
       + (opts.anim ? ' qbottle--' + opts.anim : ''));
-    /* 波浪起伏幅度：液面越高、可见瓶腔越窄，浪要收得越小，否则会「浪出瓶外」 */
-    var amp = 3.2 + 3.4 * (1 - f);
+    /* 灌满动画的位移量交给 CSS：从「贴瓶底」涨到当前位置 `y`，也就是 (95 - y)。
+       硬编码在 keyframes 里的话，以后改 fill 就会露出半截液体或灌不满。
+       （95 = f=0 时的液面高度，和上面那行 95 - 48f 是同一个基准点。） */
+    svg.style.setProperty('--qb-dy', Math.round(95 - y) + 'px');
     svg.innerHTML =
         '<defs>'
       +   '<clipPath id="' + uid + 'c"><path d="' + BOTTLE_CAVITY + '"/></clipPath>'
-      /* 绿液：上亮下深的竖向渐变，读起来像「液面反光 + 深处沉色」 */
-      +   '<linearGradient id="' + uid + 'g" x1="0" y1="0" x2="0" y2="1">'
-      +     '<stop offset="0" stop-color="var(--q-bottle-hi, #7CF7A8)"/>'
-      +     '<stop offset=".55" stop-color="var(--q-bottle, #34D27B)"/>'
-      +     '<stop offset="1" stop-color="var(--q-bottle-lo, #128A4C)"/>'
+      /* 左壁边光只画左半边（受光侧），用矩形裁一下省得另算路径 */
+      +   '<clipPath id="' + uid + 'lf"><rect x="0" y="0" width="36" height="120"/></clipPath>'
+      /* 液面亮线只在中段最亮：贴壁那一段被壁面压暗，整条亮到边反而假 */
+      +   '<clipPath id="' + uid + 'md"><rect x="20" y="0" width="56" height="120"/></clipPath>'
+      /* 玉体：**上薄下厚**（玉雕积料的常规做法）。alpha 走令牌，因为浅底上要更浓才不发白 */
+      +   '<linearGradient id="' + uid + 'jd" x1=".2" y1="0" x2=".6" y2="1">'
+      +     '<stop offset="0" stop-color="var(--q-bottle-jade-hi, rgba(120,232,175,.44))"/>'
+      +     '<stop offset=".55" stop-color="var(--q-bottle-jade, rgba(52,192,124,.46))"/>'
+      +     '<stop offset="1" stop-color="var(--q-bottle-jade-lo, rgba(8,96,60,.58))"/>'
       +   '</linearGradient>'
-      /* 液面高光：贴着液面那条亮边（越往下越透，读成「液面反光」而不是第二层液） */
-      +   '<linearGradient id="' + uid + 's" x1="0" y1="0" x2="0" y2="1">'
-      +     '<stop offset="0" stop-color="#EAFFF2" stop-opacity=".9"/>'
-      +     '<stop offset="1" stop-color="#EAFFF2" stop-opacity="0"/>'
+      /* 玉的体积：左壁亮、右壁暗（缺这层，瓶子就是一张剪纸） */
+      +   '<linearGradient id="' + uid + 'vol" x1="0" y1="0" x2="1" y2="0">'
+      +     '<stop offset="0" stop-color="#fff" stop-opacity=".13"/>'
+      +     '<stop offset=".18" stop-color="#fff" stop-opacity=".03"/>'
+      +     '<stop offset=".5" stop-color="#fff" stop-opacity="0"/>'
+      +     '<stop offset=".82" stop-color="#000" stop-opacity=".18"/>'
+      +     '<stop offset="1" stop-color="#000" stop-opacity=".34"/>'
       +   '</linearGradient>'
+      /* 浓翠（液位以下）：上亮下深，读成「灵液浸透玉胎 + 深处沉色」 */
+      +   '<linearGradient id="' + uid + 'g" x1=".15" y1="0" x2=".45" y2="1">'
+      +     '<stop offset="0" stop-color="var(--q-bottle-hi, #B4FFD6)"/>'
+      +     '<stop offset=".2" stop-color="var(--q-bottle, #2ECB80)"/>'
+      +     '<stop offset=".8" stop-color="var(--q-bottle-lo, #0A7548)"/>'
+      +     '<stop offset="1" stop-color="var(--q-bottle-deep, #03361F)"/>'
+      +   '</linearGradient>'
+      /* 瓶底聚光：光穿过灵液在圆底上聚成一团 */
+      +   '<radialGradient id="' + uid + 'ca" cx=".5" cy=".5" r=".5">'
+      +     '<stop offset="0" stop-color="var(--q-bottle-hi, #B4FFD6)" stop-opacity=".34"/>'
+      +     '<stop offset="1" stop-color="var(--q-bottle-hi, #B4FFD6)" stop-opacity="0"/>'
+      +   '</radialGradient>'
       + '</defs>'
-      /* ── 瓶身：瓷质剪影（描边 + 极淡内底，别填实 —— 要透出后面的页面底色）── */
-      + '<path d="' + BOTTLE_CAVITY + '" fill="var(--q-bottle-shell, rgba(255,255,255,.03))"'
-      +   ' stroke="var(--q-bottle-line, currentColor)" stroke-width="2.2" stroke-linejoin="round"/>'
-      /* ── 绿液：整块剪在瓶腔里，靠 translateY 涨上来 ── */
+      /* ── ① 玉胎：整只瓶都是绿的（空处是薄玉，不是透明）── */
+      + '<path d="' + BOTTLE_CAVITY + '" fill="url(#' + uid + 'jd)"/>'
+      + '<path d="' + BOTTLE_CAVITY + '" fill="url(#' + uid + 'vol)"/>'
+      /* ── ② 浓翠：整块剪在瓶腔里，靠 translateY 涨上来 ── */
       + '<g clip-path="url(#' + uid + 'c)">'
       +   '<g class="qbottle__liquid">'
-      /* 波峰：横跨 5 个周期（每周期 48），横移一个周期就是无缝循环；
-         左右各多画一段（-96 / 到 240）是为了横移时不露边。 */
-      +     '<path class="qbottle__wave" fill="url(#' + uid + 'g)" d="M-96 ' + topY + ' '
-      +       'q24 -' + amp + ' 48 0 t48 0 t48 0 t48 0 t48 0 t48 0 t48 0 V124 H-96 Z"/>'
-      +     '<path fill="url(#' + uid + 's)" d="M-96 ' + topY + ' q24 -' + amp + ' 48 0'
-      +       ' t48 0 t48 0 t48 0 t48 0 t48 0 t48 0 V' + (topY + 7) + ' H-96 Z" opacity=".45"/>'
-      /* 气泡固定落在**下腹深处**（y≈94），升高 16px 也仍在液面之下（见 CSS 的 qbBubble）：
-         fill .55 时液面在 y≈66，涨落 ±8 也只到 y≈74，气泡最高到 y≈78 —— 不会「浮在空气里」。 */
-      +     '<circle class="qbottle__bubble" cx="42" cy="96" r="2.4"/>'
-      +     '<circle class="qbottle__bubble qbottle__bubble--b" cx="55" cy="99" r="1.8"/>'
-      +     '<circle class="qbottle__bubble qbottle__bubble--c" cx="47" cy="101" r="1.4"/>'
+      +     '<path fill="url(#' + uid + 'g)" d="' + bottleSurf(y, amp, true) + '"/>'
+      /* 液位那条亮线：玉/液的界面反射。它是「装了东西」的唯一证据，不能省 */
+      +     '<path d="' + bottleSurf(y, amp) + '" fill="none"'
+      +       ' stroke="var(--q-bottle-rim, #EAFFF2)" stroke-width=".85" opacity=".75"'
+      +       ' stroke-linecap="round" clip-path="url(#' + uid + 'md)"/>'
       +   '</g>'
+      /* 聚光**不跟着液体动**：光在瓶底的位置是固定的，跟着涨落会像贴纸在滑。 */
+      +   '<ellipse cx="48" cy="95" rx="16" ry="5" fill="url(#' + uid + 'ca)"/>'
+      +   bub
       + '</g>'
-      /* ── 瓶塞：瓶颈上一枚圆角木塞（宽 16 > 瓶颈 10，两侧各出 3px，读成「塞住瓶口」）── */
-      + '<rect x="40" y="2.6" width="16" height="9.4" rx="2.6"'
-      +   ' fill="var(--q-bottle-cork, currentColor)" opacity=".42"/>'
-      /* 木塞顶面一道细亮边，免得它读成一块实心方块 */
-      + '<rect x="40" y="2.6" width="16" height="3.2" rx="1.6"'
-      +   ' fill="var(--q-bottle-hi, #7CF7A8)" opacity=".22"/>'
-      /* ── 反光：左肩一道竖向亮线 + 上腹一点高光，让瓶「有弧度」── */
-      + '<path d="M23 62c-3.4 4.4-4.6 9.4-4 14.6" stroke="var(--q-bottle-hi, #7CF7A8)" stroke-width="3"'
-      +   ' stroke-linecap="round" fill="none" opacity=".3"/>'
-      + '<ellipse cx="31" cy="78" rx="4.2" ry="6.4" fill="var(--q-bottle-hi, #7CF7A8)" opacity=".14"/>';
+      /* ── ③ 边光：左壁一道细亮线（玉的厚度感全靠它）+ 颈光 + 肩部短高光 ── */
+      + '<path d="' + BOTTLE_CAVITY + '" fill="none" stroke="var(--q-bottle-rim, #EAFFF2)"'
+      +   ' stroke-width="1.8" opacity=".3" stroke-linecap="round" clip-path="url(#' + uid + 'lf)"/>'
+      + '<path d="M52.9 18.6v6.8" stroke="var(--q-bottle-rim, #EAFFF2)" stroke-width="1.3"'
+      +   ' stroke-linecap="round" opacity=".26"/>'
+      + '<path d="M25.4 62c1.4-7.2 5-13.4 10.2-17.8" fill="none"'
+      +   ' stroke="var(--q-bottle-rim, #EAFFF2)" stroke-width="1.5"'
+      +   ' stroke-linecap="round" opacity=".24"/>'
+      /* ── ④ 轮廓：绿线，比玉胎深一档。别加粗（粗描边会把瓶子压回「线稿」）── */
+      + '<path d="' + BOTTLE_CAVITY + '" fill="none" stroke="var(--q-bottle-line, #43A06E)"'
+      +   ' stroke-width="1.15" stroke-linejoin="round"/>'
+      /* ── ⑤ 小口：内壁一圈暗 + 沿口亮（平口画法，见上面「别画撇口」那条）── */
+      + '<ellipse cx="48" cy="15.6" rx="4.9" ry="1.6" opacity=".75"'
+      +   ' fill="var(--q-bottle-deep, #03361F)"/>'
+      + '<ellipse cx="48" cy="15.3" rx="4.9" ry="1.6" fill="none"'
+      +   ' stroke="var(--q-bottle-rim, #EAFFF2)" stroke-width=".75" opacity=".55"/>'
+      /* ── ⑥ 小木塞：比口沿略宽，只在瓶口露很短一截（小绿瓶的塞子本来就很含蓄）──
+         ⚠️ 兜底色必须写死成木色，不能给 `currentColor`：SVG 的 color 继承自
+            `.qbottle{color:--q-bottle-line}`（绿），宿主没定义 --q-bottle-cork 时
+            塞子就会变成一块绿塑料（试过）。 */
+      + '<path d="M42.4 6.8h11.2a2.2 2.2 0 0 1 2.2 2.2v3.2c0 1.2-1.1 2.3-2.6 2.3h-10.4'
+      +   'c-1.4 0-2.6-1-2.6-2.3V9a2.2 2.2 0 0 1 2.2-2.2z"'
+      +   ' fill="var(--q-bottle-cork, #7A6650)"/>'
+      + '<path d="M42.4 6.8h11.2a2.2 2.2 0 0 1 2.2 2.2v1H40.2V9a2.2 2.2 0 0 1 2.2-2.2z"'
+      +   ' fill="var(--q-bottle-rim, #EAFFF2)" opacity=".2"/>';
     return svg;
   }
   var bottleSeq = 0;
@@ -229,6 +347,15 @@
       if (text != null) n.textContent = text;
       return n;
     }
+    /* 选择器里的「一行模型」：左名字、右倍率（`×0.34`）。
+       两列布局用 CSS 的 `.pick__cr` 定宽靠右，名字过长只自己省略 —— 倍率列不跟着抖。
+       倍率为空（引擎不给数据）时只画名字，不占位、不显示「×1」这类编出来的值。 */
+    function modelRow(id, credit) {
+      var row = el('span', 'pick__crow');
+      row.appendChild(el('span', 'pick__cl', qaModelText(id)));
+      if (credit) row.appendChild(el('span', 'pick__cr', credit));
+      return row;
+    }
     function svgIcon(id, size) {
       var s = document.createElementNS(SVG_NS, 'svg');
       s.setAttribute('width', size || 16); s.setAttribute('height', size || 16);
@@ -247,12 +374,40 @@
     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,
+      /* 这一轮选中的插件（2026-10-21 用户：「选择插件后 对话框中要出现一个胶囊
+         然后发送后就是提示词变成要使用这个插件做什么」）。
+         存的是 GET /desk/plugins 那一行**原样**（id/name/cli/usePrompt…），
+         不是只存 id —— 发送时要当场用它拼提示词，再回去查一次既慢又可能已变。
+         它跟着一轮走：send 时被读走并清空（见 takePlugin）。 */
+      plugin: null,
+      /* 运行中提交的追问（2026-10-21 用户：「会话中运行中允许先提交追问 类似 magic-test
+         pc 端相关」）：busy 时提交**不打断**当前轮，先排在这里，等这一轮收尾后自动发出。
+         条目 = `{text, atts, attPaths}`；atts 是气泡缩略图的快照（remoteUrl），
+         attPaths 是本轮要带给 core 的本地绝对路径。归属当前这条会话 ——
+         换会话 / 新建会话时整队作废（旧会话的追问不能画进新会话的画布）。 */
+      queue: [],
+      /* 团队模式（2026-10-21）：开关是**这一轮怎么跑**，不是这台机器的属性 ——
+         所以它在这条会话的状态里，每轮随 payload.team 下发（core 侧无状态）。
+         宿主**按会话**存在自己的 localStorage 里，通过 team / setTeam / teamConfig 交给组件。 */
+      team: !!opts.team,
+      /* 本轮 SSE 的取消钩子（transport.ask 的返回值）。一轮真正收尾时用它把**还挂着的那条流**掐掉：
+         否则 keep-alive 的 core 进程不退出、never 发 `end` 帧，runTurn 的 finally 就一直等不来。 */
+      askHandle: null,
       renderedSeq: {}, agentRaw: '', replay: false,
       /* 本轮已收到的最大 seq（**流 seq，每轮从 1 重来**，见 render 的 seq 去重注释）。
          断线后拿它当游标调 /desk/ask/{id}/events?after= 增量续传。 */
       lastSeq: 0,
       /* 断线续传轮询的取消钩子（换会话 / 开新轮时调用，避免旧轮的事件落进新画面） */
       resumeStop: null,
+      /* 打开会话时宿主给的那行清单数据（setSession 的第二参，字段同 core 的 --sessions：
+         status / state / alive / engine / model / title）。`status`（会话级，唯一口径）与
+         `alive` 用来判断这条会话是不是「登记表上还在跑」—— 在跑的才挂 follow（见 startFollow）。 */
+      meta: null,
+      /* 跨进程进度尾随：`{sid, cancel, askId}`，见 startFollow / stopFollow。null = 没在跟。 */
+      follow: null,
+      /* 上一次 follow 跟到终态的时间：`{sid, at}`。停留期巡检（watchTick）据此不重拉 ——
+         core 刚退出时 /desk/asks 里那个 run 还在保留期内，否则会整屏重画一遍。 */
+      followDone: null,
       working: null, autoFollow: true, lastPrompt: '', lastAttPaths: [],
       /* 这一轮的渲染句柄（内核给的 h + 它的工具 / 委派登记表 + 起点），见 qaEnsureAnswer */
       qa: null,
@@ -277,7 +432,11 @@
       /* 引擎停在一问上等答案（见 MagicHost.send：这种时候作答要走控制通道，不能当新的一轮发） */
       awaitingAnswer: false,
       /* 内核「重试」走 MagicHost.send(…, {echo:false})：那条气泡已经在画布上了，别再画一遍 */
-      noEcho: false
+      noEcho: false,
+      /* 最近一条**已画到画布上**的提问（签名 = 正文）。同一条提问会从三处再走一遍：
+         发送时的本地回声 / 历史日志回放 / 网关在 ask 缓冲头合成的 `type:"user"`（seq 固定 0）。
+         没有这道签名，一次提问可能画出两三个一模一样的气泡（2026-10-20 用户报「出来三个」）。 */
+      lastUserSig: ''
     };
 
   /* ══════════ markdown 渲染（**栈归内核**）══════════
@@ -495,16 +654,30 @@
   (function installDeskProbe() {
     if (!transport) return;
     var d = window.desk;
-    if (!d || typeof d !== 'object') { d = window.desk = {}; }
-    if (typeof d.pathProbe !== 'function' && typeof transport.pathProbe === 'function') {
-      d.pathProbe = function (req) { return transport.pathProbe(req); };
-    }
-    if (typeof d.mediaUrl !== 'function' && typeof transport.fileUrl === 'function') {
-      d.mediaUrl = function (p) { return transport.fileUrl(p); };
-    }
-    if (typeof d.pathRead !== 'function' && typeof transport.pathRead === 'function') {
-      d.pathRead = function (req) { return transport.pathRead(req); };
-    }
+    /* ⚠️ 宿主可能已经把 `window.desk` **冻结**了（桌面壳 preload 注入的是
+       `Object.freeze` 过的桥，且里面未必有 mediaUrl）—— 直接往上面写会抛
+       「Cannot add property mediaUrl, object is not extensible」，把整个对话组件
+       拖挂不上去（2026-10-22 移动端在壳里打开就是这个哑故障）。
+       所以：能写就写；写不进去的挪到 `window.__qaDeskExtra`（内核按同名回落）。 */
+    var extra = null;
+    if (!d || typeof d !== 'object') {
+      try { d = window.desk = {}; } catch (e) { d = null; }
+    }
+    function put(name, fn) {
+      if (!fn) return;
+      if (d && typeof d[name] === 'function') return;      // 宿主已有，链路更短
+      if (d) {
+        try { d[name] = fn; return; } catch (e) { /* 冻结/只读 → 走 extra */ }
+      }
+      extra = extra || (window.__qaDeskExtra = window.__qaDeskExtra || {});
+      if (typeof extra[name] !== 'function') extra[name] = fn;
+    }
+    put('pathProbe', typeof transport.pathProbe === 'function'
+      ? function (req) { return transport.pathProbe(req); } : null);
+    put('mediaUrl', typeof transport.fileUrl === 'function'
+      ? function (p) { return transport.fileUrl(p); } : null);
+    put('pathRead', typeof transport.pathRead === 'function'
+      ? function (req) { return transport.pathRead(req); } : null);
   })();
 
   /* 本轮产物：与 PC 工作台 / magic-test 用**同一套**（内核 qaTurnArtsTrack，见 19-attachments.js）——
@@ -512,10 +685,31 @@
      不接这一下，回放与实时都只有正文里写出来的那些图，没写进正文的产物一张不显示。 */
   var turnArts = (typeof qaTurnArtsTrack === 'function') ? qaTurnArtsTrack() : null;
 
+  /** 这一轮的渲染句柄里**已经有内容**了吗（正文 / 思考 / 工具 / 审批 / 委派 / 产物）。
+   *  空终态判定与「撤掉空助手块」共用这一份口径。 */
+  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');
+  }
+  /** 只有「引擎抬头」的助手块就撤掉（否则收尾行上方留一块空白，2026-10-20 用户截图）。 */
+  function dropEmptyAnswer(h) {
+    var el = h && h.el;
+    if (!el || turnHasContent(h)) return;
+    if (el.parentNode) el.parentNode.removeChild(el);
+  }
+
   function kernelApply(ev) {
     if (!ev || typeof ev !== 'object') return;
     var t = ev.type || ev.kind;
     if (!t) return;                                    // 畸形帧（连类型都没有）
+    /* ⚠️ 空终态（`turn_end` 无正文、无 item_id）**不是**这一轮结束（2026-10-20 用户
+       「发一个好了吗 出来三个 而且没回复」）：引擎的 result 信封偶尔先来一条空行
+       （internal/agent/streamjson.go 无条件 emitTurnEnd），1.8s 就报「已完成」、
+       掐断 SSE，10s 后真正的正文（seq 3…219）全被 qaEnsureAnswer 的 qaClosed 丢掉。
+       这里直接不喂内核 —— 不落收尾行、不置 qaClosed、不 cancel 流；真空白轮由 core
+       进程退出时的 `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 });
     if (t === 'start') {
       /* 一轮真正用的引擎 / 模型（配置里的模型链会自动降级）→ 选择器跟着改口 */
@@ -535,6 +729,12 @@
        2026-10-17 用户报：「移动端看不到会话历史」—— 症状是历史里的助手那一侧画出来了、
        用户那句提问**一个字都没有**（问到哪了全靠猜）。 */
     if (t === 'user') {
+      /* 同一条提问已经在画布上了 → 不再画第二个气泡。来源有三处（见 state.lastUserSig），
+         典型叠加：发送时本地回声画一次 → 看门狗清屏重放又画一次 → 续传补拉的合成 user 再画一次。
+         回放不走判重（历史里同样的提问本来就该各画一条，且回放是整屏重建）。 */
+      var usig = String(e.text == null ? '' : e.text).trim();
+      if (usig && !state.replay && usig === state.lastUserSig) return;
+      if (usig) state.lastUserSig = usig;
       /* 历史回放里「用户那句」就是一轮的新起点：上一轮的已收尾标记到此作废，
          否则第二轮的助手消息会被 qaEnsureAnswer 拒开（见 state.qaClosed 注释）。 */
       state.qaClosed = false;
@@ -586,6 +786,8 @@
     if (q.h.el) { q.h.el.__qaReplay = true; q.h.el.__qaMs = replaySpan(); }
     /* 先补挂「本轮产物」再封口（在 qaRunEnd 拆卡之前 —— 与 27-conv-ledger 的 finish 同序）。 */
     if (turnArts) { try { turnArts.flush(q.h); } catch (e0) {} }
+    /* 这一轮在日志里一条内容都没有（只有抬头）→ 别把空块留在历史里。 */
+    dropEmptyAnswer(q.h);
     /* qaRunEnd = finish + 摘掉「生成中」胶囊（内核的统一收口，见 03-chat-message）。
        这里只 finish 会把那枚胶囊永久钉在画布上（回放里已经真实出现过）。 */
     try { if (typeof qaRunEnd === 'function') qaRunEnd(q.h); else if (q.h.finish) q.h.finish(); }
@@ -655,11 +857,37 @@
     var ms = q.ms || (state.replay ? replaySpan() : Date.now() - (state.resumeT0 || q.t0));
     /* 收尾行落下之前补挂「本轮产物」（这一步只追加节点，不影响收尾行的位置）。 */
     if (turnArts) { try { turnArts.flush(q.h); } catch (e0) {} }
+    /* 一句正文/过程都没收到的助手块（只剩引擎抬头）就撤掉 —— 否则收尾行上方留一块空白
+       （2026-10-20 用户截图：空块 + 「已完成 · 总耗时 1.8s」）。收尾行本身挂在线程容器上，
+       不在这条消息块里，所以撤掉不丢收尾行。 */
+    dropEmptyAnswer(q.h);
     qaRenderDone(ok, label, thread(), ms);
     if (opts.onBusy) { try { opts.onBusy(false); } catch (err) {} }
+    /* 收掉运行态（2026-10-20 用户：「进行中已经变了 结束的时候图没变」）。
+       这里是「这一轮真的结束了」的**唯一收口**（turn_end / error / end 都落到这里），
+       而运行态过去只由 runTurn 的 finally 复位 —— 它要等 transport.ask 的 SSE `end` 帧，
+       可那帧是 **core 进程退出时**才发的（keep-alive 空闲窗口内不会来），
+       于是绿液瓶与绿光边框会一直挂着。所以在这里当场复位：
+       胶囊切回引擎图标、发送键切回「发送」、busy 放开。
+       ⚠️ 回放不走（历史里的 turn_end 不改变当前运行态；否则正在看别人跑的会话会被误判成空闲）。
+       ⚠️ 幂等：runTurn 的 finally 稍后还会再跑一遍，重复执行无害。 */
+    if (!state.replay) {
+      clearWorking();
+      state.busy = false;
+      state.askId = null;
+      setSendMode('idle');
+      /* 顺手把还挂着的那条流掐掉：让 runTurn 的 Promise 收口（否则它会一直等 end 帧）。
+         取消走 transport 的 aborted 分支，不会弹「发送失败」。 */
+      var ah = state.askHandle;
+      if (ah) { state.askHandle = null; try { if (ah.cancel) ah.cancel(); } catch (e2) {} }
+      /* 这一轮收尾 = 排队追问可以发了（PC 的 qaStopActive 也是在这里 qaMsgFlush）。
+         延到下一拍：runTurn 的 finally 还等着这条流的 Promise 收口。 */
+      scheduleFlush();
+    }
   }
 
   function clearThread() {
+    histSid = null;                              // 画布清空 = 历史不在场了（见 setSession 的短路）
     /* 换会话先停掉上一轮的断线续传轮询：否则补拉回来的事件会落进新会话的画面。 */
     if (state.resumeStop) { var rs = state.resumeStop; state.resumeStop = null; try { rs(); } catch (e) {} }
     thread().innerHTML = '';
@@ -674,10 +902,17 @@
     if (typeof qaScrollReset === 'function') { try { qaScrollReset(); } catch (e) {} }
     state.agentRaw = '';
     state.lastSeq = 0;
+    /* 画布清空 ⇒ seq 判重表一并作废：表里记的是**上一段画面**见过的 seq，
+       而新会话/新一段的 follow 事件走的是同一条判重路径（seq 从 1 起、跨会话重号），
+       留着它会把新会话开头的事件当成「已画过」静默丢掉。
+       ⚠️ 2026-10-21：改成 follow 优先之后这条才成为真问题 —— 以前首载走 ask 缓冲
+       （那条路径自己会清表），现在 replay 之后的增量直接进判重。 */
+    state.renderedSeq = {};
     /* 换会话：这一轮的渲染句柄也归零（否则下一条事件会落进**上一个会话**的那条消息里） */
     if (turnArts) { try { turnArts.flush(null); } catch (e0) {} }   // 上一会话残留的产物路径不带走
     state.qa = null;
     state.qaClosed = false;
+    state.lastUserSig = '';                      // 画布已清空：提问判重签名一并作废
     state.replayT0 = 0; state.replayLastAt = 0;
     state.resumeT0 = 0;
     state.awaitingAnswer = false;
@@ -693,9 +928,19 @@
   /* 控制通道：打断 / 收工 / 回答案。op 的语义与 core 的 --control 同协议；
      具体怎么送到 core 由 transport.control 决定（HTTP / IPC / CLI 都可能）。
      ⚠️ 没有 askId 就如实说，不要静默失败 —— 一个按下去没反应的按钮比报错更难查。
-     返回 Promise<boolean>，给审批卡判断「答没答上」用。 */
+     返回 Promise<boolean>，给审批卡判断「答没答上」用。
+     ⚠️ 例外：这一轮**还在宿主那里排队**（beforeAsk 没 resolve）时本来就没有 askId，
+        此时打断的真实含义是「别发这一轮了」。宿主用 opts.onInterrupt 认领这层语义：
+        返回 true = 它已经把排队撤掉，组件不再往下走 control。 */
   async function control(op, text) {
     if (!state.askId) {
+      if (op === 'interrupt' && typeof opts.onInterrupt === 'function') {
+        var owned = false;
+        try { owned = opts.onInterrupt(state.lastPrompt || ''); } catch (e) { owned = false; }
+        /* 不留提示：宿主撤掉排队后 beforeAsk 会 resolve 成 false，runTurn 那条分支
+           已经会说「已取消排队（串行模式）」—— 这里再说一遍就是两条一样的。 */
+        if (owned) return true;
+      }
       noticeItem('这一轮还没拿到轮次 id，稍等 open 事件回来再试');
       return false;
     }
@@ -761,35 +1006,305 @@
     }
 
     async function send() {
-      var text = ctx.input.value.trim();
-      if (!text || state.busy) return;
+      /* 插件胶囊在场时，用户写的只是「做什么」；**真正下发的提示词**由这一层补上
+         「用哪个 CLI 做」（见 buildPluginPrompt）。所以这里读的是原文，
+         两个都空才拦（只有插件、没写要求时用插件的模板兜住）。 */
+      var typed = ctx.input.value.trim();
+      var plug = state.plugin;
+      var attsAll = state.attachments || [];
+      /* 只贴图不写字也允许发送（粘贴 / 拖入截图后直接回车是很自然的动作）：
+         附件条上有图就算「有内容」；正文由下面补一句中性引导（与 PC 端 qaSend 的
+         `请看截图。` 同口径 —— 空 prompt 会被服务端当场拒掉）。 */
+      if (!typed && !plug && !attsAll.length) return;
       if (!state.engine) { noticeItem('还没有可用引擎：请先选一个引擎'); return; }
-      if ((state.attachments || []).some(function (a) { return a.uploading; })) { noticeItem('附件还在上传，请稍候'); return; }
-      state.lastPrompt = text;
+      /* 上传没完成 / 失败都不许发：半途发出去，引擎拿到的是空路径或不存在的路径，
+         而报错出现在下游、指向别处 —— 这类失败最难排查（同 PC 端 qaSend 的附件闸门）。 */
+      if (attsAll.some(function (a) { return a.uploading; })) { noticeItem('附件还在上传，请稍候'); return; }
+      if (attsAll.some(function (a) { return a.error; })) { noticeItem('有附件没上传成功，先移除再发'); return; }
+      var text = plug ? buildPluginPrompt(typed, plug) : typed;
+      if (!text && attsAll.length) text = '请看截图。';
       /* 发出前先把附件快照下来：气泡缩略图走**回读地址**（不用 objectURL —— 发送后
          clearAttachments 会 revoke，气泡若依赖它们会当场裂图）；本轮的附件路径也一并带走。 */
       var sent = (state.attachments || []).filter(function (a) { return a.path; });
       var sentAtts = sent.map(function (a) { return { name: a.name, remoteUrl: a.remoteUrl }; });
       var attPaths = sent.map(function (a) { return a.path; });
-      state.lastAttPaths = attPaths;             // 记住本轮附件，重试时一起重发
+      /* 输入框与附件条当场清空（不论这一轮是立刻发还是排队）：
+         用户要能马上接着写第二条，不必等上一轮跑完。 */
+      ctx.input.value = ''; autoGrow();
+      /* 插件胶囊随本轮带走：已经写进 text 了，留着会让下一轮悄悄又用它 ——
+         用户下一句可能只是追问，不该再被套一层「用 xxx 完成」。 */
+      if (plug) setPlugin(null);
+      clearAttachments();
+      /* 运行中提交 = **排队**，不打断当前轮（2026-10-21 用户：「会话中运行中允许先提交
+         追问 类似 magic-test pc 端相关」）。与 PC 工作台同一语义（07-chat-stream-render.js
+         的 qaMsgEnqueue：busy + 有正文 → 排进队列，收尾时 qaMsgFlush 自动提交）；
+         只有「忙 + 空输入」点发送键才是停止，见下面 sendBtn 的 click 分支。 */
+      /* `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 };
+        state.queue.push(item);
+        /* 取消入口做在**气泡上**（排队条那边不再重复列一遍，见 renderQueue）：
+           用户要撤的就是这一句话，按钮贴在它身上最直接。 */
+        if (qb) item.unmountCancel = mountQueueCancel(qb, item);
+        /* 气泡已经画过了，轮到它时别再画一遍。 */
+        state.noEcho = false;
+        renderQueue();
+        /* 这条队列只在内存里，刷新/关 App 就整条消失（2026-10-21 用户：
+           「非团队的串行排队也没落库」）。交给宿主记进它那套持久化队列
+           （移动端复用串行门的 magic.serial.queue.v1，重开 App 由宿主重发）；
+           宿主不给钩子就维持原来「只在内存排队」的行为。 */
+        notifyQueue('push', item);
+        setSendMode('busy');                    // 输入已空 → 发送键切回「停止」
+        return;
+      }
+      await fireTurn(text, sentAtts, attPaths);
+    }
+
+    /* 这一轮在排队期间被取消：把画布上那条气泡标成「已取消」。
+       不直接删 —— 用户刚写完就消失，会让人怀疑自己是不是根本没发出去；
+       留一条带说明的气泡，等于给这次操作留个回执。 */
+    function markLastMineCancelled() {
+      var s = document.getElementById('qa-stream');
+      if (!s) return;
+      var mines = s.querySelectorAll('.qa-msg.qa-mine');
+      var last = mines[mines.length - 1];
+      if (!last) return;
+      last.classList.remove('is-queued');
+      last.classList.add('is-cancelled');
+    }
+
+    /* 真正开跑一轮：本地用户气泡（内核的 qaRenderMine）+ 附件快照 + runTurn。
+       运行中排队的那条（flushQueue）也走这里 —— 两条路径画出来必须一模一样。
+       preBubble：这条气泡**已经画过**（排队时当场画的，见 send 的排队分支）——
+                  传进来的话就只把它从「等待中」恢复成正常态，不再重画。 */
+    async function fireTurn(text, sentAtts, attPaths, preBubble) {
+      state.lastPrompt = text;
+      state.lastAttPaths = attPaths || [];      // 记住本轮附件，重试时一起重发
       /* 用户那条气泡由**内核**画（qaRenderMine）—— 与另外两端逐字同一份实现；
          随消息发出的截图也一并交给它（第二个参数是附件清单）。
          ⚠️ 内核的「重试」走 MagicHost.send(…, {echo:false})：那条气泡本来就在画布上，
             再画一次会有两条一模一样的问题（见上面挂桥那一段）。 */
-      if (!state.noEcho) qaRenderMine(text, sentAtts);
+      var bubble = preBubble || null;
+      if (preBubble) {
+        try { preBubble.classList.remove('is-queued'); } catch (e) {}
+      } else if (!state.noEcho) bubble = qaRenderMine(text, sentAtts || []) || null;
       state.noEcho = false;
-      ctx.input.value = ''; autoGrow();
-      clearAttachments();                        // 附件随本轮带走，输入框立刻清空（不等 runTurn 结束）
-      await runTurn(text, attPaths);
+      /* 本地回声也登记签名：同一条提问随后若从补拉缓冲（网关合成的 `type:"user"`）再来一遍，
+         或者看门狗清屏重放，就不再画出第二个一样的气泡（见 state.lastUserSig）。 */
+      state.lastUserSig = text;
+      await runTurn(text, attPaths, bubble);
+    }
+
+    /* ── 排队追问：渲染 / 取消 / 收尾后自动提交 ──
+       语义照 PC 的 qaMsgQueue / qaMsgFlush：一条一轮，串行；flush 只在
+       「没有正在跑的轮次」时发生（state.busy === false），所以不会插进当前流里。
+       触发点有三处（都是「这一轮真的结束了」）：kernelDone / runTurn 的 finally /
+       followEnd（尾随别人跑的会话结束时）。flushing 标记保证不会双发。 */
+    var flushing = false;
+
+    /* 排队条目的身份：宿主据此把「进队 / 轮到 / 被撤」这三件事对应到它自己那条
+       持久化记录上（见 notifyQueue）。只在本组件内唯一即可，不必跨端可读。 */
+    function qid() { return 'q' + Date.now() + '-' + Math.floor(Math.random() * 1000); }
+
+    /* 把排队条目的变化告诉宿主（可选钩子）：
+         · push：刚进队（此时还没下发给 core，宿主要能把它写进磁盘/列表）
+         · take：轮到它了，正要真正下发（宿主该把那条「等待中」删掉）
+         · drop：用户取消了（宿主该把它从磁盘上删掉）
+       为什么不在这里自己写 localStorage：设备身份（令牌）/空间归属是宿主的，
+       同一个浏览器里可能配对过好几台桌面，键与隔离口径只有宿主知道。
+       PC 宿主不接这三个钩子 → 保持原样（纯内存排队，收尾时自动 flush）。 */
+    function notifyQueue(kind, it) {
+      var name = kind === 'push' ? 'onQueuePush' : kind === 'take' ? 'onQueueTake' : 'onQueueDrop';
+      var fn = opts[name];
+      if (typeof fn !== 'function' || !it || !it.id) return;
+      var payload = it.id;
+      if (kind === 'push') {
+        /* 字段与 beforeAsk 的 info 对齐：宿主拿同一套排队逻辑落库、重启后原样重发
+           （少了 session 追问会变成新会话，少了 team 会静默降级成单任务）。 */
+        payload = {
+          id: it.id, prompt: it.text, attachments: (it.attPaths || []).slice(),
+          session: state.session || '', workspace: state.workspace || '',
+          engine: state.engine, model: state.model, permission: state.permission,
+          team: state.team ? teamPayload() : null
+        };
+      }
+      try { fn(payload); } catch (e) {}
+    }
+
+  /* 排队条：**只在气泡画不出来时**兜底。
+     正常路径下排队的那句已经作为气泡落在画布上了（见 send 的排队分支），
+     再在输入框上方原样列一遍就是同一句话出现两次 —— 用户还得在两处找「取消在哪」。
+     所以现在的分工是：
+       · 气泡（首选）：一句「排队中 · 上一轮结束后自动发送」+ 一个「取消排队」按钮；
+       · 排队条（兜底）：只有 bubble 没画成（老内核没有 qaRenderMine 返回值、
+         或画布当时不在）的条目才在这里列一行，保证它们仍然可见、仍然能撤。 */
+  function renderQueue() {
+    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);
+    });
+  }
+
+  /* 从队列里撤掉一条：气泡（画过的）与排队条（兜底项）都要清掉，
+     否则画布上留着一句永远不会被回答的话。 */
+  function dropQueued(idx) {
+    if (idx < 0 || idx >= state.queue.length) return false;
+    var gone = state.queue.splice(idx, 1)[0];
+    if (gone && gone.bubble && gone.bubble.parentNode) gone.bubble.parentNode.removeChild(gone.bubble);
+    /* 磁盘上也要删（宿主的持久化队列），否则下次启动它又冒出来。 */
+    notifyQueue('drop', gone);
+    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 的排队分支）：换会话就得一并撤掉，
+         否则那几句话跟着进了新会话的画布，看着像「我在这个会话里问过」。 */
+      state.queue.forEach(function (it) {
+        if (it.bubble && it.bubble.parentNode) it.bubble.parentNode.removeChild(it.bubble);
+        notifyQueue('drop', it);
+      });
+      state.queue = [];
+      renderQueue();
+      return n;
     }
 
-    async function runTurn(prompt, attPaths) {
+    function scheduleFlush() {
+      setTimeout(function () {
+        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');
+      renderQueue();
+      /* 轮到它了：宿主那条「等待中」该换成真正跑起来的会话（见 notifyQueue）。 */
+      notifyQueue('take', it);
+      flushing = true;
+      try { await fireTurn(it.text, it.atts, it.attPaths, it.bubble); }
+      finally { flushing = false; }
+      /* 连排了多条：这一条也收尾之后再发下一条（让用户看得清是哪条在跑）。 */
+      if (state.queue.length) scheduleFlush();
+    }
+
+    async function runTurn(prompt, attPaths, bubble) {
+      /* 本页原本在尾随别的进程跑的那一轮（follow）：现在自己要发新一轮 →
+         先把旧尾随掐掉。**不能等收尾再掐** —— 旧会话的增量会继续 render，
+         而新一轮的事件也在同一张画布上，正文就重复了。也不走 stopFollow：
+         它会把 busy 放开，而这里马上就要置 busy。 */
+      cancelFollowQuiet();
       state.busy = true; setSendMode('busy');
+      var askHandle = null;                        // 本轮 transport.ask 的返回值（收尾时取消用）
+      /* 串行门（beforeAsk）真正把这一轮挡住时，画布上必须看得见「排队中」——
+         2026-10-21 用户：「其实在串行排队 但是没显示出来任何标识」：气泡已经画出来了，
+         可除了它什么都没有，看起来就像发出去没人理。
+         ⚠️ 2026-10-22 用户：「现在串行没有排队的也会先显示排队状态再切回」：
+            这个标记**不再由组件按时间猜**（原先 300ms 后无条件盖上，空间本来就空闲时
+            只要那道门的一个往返超过 300ms，就先闪一下假的「排队中」再切回去）。
+            现在只认宿主的裁决 —— `info.queued(true)` 是宿主在**确认要等**时才调的
+            （前面真有队 / 探到该空间在跑），组件自己永不主动盖。 */
+      var markQueued = function (on) {
+        if (!bubble || !bubble.classList) return;
+        if (on) bubble.classList.add('is-queued');
+        else bubble.classList.remove('is-queued');
+      };
       /* 发送前的等待门：宿主可在这里「按任务模式」把这一轮挂起（串行模式同空间已有任务时）。
-         info.isNew = 这是不是一段**新会话的首轮**（历史会话的追问 isNew=false、不受限）。 */
+         info 带上这一轮**完整的下发参数**（session/engine/model/permission/attachments）：
+         串行排队要在宿主侧落库、App 重启后替用户重新发出去，光有 prompt 不够 ——
+         少了 session 那句追问会变成一段新会话，少了 model 会用错档，少了附件那条任务
+         跑的就成了别的东西。
+         **返回 false = 用户在排队期间取消了这一轮**：此时不能继续往下发（那会绕过串行门），
+         把本轮状态原样还回去即可（用户气泡已经在画布上，补一条「已取消排队」说清楚）。 */
       if (typeof opts.beforeAsk === 'function') {
         setWorking();
-        try { await opts.beforeAsk({ isNew: !state.session, workspace: state.workspace, engine: state.engine, prompt: prompt }); } catch (e) {}
+        var gate;
+        try {
+          gate = await opts.beforeAsk({
+            isNew: !state.session, session: state.session || '',
+            workspace: state.workspace, engine: state.engine,
+            model: state.model, permission: state.permission,
+            /* team：团队开关也是这一轮的**下发参数**。宿主排队落库后重发时必须还原它，
+               否则「开了团队模式的任务」在串行队列里会被静默降级成单任务。 */
+            team: state.team ? teamPayload() : null,
+            prompt: prompt, attachments: (attPaths || []).slice(),
+            /* queued(on)：宿主**确认这一轮要等**时调它，把「排队中」标到气泡上；
+               放行时调 queued(false)（或不调，runTurn 收口时会摘）。
+               组件不按时间猜 —— 空闲时的短等不该闪一下排队态（见上面那段注释）。 */
+            queued: markQueued
+          });
+        } catch (e) { gate = undefined; }
+        /* 门已经开了（或这一轮被取消）：先把「排队中」摘掉，别让放行后的气泡还挂着那句话。
+           取消那条由 markLastMineCancelled 接手续标。 */
+        markQueued(false);
+        if (gate === false) {
+          clearWorking();
+          state.busy = false; state.askId = null; setSendMode('idle');
+          /* 气泡已经画在画布上了（fireTurn 先画再等门）：这一轮不会有人回答它，
+             标成「已取消」比留一句悬空的话强 —— 用户至少知道它被撤了、不是还在等。 */
+          markLastMineCancelled();
+          noticeItem('已取消排队（串行模式）');
+          return;
+        }
       }
       /* ⚠️ 收尾一律由**内核那一路**做（h.finish / qaRunEnd / qaRenderDone，见 kernelDone）——
          这里不再补「收思考区 / 收工具卡 / 把过程并进任务耗时组」那一套（那是旧渲染器的活儿，
@@ -820,6 +1335,10 @@
         /* 空值就不传：让 core 用它自己的默认档，不替用户预设（安全语义）。 */
         if (state.permission && engineSupportsPermission(state.engine)) payload.permission = state.permission;
         if (state.session) payload.session = state.session;
+        /* 团队模式：只在开着时带这个字段（关 = 字段缺省，老 core / 老插件都不受影响）。
+           路由配置每次下发都现读宿主的配置 —— 用户在「我的」里改了图像引擎，
+           下一条消息就该用上，不必重新挂载组件。 */
+        if (state.team) payload.team = teamPayload();
         await new Promise(function (resolve) {
           var resolved = false;
           var deliver = function () {
@@ -908,11 +1427,13 @@
             hardFinish(code);
           };
           try {
-            transport.ask(payload, {
+            askHandle = transport.ask(payload, {
               onOpen: function (runID) { state.askId = runID || state.askId; },
               onEvent: function (ev) { try { render(ev); } catch (e) {} },
               onEnd: finish
             });
+            /* 存下取消钩子：kernelDone 在 turn_end 收尾时用它掐断这条流（见那里的注释） */
+            state.askHandle = askHandle;
           } catch (e) {
             noticeItem('发送失败：' + (e.message || e));
             finish(null);
@@ -926,27 +1447,44 @@
            内核那条收尾行已经写了，补一条会变成画布上多一行重复的「完成」。 */
         clearWorking();
         state.busy = false; state.askId = null; setSendMode('idle');
+        /* 只收自己那条流：收尾后用户可能已经发了新一轮，别把新一轮的钩子抹掉 */
+        if (state.askHandle === askHandle) state.askHandle = null;
         if (opts.onBusy) { try { opts.onBusy(false); } catch (e) {} }
+        /* 兜底再排一次 flush：有些收尾（没有任何终态事件、qa 都没建起来）
+           到不了 kernelDone，只有这里会放开 busy。重复调度由 flushing 挡住。 */
+        scheduleFlush();
       }
     }
 
     function setSendMode(mode) {
       var b = ctx.sendBtn;
+      var busy = mode === 'busy';
+      /* 运行中**有内容**时它不是「停止」而是「排队发送」（2026-10-21 用户：
+         「会话中运行中允许先提交追问 类似 magic-test pc 端相关」）。
+         判据与 PC 的 qaSendBtnSync 一致：busy && 输入框有字 → 可发送；busy && 空 → 停止。
+         输入框里的字一敲一删都会回调这里（见下面 input 监听）。 */
+      var typed = '';
+      try { typed = String(ctx.input.value || '').trim(); } catch (e) { typed = ''; }
+      var stop = busy && !typed && !state.plugin;
       /* ⚠️ busy 时**不能**把它 disabled：那样点它不会派发 click，
          它就从「中断」退化成一枚按不动的图标。改指中断后，
          重复发送由 send() 自己的 state.busy 守卫拦住，不需要靠 disabled 防。 */
       b.disabled = false;
-      b.classList.toggle('sendbtn--stop', mode === 'busy');
+      b.classList.toggle('sendbtn--stop', stop);
       b.innerHTML = '';
-      b.appendChild(svgIcon(mode === 'busy' ? 'i-clock' : 'i-up', 17));
-      b.setAttribute('aria-label', mode === 'busy' ? '中断' : '发送');
-      b.title = mode === 'busy' ? '中断这一轮' : '发送';
-      /* 「生成中」提示行（2026-10-20 用户：「两个胶囊合并成1个 在下面显示生成中效果即可」）：
-         这枚胶囊**下面**那一行小字，就是合并后「这一轮在跑」的表达 ——
-         画布底部内核那枚同文案的胶囊在本壳不画（见 conversation.css）。
+      /* 停止用方块、且比发送箭头略小（方块本身比箭头「重」，同尺寸会显得头重脚轻） */
+      b.appendChild(svgIcon(stop ? 'i-stop' : 'i-up', stop ? 14 : 17));
+      b.setAttribute('aria-label', !busy ? '发送' : (stop ? '中断' : '排队发送'));
+      b.title = !busy ? '发送'
+        : (stop ? '中断这一轮' : '排队发送 · 上一条处理中，结束后自动提交');
+      /* 运行态并进引擎 · 模型那枚胶囊（2026-10-20 用户：「两个胶囊合并成1个」
+         →「是图中胶囊下方的生成中 应该跟胶囊合并」→「不需要文字了 用其他动画效果代替」）——
+         运行态时这枚胶囊**自己**变成运行态：前面的小图标换成绿液瓶（会涨落）。
          ⚠️ 跟着 busy 走（setSendMode 是 busy 的唯一出口：发一轮 / 收一轮 / 续传轮
-         都经过它），所以不需要另开一个状态位。 */
-      if (ctx.genRow) ctx.genRow.classList.toggle('on', mode === 'busy');
+         都经过它），所以不需要另开一个状态位。
+         ⚠️ 引擎·模型的真值仍在胶囊里：降级换模型时 'start' 事件会改写它
+         （见 kernelApply 的 'start' 分支 → syncPickers），所以不丢信息。 */
+      if (ctx.casc) ctx.casc.classList.toggle('is-running', mode === 'busy');
     }
 
     /* ══════════ 底部抽屉组件 Sheet（引擎 / 模型 / 授权共用）══════════
@@ -1086,7 +1624,9 @@
         models.forEach(function (mm) {
           var b = el('button', 'pick__citem' + (state.engine === cur.engine && state.model === mm ? ' is-on' : ''));
           b.type = 'button';
-          b.appendChild(el('span', 'pick__cl', mm));
+          /* 清单项显示剥离前缀后的名字（`mm` 本身是 CLI 认的完整 id，选它时原样写回）。
+             倍率（`model_credits`）靠右挂在同一行：模型名再长也只挤自己，倍率列不会错位。 */
+          b.appendChild(modelRow(mm, qaModelCredit(state.engines, cur.engine, mm)));
           b.onclick = function () { state.engine = cur.engine; state.model = mm; syncPickers(); notifyPick(); Sheet.close(); };
           right.appendChild(b);
         });
@@ -1094,6 +1634,104 @@
       paint();
     }
 
+    /* ══════════ 团队模式 ══════════
+       开关本身很薄：它只决定 payload 里带不带 `team`。真正的编排全在 core
+       （internal/team：主引擎拆任务 → 子引擎分头跑 → 主引擎汇总），界面上的表现
+       复用**委派卡**（子任务的事件带 parent，内核早就画成嵌套卡了）—— 所以这里
+       不需要任何画法，也不需要新的事件类型。
+
+       为什么只传「配置」不传「模式细节」：parallel / 路由都是用户的**偏好**（「我的」页里配的），
+       由宿主持有并通过 opts.teamConfig 交给组件。组件每轮现读一次 —— 用户在设置里
+       换了图像引擎，下一条消息就生效，不必重新挂载。 */
+    function teamPayload() {
+      var cfg = null;
+      if (typeof opts.teamConfig === 'function') {
+        try { cfg = opts.teamConfig(); } catch (e) { cfg = null; }
+      }
+      var out = {};
+      var routes = (cfg && cfg.routes) || null;
+      if (routes && typeof routes === 'object') {
+        var clean = {};
+        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 model = String(r.model || '').trim();
+          if (model) item.model = model;
+          clean[k] = item;
+        });
+        if (Object.keys(clean).length) out.routes = clean;
+      }
+      var n = parseInt((cfg && cfg.parallel), 10);
+      if (n > 0) out.parallel = n;
+      // 拆解规则：粒度只认三档（写错就按 core 默认 standard，不让脏值把请求打成 400）；
+      // 两个布尔是「显式表达偏好」，只有与 core 默认不同才传，免得每轮都塞无意义的字段。
+      var split = String((cfg && cfg.split) || '').trim().toLowerCase();
+      if (split === 'coarse' || split === 'standard' || split === 'fine') out.split = split;
+      if (cfg && cfg.splitCode === true) out.splitCode = true;
+      if (cfg && cfg.adaptive === false) out.adaptive = false;
+      // 角色规则：空文本不传（留空 = 用 core 内置的「这类任务适合什么」）。
+      var rules = (cfg && cfg.rules) || null;
+      if (rules && typeof rules === 'object') {
+        var cleanRules = {};
+        Object.keys(rules).forEach(function (k) {
+          var t = String(rules[k] || '').replace(/\s+/g, ' ').trim();
+          if (t) cleanRules[k] = t;
+        });
+        if (Object.keys(cleanRules).length) out.rules = cleanRules;
+      }
+      return out;
+    }
+
+    /* 团队开关的唯一写入口。两件事必须一起发生，否则会出现「界面开了、下一轮没开」
+       （或者反过来）：① 改自己的 state 并重画；② 叫醒宿主 —— 开关的**权威状态**在
+       宿主的按会话记录里（每条会话一份、落 localStorage），组件只是这一轮的执行者。 */
+    function setTeamState(on) {
+      state.team = !!on;
+      syncPickers();
+      if (opts.onTeamChange) { try { opts.onTeamChange(state.team); } catch (e) {} }
+    }
+
+    /* 团队开关的选择器。两个入口（会话页右上角的运行设置、我的页的团队模式卡片）
+       都调它 —— 「选择器只有一份」是这套 UI 的硬约束（与权限选择器同理）。 */
+    function openTeamPicker(anchor) {
+      Sheet.open(anchor, function (M) {
+        M.title('团队模式');
+        if (!featureOn('feature.session.team')) {
+          M.row({ label: '当前 core 不支持团队模式',
+                  desc: '需要升级 magic-agent（缺 feature.session.team 能力位）' });
+          return;
+        }
+        M.row({
+          label: '关闭', desc: '一个引擎从头做到尾（默认）',
+          selected: !state.team,
+          onPick: function () { setTeamState(false); }
+        });
+        M.row({
+          label: '开启', desc: '主引擎拆任务 → 子引擎分头执行 → 主引擎汇总；'
+            + '每个子任务在对话里是一张委派卡（哪类活交给谁，按引擎擅长什么在设置里配）',
+          selected: !!state.team,
+          onPick: function () { setTeamState(true); }
+        });
+      });
+    }
+
+    /* core 能力位（feature.*）是否具备。清单来自 /desk/health 或 /desk/contract，
+       由宿主经 opts.features 交进来 —— 可以是**数组**，也可以是**函数**（推荐：
+       能力清单是异步拉到的，函数形式让「查到之后才亮出开关」不需要重新挂载组件）。
+       **没给 / 空 = 不知道 = 当作不支持**（诚实降级：宁可不显示开关，
+       也不要让用户打开一个 core 会以 exit 2 拒绝的选项）。 */
+    function featureOn(name) {
+      var list = opts.features;
+      if (typeof list === 'function') {
+        try { list = list(); } catch (e) { list = null; }
+      }
+      if (!list) return false;
+      if (typeof list.indexOf === 'function') return list.indexOf(name) >= 0;
+      return !!list[name];
+    }
+
     function openPermissionPicker(anchor) {
       Sheet.open(anchor, function (M) {
         M.title('授权档位');
@@ -1230,8 +1868,12 @@
     }
 
     /* 把画面接回一条**还在跑**的轮次（2026-10-20 用户：「切回来还是没好」）。
-       打开会话时若发现同会话的轮次仍在跑：历史只回放到那条 user，这里从 ask 缓冲
-       `after=0` 补齐并持续增量补拉，直到终态；同时置 busy（拦住误发新消息）。
+       从本进程的 ask 缓冲 `after=0` 补齐并持续增量补拉，直到终态；同时置 busy。
+
+       ⚠️ 2026-10-21 起这是**兜底**通道：网关有 `/follow` 时优先尾随磁盘日志
+       （见 loadHistory 的接续一段）。只在这两种情况下走到这里：
+         · 旧网关没有 followSession；
+         · follow 建不起来（连不上 / 立刻报错）。
 
        alreadyRenderedUser：那条 user 已经由日志重放画过了（loadHistory 的 partial 分支）。
        网关从 2026-10-20 起会在缓冲头合成一条 `type:"user"`（core 的事件流里没有这条），
@@ -1289,7 +1931,129 @@
       return true;
     }
 
-    /* 相邻 thinking 分片并成一条（只并相邻；用数组攒再 join，别用 text += 逐片拼）。 */
+    /* ══════════ 尾随一条还在跑的会话（磁盘日志，跨进程）══════════
+       2026-10-21 报障：「移动端发出的回话在 PC 端打开看不到进度，PC 端发出的移动端看不到」。
+       上一节的 attachRunningAsk 走 /desk/asks —— 那是**本插件进程内存里**的轮次：
+       掌天瓶桌面壳直接 exec core，它起的一轮在本插件里从来不存在（反之亦然）。
+       这里走网关的 /desk/session/{id}/follow：服务端读磁盘上那条会话日志
+       （跨进程共享，谁跑的都一样），按 ~500ms 增量推送，一次连接跟到终态。
+
+       ⚠️ 2026-10-21 起它是**首选**通道（见 loadHistory 的接续一段）：只要清单说这条会话
+       还在跑就用它，本进程有 run 也不例外 —— ask 缓冲的 seq 口径与文件不同、且有上限裁剪，
+       长轮次里必然「进来看一眼就静止」。attachRunningAsk 降级为「网关没有 /follow」时的兜底。
+
+       收摊三种：END 帧 / 换会话或组件销毁（stopFollow）/ 游标超前（重拉历史）。 */
+    /* 文件尾那条事件的 seq —— 尾随游标（follow 的 `after`）。
+       ⚠️ 不能用「全文件最大」：续跑会让 seq 回落，取最大会得到比文件尾还大的游标，
+       网关据此判「游标超前」→ 回 snapshot 帧 → 客户端清屏重拉 → 一直循环。
+       文件顺序即时间顺序，最后一条的 seq 就是「已经画到哪」。 */
+    function tailEventSeq(list) {
+      for (var i = list.length - 1; i >= 0; i--) {
+        var n = Number(list[i] && list[i].seq);
+        if (isFinite(n) && n > 0) return n;
+      }
+      return 0;
+    }
+    function sessionLive() {
+      var m = state.meta;
+      if (!m) return false;
+      /* `status` 是会话级统一状态（core 的 --sessions，与标题同源保存）；`state` 只是
+         「挑中的那一轮」的状态，两端挑中不同轮会得出不同结论。老版本 CLI 没有 status 时回落。 */
+      var st = String(m.status || m.state || '');
+      return !!(m.alive || st === 'running' || st === 'waiting_approval');
+    }
+    /* 断流。busy 是 follow 置的（没有本地 askId）就一并放开，别让输入框一直卡在「发送中」。
+       askId 由 follow 借来（见 startFollow 的 askID 参数）也一并还回去 —— 否则换会话后
+       「打断」会打到一个早已不存在的轮次上。 */
+    function stopFollow() {
+      var f = state.follow;
+      if (!f) return;
+      state.follow = null;
+      try { if (f.cancel) f.cancel(); } catch (e) {}
+      if (f.askId && state.askId === f.askId) state.askId = null;
+      if (!state.askId) {
+        clearWorking();
+        state.busy = false;
+        setSendMode('idle');
+        if (opts.onBusy) { try { opts.onBusy(false); } catch (e) {} }
+      }
+    }
+    /* 只掐连接，**不碰** busy / 输入框：用于「本页自己发起新一轮」——
+       那一轮由 runTurn 管状态，而旧的那条尾随必须立刻断开（否则它的增量会和新一轮
+       的实时事件写进同一张卡，正文重复一遍）。 */
+    function cancelFollowQuiet() {
+      var f = state.follow;
+      if (!f) return;
+      state.follow = null;
+      try { if (f.cancel) f.cancel(); } catch (e) {}
+      if (f.askId && state.askId === f.askId) state.askId = null;
+    }
+    function followEnd(info) {
+      var f = state.follow;
+      if (!f) return;
+      state.follow = null;
+      var reason = String((info && info.reason) || '');
+      var st = String((info && info.state) || '');
+      clearWorking();
+      state.busy = false;
+      state.askId = null;
+      state.resumeT0 = 0;
+      setSendMode('idle');
+      if (opts.onBusy) { try { opts.onBusy(false); } catch (e) {} }
+      /* 尾随的这条会话跑完了：排在输入框上方的追问现在可以发（同上，排队不打断）。 */
+      scheduleFlush();
+      /* 记下「这条会话刚由 follow 跟到终态」：core 退出后 /desk/asks 里还会留这个 run 一会儿
+         （askRetention），停留期巡检若据此重拉会把刚画完的画面整屏重画一遍（长会话=一次
+         全量读）。见 watchTick 的抑制判据。 */
+      if (reason === 'terminal') state.followDone = { sid: state.session, at: Date.now() };
+      if (state.qaClosed || !state.qa || !state.qa.h) return;
+      if (reason === 'terminal') {
+        var ok = !(st === 'failed' || st === 'cancelled' || st === 'interrupted' || st === 'gone');
+        closeAttached(ok, ok ? '已完成' : '这一轮已结束');
+      } else if (reason === 'max_duration') {
+        noticeItem('进度同步到时（30 分钟），重开会话可继续同步');
+        closeAttached(false, '进度同步已暂停');
+      } else {
+        closeAttached(false, '进度同步已断开 · 重开会话可继续');
+      }
+    }
+    /* after = 已经画到哪（日志 seq）。askID = 本进程里这一轮的 id（跨进程跟随时没有）。
+       返回是否真的跟上了。 */
+    function startFollow(sid, after, askID) {
+      stopFollow();
+      if (!sid || typeof transport.followSession !== 'function') return false;
+      var tok = { sid: sid, cancel: null, askId: askID || null };
+      var h = transport.followSession(String(sid), after || 0, {
+        onEvent: function (ev) {
+          if (state.follow !== tok || sid !== state.session) return;
+          try { render(ev); } catch (e) { /* 单条坏事件吞掉 */ }
+        },
+        onSnapshot: function () {
+          /* 游标超前（日志被重置 / 换了会话）→ 整份重来，别在半截上续。
+             ⚠️ 必须连 busy 一起放开（并把借来的 askId 还掉）：loadHistory 只在「本页空闲」
+             时才肯重新挂 follow，否则重拉出来的是一份不跟流的静态历史。 */
+          if (state.follow !== tok || sid !== state.session) return;
+          if (tok.askId && state.askId === tok.askId) state.askId = null;
+          stopFollow();
+          clearThread();
+          threadEl.appendChild(empty);
+          state.qaClosed = false;
+          loadHistory(sid).catch(function () { /* 下一拍由用户重开 */ });
+        },
+        onEnd: function (info) { if (state.follow === tok) followEnd(info); },
+        onError: function () { if (state.follow === tok) followEnd({ reason: 'error' }); }
+      });
+      if (!h || typeof h.cancel !== 'function') return false;
+      tok.cancel = h.cancel;
+      state.follow = tok;
+      if (askID) state.askId = askID;
+      state.busy = true;
+      setSendMode('busy');
+      setWorking();
+      if (opts.onBusy) { try { opts.onBusy(true); } catch (e) {} }
+      return true;
+    }
+
     function mergeThinkDeltas(list) {
       var out = [];
       for (var i = 0; i < list.length; i++) {
@@ -1386,6 +2150,10 @@
        140ms 内就回来的（本地小会话）根本不亮，避免「刚出现就消失」的抖动。
        ⚠️ 动画只动 transform / opacity（见 conversation.css）：回放大日志会占死主线程，
           动 layout 的属性会让这一屏跟着冻住，看上去就像「卡在读取」。 */
+    /* 已经为哪条会话拉过历史（首载发起时落定，换会话 / 读失败时清空）。
+       `setSession` 的同会话短路要看它：只有「历史确实在这块画布里」才跳过重放，
+       否则 `create({session})` 那条路（state.session 事先就有值）会被误判成重入。 */
+    var histSid = null;
     var histLoading = null;         // loading 节点（懒建：没读过历史就不建）
     var histLoadingWant = false;    // 这一轮首载还没结束
     var histLoadingTimer = 0;       // 「140ms 还没回来才显示」的定时器
@@ -1430,7 +2198,7 @@
 
     function loadHistory(sid, after) {
       if (!sid) return Promise.resolve(0);
-      if (after == null) beginHistLoading();
+      if (after == null) { histSid = sid; beginHistLoading(); }
       /* 打开会话时**并行**问两件事：日志 + 本进程有没有挂在同一会话上的运行中轮次。
          后者决定历史回放到哪（见 lastTurnInfo）；拉不到就当没有 ——
          旧网关没有 /desk/asks，不能因为它让历史打不开。 */
@@ -1464,15 +2232,37 @@
         /* ⚠️ 回放标记（2026-10-12）：回放**不走 seq 去重**（见 render 开头那段）——
            日志是跨轮追加的，老日志里每轮的 seq 都从 1 重来，去重会把第二轮起的事件当成
            重复帧全丢掉。打了这个标，render 那边就跳过 seq 判重。 */
+        var canFollow = typeof transport.followSession === 'function';
         var run = runningAskOf(rs[1], sid);
         var info = lastTurnInfo(events);
-        /* 有运行中的同会话轮次、且日志里那一轮还没收尾 → 只重放到那条 user（含），
-           提问之后的助手侧内容一律交给 ask 缓冲补齐（日志可能落后 / seq 口径不同）。 */
-        var partial = !!(run && info.index >= 0 && !info.terminal);
+        /* 「本页要接着看一条还在跑的会话」——两个来源任一成立：
+             · 清单说它还在跑（sessionLive）—— 跨进程跑的那一轮在本插件里根本不存在
+               （桌面壳直接 exec core、或另一台设备起的），只能看清单；
+             · 本进程还有它的运行中轮次（run）—— 清单行可能是进页面时拿的旧快照。
+           只首载跟一次：分页拉「更早」不该把流接回去。 */
+        var live = !!(after == null && sid === state.session && !state.busy
+          && (sessionLive() || !!run));
+        /* ⚠️ 通道在这里一次定死（回放怎么画取决于走哪条）：
+             · useFollow —— 磁盘日志（首选，见下面的说明）；
+             · useAsk    —— 本进程的 ask 缓冲（网关没有 /follow 时的兜底）。
+           `info.terminal` = 日志里这一轮**已经有终态**：那就是真的跑完了（清单行可能是滞后的
+           旧快照）。这时两条都不该挂 —— 否则会先亮起「生成中」、再被 follow 的 END 摘掉，
+           白白闪一下，还会把已经封口的画面再解封。 */
+        var useFollow = live && canFollow && !info.terminal;
+        var useAsk = !useFollow && live && !!run && !info.terminal;
+        /* partial = 「这一轮还没收尾，但首载之后还要接着看它」→ 回放**不封口**
+           （封口后后续事件会另起一张卡，同一轮变成两张、正文各半截）。
+           重放到哪分两种：
+             · 接 ask 缓冲：截到那条 user，其余交给缓冲 —— 缓冲的 seq 是 core 每轮的原始
+               序号，与文件 seq 不同口径，重放多了会对不上（见 attachRunningAsk 的说明）；
+             · 尾随磁盘日志：**全量重放**，游标接在文件末尾 —— 同一份数据同一口径，
+               磁盘上有多少画多少，剩下的由 follow 增量推。 */
+        var partial = !!((useFollow || useAsk) && info.index >= 0);
+        var replayTo = useAsk ? Math.max(0, info.index + 1) : events.length;
         state.replay = true;
         state.replayT0 = 0; state.replayLastAt = 0;
         try {
-          var replayList = events.slice(0, partial ? info.index + 1 : events.length);
+          var replayList = events.slice(0, partial ? replayTo : events.length);
           /* 相邻思考增量先并成一段再喂（2026-10-20 用户：「移动端加载也很慢」）：
              日志是按流式增量落盘的，一条长会话实测 95838 条事件里 94015 条是
              ~3 字符的 thinking 分片 —— 逐条 render 要 16s、主线程整段占死。
@@ -1486,7 +2276,7 @@
           });
           /* 日志尾部没有终态事件（那一轮被中断）→ 把最后一轮也封口，
              否则底部会永远留着一枚「生成中」胶囊。
-             续传中的那一轮**不封**：它的收尾由 ask 缓冲的终态事件落定。 */
+             续传中的那一轮（partial）**不封**：它的收尾由后面接上的实时通道落定。 */
           if (!partial) finishReplayRound();
         } finally { state.replay = false; }
         var t = thread(); t.scrollTop = t.scrollHeight;
@@ -1496,8 +2286,34 @@
         /* 分页游标落定后才显示入口（旧服务端 hist = null → 不显示，行为与改动前一致）。 */
         state.hist = after == null ? hist : state.hist;
         syncMore();
-        /* partial 时那条 user 已由上面的日志重放画过 → 让 attach 跳过网关合成的同一条。 */
-        if (run) attachRunningAsk(run, info.at, partial);
+        /* 接续（2026-10-21 用户：「在会话列表看到还在跑 点进来就没增量」）：
+           **磁盘日志优先**。只要清单说这条会话还在跑，就尾随网关的文件增量（/follow，
+           跨进程、只追加、不裁剪）；本进程的 ask 缓冲只在日志通道不可用时兜底。
+
+           为什么反过来（原来是有 run 就 attachRunningAsk）：ask 缓冲有两个致命口径问题，
+           长轮次下必然「进来看一眼就静止」——
+             ① 缓冲里事件的 seq 是 **core 每轮的原始序号**（每轮从 1 起），文件的是跨轮
+                接号的（见 cli/sessionlog.go 的 openFile）。拿缓冲 seq 当游标续拉，
+                在第二次之后的轮次里永远 `after > lastSeq` → 一条都补不到；
+             ② 缓冲有上限（askBufMaxEvents / askBufMaxBytes），超了从头裁并置 dropped，
+                于是 after=0 直接 snapshotRequired，中间过程永久缺失。
+           而文件日志是同一份、同一口径、且 500ms 就 flush 一次（跨进程也读得到）。
+           只首载跟一次：分页拉「更早」不该把流接回去。 */
+        var attached = false;
+        if (useFollow) {
+          /* 耗时的起点是日志里那条 user 的墙钟（不是「进这条会话的时刻」）——
+             否则「已完成 · 总耗时 1.2s」会把跑了十分钟的轮次写成两秒（见 kernelDone 的 resumeT0）。 */
+          state.resumeT0 = info.at || 0;
+          /* 本进程正好也有这条会话的轮次时把 id 交出去：「打断」才打得到（跨进程的没有）。 */
+          attached = startFollow(sid, tailEventSeq(events), run && run.id);
+        }
+        /* 兜底：网关没有 /follow（旧版）时走本进程的 ask 缓冲。
+           ⚠️ 只在 useAsk 为真时接：那时回放**截到了那条 user**，缓冲从 0 补不会重影。
+           反过来（日志已全量重放、再拿缓冲从 0 补）会把整轮画第二遍。 */
+        if (!attached && useAsk) attached = attachRunningAsk(run, info.at, partial);
+        /* 说好要接着看、结果一条通道都没接上（旧网关 / 读盘抖动）→ 把这一轮按「已结束」封口，
+           否则底部会永远留着一枚「生成中」胶囊，且输入框一直卡在「发送中」。 */
+        if (partial && !attached) finishReplayRound();
         /* 首载结束：骨架屏撤下。一条都没画出来（空会话）→ 把空态那句还回去。
            ⚠️ 期间用户可能已经切走（迟到的这一份不许撤新会话的骨架屏）。 */
         if (after == null && sid === state.session) endHistLoading(true);
@@ -1505,7 +2321,10 @@
       });
       /* 读失败也要撤骨架屏（否则它会一直挂着，看着像永远读不完）。 */
       return done.catch(function (e) {
-        if (after == null && sid === state.session) endHistLoading(true);
+        if (after == null && sid === state.session) {
+          endHistLoading(true);
+          histSid = null;          // 读失败不算「已在这块画布里」：下次重开还要再试
+        }
         throw e;
       });
     }
@@ -1613,6 +2432,9 @@
       if (watchTimer) { clearInterval(watchTimer); watchTimer = 0; }
       watchSeen = '';
       watchInflight = false;
+      /* 实时的文件尾随同属「停留期的后台同步」：换会话 / 新建 / 销毁时一并掐掉
+         （否则旧会话的事件会继续写进清空后的画布，见 startFollow 的 tok 守卫）。 */
+      stopFollow();
     }
     function watchTick() {
       var sid = state.session;
@@ -1626,6 +2448,10 @@
         var run = runningAskOf(asks, sid);
         /* 同一条 run 只刷一次：接不上（旧网关缺 askEvents）时别每 5s 重画一遍。 */
         if (!run || watchSeen === run.id) return;
+        /* 这条会话刚被 follow 跟到终态（<15s）：/desk/asks 里那个 run 还没过保留期，
+           此时重拉 = 把刚画完的一整轮再画一遍（长会话是一次全量读）。 */
+        if (state.followDone && state.followDone.sid === sid
+            && Date.now() - state.followDone.at < 15000) return;
         watchSeen = run.id;
         clearThread();
         threadEl.appendChild(empty);
@@ -1645,7 +2471,9 @@
       var casc = root.querySelector('.casc');
       if (casc) {
         casc.querySelector('.casc__p').textContent = state.engine || '选择引擎';
-        casc.querySelector('.casc__s').textContent = state.model || '默认模型';
+        /* 展示走 qaModelText：剥掉 codebuddy 系自定义模型的 `custom-local:` 前缀
+           （`state.model` 本身仍是完整 id，`-m` 要用它）。 */
+        casc.querySelector('.casc__s').textContent = qaModelText(state.model) || '默认模型';
       }
       var chip = ctx.permBtn;
       if (chip) {
@@ -1689,6 +2517,18 @@
        引擎提问 / 待授权时卡钉在输入框上方。显隐与进出全由内核管，这里只给一块地。 */
     var askDock = el('div', 'qa-askdock'); askDock.id = 'home-askdock'; askDock.hidden = true;
     cbox.appendChild(askDock);
+    /* 排队追问的停靠位（2026-10-21）：运行中提交的那几条排在这里，不进画布 ——
+       它们**还没跑**，画成用户气泡会让人以为已经发出去了。位置贴着输入框上沿
+       （与 PC 的 qaMsgList 同一意图：「新需求排列在会话框上面」）。 */
+    var queueBar = el('div', 'queuebar'); queueBar.hidden = true;
+    ctx.queueBar = queueBar;
+    cbox.appendChild(queueBar);
+    /* 选中的插件胶囊的**停靠位**：在附件条上方、输入框之外。
+       ⚠️ 不塞进 .attachbar 里：那是附件的地盘，混在一起后 clearAttachments
+          （每轮必跑）会把胶囊一起清掉，而插件是「本轮怎么干」不是附件。 */
+    var plugBar = el('div', 'plugbar'); plugBar.hidden = true;
+    ctx.plugBar = plugBar;
+    cbox.appendChild(plugBar);
     var attachBar = el('div', 'attachbar'); attachBar.hidden = true;
     ctx.attachBar = attachBar;
     cbox.appendChild(attachBar);
@@ -1703,12 +2543,25 @@
     }
     var casc = el('button', 'casc');
     casc.type = 'button';
-    casc.appendChild(svgIcon('i-cpu', 14));
+    /* 前面这一格放两样东西：平时是「引擎」小图标，跑的时候换成绿液瓶（掌天瓶那套加载图形）。
+       「生成中」不配文字（2026-10-20 用户：「不需要文字了 用其他动画效果代替」）——
+       一枚会动的小瓶比三个字更轻，也不占宽度。
+       ⚠️ 换图标而不换整枚胶囊：胶囊本身就是引擎·模型选择器（点它开抽屉），
+          换掉整枚会让人以为运行态不能点。 */
+    var lead = el('span', 'casc__lead');
+    var cpuIco = svgIcon('i-cpu', 14);
+    cpuIco.classList.add('casc__cpu');
+    lead.appendChild(cpuIco);
+    var bottleBox = el('span', 'casc__bottle');
+    bottleBox.appendChild(bottleSVG({ fill: 0.62, anim: 'hist' }));
+    lead.appendChild(bottleBox);
+    casc.appendChild(lead);
     casc.appendChild(el('span', 'casc__p', '选择引擎'));
     casc.appendChild(el('span', 'casc__sep', '·'));
     casc.appendChild(el('span', 'casc__s', '默认模型'));
     casc.appendChild(svgIcon('i-chev', 13));
     casc.className = 'casc';
+    ctx.casc = casc;
     ctx.permBtn = el('button', 'permchip');
     ctx.permBtn.type = 'button';
     ctx.permBtn.appendChild(svgIcon('i-set', 14));
@@ -1720,23 +2573,11 @@
     var trow = el('div', 'composer__tools');
     trow.appendChild(casc);
     if (opts.showPermission !== false) trow.appendChild(ctx.permBtn);
-    /* 「生成中」提示行（2026-10-20 用户：「两个胶囊合并成1个 在下面显示生成中效果即可」）：
-       画布底部内核那枚「引擎 · 模型 · 生成中」胶囊，与本行这枚「引擎 · 模型」胶囊
-       显示的是同一串字、上下挨着，像同一件事说了两遍 → 画布那枚在本壳**不画**
-       （皮肤见 conversation.css 的 .conv__thread .qa-run）；「这一轮在跑」改由
-       这枚胶囊**下面**这一行小字表达（转圈 + 「生成中」）。
-       ⚠️ 引擎·模型的真值仍在 .casc 上：降级换模型时 'start' 事件会改写它
-       （见 kernelApply 的 'start' 分支 → syncPickers），所以不丢信息。 */
-    var genRow = el('div', 'composer__gen');
-    genRow.appendChild(el('span', 'composer__gen__sp'));
-    genRow.appendChild(el('span', 'composer__gen__t', '生成中'));
-    ctx.genRow = genRow;
     ctx.sendBtn = el('button', 'sendbtn');
     ctx.sendBtn.type = 'submit';
     crow.appendChild(cleft); crow.appendChild(ctx.sendBtn);
     cbox.appendChild(crow);
     form.appendChild(trow);
-    form.appendChild(genRow);
     form.appendChild(cbox);
     wrap.appendChild(form);
     root.appendChild(wrap);
@@ -1749,6 +2590,11 @@
     /* 代码块与工具明细的复制按钮、提问卡选项、思考块折叠……这些点击**全部**走内核那份委托
        （`shared/conv/07-stream-delegation.js` 的 bindQaStreamDelegation，在下面挂桥那段绑一次）。
        本文件不再挂自己的画布委托 —— 节点随快照重建也不会失效。 */
+    /* 内核的「用户离开底部」闸（2026-10-21 用户：「移动端对话框向上滑动看历史时总又自动跳回
+       聚焦到结尾」）：这套监听维护 `qaUserAway`，而 `qaScrollIntoView` 靠它决定要不要把画布
+       贴到底。它原来只在圆点轨的 qaDotsBind 里绑，本组件从不调那个 —— 闸恒开，于是手机上
+       每一次上滑都被下一笔流式增量拽回结尾。这里补上（幂等，圆点轨复用时不会再绑一遍）。 */
+    if (typeof qaScrollGateBind === 'function') qaScrollGateBind();
     threadEl.addEventListener('scroll', function () {
       state.autoFollow = nearBottom();
       syncBottomBtn();
@@ -1759,16 +2605,91 @@
     threadEl.addEventListener('wheel', function (e) {
       if (e.deltaY < 0 && threadEl.scrollHeight <= threadEl.clientHeight + 8) loadMore();
     }, { passive: true });
-    ctx.input.addEventListener('input', autoGrow);
+    ctx.input.addEventListener('input', function () {
+      autoGrow();
+      /* 运行中输入/删除文字：发送键在「停止」与「排队发送」之间当场切换
+         （PC 的 qaSendBtnSync 挂在 input 上，同一口径）。 */
+      if (state.busy) setSendMode('busy');
+    });
     form.addEventListener('submit', function (e) { e.preventDefault(); send(); });
     ctx.input.addEventListener('keydown', function (e) {
       if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) { e.preventDefault(); send(); }
     });
+    /* ── 粘贴 / 拖入图片（2026-10-21 用户：「对话框中现在没支持粘贴图片」）──
+       与 ＋ 菜单里的「照片 / 文件」走**同一条**上传管线（uploadFiles → maybeNormalize
+       → POST /desk/upload），拿到 core 那台机器的绝对路径后随 payload.attachments 下发。
+       ⚠️ 只认「真的带图片文件」的剪贴板：纯文本 / 富文本粘贴必须继续走浏览器默认行为 ——
+          无差别 preventDefault 会把正常文字粘贴吃掉（这类实现最常见的一处自伤）。
+       ⚠️ 拖拽的 dragenter / dragover 必须 preventDefault：否则浏览器默认行为是**直接打开
+          这个文件**，整个页面会被替换成一张图片（比粘贴更容易踩、也更难排查）。 */
+    function clipImageFiles(dt) {
+      var out = [];
+      if (!dt) return out;
+      var items = dt.items;
+      if (items && items.length) {
+        for (var i = 0; i < items.length; i++) {
+          var it = items[i];
+          if (!it || it.kind !== 'file') continue;      // 非 file 项 getAsFile() 恒为 null
+          if (!/^image\//i.test(it.type || '')) continue;
+          var f = it.getAsFile();
+          if (f && f.size) out.push(f);
+        }
+      }
+      if (!out.length && dt.files) {                    // 拖拽的文件在 files 里；粘贴侧只是回退
+        for (var j = 0; j < dt.files.length; j++) {
+          var g = dt.files[j];
+          if (g && /^image\//i.test(g.type || '') && g.size) out.push(g);
+        }
+      }
+      return out;
+    }
+    form.addEventListener('paste', function (e) {
+      var files = clipImageFiles(e.clipboardData);
+      if (!files.length) return;                        // 文字粘贴：不拦
+      e.preventDefault();
+      uploadFiles(files);
+    });
+    /* 拖拽过程中有些浏览器（Safari / 部分 WebView）不暴露 items 的文件项，只在 types 里给
+       'Files' —— 这时也必须放行，否则默认行为是**把整页替换成那张图**。 */
+    function dtHasFiles(dt) {
+      var types = (dt && dt.types) ? dt.types : null;
+      if (!types) return false;
+      for (var i = 0; i < types.length; i++) { if (types[i] === 'Files') return true; }
+      return false;
+    }
+    ['dragenter', 'dragover'].forEach(function (t) {
+      form.addEventListener(t, function (e) {
+        if (!clipImageFiles(e.dataTransfer).length && !dtHasFiles(e.dataTransfer)) return;
+        e.preventDefault(); e.stopPropagation();
+        cbox.classList.add('is-drop');
+      });
+    });
+    form.addEventListener('dragleave', function (e) {
+      if (!form.contains(e.relatedTarget)) cbox.classList.remove('is-drop');
+    });
+    form.addEventListener('drop', function (e) {
+      var files = clipImageFiles(e.dataTransfer);
+      var anyFile = !!(e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files.length);
+      cbox.classList.remove('is-drop');
+      if (!files.length) {
+        /* 拖进来的不是图片：明说，不留一个「什么都没发生」 */
+        if (anyFile) { e.preventDefault(); e.stopPropagation(); noticeItem('只支持图片（PNG / JPEG / WebP / GIF / BMP）'); }
+        return;
+      }
+      e.preventDefault(); e.stopPropagation();
+      uploadFiles(files);
+    });
     casc.addEventListener('click', function (e) { e.stopPropagation(); openEnginePicker(casc); });
     if (ctx.attachBtn) ctx.attachBtn.addEventListener('click', function (e) { e.stopPropagation(); openAttachSheet(ctx.attachBtn); });
     ctx.permBtn.addEventListener('click', function (e) { e.stopPropagation(); openPermissionPicker(ctx.permBtn); });
     ctx.sendBtn.addEventListener('click', function (e) {
       if (!state.busy) return;          // 空闲时照常 submit
+      /* 运行中**有内容** → 不打断，交给 submit 走「排队」（见 send）；
+         只有「忙 + 空输入」才是停止（PC：92-composer.js 同一个判据）。 */
+      var typed = '';
+      try { typed = String(ctx.input.value || '').trim(); } catch (e0) { typed = ''; }
+      /* 附件也算「有内容」：忙时贴了图再点发送 = 排队，不能把它当成「停止」（同 send 的闸门）。 */
+      if (typed || state.plugin || (state.attachments || []).length) return;
       e.preventDefault();
       control('interrupt');
     });
@@ -1805,7 +2726,10 @@
     };
     window.MagicHost.model = {
       cur: function () { return state.model || ''; },
-      name: function (id) { return id ? String(id) : (state.model || ''); },
+      /* 内核的角色行 / 「生成中」胶囊都走这里取显示名。**必须剥掉 `custom-local:`**
+         —— 本壳没有 modelLabels，宿主回不出可读名时内核会退回 id，前缀就露出来了
+         （移动端尤其明显：它没有 PC 那份 qaModelName 标签表，见 04-task-list.js）。 */
+      name: function (id) { return qaModelText(id) || qaModelText(state.model); },
       set: function (id) { state.model = id ? String(id) : ''; syncPickers(); return true; },
     };
     window.MagicHost.toast = function (msg) { console.info('[conv] ' + String(msg == null ? '' : msg)); };
@@ -1818,11 +2742,32 @@
        再由 ask 的 payload.attachments 透传给 -a/--attach —— 附件是本地路径，跨机无意义。 */
     /* 附件视觉：图片出缩略图，其余退回文件名 chip。onRemove 为空 = 只读（用户气泡 / 历史回放）。
        历史附件没有本地 objectURL，靠回读地址（transport.mediaUrl）；回读失败就地退回 chip，不留破图。 */
+    /* 缩略图**按原图宽高比**定框（用户要求：「粘贴显示应该保持原图的宽高比」），
+       不再一律 56×56 硬裁 —— 粘贴进来的截图多是 16:9 / 竖屏长图，裁成正方形只剩中间
+       一小块（用户报障截图里那枚缩略图只剩一个蓝色加号）。
+       做法：只算一个缩放系数 s，宽高同时乘 s，所以比例天然一致；
+       小图最多放大到短边 56（不放更大，避免糊），长边仍受 148×96 的框约束。
+       早先的写法给宽、高各自 Math.max(56,…)，1:2 的竖图会被掰成 56×96（0.58），
+       看着就是变形 —— 比例和最小尺寸冲突时，**比例优先**。 */
+    function fitThumb(img, node) {
+      var w = img.naturalWidth, h = img.naturalHeight;
+      if (!w || !h) return;
+      var MAX_W = 148, MAX_H = 96, MIN_SHORT = 56;
+      var s = Math.min(MAX_W / w, MAX_H / h);
+      if (s > 1) s = Math.min(s, Math.max(1, MIN_SHORT / Math.min(w, h)));
+      node.style.width = Math.max(1, Math.round(w * s)) + 'px';
+      node.style.height = Math.max(1, Math.round(h * s)) + 'px';
+    }
     function thumbNode(a, onRemove, removeArg) {
       var node = el('span', 'attachthumb');
       var img = el('img', 'attachthumb__img');
-      img.src = a.url || a.remoteUrl || '';
       img.alt = a.name || '';
+      img.onload = function () {
+        /* naturalWidth 为 0 时（SVG / 解码失败）保持默认方框，别写成 0×0。 */
+        if (img.naturalWidth) fitThumb(img, node);
+      };
+      img.src = a.url || a.remoteUrl || '';
+      if (img.complete && img.naturalWidth) fitThumb(img, node);
       img.onerror = function () {
         var chip = el('span', 'attachchip');
         chip.appendChild(el('span', 'attachchip__n', a.name || '附件'));
@@ -1876,6 +2821,71 @@
       bar.hidden = !list.length;
       list.forEach(function (a) { bar.appendChild(attNode(a, removeAttachment)); });
     }
+
+    /* ── 插件胶囊（2026-10-21 用户：「选择插件后 对话框中要出现一个胶囊」）──
+       胶囊只在**输入框上方**表示「这一轮要用哪个 CLI」；它不参与附件那套上传流程
+       （插件不是文件），发出去之后由 send 读走并清空。
+       位置刻意用独立一条 .plugbar：clearAttachments 每轮都会跑，
+       混在附件条里会被一起清掉。 */
+    function setPlugin(p) {
+      state.plugin = p || null;
+      renderPlugin();
+      syncInputHint();
+      /* 选/取消插件也会改变「能不能排队发送」（只有插件、没写要求也算有内容）。 */
+      if (state.busy) setSendMode('busy');
+      return state.plugin;
+    }
+    function renderPlugin() {
+      var bar = ctx.plugBar;
+      if (!bar) return;
+      bar.innerHTML = '';
+      var p = state.plugin;
+      bar.hidden = !p;
+      if (!p) return;
+      var chip = el('span', 'plugchip');
+      chip.appendChild(svgIcon('i-terminal', 13));
+      chip.appendChild(el('span', 'plugchip__n', p.cli || p.name || p.id || '插件'));
+      var x = el('button', 'plugchip__x', '✕');
+      x.type = 'button'; x.setAttribute('aria-label', '取消使用该插件');
+      x.onclick = function () { setPlugin(null); };
+      chip.appendChild(x);
+      chip.title = p.installed ? ('已安装' + (p.version ? ' v' + p.version : ''))
+        : '还没安装：发送后 Agent 会在桌面端提示安装';
+      bar.appendChild(chip);
+    }
+
+    /* 提示词拼装：用户写「做什么」，这里补上「用哪个 CLI、怎么调」。
+       模板来自服务端的 usePrompt（插件作者写的），组件不自己编命令 ——
+       它写的是**意图**（用这个 CLI 干活），具体命令由 Agent 在桌面端执行。
+       用户什么都没写时，退回 usePrompt 的骨架（它本身就是带空行的填空模板）。
+       ⚠️ usePrompt 通常**自己就以「用 <cli> …」开头**（插件作者写的），
+          再加一行 head 会变成「用 magic-video 完成下面的任务。／用 magic-video 写一集短剧。」
+          —— 用户实测会看到这句重复。所以先看它有没有点名这个 CLI，点了就直接用。 */
+    function buildPluginPrompt(typed, p) {
+      var cli = p.cli || p.name || p.id || '';
+      var uninstalled = p.installed === false
+        ? '\n（这个 CLI 还没装在桌面端：请先执行安装命令，装好再继续）' : '';
+      if (!typed) {
+        var tpl = String(p.usePrompt || '').trim();
+        if (tpl) {
+          /* 模板已点名这个 CLI → 原样用（它比我们拼的更贴这个插件的用法）。 */
+          if (tpl.indexOf(cli) >= 0) return tpl + uninstalled;
+          return '用 ' + cli + ' 完成下面的任务。' + uninstalled + '\n\n' + tpl;
+        }
+        return '用 ' + cli + ' 完成一个任务。\n要求：' + uninstalled;
+      }
+      return '用 ' + cli + ' 完成下面的任务。' + uninstalled + '\n\n' + typed;
+    }
+
+    /* 输入框占位文案跟着胶囊走：有插件时提示「写要它做什么」，
+       否则还是原来那句「回复 Agent」—— 一个小提示能省掉一次「我该写什么」。 */
+    function syncInputHint() {
+      if (!ctx.input) return;
+      var p = state.plugin;
+      ctx.input.placeholder = p
+        ? ('让 ' + (p.cli || p.name || '它') + ' 做什么？')
+        : '回复 Agent';
+    }
     /* 按对象身份移除（不要用下标：上传是异步的，多次渲染后下标会漂）。 */
     function removeAttachment(a) {
       var i = (state.attachments || []).indexOf(a);
@@ -1999,6 +3009,133 @@
       });
       return chain;
     }
+    /* ── 插件（2026-10-21）────────────────────────────────────────────────
+       用户原话：「在会话加号中增加插件 可以选到这两cli」。
+       清单与命令**全部来自宿主**（magic-client 的 GET /desk/plugins，见 CLIENT-CONTRACT.md）；
+       组件里不写死任何 CLI 名，也不自己拼命令行 —— 命令是由服务端那张固定表给的，
+       这里只负责把它摆出来、复制出去、以及发起执行。
+       ⚠️ 宿主的 transport 没有 listPlugins（老版本）→ 连这一节都不画，
+          而不是画一张空表让人以为「没有插件」。 */
+    function pluginRow(p, onPick) {
+      var b = el('button', 'plgrow'); b.type = 'button';
+      b.appendChild(el('span', 'plgrow__n', p.name || p.id || ''));
+      b.appendChild(el('span', 'plgrow__s', p.tagline || ''));
+      b.appendChild(el('span', 'plgrow__b' + (p.installed ? ' is-on' : ''),
+        p.installed ? ('已安装' + (p.version ? ' v' + p.version : '')) : '未安装'));
+      b.onclick = onPick;
+      return b;
+    }
+    function renderPluginList(M) {
+      M.title('插件');
+      var box = el('div', 'plglist');
+      box.appendChild(el('div', 'pick__cap', '读取中…'));
+      M.node(box);
+      transport.listPlugins().then(function (j) {
+        var list = (j && Array.isArray(j.plugins)) ? j.plugins : [];
+        box.innerHTML = '';
+        if (!list.length) { box.appendChild(el('div', 'pick__cap', '桌面端没有返回任何插件')); return; }
+        box.appendChild(el('div', 'pick__cap', '工程 CLI'));
+        list.forEach(function (p) {
+          box.appendChild(pluginRow(p, function () { Sheet.render(function (M2) { renderPluginDetail(M2, p); }); }));
+        });
+        box.appendChild(el('div', 'pick__cap', '选中即进入该 CLI 的安装 / 升级 / 用法；装好后在会话里让 Agent 调用它。'));
+      }, function (e) {
+        box.innerHTML = '';
+        box.appendChild(el('div', 'pick__cap',
+          '读取插件目录失败：' + ((e && e.message) || e) + '（需要较新的桌面端）'));
+      });
+    }
+    /** 二级：某个插件的介绍 / 命令 / 执行 / 用它干活。 */
+    function renderPluginDetail(M, p) {
+      M.title(p.name || p.id || '');
+      M.back('插件', function () { Sheet.render(renderPluginList); });
+      if (p.tagline) M.node(el('div', 'plg__tag', p.tagline));
+      if (p.note) M.node(el('div', 'plg__note', p.note));
+      if (p.description) M.node(el('div', 'plg__p', p.description));
+      if (p.requirements) M.node(el('div', 'plg__note', '环境要求：' + p.requirements));
+
+      var action = p.installed ? 'upgrade' : 'install';
+      var cmd = (action === 'install' ? p.install : p.upgrade) || '';
+      var label = action === 'install' ? '安装' : '升级';
+
+      M.node(el('div', 'pick__cap', label + '命令（在桌面端执行）'));
+      M.node(el('pre', 'plg__cmd', cmd || '（服务端没有给出命令）'));
+
+      var log = el('pre', 'plg__log'); log.hidden = true;
+      var btns = el('div', 'plg__btns');
+      var go = el('button', 'plg__btn plg__btn--go', label); go.type = 'button';
+      go.disabled = !cmd;
+      var cp = el('button', 'plg__btn', '复制命令'); cp.type = 'button';
+      cp.onclick = function () {
+        if (!cmd) return;
+        try {
+          if (navigator.clipboard && navigator.clipboard.writeText) {
+            navigator.clipboard.writeText(cmd).then(function () { noticeItem('命令已复制'); },
+              function () { noticeItem('复制失败'); });
+            return;
+          }
+        } catch (e) {}
+        noticeItem('当前环境不支持复制');
+      };
+      go.onclick = function () {
+        if (!cmd) return;
+        /* 执行期间按钮锁住：安装是几十秒的事，重复点会并发跑同一个 npm install。 */
+        go.disabled = true; cp.disabled = true;
+        go.textContent = '正在' + label + '…';
+        log.hidden = false; log.textContent = '▶ 开始' + label + '…\n';
+        var push = function (s) { log.textContent += s; log.scrollTop = log.scrollHeight; };
+        transport.pluginAction({ id: p.id, action: action }, {
+          onStep: function (ev) { push('\n$ ' + (ev.command || '') + '\n'); },
+          onLine: function (ev) { push((ev.line == null ? '' : ev.line) + '\n'); },
+          onEnd: function (out) {
+            go.disabled = false; cp.disabled = false;
+            if (out && out.ok) {
+              push('\n✔ 完成\n');
+              go.textContent = '已' + label;
+              /* 服务端在 end 里带回重探测后的完整信息 → 就地换掉这一行，
+                 不然装完了徽标还是「未安装」，用户会以为没装上。 */
+              if (out.plugin) {
+                p = out.plugin;
+                var nb = el('div', 'plg__note',
+                  '现在：' + (p.installed ? ('已安装' + (p.version ? ' v' + p.version : '')) : '未安装')
+                  + (p.bin ? ' · ' + p.bin : ''));
+                btns.parentNode.insertBefore(nb, btns);
+                go.textContent = p.installed ? '升级' : '安装';
+                go.onclick = function () {
+                  Sheet.render(function (M2) { renderPluginDetail(M2, p); });
+                };
+              }
+            } else {
+              push('\n✘ 失败：' + ((out && (out.error || ('退出码 ' + out.code))) || '未知错误') + '\n');
+              go.disabled = false; cp.disabled = false; go.textContent = '重试' + label;
+            }
+          },
+        });
+      };
+      btns.appendChild(go); btns.appendChild(cp);
+      M.node(btns); M.node(log);
+
+      /* 用起来（2026-10-21 用户改口径）：**选中**它 —— 输入框上方出现一枚胶囊，
+         写清要用哪个 CLI；发送时由 send 把「用 magic-shorts 完成下面的任务」补到
+         用户那句话前面（见 buildPluginPrompt）。不预填模板了：
+         预填会把每个字都变成用户自己要删的噪音，胶囊才是「选了它」的表示。 */
+      M.node(el('div', 'pick__cap', '用起来'));
+      var use = el('button', 'plg__btn plg__btn--go', '使用这个插件'); use.type = 'button';
+      use.onclick = function () {
+        Sheet.close();
+        setPlugin(p);
+        ctx.input.focus();
+      };
+      /* ⚠️ 必须包一层 .plg__btns：.plg__btn 的 flex:1 只在 flex 容器里撑得开，
+         直接塞进抽屉正文会塌成一个小方块（按钮宽度由内容决定）。 */
+      var useRow = el('div', 'plg__btns'); useRow.appendChild(use);
+      M.node(useRow);
+      if (p.examples && p.examples.length) M.node(el('pre', 'plg__cmd', p.examples.join('\n')));
+      M.node(el('div', 'pick__cap',
+        '选中后输入框上方会出现胶囊；发送时 Agent 会用它在桌面端干活'
+        + (p.installed ? '' : '（还没安装，发送前先装）')));
+    }
+
     function openAttachSheet(anchor) {
       Sheet.open(anchor, function (M) {
         M.title('添加');
@@ -2013,6 +3150,16 @@
         tile('i-img', '照片 / 视频', function () { Sheet.close(); pickFiles('image/*,video/*', null, true, uploadFiles); });
         tile('i-doc', '添加文件', function () { Sheet.close(); pickFiles(null, null, true, uploadFiles); });
         M.node(grid);
+        /* 插件：只在宿主真能给出清单时才出现（见 transport.listPlugins）—— 与下面四条
+           「暂未接入」的占位行不同，这一条是真的能选、能装、能用。 */
+        if (transport && typeof transport.listPlugins === 'function') {
+          var pb = el('button', 'sheetrow'); pb.type = 'button';
+          pb.appendChild(svgIcon('i-terminal', 18));
+          pb.appendChild(el('span', 'sheetrow__l', '插件'));
+          pb.appendChild(svgIcon('i-chev', 16));
+          pb.onclick = function () { Sheet.render(renderPluginList); };
+          M.node(pb);
+        }
         var rows = [['i-user', '专家', 'specialist'], ['i-spark', '技能', 'skills'], ['i-link', '连接器', 'connectors'], ['i-clock', '定时任务', 'scheduled']];
         rows.forEach(function (r) {
           var b = el('button', 'sheetrow'); b.type = 'button';
@@ -2046,18 +3193,43 @@
     function newTitleText() { return state.engine ? ('新会话 · ' + state.engine) : '新会话'; }
     function syncNewTitle() { if (ctx.titleEl && !state.session) ctx.titleEl.textContent = newTitleText(); }
     function newSession() {
-      stopWatch();
+      stopWatch();                                     // 内含 stopFollow：上一段会话的实时尾随到此为止
+      clearQueue();                                   // 上一段会话排队的追问不跟到新会话
       state.session = null; state.askId = null;
+      state.meta = null;                               // 新会话没有清单行，别拿上一条的 state 判存活
       clearThread();
       clearAttachments();                              // 新会话不继承上一段会话待发的附件
+      setPlugin(null);                                 // 插件胶囊同理：新会话从干净的输入框开始
       ctx.input.value = ''; autoGrow();
       threadEl.appendChild(empty);
       syncNewTitle();
       setTimeout(function () { ctx.input.focus(); }, 0);
     }
     function setSession(sid, s) {
+      /* 同一条会话重入（移动端「返回列表 → 再点进来」的高频路径）：画面就在眼前，
+         别清屏重放整段历史 —— 宿主复用的是同一个组件实例（见 client-ui-mobile 的
+         mountConversation），历史与实时流都还在内存里。判据除了「同一条会话」还要
+         `histSid === sid`（历史真的在这块画布里，见 loadHistory / clearThread）。
+         这里只同步外壳状态：会话标题可能在列表里被改过，引擎 / 模型要跟着清单行走。 */
+      if (sid && sid === state.session && histSid === sid) {
+        if (s) {
+          /* 清单行的 state / alive 是「要不要尾随实时进度」的判据（见 sessionLive）：
+             重入时它可能刚从 running 变 done，必须跟着更新，否则会去尾随一条已收尾的会话。 */
+          state.meta = s;
+          if (s.engine) { state.engine = s.engine; }
+          state.model = s.model || '';
+          if (ctx.titleEl) ctx.titleEl.textContent =
+            (s.title || s.prompt_head) || String(sid).slice(0, 8);
+          syncPickers();
+        }
+        return Promise.resolve(0);
+      }
       stopWatch();                                     // 上一段会话的「新轮次发现」不许落进这一段
+      /* 换会话：上一条会话排队的追问作废（旧会话的队列不能画进新会话的画布）。
+         提示放到清屏之后再说 —— 这里先说会被 clearThread 一起清掉。 */
+      var droppedQueue = clearQueue();
       state.session = sid || null;
+      state.meta = s || null;                          // 见 sessionLive：决定首载后要不要尾随实时进度
       if (s && s.engine) { state.engine = s.engine; }
       /* 模型跟引擎一起继承（2026-10-20 用户：「没有显示历史会话对应的模型 引擎显示了」）——
          清单行里带着这条会话真正用的 `model`（core 的 --sessions，见 session.Record），
@@ -2065,9 +3237,13 @@
          `t.model = s.model || ""`）：空值 = 让 core 用默认档，不替用户预设。 */
       state.model = (s && s.model) || '';
       clearThread();
+      /* 换到另一条会话：上一条留下的插件胶囊不跟过来（它是「这一轮用哪个 CLI」，
+         属于未发出的那一句，换了会话就该作废）。 */
+      setPlugin(null);
       threadEl.appendChild(empty);
+      if (droppedQueue) noticeItem('已切换会话，取消了 ' + droppedQueue + ' 条排队追问');
       /* ⚠️ 会话标题**以 core 的 `title` 为准**（2026-10-18 用户：「同一个会话 pc 端还是跟移动端
-         标题不一样 需一致」）。core 的 `--sessions` 早已把「标题表的归纳结果 → prompt_head」
+          标题不一样 需一致」）。core 的 `--sessions` 早已把「标题表的归纳结果 → prompt_head」
          合并成一个 `title` 字段，列表页（移动端 titleOf / PC 掌天瓶的 cliRows）读的都是它；
          只有**这个详情页顶栏**此前优先 `prompt_head` —— 于是同一条会话：PC 显示归纳要点
          （如「完整复刻水世界场景」），移动端详情页显示首问原文（如「现在水世界跟参考图还不一样…」）。
@@ -2087,8 +3263,8 @@
          移动端上这一下会直接顶起软键盘，刚回放出来的历史被键盘挡掉大半。
          要打字时用户自己点输入框即可；newSession（用户主动「新建」）仍保留聚焦。 */
     }
-    function refreshEngines() {
-      return Promise.resolve(transport.listEngines()).then(function (list) {
+    function refreshEngines(force) {
+      return Promise.resolve(transport.listEngines(force)).then(function (list) {
         state.engines = Array.isArray(list) ? list : [];
         /* 记住的引擎已不在本机（卸载 / 改名 / 清单变了）→ 回首个可用。
            不做这步的话，带着一个跑不起来的引擎发任务，报错指向 core 而不是
@@ -2139,6 +3315,15 @@
       permissionLabel: function () { return tierOf(state.permission || '').label; },
       permissionTier: function () { return state.permission || ''; },
       openPermissionPicker: openPermissionPicker,
+      /* 团队模式：开关与标签（宿主的运行设置面板用 openTeamPicker 弹出，
+         与权限模式同一套交互 —— 用户 2026-10-21：「跟权限模式一样也支持选择」）。
+         `setTeam` 是**宿主灌进来的**，所以刻意不触发 onTeamChange ——
+         那是「用户改了」的回传口，宿主自己改完再收到自己的回调只会绕一圈。 */
+      setTeam: function (on) { state.team = !!on; syncPickers(); },
+      teamOn: function () { return !!state.team; },
+      teamLabel: function () { return state.team ? '开启' : '关闭'; },
+      openTeamPicker: openTeamPicker,
+      featureOn: featureOn,
       setEngines: function (list) { state.engines = list || []; syncPickers(); },
       refreshEngines: refreshEngines,
       setSession: setSession,