magic-agent 2.3.0 → 2.3.2

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 用户：「移动端要支持环境切换 可以有多个连接」。
      一台手机可以记住多台桌面（家里 / 公司 / 另一台机器），任务页标题就是切换入口。
@@ -1620,7 +1721,8 @@ button.setrow{font-family:inherit}
      —— 内存态全部重新初始化，不留上一台机器的影子。
      ⚠️ 分桶键用 host:port 而不是 url|token：token 会随 App 重启变，按 token 分桶等于每次都丢现场。 */
   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',
@@ -1676,7 +1778,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'
   ];
@@ -2061,6 +2164,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 +2733,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 +2798,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 +2815,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 +2872,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 +2881,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' });
       conv = window.MagicConversation.create({
         el: convEl, transport: transport, titleEl: titleEl, workspace: WS,
         engine: RUN_PREF.engine, model: RUN_PREF.model,
+        /* 建议功能默认关闭：只有「我的 → 建议引擎」里显式选了引擎才传非空值；
+           模型为空 = 引擎默认（core 对 llm 会自动挑最快变体）。 */
+        suggestEngine: SUGGEST.engine, suggestModel: SUGGEST.model,
         showPermission: false, showAttach: true, beforeAsk: gateAsk,
         onInterrupt: cancelWaitingAsk,
         /* 组件内排队也要落库（2026-10-21 用户：「非团队的串行排队也没落库」）：
@@ -2759,9 +2903,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 +2923,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 +2953,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 +2995,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 用户：「大的新建会话 空间应该是
@@ -3265,12 +3449,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"），其余**设备形状按来源端**
@@ -3854,6 +4050,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 +4124,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 用它把排队气泡原样画回来 —— 只存路径的话恢复出来会丢图。 */
@@ -4301,6 +4505,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();
@@ -4570,6 +4776,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 +5185,67 @@ button.setrow{font-family:inherit}
     el.style.textAlign = 'left';
     return el;
   }
+  /* 「我的 → 建议引擎」：单列，首项「不开启」。不展示模型 —— 建议是纯文本短任务，
+     选模型只会让界面更复杂；core 对 llm 会自动挑不思考的变体。 */
+  /* 「我的 → 建议引擎 / 模型」：与默认引擎同一个二列抽屉（左引擎 · 右模型）。
+     首项「不开启」；点左列只浏览、点右列才落定。llm 放最前，模型为空时 core 自动挑最快变体。 */
+  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: '不指定模型（llm 会自动挑最快变体）',
+        });
+        /* 建议生成一律不思考。各引擎都走官方关闭参数；某些模型路由不支持时
+           才在超时/报错后降级 llm，不预先吞掉用户的选择。 */
+        var nk = hEl('div', 'history__hint',
+          '建议生成固定关闭思考：claude --thinking disabled、codex effort none、llm no-think / reasoning_effort、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 +5278,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 +5295,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 +5320,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 +5430,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 +5501,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 +5514,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 → 内核 → 桌面端 → 互联网。