magic-agent 2.3.0 → 2.3.9

package/client-ui-mobile/index.html

@@ -67,6 +67,12 @@
   /* 状态色底（半透明叠加色，明暗主题通用） */
   --tint-run:rgba(59,130,246,.18); --tint-wait:rgba(245,158,11,.20); --tint-done:rgba(34,197,94,.18);
   --tint-queued:rgba(139,92,246,.18); --queued:#8B5CF6;
+  /* 异常终态两档（2026-10-23 用户：「现在没有异常状态的颜色」）：
+       · 失败（failed / gone）→ 红：这条没跑完就没了，要人看一眼；
+       · 已取消 / 已打断（cancelled / interrupted）→ 石褐：人为收工，不是故障，
+         所以不上红，但也绝不能和「正常结束」的绿或兜底的白同色。 */
+  --tint-fail:rgba(239,68,68,.18); --fail:#F87171;
+  --tint-stop:rgba(120,113,108,.24); --stop:#A8A29E;
 
   /* ── 掌天瓶绿液（可选令牌，shared/conversation.css 用 `var(--q-bottle*, 兜底)` 取）──
      瓶是**玉**不是玻璃（见 conversation.js 的形制说明），所以颜色分两组：
@@ -112,6 +118,9 @@
     --error-surface:#FEF2F2; --error-border:#FECACA; --error-text:#B91C1C; --error-icon:#DC2626;
     --running:#16A34A; --transitioning:#2563EB; --active:#D97706;
     --running:#16A34A; --transitioning:#2563EB; --active:#D97706;
+    /* 浅底上异常终态要更重（半透明红 / 石褐在 #F8FAFC 上否则会糊成灰） */
+    --tint-fail:rgba(220,38,38,.13); --fail:#DC2626;
+    --tint-stop:rgba(120,113,108,.16); --stop:#78716C;
     /* 浅底上玉胎要更浓：`.42` 那档实测会被冲成白瓷，读不出「翠」。浓到 .66 又像实心塑料。 */
     --q-bottle-jade-hi:rgba(146,231,184,.62);
     --q-bottle-jade:rgba(96,205,152,.60);
@@ -137,6 +146,9 @@ html[data-theme="light"]{color-scheme:light;
   --accent:#2563EB; --warning:#D97706; --success:#16A34A;
   --error-surface:#FEF2F2; --error-border:#FECACA; --error-text:#B91C1C; --error-icon:#DC2626;
   --running:#16A34A; --transitioning:#2563EB; --active:#D97706;
+  /* 浅底上异常终态要更重（同 prefers-color-scheme:light 那一份） */
+  --tint-fail:rgba(220,38,38,.13); --fail:#DC2626;
+  --tint-stop:rgba(120,113,108,.16); --stop:#78716C;
   /* 浅底上玉胎要更浓（同上一条注释） */
   --q-bottle-jade-hi:rgba(146,231,184,.62);
   --q-bottle-jade:rgba(96,205,152,.60);
@@ -288,6 +300,11 @@ textarea{font:inherit}
 .srow__ico--run{background:var(--tint-run);color:var(--primary-action)}
 .srow__ico--wait{background:var(--tint-wait);color:var(--warning)}
 .srow__ico--done{background:var(--tint-done);color:var(--success)}
+/* 异常终态：以前和 idle 一起落在灰白兜底档，用户看不出「这条是挂了 / 被停了，
+   还是只是没跑过」（2026-10-23 用户：「现在没有异常状态的颜色」）。
+   失败（failed / gone）= 红；已取消 / 已打断（cancelled / interrupted）= 石褐。 */
+.srow__ico--fail{background:var(--tint-fail);color:var(--fail)}
+.srow__ico--stop{background:var(--tint-stop);color:var(--stop)}
 .srow__ico--idle{background:var(--subtle);color:var(--muted)}
 /* 等待中（串行排队）：紫色 + 一圈**呼吸**的环。
    与「运行中」的扫光刻意分开 —— 扫光在转（在动），这圈只明暗（在等）；
@@ -971,20 +988,18 @@ button.setrow{font-family:inherit}
           <button class="seg__b" data-v="serial">串行</button>
         </span>
       </div>
-      <!-- 会话托管（2026-10-23 用户：「托管模式下自动按照最佳建议提交到会话中执行，
-           是否开启在我的 tab 中可配置」）。开关是**设备级**，落 localStorage；
-           组件执行、这里只存与显示。给一行说明，避免只看到四个字不知道会发生什么。 -->
-      <div class="setrow">
-        <span class="setrow__main">
-          <span class="setrow__l">会话托管</span>
-          <span class="setrow__sub">每轮结束自动发送最合适的建议；提问卡自动选第一项继续（最多连续 12 轮）</span>
-        </span>
-        <button class="tgl" id="tglHosting" aria-label="会话托管"></button>
-      </div>
+      <!-- 会话托管（2026-10-23 用户：「托管模式下自动按照最佳建议提交到会话中执行」；
+           同日再定：「跟团队模式一样改成挂在会话上，子会话继承，不再是全局」）。
+           所以这里**没有**全局开关 —— 与团队模式同一处入口：会话页右上角 → 任务运行设置。 -->
       <!-- 默认引擎 / 模型：新建任务的初值（会话里输入框上方的级联切换会回写这里）。
            两行点开的是同一个「引擎 → 模型」二列选择器，模型必须挂在引擎下。 -->
       <button class="setrow" id="btnDefaultEngine"><span class="setrow__l">默认引擎</span><span class="setrow__v" id="defaultEngine">自动（首个可用）</span></button>
       <button class="setrow" id="btnDefaultModel"><span class="setrow__l">默认模型</span><span class="setrow__v" id="defaultModel">跟随引擎</span></button>
+      <!-- 建议引擎 / 模型（2026-10-23 用户：「是选择引擎和模型 跟默认引擎那种抽屉一样」）。
+           两行点开同一个「引擎 → 模型」二列抽屉；**默认不开启**：引擎空 = 组件不请求
+           /desk/suggest、不画建议、不补历史建议、托管不自动跑。选了引擎才启用。 -->
+      <button class="setrow" id="btnSuggestEngine"><span class="setrow__l">建议引擎</span><span class="setrow__v" id="suggestEngine">不开启</span></button>
+      <button class="setrow" id="btnSuggestModel"><span class="setrow__l">建议模型</span><span class="setrow__v" id="suggestModel">跟随引擎</span></button>
       <!-- 2026-10-22 用户：「触感反馈 / 语言」这两项不需要 —— 已移除（设备级偏好只剩主题/字体）。 -->
       <div class="setrow"><span class="setrow__l">网络代理</span><button class="tgl" id="tglVpn" aria-label="网络代理"></button></div>
       <button class="setrow" id="btnNotify"><span class="setrow__l">消息通知设置</span><span class="setrow__v" id="notifyState">—</span></button>
@@ -1033,7 +1048,8 @@ button.setrow{font-family:inherit}
 
 <!-- ══════════ 会话页 → 任务运行设置（独立子页面）══════════
      会话页右上角的调节键点进来（2026-10-21 用户：「运行设置在任务对话框里 不也应该是独立页面吗」）。
-     四项都是**当前这条会话**的运行参数：设备只读，其余三项点开还是原来的选择器（选择器只有一份）。 -->
+     五项都是**当前这条会话**的运行参数：设备只读，其余点开还是原来的选择器（选择器只有一份）。
+     会话托管（2026-10-23）也在这里：它跟团队模式一样**属于这条会话**，不再是「我的」里的全局开关。 -->
 <div class="history" id="runSettingsPage" hidden>
   <div class="history__top">
     <button class="topbar__icon" id="btnRunSettingsBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
@@ -1045,7 +1061,9 @@ button.setrow{font-family:inherit}
       <button class="setrow" id="btnRsWorkspace"><span class="setrow__l">工作空间</span><span class="setrow__v" id="rsWorkspace">默认（不属于任何空间）</span></button>
       <button class="setrow" id="btnRsPermission"><span class="setrow__l">权限模式</span><span class="setrow__v" id="rsPermission">沿用默认</span></button>
       <button class="setrow" id="btnRsTeam"><span class="setrow__l">团队模式</span><span class="setrow__v" id="rsTeam">关闭</span></button>
+      <button class="setrow" id="btnRsHosting"><span class="setrow__l">会话托管</span><span class="setrow__v" id="rsHosting">关闭</span></button>
     </div>
+    <div class="history__hint" style="text-align:left">会话托管：每轮成功结束自动发送最合适的建议（最多连续 12 轮）。只作用于当前会话；团队子会话默认继承主会话的开关。</div>
   </div>
 </div>
 
@@ -1286,6 +1304,8 @@ button.setrow{font-family:inherit}
   /* 默认引擎 / 模型（「我的」可改；函数与选择器见下面「默认引擎 / 模型」段）。
      提前到这里声明：首屏 paintRunPref 会读它，晚于 PREFS 初始化赋值就会踩 undefined。 */
   var RUN_PREF = loadRunPref();
+  /* 建议引擎 / 模型（「我的」）：引擎空 = 不开启建议功能（默认）。与默认引擎分开存，互不影响。 */
+  var SUGGEST = loadSuggestPref();
   var ENGINES = [];          // 最近一次从 /desk/engines?models=1 拿到的清单
   var ENGINES_STALE_AT = '';  // 非空 = 这份清单是插件侧的兜底缓存（探测超时/失败），值是缓存时间
   /* ── 团队模式（2026-10-21）──
@@ -1409,6 +1429,87 @@ button.setrow{font-family:inherit}
     saveTeamPref();
   }
 
+  /* ── 会话托管（2026-10-23，按会话）──
+     与团队模式同一套形状：`sessions` = sid → 开/关，`fresh` = 新会话还没拿到 session_id
+     时的临时开关。旧版 `magic.hosting` 是设备级全局值，不迁移（见上面的注释）。 */
+  var HOSTING_KEY = 'magic.hosting.sessions.v1';
+  function loadHostingPref() {
+    var o = { sessions: {}, fresh: false };
+    try {
+      var m = JSON.parse(localStorage.getItem(HOSTING_KEY) || '{}');
+      if (m && typeof m === 'object' && !Array.isArray(m)) {
+        Object.keys(m).forEach(function (sid) { o.sessions[sid] = !!m[sid]; });
+      }
+    } catch (e) {}
+    /* 旧版全局开关：属于「改一条会话，所有会话都变」的旧语义，清掉不迁移。 */
+    try { localStorage.removeItem('magic.hosting'); } catch (e) {}
+    return o;
+  }
+  function saveHostingPref() {
+    /* 与团队模式同一条容量护栏：最多 400 条，超出按 key 顺序丢（只影响容量）。 */
+    var ids = Object.keys(HOSTING.sessions || {});
+    if (ids.length > 400) {
+      ids.slice(0, ids.length - 400).forEach(function (sid) { delete HOSTING.sessions[sid]; });
+    }
+    try { localStorage.setItem(HOSTING_KEY, JSON.stringify(HOSTING.sessions || {})); } catch (e) {}
+    schedulePushPrefs();
+    paintRunSettings();
+  }
+  /* 按任意 id（session_id / run_id）找会话对象：父指针与本地表可能各用一个别名。 */
+  function sessionByAnyId(key) {
+    var k = String(key || '');
+    if (!k) return null;
+    for (var i = 0; i < LAST_SESSIONS.length; i++) {
+      var s = LAST_SESSIONS[i];
+      if (!s) continue;
+      if (sidOf(s) === k || String(s.session_id || '') === k || String(s.run_id || '') === k) return s;
+    }
+    return null;
+  }
+  /* 这条会话的显式记录（session_id / run_id 任一命中即算）。 */
+  function hostingRecordOf(s) {
+    if (!s) return null;
+    var keys = [sidOf(s), s.session_id, s.run_id];
+    for (var i = 0; i < keys.length; i++) {
+      var k = keys[i];
+      if (k && Object.prototype.hasOwnProperty.call(HOSTING.sessions, String(k))) {
+        return HOSTING.sessions[String(k)];
+      }
+    }
+    return null;
+  }
+  /* 这条会话的托管开关。自己有记录就用自己那条；没有就**沿父链继承**（用户 2026-10-23：
+     「子会话继承」）：团队子会话默认跟主会话一致，主会话改开关，没单独设过的子会话也跟着变。
+     子会话里手动改一次 = 写下自己的记录，从此不再继承（显式覆盖 > 继承）。
+     新会话（还没有 sid）用 `fresh`，不跨会话继承。 */
+  function hostingOnFor(sid, s) {
+    if (!sid) return !!HOSTING.fresh;
+    var cur = s || sessionByAnyId(sid);
+    var seen = {};
+    for (var depth = 0; cur && depth < 16; depth++) {
+      var key = sidOf(cur) || String(sid);
+      if (seen[key]) break;              // 脏数据成环：最多走 16 层并去重
+      seen[key] = 1;
+      var rec = hostingRecordOf(cur);
+      if (rec !== null) return !!rec;
+      var pk = parentKeyOf(cur);
+      if (!pk) break;
+      /* 父会话可能已经不在清单里（被清理 / 只给了指针），仍然认它的显式记录。 */
+      if (Object.prototype.hasOwnProperty.call(HOSTING.sessions, String(pk))) {
+        return !!HOSTING.sessions[String(pk)];
+      }
+      cur = sessionByAnyId(pk);
+    }
+    return false;
+  }
+  /* 新会话的开关要等 core 给出 session_id 才落得下来（见 mountConversation 的 onEvent）。 */
+  function bindFreshHosting(sid) {
+    if (!HOSTING.fresh || !sid) return;
+    HOSTING.sessions[String(sid)] = true;
+    HOSTING.fresh = false;
+    saveHostingPref();
+  }
+
   /* ══════════ 环境（多连接）══════════
      2026-10-22 用户：「移动端要支持环境切换 可以有多个连接」。
      一台手机可以记住多台桌面（家里 / 公司 / 另一台机器），任务页标题就是切换入口。
@@ -1474,24 +1575,44 @@ button.setrow{font-family:inherit}
     var id = connIdOf(t);
     var old = findConn(id) || {};
     var list = loadConns().filter(function (c) { return c.id !== id; });
+    /* eid：环境的稳定身份（见 ensureEnvId）。改地址/改令牌时由调用方带过来（t.eid），
+       否则沿用老记录的；都没有才发新号。 */
+    var eid = t.eid || old.eid || newEid();
     var next = {
       id: id, url: t.url || '', token: t.token || '',
       name: (t.name != null && t.name !== '') ? t.name : (old.name || ''),
       host: connHost(t.url), app: old.app || '', at: Date.now(),
+      eid: eid,
       seed: !!old.seed      // 种出来的默认环境：改名/改地址后仍然认出它
     };
     list.unshift(next);
     saveConns(list);
+    /* 第一次拿到 eid：把这个环境原先按 host 哈希分区的队列行与配置槽迁过来。 */
+    if (!old.eid && !t.eid) migrateEnvData(envHashOf(next), eidKey(eid));
     return next;
   }
-  function removeConn(id) {
+  /* 删环境时把它名下的排队任务一起清掉：地址可能被别的服务器复用，
+     留着就会在下次连上时被当成那台的任务发出去。
+     keepQueue=true 用于「改地址/改令牌」——那不是删环境，eid 不变，队列要跟着走。 */
+  function removeConn(id, keepQueue) {
     var list = loadConns();
     var hit = null;
     list.forEach(function (c) { if (c && c.id === id) hit = c; });
     /* 用户主动删掉种出来的默认环境：记一笔，下次启动别再自动加回来。 */
     if (hit && hit.seed) { try { localStorage.setItem('magic.remote.seedoff.v1', '1'); } catch (e) {} }
+    if (hit && !keepQueue) dropEnvQueue(hit);
     saveConns(list.filter(function (c) { return c.id !== id; }));
   }
+  /* 清掉某条环境名下的排队行（eid 桶与老 host 桶都清）。 */
+  function dropEnvQueue(conn) {
+    if (!conn) return;
+    var keys = [eidKey(conn.eid), envHashOf(conn)].filter(function (k) { return !!k; });
+    if (!keys.length) return;
+    try {
+      var rows = readQueueAll().filter(function (p) { return !p || keys.indexOf(String(p.env || '')) < 0; });
+      localStorage.setItem(QUEUE_KEY, JSON.stringify(rows));
+    } catch (e) {}
+  }
   function clearConns() {
     saveConns([]);
     try {
@@ -1587,9 +1708,12 @@ button.setrow{font-family:inherit}
     /* 隧道换域名（cloudflared 每次重启都换）：把上一枚**默认命名**的种子远程记录换到新地址。
        用户改过名字的不动 —— 那条是他自己配的环境。 */
     var kept = [];
+    var replacedEid = '';
     for (var k = 0; k < list.length; k++) {
       var o = list[k];
-      if (o && o.seed && o.name === SEED_NAME && o.url !== url) continue;
+      /* 隧道换域名 = 同一台桌面换了入口：把它的 eid 带过去，
+         否则新记录会发新号，这台环境排队中的任务与配置槽全部变孤儿。 */
+      if (o && o.seed && o.name === SEED_NAME && o.url !== url) { replacedEid = o.eid || replacedEid; continue; }
       kept.push(o);
     }
     if (kept.length !== list.length) saveConns(kept);
@@ -1609,18 +1733,20 @@ button.setrow{font-family:inherit}
         return;
       }
     }
-    seedMark(upsertConn({ url: url, token: TOKEN, name: SEED_NAME }));
+    seedMark(upsertConn({ url: url, token: TOKEN, name: SEED_NAME, eid: replacedEid }));
   }
 
   /* ── 设备现场（按环境隔离）──
      2026-10-22 用户：「切换环境后 所有东西都要跟着变 包括会话 需求 我的这些 是选择环境上的东西」。
      会话与需求本来就来自桌面端（切完重拉）；这里解决的是**留在本机的那部分状态**：
      主题 / 字体 / 任务模式 / 默认引擎与模型 / 团队配置 / 当前空间 / 置顶 / 通知 / 浏览器收藏。
-     做法：切环境时把这一组键快照到「按地址分桶」的槽里，再把目标环境的槽写回来，然后整页重载
+     做法：切环境时把这一组键快照到「按环境身份分桶」的槽里，再把目标环境的槽写回来，然后整页重载
      —— 内存态全部重新初始化，不留上一台机器的影子。
-     ⚠️ 分桶键用 host:port 而不是 url|token：token 会随 App 重启变，按 token 分桶等于每次都丢现场。 */
+     ⚠️ 分桶键用稳定 eid（见 ensureEnvId），不是 url|token（令牌会轮换）、也不是 host:port
+        （换 IP/端口/隧道域名就变成另一台，现场全丢）。老数据按 host 哈希做一次迁移。 */
   var ENV_SCOPE_KEYS = [
-    'magic.ws', 'magic.taskmode', 'magic.hosting', 'magic.engine', 'magic.model',
+    'magic.ws', 'magic.taskmode', 'magic.hosting.sessions.v1', 'magic.engine', 'magic.model',
+    'magic.suggest.engine', 'magic.suggest.model',
     'magic.theme', 'magic.font', 'magic.notify',
     'magic.pinned', 'magic.spaces', 'magic.browser.stars.v1',
     'magic.team.sessions.v1', 'magic.team.routes.v1', 'magic.team.rules.v1',
@@ -1636,11 +1762,64 @@ button.setrow{font-family:inherit}
     for (var i = 0; i < str.length; i++) h = ((h << 5) + h + str.charCodeAt(i)) >>> 0;
     return h.toString(36);
   }
-  function envScopeIdOf(conn) {
+  /* ── 稳定环境身份（eid）──
+     地址会变（IP/端口/隧道域名），令牌会轮换（App 每次启动换注入令牌），两者都不能当环境身份：
+     地址变了 → 旧队列/旧配置变孤儿；地址被别的服务器复用 → 旧队列发错环境。
+     eid 在环境第一次落盘时生成，之后跟着这条记录走：改地址、改令牌都不换号。 */
+  function newEid() {
+    return 'e' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+  }
+  function eidKey(id) { return id ? ('eid:' + id) : ''; }
+  /* 老版本按 host:port 分区的键（只用于一次性迁移和「还没拿到 eid」的临时记录）。 */
+  function envHashOf(conn) {
     var host = connHost((conn && conn.url) || connUrlNow());
     return host ? envScopeHash(host) : '';
   }
+  function envScopeIdOf(conn) {
+    if (conn && conn.eid) return eidKey(conn.eid);
+    return envHashOf(conn);
+  }
   function envScopeId() { return envScopeIdOf(activeConn()); }
+  /* 给一条**已落盘**的环境补 eid（老记录没有），并把按 host 分区的旧队列/旧配置槽迁过来。 */
+  function ensureEnvId(conn) {
+    if (!conn) return conn;
+    var oldHash = envHashOf(conn);
+    if (conn.eid) {
+      migrateEnvData(oldHash, eidKey(conn.eid));   // 上次可能只写了一半：重入也要幂等补齐
+      return conn;
+    }
+    var list = loadConns(), hit = null;
+    /* 扫码/粘贴进来的临时目标没有 id：按 url+令牌现算一个，才能跟上已落盘的那条。 */
+    var wantId = conn.id || connIdOf({
+      url: conn.url || connUrlNow(),
+      token: conn.token != null ? conn.token : (TOKEN || '')
+    });
+    for (var i = 0; i < list.length; i++) if (list[i] && list[i].id === wantId) { hit = list[i]; break; }
+    if (!hit) return conn;          // 临时记录（还没落盘）：等 upsertConn 落盘时再发号
+    hit.eid = newEid();
+    saveConns(list);
+    migrateEnvData(oldHash, eidKey(hit.eid));
+    return hit;
+  }
+  /* 把旧键名下的排队行与配置槽搬到新键名下（幂等）。 */
+  function migrateEnvData(from, to) {
+    if (!from || !to || from === to) return;
+    migrateQueueEnv(from, to);
+    try {
+      var v = localStorage.getItem(ENV_SCOPE_PREFIX + from);
+      if (v != null) {
+        if (localStorage.getItem(ENV_SCOPE_PREFIX + to) == null) localStorage.setItem(ENV_SCOPE_PREFIX + to, v);
+        localStorage.removeItem(ENV_SCOPE_PREFIX + from);
+      }
+    } catch (e) {}
+  }
+  function migrateQueueEnv(from, to) {
+    try {
+      var rows = readQueueAll(), changed = false;
+      rows.forEach(function (p) { if (p && String(p.env || '') === from) { p.env = to; changed = true; } });
+      if (changed) localStorage.setItem(QUEUE_KEY, JSON.stringify(rows));
+    } catch (e) {}
+  }
   /* 把当前这组键存进 id 的槽（切走之前调用）。 */
   function saveEnvScope(id) {
     if (!id) return;
@@ -1676,7 +1855,8 @@ button.setrow{font-family:inherit}
        · 本地任何一处改了，防抖推回远端。
      纯设备偏好（主题/字体/通知）**不同步** —— 那是手机自己的事。 */
   var PREF_SYNC_KEYS = [
-    'magic.engine', 'magic.model', 'magic.ws', 'magic.spaces', 'magic.pinned',
+    'magic.engine', 'magic.model', 'magic.suggest.engine', 'magic.suggest.model', 'magic.ws', 'magic.spaces', 'magic.pinned',
+    'magic.hosting.sessions.v1',
     'magic.team.sessions.v1', 'magic.team.routes.v1', 'magic.team.rules.v1',
     'magic.team.parallel', 'magic.team.split', 'magic.team.splitcode', 'magic.team.adaptive'
   ];
@@ -1790,7 +1970,8 @@ button.setrow{font-family:inherit}
     if (btn) btn.classList.remove('is-open');
   }
   /* 换环境 = 换一台桌面：对话、轮询、运行态都属于旧连接，必须一起收掉。
-     排队任务按令牌分别落库（见 QUEUE_KEY），旧环境那批留在原地，切回来再接着跑。 */
+     排队任务按**环境**分别落库（见 QUEUE_KEY）：旧环境那批留在原地，切回来再接着跑 ——
+     队列绝不能被带到另一台环境上跑，那边的会话结束事件这边根本收不到。 */
   /* 换环境 = 换一台桌面：会话 / 需求 / 我的设置全都属于那台机器。
      做法分两步：① 把当前这台的本机状态快照进它的槽，再把目标环境的槽写回来；
      ② 记住「停在哪个环境」并整页重载 —— 重载后内存态从零初始化，按目标环境的
@@ -1798,6 +1979,7 @@ button.setrow{font-family:inherit}
      ⚠️ 不在这里手写「清哪些变量」：那种清单永远会漏（漏一个就带着上一台的数据）。 */
   function switchEnv(c) {
     if (!c) return;
+    c = ensureEnvId(c) || c;          // 先把目标环境的 eid 补上，下面取槽才是稳定键
     if (c.url === connUrlNow() && String(c.token || '') === String(TOKEN || '')) {
       toast('已在「' + (connLabel(c) || '当前环境') + '」');
       return;
@@ -1954,9 +2136,12 @@ button.setrow{font-family:inherit}
       }
       function persist(t) {
         var wasActive = !!(conn && conn.url === connUrlNow() && String(conn.token || '') === String(TOKEN || ''));
+        /* 改地址/改令牌 = 同一台环境换了入口：eid 带过去，队列与配置槽跟着走。 */
+        if (conn && conn.eid) t.eid = conn.eid;
         var next = upsertConn(t);
-        /* 改了地址/令牌 = 换了一条记录：旧的那条要删掉，别留一条连不上的僵尸。 */
-        if (conn && conn.id !== next.id) removeConn(conn.id);
+        /* 改了地址/令牌 = 换了一条记录：旧的那条要删掉，别留一条连不上的僵尸。
+           队列已经跟着 eid 走了，这里不能再按旧记录清一遍。 */
+        if (conn && conn.id !== next.id) removeConn(conn.id, true);
         /* 名称允许清空，也允许改：upsertConn 会沿用旧名，这里按输入框的最终值覆盖。 */
         var list = loadConns();
         for (var i = 0; i < list.length; i++) {
@@ -2061,6 +2246,7 @@ button.setrow{font-family:inherit}
   function showMine() {
     hideAll(); mineEl.hidden = false; tabbarEl.hidden = false; setActive('mine');
     mineDevice.textContent = histSubtitle || '本机';
+    paintSuggestPref();
     var ns = document.getElementById('notifyState');
     if (ns) { var p = notifyPermState(); ns.textContent = p === 'plugin' ? '已接入' : (p === 'granted' ? '已开启' : '未开启'); }
     markSeg(segTheme, PREFS.theme); markSeg(segFont, PREFS.font); markSeg(segMode, TASK_MODE);
@@ -2629,10 +2815,12 @@ button.setrow{font-family:inherit}
   /* 任务模式：parallel（默认，全部并行）| serial（同一空间同时只跑一个新任务）。 */
   var TASK_MODE = 'parallel';
   try { TASK_MODE = localStorage.getItem('magic.taskmode') || 'parallel'; } catch (e) {}
-  /* 会话托管（2026-10-23）：默认关；跟着环境走（见 ENV_SCOPE_KEYS），
-     同一台手机切到另一台桌面时，两台各自的托管开关互不继承。 */
-  var HOSTING = false;
-  try { HOSTING = localStorage.getItem('magic.hosting') === '1'; } catch (e) {}
+  /* 会话托管（2026-10-23）：跟团队模式一样**挂在会话上**（用户：「跟团队模式一样改成
+     挂在会话上，子会话继承，不再是全局」）。`sessions` 是 sid → 开/关；`fresh` 只临时装
+     「新会话还没拿到 session_id 时」的开关（首帧带回 id 就落到 `sessions` 上）。
+     旧版是全设备一个 `magic.hosting` —— 那正是「改一条会话，所有会话都变」的来源，
+     不迁移（把全局值抄给每条会话等于把 bug 换个地方），直接清掉。 */
+  var HOSTING = loadHostingPref();
   var PREFS = loadPrefs();
   applyThemePref(PREFS.theme); applyFontPref(PREFS.font);
   paintRunPref();
@@ -2692,7 +2880,8 @@ button.setrow{font-family:inherit}
            宿主这边的筛选只是第一道。 */
         session: p.session,
         attachments: (p.attachments || []).slice(),
-        atts: (p.atts || []).slice()
+        atts: (p.atts || []).slice(),
+        hosted: !!p.hosted
       };
     });
     try { return conv.adoptQueue(items) || 0; } catch (e) { return 0; }
@@ -2708,16 +2897,48 @@ button.setrow{font-family:inherit}
       adoptPendingFor(sid);
     });
   }
-  /* 会话托管的开关落盘 + 同步「我的」里那枚 toggle。
+  /* 会话托管的开关：**按当前这条会话**落盘（用户 2026-10-23：「跟团队模式一样改成
+     挂在会话上，子会话继承，不再是全局」）。开关的权威值在这里，组件只执行。
      reason 非空 = 组件自己暂停的（失败 / 被停 / 到上限 / 用户点了「托管中」标记），
-     这里要如实弹一句；宿主自己拨开关时传空串，由调用处给更具体的提示。 */
-  function setHostingPref(on, reason) {
-    HOSTING = !!on;
-    try { localStorage.setItem('magic.hosting', HOSTING ? '1' : '0'); } catch (e) {}
-    var tgl = document.getElementById('tglHosting');
-    if (tgl) tgl.classList.toggle('is-on', HOSTING);
+     这里要如实弹一句；宿主自己拨开关时由调用处给更具体的提示。 */
+  function convSessionKey() {
+    var raw = (conv && conv.state && conv.state.session) || convSid || '';
+    var s = raw ? sessionByAnyId(raw) : null;
+    return s ? (sidOf(s) || String(raw || '')) : String(raw || '');
+  }
+  function writeHostingFor(on) {
+    var key = convSessionKey();
+    if (key) {
+      var s = sessionByAnyId(key);
+      /* 同一会话的 run_id ↔ session_id 别名只留一条，避免两个键各说一套。 */
+      if (s) {
+        [s.session_id, s.run_id].forEach(function (k) {
+          if (k && String(k) !== key) delete HOSTING.sessions[String(k)];
+        });
+      }
+      HOSTING.sessions[key] = !!on;
+      HOSTING.fresh = false;
+    } else {
+      HOSTING.fresh = !!on;
+    }
+    saveHostingPref();
+  }
+  function onHostingToggleFromConv(on, reason) {
+    writeHostingFor(!!on);
     if (reason) toast('会话托管已暂停：' + reason);
   }
+  /* 运行设置里那一行：直接翻当前会话的开关（不弹选择器 —— 托管只有开 / 关两档）。 */
+  function toggleHostingHere() {
+    if (!SUGGEST.engine) { toast('先在「我的 → 建议引擎」里选一个引擎，才能开启会话托管'); return; }
+    if (!conv) { toast('会话还没准备好'); return; }
+    var on = typeof conv.hostingOn === 'function' ? !!conv.hostingOn() : false;
+    var next = !on;
+    try { conv.setHosting(next); } catch (e) {}
+    writeHostingFor(next);
+    toast(next
+      ? '会话托管已开启：每轮结束自动发送最合适的建议，提问卡自动选第一项继续'
+      : '会话托管已关闭');
+  }
 
   function mountConversation(sid, s) {
     /* 同一条会话、同一个空间：组件还活着，画面也还在 —— 直接把这一屏端回来。
@@ -2733,6 +2954,7 @@ button.setrow{font-family:inherit}
       /* same:true —— 上面已经确认是同一屏会话。组件按字面判 id 会把别名当成
          「换了会话」→ clearQueue() 删掉排队追问（本次报障的病根之一）。 */
       try { conv.setSession(sid, s, { same: true }); } catch (e) {}
+      if (typeof conv.setSuggestEngine === 'function') conv.setSuggestEngine(SUGGEST.engine, SUGGEST.model);
       window.magicConv = conv;
       return;
     }
@@ -2741,14 +2963,18 @@ button.setrow{font-family:inherit}
     convSid = sid || null;
     convWs = WS;
     /* 每次重建组件都丢掉「上一条还没落定的新会话」的临时开关 —— 否则用户在新会话里
-       开了团队但没发消息，转去打开一条历史会话时，那条会话的首帧会把开关误记成开启。
-       老会话的开关由 teamOnFor 从它自己那份记录里取；新会话从「关」起。 */
+       开了团队 / 托管但没发消息，转去打开一条历史会话时，那条会话的首帧会把开关误记成开启。
+       老会话的开关由 teamOnFor / hostingOnFor 从它自己那份记录里取；新会话从「关」起。 */
     TEAM.fresh = false;
+    HOSTING.fresh = false;
     try {
-      var transport = window.MagicTransportHttp({ base: BASE, token: TOKEN, client: 'mobile' });
+      var transport = wrapTransportForJobs(window.MagicTransportHttp({ base: BASE, token: TOKEN, client: 'mobile' }));
       conv = window.MagicConversation.create({
         el: convEl, transport: transport, titleEl: titleEl, workspace: WS,
         engine: RUN_PREF.engine, model: RUN_PREF.model,
+        /* 建议功能默认关闭：只有「我的 → 建议引擎」里显式选了引擎才传非空值；
+           模型为空 = 引擎默认（建议生成对 llm 用 no-think 变体作默认值）。 */
+        suggestEngine: SUGGEST.engine, suggestModel: SUGGEST.model,
         showPermission: false, showAttach: true, beforeAsk: gateAsk,
         onInterrupt: cancelWaitingAsk,
         /* 组件内排队也要落库（2026-10-21 用户：「非团队的串行排队也没落库」）：
@@ -2759,9 +2985,10 @@ button.setrow{font-family:inherit}
         onQueueTake: queueTaken,
         onQueueDrop: queueDropped,
         onPick: rememberRunPick,
-        /* 会话托管：开关值由宿主给（权威在 localStorage），自动暂停时组件回调这里同步。 */
-        hosting: HOSTING,
-        onHostingChange: setHostingPref,
+        /* 会话托管：开关初值按**这条会话**给（自己没有记录就沿父链继承，见 hostingOnFor）；
+           组件自己暂停时回调这里把这条会话的开关关掉。 */
+        hosting: hostingOnFor(sid, s),
+        onHostingChange: onHostingToggleFromConv,
         /* 团队模式：开关初值按**这条会话**给；配置是设备偏好（每轮现读，改配置立刻生效）。
            features 也给函数：能力清单是异步拉到的（/desk/health），
            查到之后开关才会亮出来，不必重新挂载组件。 */
@@ -2778,9 +3005,12 @@ button.setrow{font-family:inherit}
           };
         },
         features: function () { return CORE_FEATURES; },
-        /* 新会话的开关先记在 TEAM.fresh：core 的首帧带回 session_id 时，当场绑到这条会话上
-           （否则返回列表再点进来就找不到它了）。 */
-        onEvent: function (ev) { bindFreshTeam(ev && ev.session_id); },
+        /* 新会话的开关先记在 TEAM.fresh / HOSTING.fresh：core 的首帧带回 session_id 时，
+           当场绑到这条会话上（否则返回列表再点进来就找不到它了）。 */
+        onEvent: function (ev) {
+          bindFreshTeam(ev && ev.session_id);
+          bindFreshHosting(ev && ev.session_id);
+        },
         /* 菜单里的「定时任务」还在，但底部那个 tab 已经删了（2026-10-22 用户：
            「定时任务tab先删除」）。现在点它给一句说明，而不是跳去一张只有一个占位符的页 ——
            原先那页的正文就是这句说明，页面本身没有承载任何数据。
@@ -2805,6 +3035,39 @@ button.setrow{font-family:inherit}
       convEl.appendChild(d);
     }
   }
+  /* ── 进详情时补拉这一条的状态（2026-10-23 用户：「白色会话进会话详情时应该再拉一波更新状态」）──
+     列表里的 status 是**进列表那一刻**的快照；而 core 的 `--sessions` 读侧还会把「记录写着
+     在跑、进程其实已经不在」的行当场归一成 gone。用户点开一条**没有颜色**的会话（既不是
+     运行中 / 等审批，也不是已完成 / 失败 / 已取消）时，多半就是这份快照已经过期。
+     这里只补这一条：拉一次登记表、按 id 别名（session_id ↔ run_id）对上就地更新，
+     状态真的变了才重绘。失败静默 —— 它是补刀，不是主路径。 */
+  function refreshRowStatus(sid) {
+    if (!sid || !TOKEN) return;
+    var seq = CONN_SEQ;
+    fetch(BASE + '/desk/sessions', { headers: { 'X-Magic-Token': TOKEN } })
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .then(function (list) {
+        if (seq !== CONN_SEQ || !Array.isArray(list)) return;
+        var row = null, cur = null, i;
+        for (i = 0; i < list.length; i++) {
+          var x = list[i];
+          if (!x) continue;
+          if (sameConvId(x.session_id, sid) || sameConvId(x.run_id, sid)) { row = x; break; }
+        }
+        if (!row) return;
+        for (i = 0; i < LAST_SESSIONS.length; i++) {
+          if (sameConvId(sidOf(LAST_SESSIONS[i]), sid)) { cur = LAST_SESSIONS[i]; break; }
+        }
+        if (!cur) return;
+        var was = statusOf(cur);
+        if (row.status) cur.status = row.status;
+        if (row.state) cur.state = row.state;
+        cur.alive = row.alive === true;
+        if (row.updated_at) cur.updated_at = row.updated_at;
+        if (statusOf(cur) !== was) renderSessions(LAST_SESSIONS);
+      })
+      .catch(function () { /* 拉不到就保持原样 */ });
+  }
   function openSession(sid, s) {
     /* ⚠️ 一律以会话自己的归属为准，**不能**只在其有 workspace 时才改 WS（2026-10-21）：
        原写法 `if (s && s.workspace) { WS = s.workspace; }` 会让「打开一条默认空间的会话」
@@ -2814,6 +3077,9 @@ button.setrow{font-family:inherit}
     saveWs();
     showSession(s && s.workspace ? basename(s.workspace) : histSubtitle);
     mountConversation(sid, s);
+    /* 灰白档 = 状态未知（或列表快照过期）：进详情时补拉一次，见 refreshRowStatus。
+       其它档（运行中 / 等审批 / 已完成 / 失败 / 已取消）列表已经说清楚了，不必再打一发。 */
+    if (statusOf(s) === 'idle') refreshRowStatus(sid);
   }
   /* ws：不传 = 默认（不属于任何空间）；传字符串 = 在该空间里新建（列表里空间组的「＋」）。
      ⚠️ 「新建任务」大按钮必须从**默认**起（2026-10-21 用户：「大的新建会话 空间应该是
@@ -2828,6 +3094,15 @@ button.setrow{font-family:inherit}
   }
 
   function connect(target) {
+    if (!target) return;
+    /* 已经连着另一台：换环境必须走 switchEnv（整页重载）。
+       就地改 BASE/TOKEN 会把内存里的队列、串行门、会话组件留在旧环境，
+       而 saveQueue 又会把旧 PENDING 行按新环境重标后发出去 —— 这正是跨环境串队的入口。 */
+    if ((BASE || TOKEN) && (String(target.url || '') !== String(connUrlNow()) ||
+        String(target.token || '') !== String(TOKEN || ''))) {
+      switchEnv(target);
+      return;
+    }
     BASE = target.url || '';
     TOKEN = target.token || '';
     CONN_SEQ++;              // 上一台桌面还在飞的请求：回来时直接丢弃（见 loadSessions）
@@ -2852,6 +3127,7 @@ button.setrow{font-family:inherit}
     ACTIVE_ID = '';
     try { localStorage.removeItem(ACTIVE_ENV_KEY); } catch (e) {}   // 主动断开 = 下次回启动页
     SERVER_VERSION = '';   // 版本号属于「那一条连接」：断开就清掉，避免下次连到别的机器还显示旧值
+    SERVER_JOBS = false;   // 作业队列能力也属于那一条连接
     /* 排队任务**不跟着断连消失**（它们已经落库）：只清内存里的等待态，下次连上由
        restoreQueue 从磁盘接回来。串行门的 FIFO 也一并重置 —— 里面的 tail 是挂在一条
        已废弃页面上的 promise，留着会让新连接的第一条永远排在它后面。 */
@@ -2930,6 +3206,7 @@ button.setrow{font-family:inherit}
       TITLES = a[1] || {};
       DW = (a[2] && a[2].defaultWorkspace) || '';
       DW_READY = true;
+      SERVER_JOBS = !!(a[2] && a[2].jobs);
       /* 环境配置以桌面端为准：连上后拉一次（见 pullPrefs）。只拉一次，
          后面本地的改动由 schedulePushPrefs 推回去。 */
       if (!PREFS_PULLED) pullPrefs();
@@ -2993,6 +3270,10 @@ button.setrow{font-family:inherit}
   var TITLES = {};   // 服务端标题覆盖表（GET /desk/titles），重命名用
   var DW = '';       // 桌面默认工作空间（GET /desk/health 的 defaultWorkspace = core 的 cwd）
   var DW_READY = false;   // DW 是否已从 health 落定（空间键归一依赖它，见 restoreQueue）
+  /* 服务端作业队列是否可用（GET /desk/health 的 jobs 字段，2026-10-23）。
+     有它：排队与互斥在服务端（多客户端同一 workspace 串行 + request_id 幂等）；
+     没有：退回本地串行门（老服务端，只有本设备自己排）。 */
+  var SERVER_JOBS = false;
   var SPACES_ROOT = '';   // 工作空间根（health.workspacesRoot）
   var ROOT_DIRS = [];     // 根目录下 magic-* 目录（GET /desk/dirs）
   var CUSTOM_SPACES = [];
@@ -3177,18 +3458,19 @@ button.setrow{font-family:inherit}
     rowMenuEl.style.top = Math.max(12, Math.min(r.top, window.innerHeight - mh - 12)) + 'px';
     rowMenuEl.style.left = Math.max(12, Math.min(r.left + 10, window.innerWidth - mw - 12)) + 'px';
   }
-  /* 重命名：写服务端标题表（PUT /desk/session/{id}/title），成功后就地更新并重绘。 */
+  /* 重命名：写服务端标题表（PUT /desk/session/{id}/title），成功后就地更新并重绘。
+     输入走抽屉里的真输入框（openTextInputSheet）—— window.prompt 在悬浮球 / WebView 里
+     点了没反应，与「自定义路径」是同一处坑（2026-10-23）。 */
   function renameSession(s) {
     var id = sidOf(s);
-    var name = window.prompt('重命名会话', titleOf(s));
-    if (name == null) return;
-    name = name.trim(); if (!name) return;
-    var hdr = { 'Content-Type': 'application/json' };
-    if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
-    fetch(BASE + '/desk/session/' + encodeURIComponent(id) + '/title', { method: 'PUT', headers: hdr, body: JSON.stringify({ title: name }) })
-      .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
-      .then(function () { TITLES[id] = name; renderSessions(LAST_SESSIONS); })
-      .catch(function (e) { window.alert('重命名失败：' + (e && e.message ? e.message : e)); });
+    openTextInputSheet({ title: '重命名会话', value: titleOf(s), emptyHint: '名称不能为空' }, function (name) {
+      var hdr = { 'Content-Type': 'application/json' };
+      if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
+      fetch(BASE + '/desk/session/' + encodeURIComponent(id) + '/title', { method: 'PUT', headers: hdr, body: JSON.stringify({ title: name }) })
+        .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
+        .then(function () { TITLES[id] = name; renderSessions(LAST_SESSIONS); })
+        .catch(function (e) { toast('重命名失败：' + (e && e.message ? e.message : e)); });
+    });
   }
   /* 删除一棵会话树：删主会话时，挂在它下面的**子任务会话**也要从本地列表一起消失。
      服务端（session.Delete）已经级联删了登记记录 / 日志 / 标题 / 状态；这里只是不让
@@ -3265,12 +3547,24 @@ button.setrow{font-family:inherit}
     return h;
   }
   /* 会话状态：由 /desk/sessions 的 status（会话级统一状态，见 core 的 session-status.json）
-     映射；老版本 CLI 不给 status 时回落 state。running / waiting_approval / done / 其它。 */
+     映射；老版本 CLI 不给 status 时回落 state。
+     词表与 core 的 session.Record.State 一一对应（不再是「除了三种都算灰色」）：
+       running / alive      → run   蓝 + 扫光环
+       waiting_approval     → wait  琥珀（活着的等待）
+       done / idle          → done  绿（idle = 常驻会话本轮跑完、进程还在等追加，
+                                    与 PC 左栏的「已完成」同口径）
+       failed / gone        → fail  红（gone = 记录写着在跑、进程已不在）
+       cancelled / interrupted → stop 石褐（人为收工 / 被打断，不是故障）
+       其它（空 / 陌生值）  → idle  灰白兜底
+     ⚠️ 2026-10-23 之前 failed / cancelled / gone 全落进 idle，列表上是一片白 ——
+        用户分不清「正常结束」和「挂了」（报障：「这两个会话为什么是白色」）。 */
   function statusOf(s) {
     var st = String((s && (s.status || s.state)) || '');
     if (st === 'running' || s.alive === true) return 'run';
     if (st === 'waiting_approval') return 'wait';
-    if (st === 'done') return 'done';
+    if (st === 'done' || st === 'idle') return 'done';
+    if (st === 'failed' || st === 'gone') return 'fail';
+    if (st === 'cancelled' || st === 'interrupted' || st === 'stopped') return 'stop';
     return 'idle';
   }
   /* 会话行图标：团队会话=双人图形（mode:"team"），其余**设备形状按来源端**
@@ -3832,6 +4126,38 @@ button.setrow{font-family:inherit}
     else { b.style.cursor = 'default'; }
     body.appendChild(b);
   }
+  /* 单行文本输入抽屉（重命名 / 自定义路径共用）。
+     ⚠️ **不用 window.prompt**：悬浮球（Electron 小窗）与 Android WebView 都没实现它，
+        调用只会静默返回 null —— 表现就是「点击无效」且抽屉原样不动（2026-10-23 报障）。
+        这里换成抽屉里的真输入框，样式沿用启动页那套 .field / .btn；空值给红字提示，
+        不再静默 return（否则和上面的 bug 长得一模一样）。 */
+  function openTextInputSheet(opt, onOk) {
+    openHostSheet(opt.title || '', function (body) {
+      var f = hEl('div', 'field');
+      var inp = document.createElement('input');
+      inp.type = 'text';
+      inp.value = opt.value || '';
+      if (opt.placeholder) inp.placeholder = opt.placeholder;
+      inp.setAttribute('autocapitalize', 'off');
+      inp.setAttribute('autocorrect', 'off');
+      inp.setAttribute('spellcheck', 'false');
+      f.appendChild(inp);
+      body.appendChild(f);
+      var err = hEl('div', 'field__err'); err.hidden = true;
+      body.appendChild(err);
+      var ok = hEl('button', 'btn btn--filled', '确定'); ok.type = 'button';
+      body.appendChild(ok);
+      function commit() {
+        var v = String(inp.value || '').trim();
+        if (!v) { err.textContent = opt.emptyHint || '不能为空'; err.hidden = false; inp.focus(); return; }
+        closeHostSheet();
+        if (onOk) onOk(v);
+      }
+      ok.onclick = commit;
+      inp.onkeydown = function (e) { if (e.key === 'Enter') { e.preventDefault(); commit(); } };
+      setTimeout(function () { try { inp.focus(); inp.select(); } catch (e) {} }, 30);
+    });
+  }
   function applyWs() { if (conv && conv.setWorkspace) conv.setWorkspace(WS); }
   /* 工作空间值的显示：WS 为空 = 默认（不传 -w，core 用调用方 cwd）。
      ⚠️ **绝不显示目录名**（2026-10-21 用户：「默认就是要不属于任何空间目录」）。
@@ -3854,6 +4180,11 @@ button.setrow{font-family:inherit}
     if (permBtn) permBtn.classList.toggle('setrow--danger', !!(conv && conv.permissionTier && conv.permissionTier() === 'full'));
     var t = document.getElementById('rsTeam');
     if (t) t.textContent = (conv && conv.teamLabel) ? conv.teamLabel() : '关闭';
+    /* 会话托管（2026-10-23，按会话）：与团队模式并列在同一张卡里。
+       标签读**组件此刻的真实状态**（子会话可能是从父会话继承来的开启值）。 */
+    var h = document.getElementById('rsHosting');
+    if (h) h.textContent = !SUGGEST.engine ? '未配置建议引擎'
+      : ((conv && typeof conv.hostingOn === 'function' && conv.hostingOn()) ? '开启' : '关闭');
     /* 团队模式：与权限模式并列（用户 2026-10-21：「团队模式开关在界面右上角跟权限模式一样」）。
        core 没有这个能力位时**不显示**这一行 —— 显示一个点了必然失败的开关是最坏的做法。 */
     var showTeam = !conv || typeof conv.featureOn !== 'function' || conv.featureOn('feature.session.team');
@@ -3923,6 +4254,9 @@ button.setrow{font-family:inherit}
               /* team：重发时原样还原团队配置（见 fireQueued）——
                  丢了它这条排队任务就会从「团队」静默降级成单任务。 */
               team: info.team || null,
+              /* hosted：托管自动发的那一轮被串行门挡住 / 重启恢复时要原样还原，
+                 否则重发出去的历史事件会退回「用户亲手发的」画法。 */
+              hosted: !!info.hosted,
               attachments: (info.attachments || []).slice(),
               /* atts：气泡缩略图的快照（{name, remoteUrl}，见 conversation.js 的 notifyQueue）。
                  重进会话时 adoptPendingFor 用它把排队气泡原样画回来 —— 只存路径的话恢复出来会丢图。 */
@@ -3934,7 +4268,7 @@ button.setrow{font-family:inherit}
                  组件被销毁重建后，它的 owner='conv' 条目还留在 PENDING 里，由
                  adoptPendingFor 接回新实例 —— 状态只能落在条目上，不能只存在组件内存。 */
               owner: info.owner || 'gate',
-              hide: !!hide, dev: devKey(), at: Date.now() };
+              hide: !!hide, env: queueEnvKey(), dev: devKey(), at: Date.now() };
     PENDING.push(p); saveQueue();
     if (!hide) renderSessions(LAST_SESSIONS);
     return p;
@@ -3980,14 +4314,88 @@ button.setrow{font-family:inherit}
     delete QPEND[id];
     cancelPending(pid);          // 标取消 + 从 PENDING 与磁盘上一并删掉
   }
-  /* ── 队列落库 ──
-     键用**令牌**而不是地址：令牌是这台桌面的身份（magic-client 把它落盘复用，跨重启不变），
-     而地址会变 —— 手机从 Wi-Fi 切到热点、桌面换了 IP、端口变了，用地址当键就等于把上次的
-     排队任务判成「另一台机器的」而整批丢掉。换一台桌面来配对时令牌不同，自然互不干扰。
-     loadQueue 只认当前令牌那批，别的**留在原地不动**（那台机器再连上来时还能用）——
+  /* 服务端已受理（open 到达）：本地排队行交给服务端，删掉并清干净映射。 */
+  function clearPendingRow(id) {
+    if (!id) return;
+    Object.keys(QPEND).forEach(function (k) { if (QPEND[k] === id) delete QPEND[k]; });
+    ASK_WAITING = ASK_WAITING.filter(function (x) { return !x || x.id !== id; });
+    dropPending(id);
+  }
+  /* ── 把服务端作业队列接进对话组件（2026-10-23）──
+     · 每个 ask 都带 request_id：与本地排队行同一个 id，断线/重启/换标签页重发也只跑一次；
+     · 排队时服务端发 `event: queued`（老服务端没有，忽略）→ 把本地行翻成可见的「等待中」；
+     · `open` 到达 = 服务端已受理并开跑 → 删本地行。此后刷新页面也不会再重发。
+     老服务端（没有 jobs 能力）也照样带这些字段 —— 多出来的键会被忽略，行为不变。 */
+  function wrapTransportForJobs(t) {
+    if (!t || t.__jobsWrapped) return t;
+    t.__jobsWrapped = true;
+    var baseAsk = t.ask;
+    t.ask = function (payload, h) {
+      var p = payload || {};
+      var pend = pendingOf(p.prompt);
+      var rid = (pend && pend.id) || ('q' + Date.now() + '-' + Math.floor(Math.random() * 100000));
+      p.request_id = rid;
+      /* 串行模式由用户选；并行模式显式传 false，服务端仍会套全局并发上限。 */
+      if (p.serial === undefined) p.serial = (TASK_MODE === 'serial');
+      var hs = h || {};
+      var onOpen = hs.onOpen, onEvent = hs.onEvent, onEnd = hs.onEnd, onErr = hs.onError;
+      if (pend && !pend.gone) {
+        pend.dispatching = true;
+        pend.requestId = rid;
+        if (ASK_WAITING.indexOf(pend) < 0) ASK_WAITING.push(pend);
+      }
+      hs.onEvent = function (ev) {
+        if (ev && ev.state === 'queued' && pend && !pend.gone) {
+          if (ev.job) pend.job = ev.job;
+          pend.pos = ev.position || 0;
+          if (pend.hide) { pend.hide = false; renderSessions(LAST_SESSIONS); }
+          if (typeof pend.queuedCb === 'function') { try { pend.queuedCb(true); } catch (e) {} }
+        }
+        if (onEvent) { try { onEvent(ev); } catch (e) {} }
+      };
+      hs.onOpen = function (id) {
+        if (pend && !pend.gone) {
+          if (typeof pend.queuedCb === 'function') { try { pend.queuedCb(false); } catch (e) {} }
+          clearPendingRow(pend.id);
+        }
+        if (onOpen) { try { onOpen(id); } catch (e) {} }
+      };
+      hs.onEnd = function (code, ev) {
+        if (pend && !pend.gone) {
+          if (typeof pend.queuedCb === 'function') { try { pend.queuedCb(false); } catch (e) {} }
+          ASK_WAITING = ASK_WAITING.filter(function (x) { return x !== pend; });
+        }
+        if (onEnd) { try { onEnd(code, ev); } catch (e) {} }
+      };
+      hs.onError = function (e) {
+        /* 发不出去：本地行留着（下次连上 / 重开 App 由 restoreQueue 重发，request_id 不变）。 */
+        if (pend && !pend.gone) { pend.dispatching = false; }
+        if (onErr) { try { onErr(e); } catch (e2) {} }
+      };
+      return baseAsk.call(t, p, hs);
+    };
+    return t;
+  }
+  /* ── 队列落库（按**环境**分区）──
+     分区键用稳定 eid（见 ensureEnvId），与 ENV_SCOPE 同一口径；不是令牌也不是地址：
+       · 令牌会变 —— App 每次启动会换注入令牌，按令牌分桶等于每次重启换一个新桶；
+       · 令牌还会**重复** —— 多台桌面用同一枚显式 `--token` 部署时，按令牌分桶就把
+         A 的队列当成 B 的：切过去直接发到 B，而「A 的会话结束」事件还在 A，这边等不到；
+       · 地址也会变/会被复用 —— 按 host 分桶要么变孤儿，要么把旧任务发给后来占用
+         同一地址的另一台服务器。
+     loadQueue 只认当前环境那批，别的**留在原地不动**（切回去时接着跑）——
      所以这里是读改写，不是整体覆盖。 */
   var QUEUE_KEY = 'magic.serial.queue.v1';
+  function queueEnvKey() { return envScopeIdOf(activeConn()) || String(BASE || ''); }
+  /* 兼容旧行（没有 env、只有令牌派生的 dev）：只有令牌正好是当前这台时才认领 ——
+     认领后下一次写盘会补上 env。其余环境的行原样留着，等切回去再接。 */
   function devKey() { return String(TOKEN || '').slice(0, 12) || String(BASE || ''); }
+  function rowEnv(p) {
+    if (!p) return '';
+    if (p.env) return String(p.env);
+    if (p.dev && p.dev === devKey()) return queueEnvKey();
+    return '';
+  }
   function readQueueAll() {
     try {
       var a = JSON.parse(localStorage.getItem(QUEUE_KEY) || '[]');
@@ -3995,7 +4403,11 @@ button.setrow{font-family:inherit}
     } catch (e) { return []; }
   }
   function saveQueue() {
-    var mine = devKey(), others = readQueueAll().filter(function (p) { return p.dev !== mine; });
+    /* 没连上就不知道自己是哪台环境：此时宁可不写，也不能把「认不出归属」的行
+       当成自己的冲掉（那正是旧实现丢别的环境队列的方式）。 */
+    var mine = queueEnvKey();
+    if (!mine) return;
+    var others = readQueueAll().filter(function (p) { return rowEnv(p) !== mine; });
     /* 只落**持久**字段：hide / gone 是这一次页面会话里的显示态，存下去会让「关掉 App 时
        正好还没到 300ms」的那条永远隐藏 —— 队列里有它、列表上却看不见，最难查的一种。
        id 保留：恢复时据此与内存里已有的条目去重。 */
@@ -4008,13 +4420,41 @@ button.setrow{font-family:inherit}
                /* owner 刻意不落盘：重启后所有残留条目都由 restoreQueue 交给宿主
                   （enqueueDispatch），语义与 'host' 一致 —— 存下来反而会让「上次是
                   组件排队」的那条永远等不到组件接管。 */
-               dev: p.dev, at: p.at };
+               env: mine, dev: p.dev, at: p.at };
     });
     try { localStorage.setItem(QUEUE_KEY, JSON.stringify(others.concat(mineRows))); } catch (e) {}
+    queueBroadcast();
   }
   function loadQueue() {
-    var mine = devKey();
-    return readQueueAll().filter(function (p) { return p && p.dev === mine && p.prompt; });
+    var mine = queueEnvKey();
+    if (!mine) return [];
+    return readQueueAll().filter(function (p) { return p && rowEnv(p) === mine && p.prompt; });
+  }
+  /* 同源多标签页：队列变了就互相知会一声（真正的一致性由服务端负责，
+     这里只是让列表不用等下一次轮询才更新）。 */
+  var QUEUE_BC = null;
+  try { if (window.BroadcastChannel) QUEUE_BC = new BroadcastChannel('magic.queue'); } catch (e) { QUEUE_BC = null; }
+  function queueBroadcast() {
+    if (!QUEUE_BC) return;
+    try { QUEUE_BC.postMessage({ env: queueEnvKey(), at: Date.now() }); } catch (e) {}
+  }
+  function syncPendingFromDisk() {
+    var disk = loadQueue();
+    var keep = [];
+    PENDING.forEach(function (p) { if (p && (p.dispatching || p.owner === 'conv')) keep.push(p); });
+    var ids = {};
+    keep.forEach(function (p) { ids[p.id] = 1; });
+    PENDING = disk.filter(function (p) { return !ids[p.id]; }).concat(keep);
+    renderSessions(LAST_SESSIONS);
+  }
+  if (QUEUE_BC) {
+    try {
+      QUEUE_BC.onmessage = function (ev) {
+        var d = ev && ev.data;
+        if (!d || d.env !== queueEnvKey()) return;
+        try { syncPendingFromDisk(); } catch (e) {}
+      };
+    } catch (e) {}
   }
   /* 某条排队任务被用户放弃（划掉 / 删除）：磁盘上也要删，否则下次启动它又冒出来。 */
   function purgeQueue(id) {
@@ -4022,6 +4462,7 @@ button.setrow{font-family:inherit}
       var rest = readQueueAll().filter(function (p) { return p.id !== id; });
       localStorage.setItem(QUEUE_KEY, JSON.stringify(rest));
     } catch (e) {}
+    queueBroadcast();
   }
   /* 占位何时能还：等登记表里该空间真的出现这一条（= 它的 core 已落盘）。
      判据不能只看 `running`：几十毫秒就收工的任务，落盘那一刻起就不是 running 了，
@@ -4142,6 +4583,15 @@ button.setrow{font-family:inherit}
   function gateAsk(info) {
     if (TASK_MODE !== 'serial' || !info) return Promise.resolve(true);
     var ws = wsKey(info.workspace);
+    /* 服务端有作业队列：真正的「谁先跑」由服务端裁决（多客户端同一 workspace 串行），
+       宿主这里只把这条登记成本地行（关 App 后能恢复），然后立刻放行 ——
+       组件照常发 /desk/ask，服务端会先排队再开跑，排队时推 `queued` 事件回来。 */
+    if (SERVER_JOBS) {
+      var pend = addPending(ws, info, true);
+      ASK_WAITING.push(pend);
+      pend.queuedCb = (typeof info.queued === 'function') ? info.queued : null;
+      return Promise.resolve(true);
+    }
     var q = serialQ(ws);
     /* 落库是同步写，很便宜；而「点了发送、网还没回、用户退出了」正是丢任务的高危窗口，
        所以不等任何延时，先进队列进磁盘。 */
@@ -4201,6 +4651,19 @@ button.setrow{font-family:inherit}
     if (!hit) return false;
     hit.cancelled = true;
     hit.gone = true;
+    /* 服务端作业队列：排队中要把它从服务端撤掉，否则这边删了行、那边照样会开跑。
+       有 job id 走 job 路由；还没拿到（queued 事件未到）就按 request_id 撤。 */
+    if (SERVER_JOBS && (hit.job || hit.requestId || hit.id)) {
+      try {
+        var hdr = TOKEN ? { 'X-Magic-Token': TOKEN, 'Content-Type': 'application/json' } : { 'Content-Type': 'application/json' };
+        if (hit.job) {
+          fetch(BASE + '/desk/jobs/' + encodeURIComponent(hit.job) + '/cancel', { method: 'POST', headers: hdr }).catch(function () {});
+        } else {
+          fetch(BASE + '/desk/jobs/cancel', { method: 'POST', headers: hdr,
+            body: JSON.stringify({ request_id: hit.requestId || hit.id }) }).catch(function () {});
+        }
+      } catch (e) {}
+    }
     dropPending(id);
     renderSessions(LAST_SESSIONS);
     return true;
@@ -4250,7 +4713,62 @@ button.setrow{font-family:inherit}
     list.forEach(function (p) { p.owner = 'host'; });
     PENDING = list;
     renderSessions(LAST_SESSIONS);
-    list.forEach(function (p) { enqueueDispatch(p); });
+    if (!SERVER_JOBS) {
+      list.forEach(function (p) { enqueueDispatch(p); });
+      return;
+    }
+    /* 服务端作业队列：直接按 request_id 重新提交（幂等），提交成功才算交给服务端。
+       用 Web Locks 串行化「同源多标签页同时恢复」，避免两边各发一遍
+       —— 即使没有 Web Locks，服务端的 request_id 幂等也能兜住。 */
+    var submitAll = function () {
+      list.forEach(function (p) { submitQueuedJob(p); });
+    };
+    try {
+      if (navigator.locks && navigator.locks.request) {
+        navigator.locks.request('magic.queue.restore.' + queueEnvKey(), submitAll);
+      } else {
+        submitAll();
+      }
+    } catch (e) { submitAll(); }
+  }
+  /* 服务端作业提交：受理即删本地行（服务端接管，之后刷新/重开 App 都不会重发）。
+     失败则保留并标「未能启动」，下次连上由 restoreQueue 再试（request_id 不变 → 幂等）。 */
+  function submitQueuedJob(p) {
+    if (!connected()) return Promise.resolve(false);
+    var body = { engine: p.engine, prompt: p.prompt, request_id: p.id, serial: (TASK_MODE === 'serial') };
+    if (p.model) body.model = p.model;
+    if (p.w) body.workspace = p.w;
+    if (p.session) body.session = p.session;
+    if (p.permission) body.permission = p.permission;
+    if (p.team) body.team = p.team;
+    if (p.hosted) body.hosted = true;
+    if (p.attachments && p.attachments.length) body.attachments = p.attachments;
+    var hdr = { 'Content-Type': 'application/json' };
+    if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
+    return fetch(BASE + '/desk/jobs', { method: 'POST', headers: hdr, body: JSON.stringify(body) })
+      .then(function (r) {
+        if (!r.ok) {
+          return r.text().then(function (txt) {
+            var why = '';
+            try { var j = JSON.parse(txt); why = (j && j.error) || ''; } catch (e) {}
+            throw new Error(why || ('HTTP ' + r.status));
+          });
+        }
+        return r.json();
+      })
+      .then(function (out) {
+        if (!out || !out.job) return false;
+        if (p.stalled) { p.stalled = false; p.stalledReason = ''; }
+        dropPending(p.id);
+        if (typeof loadSessions === 'function') loadSessions(true);
+        return true;
+      })
+      .catch(function (e) {
+        p.stalled = true;
+        p.stalledReason = (e && e.message) || '网络错误';
+        renderSessions(LAST_SESSIONS);
+        return false;
+      });
   }
   function enqueueDispatch(p) {
     var ws = wsKey(p.w);
@@ -4301,6 +4819,8 @@ button.setrow{font-family:inherit}
     /* 团队配置是在发送那一刻快照下来的（见 addPending）：重发必须带上，
        否则这条排队任务会被当成普通单任务跑。 */
     if (p.team) payload.team = p.team;
+    /* 托管自动发的那一轮：重发也要把标识带上（历史回放才能继续画成「托管发送」）。 */
+    if (p.hosted) payload.hosted = true;
     if (p.attachments && p.attachments.length) payload.attachments = p.attachments;
     return new Promise(function (resolve) {
       var done = false, handle = null, t0 = Date.now();
@@ -4555,13 +5075,19 @@ button.setrow{font-family:inherit}
         var isCustom = CUSTOM_SPACES.indexOf(w) >= 0;
         hRow(body, basename(w), isCustom ? '自定义' : null, function () { WS = w; saveWs(); applyWs(); closeHostSheet(); paintRunSettings(); }, false, WS === w);
       });
-      hRow(body, '自定义路径…', '＋', function () {
-        var p = window.prompt('输入工作空间的绝对路径', SPACES_ROOT || DW || '');
-        if (p == null) return;
-        p = p.trim(); if (!p) return;
-        if (CUSTOM_SPACES.indexOf(p) < 0) { CUSTOM_SPACES.push(p); saveSpaces(); }
-        WS = p; saveWs(); applyWs(); closeHostSheet(); loadSessions(); paintRunSettings();
-      });
+      hRow(body, '自定义路径…', '＋', openCustomPathSheet);
+    });
+  }
+  /* 自定义路径：复用单行输入抽屉（见 openTextInputSheet 上方的 prompt 说明）。 */
+  function openCustomPathSheet() {
+    openTextInputSheet({
+      title: '自定义路径',
+      value: SPACES_ROOT || DW || '',
+      placeholder: '/绝对路径',
+      emptyHint: '请输入工作空间的绝对路径'
+    }, function (p) {
+      if (CUSTOM_SPACES.indexOf(p) < 0) { CUSTOM_SPACES.push(p); saveSpaces(); }
+      WS = p; saveWs(); applyWs(); loadSessions(); paintRunSettings();
     });
   }
 
@@ -4570,6 +5096,40 @@ button.setrow{font-family:inherit}
      会话里输入框上方的级联切换也会回写这里（见 mountConversation 的 onPick）——
      与 PC 端「选过一次就一直用」的语义一致，「我的」里显示的就是下次新建会用的那一组。
      ⚠️ 模型必须挂在引擎下：engine 为空时 model 一律清空，不留孤儿模型。 */
+  /* 建议引擎：只认**显式配置过**的值；没有 / 空串 = 不开启建议功能（默认）。
+     不能回落到 RUN_PREF.engine —— 那等于「配了默认编码引擎就自动有建议」，
+     与用户「默认不配置就不开启」相反。 */
+  function loadSuggestPref() {
+    var o = { engine: '', model: '' };
+    try {
+      o.engine = String(localStorage.getItem('magic.suggest.engine') || '').trim();
+      o.model = String(localStorage.getItem('magic.suggest.model') || '').trim();
+    } catch (e) {}
+    if (!o.engine) o.model = '';
+    return o;
+  }
+  function saveSuggestPref() {
+    try {
+      localStorage.setItem('magic.suggest.engine', SUGGEST.engine || '');
+      localStorage.setItem('magic.suggest.model', SUGGEST.model || '');
+    } catch (e) {}
+    schedulePushPrefs();
+    paintSuggestPref();
+  }
+  function paintSuggestPref() {
+    var e = document.getElementById('suggestEngine');
+    var m = document.getElementById('suggestModel');
+    if (e) e.textContent = SUGGEST.engine || '不开启';
+    if (m) m.textContent = SUGGEST.engine ? (qaModelText(SUGGEST.model) || '引擎默认') : '跟随引擎';
+  }
+  function applySuggestToLive() {
+    if (conv && typeof conv.setSuggestEngine === 'function') {
+      conv.setSuggestEngine(SUGGEST.engine, SUGGEST.model);
+    }
+    paintSuggestPref();
+    paintRunSettings();
+  }
+
   function loadRunPref() {
     var o = { engine: '', model: '' };
     try {
@@ -4945,6 +5505,67 @@ button.setrow{font-family:inherit}
     el.style.textAlign = 'left';
     return el;
   }
+  /* 「我的 → 建议引擎」：单列，首项「不开启」。不展示模型 —— 建议是纯文本短任务，
+     选模型只会让界面更复杂；建议生成对 llm 会用不思考的变体作默认值。 */
+  /* 「我的 → 建议引擎 / 模型」：与默认引擎同一个二列抽屉（左引擎 · 右模型）。
+     首项「不开启」；点左列只浏览、点右列才落定。llm 放最前，模型为空时建议生成用 no-think 变体作默认值。 */
+  function openSuggestEnginePicker() {
+    openHostSheet('建议引擎 / 模型', function (body) {
+      body.innerHTML = '';
+      var hint = hEl('div', 'history__hint', '正在探测引擎与模型…');
+      hint.style.textAlign = 'left';
+      body.appendChild(hint);
+      fetchEngines().then(function (list) {
+        if (hint.parentNode) hint.remove();
+        var stale = enginesStaleHint();
+        if (stale) body.appendChild(stale);
+        var avail = (list || []).filter(function (x) { return x && x.ok; });
+        /* 推荐的放最上面：llm 是建议这条旁路最快的引擎。 */
+        avail.sort(function (a, b) {
+          if (a.engine === 'llm') return -1;
+          if (b.engine === 'llm') return 1;
+          return String(a.engine).localeCompare(String(b.engine));
+        });
+        if (!avail.length) {
+          var d = hEl('div', 'history__hint',
+            '没有可用引擎：先在这台机器上装一个（终端跑 magic-agent --engines 会给出安装命令）。');
+          d.style.textAlign = 'left';
+          body.appendChild(d);
+          return;
+        }
+        buildEngineCascade(body, avail, {
+          prefs: SUGGEST,
+          pick: pickSuggestPref,
+          offLabel: '不开启',
+          offDesc: '不生成下一轮建议（默认）',
+          modelDefaultDesc: '不指定模型（建议生成用 no-think 变体）',
+        });
+        /* 建议生成一律不思考。各引擎都走官方关闭参数；某些模型路由不支持时
+           才在超时/报错后降级 llm，不预先吞掉用户的选择。 */
+        var nk = hEl('div', 'history__hint',
+          '建议生成固定关闭思考：claude --thinking disabled、codex effort none、llm reasoning_effort=none（显式模型不换；空模型用 no-think 变体）、codebuddy alwaysThinkingEnabled=false、dsh reasoningEffort=off；引擎失败才降级 llm。');
+        nk.style.textAlign = 'left';
+        body.appendChild(nk);
+      }, function (e) {
+        hint.textContent = '拉取引擎清单失败：' + ((e && e.message) || e);
+        var retry = hEl('button', 'pick__citem', '重试');
+        retry.type = 'button';
+        retry.onclick = function () { openSuggestEnginePicker(); };
+        body.appendChild(retry);
+      });
+    });
+  }
+  function pickSuggestPref(engine, model) {
+    SUGGEST.engine = String(engine || '').trim();
+    SUGGEST.model = (SUGGEST.engine && model) ? String(model).trim() : '';
+    saveSuggestPref();
+    applySuggestToLive();
+    closeHostSheet();
+    toast(SUGGEST.engine
+      ? ('建议引擎：' + SUGGEST.engine + ' · ' + (qaModelText(SUGGEST.model) || '引擎默认模型'))
+      : '已关闭建议功能');
+  }
+
   function openDefaultEnginePicker() {
     openHostSheet('默认引擎 / 模型', function (body) {
       function load() {
@@ -4977,8 +5598,16 @@ button.setrow{font-family:inherit}
     });
   }
   /* 二列级联（左引擎 · 右该引擎的模型），与对话框里那套同构：
-     点左列只切右列，点右列才落定 —— 避免「引擎换了、模型还挂在旧引擎下」。 */
-  function buildEngineCascade(body, avail) {
+     点左列只切右列，点右列才落定 —— 避免「引擎换了、模型还挂在旧引擎下」。
+     默认引擎与建议引擎共用；o 可换目标 / 落定回调 / 关闭项文案。 */
+  function buildEngineCascade(body, avail, o) {
+    o = o || {};
+    var prefs = o.prefs || RUN_PREF;
+    var pick = o.pick || pickRunPref;
+    var offLabel = o.offLabel || '自动';
+    var offDesc = o.offDesc || '首个可用引擎';
+    var modelDefaultDesc = o.modelDefaultDesc || '不指定模型，由引擎自己挑';
+
     var wrap = hEl('div', 'pick__cols');
     var left = hEl('div', 'pick__col');
     var right = hEl('div', 'pick__col pick__col--r');
@@ -4986,24 +5615,24 @@ button.setrow{font-family:inherit}
     body.appendChild(wrap);
 
     var cur = avail[0];
-    avail.forEach(function (en) { if (en.engine === RUN_PREF.engine) cur = en; });
+    avail.forEach(function (en) { if (en.engine === prefs.engine) cur = en; });
 
     function paint() {
       left.innerHTML = ''; right.innerHTML = '';
-      var auto = hEl('button', 'pick__citem' + (!RUN_PREF.engine ? ' is-on' : ''));
-      auto.type = 'button';
-      auto.appendChild(hEl('span', 'pick__cl', '自动'));
-      auto.appendChild(hEl('span', 'pick__cd', '首个可用引擎'));
-      auto.onclick = function () { pickRunPref('', ''); };
-      left.appendChild(auto);
+      var off = hEl('button', 'pick__citem' + (!prefs.engine ? ' is-on' : ''));
+      off.type = 'button';
+      off.appendChild(hEl('span', 'pick__cl', offLabel));
+      off.appendChild(hEl('span', 'pick__cd', offDesc));
+      off.onclick = function () { pick('', ''); };
+      left.appendChild(off);
 
       avail.forEach(function (en) {
         var n = (en.models || []).length;
-        /* is-on = 已保存的默认（浅蓝实底）；is-cur = 右列此刻在浏览谁（左侧细条，无底色）——
-           两者分开，默认是「自动」时不会出现两个一样的选中块。 */
+        /* is-on = 已保存的值（浅蓝实底）；is-cur = 右列此刻在浏览谁（左侧细条，无底色）——
+           两者分开，关闭项选中时不会出现两个一样的选中块。 */
         var b = hEl('button', 'pick__citem'
-          + (RUN_PREF.engine === en.engine ? ' is-on' : '')
-          + (en.engine === cur.engine && RUN_PREF.engine !== en.engine ? ' is-cur' : ''));
+          + (prefs.engine === en.engine ? ' is-on' : '')
+          + (en.engine === cur.engine && prefs.engine !== en.engine ? ' is-cur' : ''));
         b.type = 'button';
         b.appendChild(hEl('span', 'pick__cl', en.engine));
         b.appendChild(hEl('span', 'pick__cd', n ? (n + ' 个模型') : '引擎默认'));
@@ -5011,20 +5640,20 @@ button.setrow{font-family:inherit}
         left.appendChild(b);
       });
 
-      var d = hEl('button', 'pick__citem' + (RUN_PREF.engine === cur.engine && !RUN_PREF.model ? ' is-on' : ''));
+      var d = hEl('button', 'pick__citem' + (prefs.engine === cur.engine && !prefs.model ? ' is-on' : ''));
       d.type = 'button';
       d.appendChild(hEl('span', 'pick__cl', '引擎默认'));
-      d.appendChild(hEl('span', 'pick__cd', '不指定模型，由引擎自己挑'));
-      d.onclick = function () { pickRunPref(cur.engine, ''); };
+      d.appendChild(hEl('span', 'pick__cd', modelDefaultDesc));
+      d.onclick = function () { pick(cur.engine, ''); };
       right.appendChild(d);
 
       (cur.models || []).forEach(function (mm) {
-        var b = hEl('button', 'pick__citem' + (RUN_PREF.engine === cur.engine && RUN_PREF.model === mm ? ' is-on' : ''));
+        var b = hEl('button', 'pick__citem' + (prefs.engine === cur.engine && prefs.model === mm ? ' is-on' : ''));
         b.type = 'button';
-        /* 显示剥掉 `custom-local:` 前缀（`mm` 本身是完整 id，选中时原样存进 RUN_PREF），
+        /* 显示剥掉 `custom-local:` 前缀（`mm` 本身是完整 id，选中时原样存进 prefs），
            倍率挂同行右侧。 */
         modelItem(b, cur.engine, mm);
-        b.onclick = function () { pickRunPref(cur.engine, mm); };
+        b.onclick = function () { pick(cur.engine, mm); };
         right.appendChild(b);
       });
     }
@@ -5121,6 +5750,8 @@ button.setrow{font-family:inherit}
   /* 权限 / 团队沿用会话组件里那唯一一份选择器（浮层盖在本页之上）；选完就地重画。 */
   on('btnRsPermission', function () { if (conv && conv.openPermissionPicker) conv.openPermissionPicker(); });
   on('btnRsTeam', function () { if (conv && conv.openTeamPicker) conv.openTeamPicker(); });
+  /* 会话托管（2026-10-23，按会话）：只有开 / 关两档，直接翻当前这条会话。 */
+  on('btnRsHosting', toggleHostingHere);
   /* 选择器由会话组件管理、没有回调通知宿主，所以用一次点击兜底重画：
      本页可见时任何一次点击（包括选择器里点中一行）之后重读状态。 */
   document.addEventListener('click', function () {
@@ -5190,6 +5821,8 @@ button.setrow{font-family:inherit}
   on('btnNotify', openNotifySettings);
   on('btnDefaultEngine', openDefaultEnginePicker);
   on('btnDefaultModel', openDefaultEnginePicker);
+  on('btnSuggestEngine', openSuggestEnginePicker);
+  on('btnSuggestModel', openSuggestEnginePicker);
   /* 团队模式配置（「我的」→ 子页面）：计划 + 7 个角色，行由 paintTeamRoles 动态渲染，
      行的点击在渲染时绑定（见 addTeamRouteRow / addTeamRuleRow），这里只留入口与返回。 */
   on('btnTeamPage', showTeamPage);
@@ -5201,20 +5834,9 @@ button.setrow{font-family:inherit}
   if (segFont) takeSeg(segFont, 'magic.font', function (v) { PREFS.font = v; applyFontPref(v); });
   if (segMode) takeSeg(segMode, 'magic.taskmode', function (v) { TASK_MODE = v; });
 
-  /* 会话托管开关（我的 tab）。拨动只改「接下来的轮次」：
-     正在跑的这一轮不受影响，收尾后若打开就自动接上。 */
-  var tglHosting = document.getElementById('tglHosting');
-  if (tglHosting) {
-    tglHosting.classList.toggle('is-on', HOSTING);
-    tglHosting.onclick = function () {
-      var next = !HOSTING;
-      setHostingPref(next, '');
-      if (conv) { try { conv.setHosting(next); } catch (e) {} }
-      toast(next
-        ? '会话托管已开启：每轮结束自动发送最合适的建议，提问卡自动选第一项继续'
-        : '会话托管已关闭');
-    };
-  }
+  /* 会话托管（2026-10-23 起按会话）：入口在会话页 → 任务运行设置（见 btnRsHosting）。
+     「我的」里不再有全局开关 —— 曾经那枚 `tglHosting` 写的是设备级 `magic.hosting`，
+     改一条会话会把所有会话都改掉（用户 2026-10-23：「跟团队模式一样…不再是全局」）。 */
 
   /* ══════════ 网络代理（VPN 隧道）══════════
      把整机流量经隧道送到桌面端的 SOCKS5 出口：TUN → 内核 → 桌面端 → 互联网。
@@ -5352,7 +5974,9 @@ button.setrow{font-family:inherit}
           var tok = (lastUrl === injUrl && injectedToken)
             ? injectedToken : (sc.token || injectedToken);
           if (!tok) break;
-          BASE = sc.url; TOKEN = tok; ACTIVE_ID = sc.id;
+          BASE = sc.url; TOKEN = tok;
+          sc = ensureEnvId(sc) || sc;   // 老记录补 eid，并把按地址分区的旧队列/配置槽迁过来
+          ACTIVE_ID = sc.id;
           showHistory(sc.host || connHost(sc.url));
           restoreQueue();
           resumed = true;
@@ -5365,6 +5989,7 @@ button.setrow{font-family:inherit}
       /* 把当前这条（壳注入的）连接落成环境，名字默认「公司远程」——
          否则它只是一条改不了名、也留不住的「未命名」。 */
       seedCurrentConn();
+      ensureEnvId(activeConn());   // 种出来的这条也补 eid；seedoff 没落盘时按老键回退
       showHistory(injectedBase ? injectedBase.replace(/^https?:\/\//, '') : '本机');
       restoreQueue();      // App 重启：上次没轮到的排队任务接着排（见 restoreQueue）
     } else if (!resumed) {
@@ -5375,6 +6000,7 @@ button.setrow{font-family:inherit}
       all.sort(function (a, b) { return (b.at || 0) - (a.at || 0); });
       var pick = all[0];
       if (pick) {
+        pick = ensureEnvId(pick) || pick;
         BASE = pick.url; TOKEN = pick.token || ''; ACTIVE_ID = pick.id;
         try { localStorage.setItem(ACTIVE_ENV_KEY, pick.url); } catch (e) {}
         showHistory(pick.host || connHost(pick.url));