magic-agent 2.1.5 → 2.3.2

package/client-ui-mobile/index.html

@@ -32,6 +32,9 @@
 <!-- 对话内核那套 DOM（.qa-*）的**共用皮肤**：三端同一份（见 shared/conv/conv.css 的文件头）。
      里面的取值全走令牌，本页只负责给令牌（下面的 :root）—— 皮肤本身不定义颜色。 -->
 <link rel="stylesheet" href="shared/conv/conv.css">
+<!-- 需求页（「需求」tab）是独立子页面：样式在 reqs.css、结构/逻辑在 reqs.js。
+     本文件只给两个空容器与一次 mount，不再混入这一页的实现。 -->
+<link rel="stylesheet" href="reqs.css">
 <style>
 /* ===== 令牌：ZCode 安卓端那一套，映射到共享组件的颜色契约 =====
    ⚠️ 默认 = 暗色：跟 ZCode 的 DarkColorScheme 逐字段对齐。 */
@@ -64,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 的形制说明），所以颜色分两组：
@@ -109,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);
@@ -134,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);
@@ -285,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)}
 /* 等待中（串行排队）：紫色 + 一圈**呼吸**的环。
    与「运行中」的扫光刻意分开 —— 扫光在转（在动），这圈只明暗（在等）；
@@ -313,11 +333,25 @@ textarea{font:inherit}
 .srow__s{display:flex;align-items:center;gap:5px;min-width:0;font-size:12px;color:var(--muted);white-space:nowrap;overflow:hidden}
 .srow__stext{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .srow__time{flex:0 0 auto;font-size:12px;color:var(--muted)}
+/* 运行中**自动临时置顶**的小图钉（2026-10-22）：让「它凭什么在最上面」有据可查。
+   手动置顶靠「置顶」分段表达，不重复画；跑完 statusOf 不再是 run，图钉随之消失。 */
+.srow__auto{flex:0 0 auto;display:flex;align-items:center;color:var(--primary-action);opacity:.75}
 /* 子会话（团队模式拆出的子任务，2026-10-22）：**缩进挂在主会话下面**，不占顶层一行。
    左侧一道竖线 + 小一档图标 —— 读起来是「这条主会话拆出去的活」；点开仍是它自己
-   那份完整过程（自己的日志）。行本身可点、可长按（重命名 / 删除同普通会话）。 */
+   那份完整过程（自己的日志）。行本身可点、可长按（重命名 / 删除同普通会话）。
+   ⚠️ 默认**折叠**（2026-10-23 用户：「列表中默认不展开显示子会话」）：父行只留一枚
+   计数徽标（有几个子会话 / 是否有子任务在跑），点它才展开。 */
 .sblock{min-width:0}
 .sblock__kids{margin:0 8px 6px 30px;padding-left:8px;border-left:2px solid var(--border)}
+.srow__kids{flex:0 0 auto;display:inline-flex;align-items:center;gap:3px;height:20px;padding:0 5px;
+  border:1px solid var(--border);border-radius:999px;background:var(--subtle);color:var(--muted);
+  font-size:11px;font-weight:600;line-height:1;cursor:pointer;user-select:none;-webkit-user-select:none}
+.srow__kids:active{opacity:.7}
+.srow__kids svg{transition:transform .15s ease}
+.srow__kids.is-open svg{transform:rotate(90deg)}
+/* 有子任务在跑：徽标转成运行色 + 一个小圆点（折叠时也能看出「下面有活在跑」）。 */
+.srow__kids.is-run{color:var(--running);border-color:currentColor}
+.srow__kids-dot{width:6px;height:6px;border-radius:50%;background:var(--running)}
 .srow--sub{padding:9px 8px 9px 4px;gap:10px}
 .srow--sub .srow__ico{width:32px;height:32px}
 .srow--sub .srow__ico svg{width:16px;height:16px}
@@ -365,12 +399,6 @@ textarea{font:inherit}
 .wsrow__open{flex:1;display:flex;align-items:center;gap:12px;min-width:0;padding:10px 8px;border-radius:14px;text-align:left}
 .wsrow__open:active{background:var(--subtle)}
 .wsrow__l{flex:1;min-width:0;font-size:15px;color:var(--ink);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-/* 空间规模（几模块 · 几条）：紧跟在空间名后面，中性色 —— 不是状态，别用徽标色。
-   需求页专属：空间名改成自适应宽度，meta 才会贴在名字后面；meta 的 margin-right:auto
-   把「待整理」徽标和箭头推到行尾。 */
-.wsrow__open--req .wsrow__l{flex:0 1 auto}
-.wsrow__open--req .wsrow__meta{margin-right:auto}
-.wsrow__meta{flex:0 1 auto;min-width:0;font-size:12px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
 /* 串行等待中的任务数：空间组折叠时也要看得见（颜色与「等待中」行一致） */
 .wsrow__badge{flex:0 0 auto;padding:1px 7px;border-radius:var(--r-full);font-size:11px;line-height:16px;
   color:var(--queued);background:var(--tint-queued);white-space:nowrap}
@@ -378,33 +406,6 @@ textarea{font:inherit}
 .wsrow__chev.is-open{transform:rotate(90deg)}
 .wsrow__add{flex:0 0 auto;width:36px;height:36px;border-radius:var(--r-full);display:flex;align-items:center;justify-content:center;color:var(--muted)}
 .wsrow__add:active{background:var(--subtle)}
-/* 每个空间自己的「整理」：需求页会同时列出多个空间，顶部那一枚只认当前会话的空间。
-   把入口放到组头，用户点哪个空间就初始化/增量哪个空间，不再猜「当前空间」是谁。 */
-.wsrow__sync{flex:0 0 auto;height:32px;padding:0 10px;border-radius:var(--r-full);
-  font-size:12px;font-weight:500;color:var(--primary-action);background:var(--subtle);white-space:nowrap}
-.wsrow__sync:active{opacity:.7}
-.wsrow__sync:disabled{color:var(--muted);opacity:.6}
-/* 「未初始化」与「待整理」同形不同色：前者是「还没按目录生成过基线」，
-   后者是「有对话等着归纳」，两种提示不能混成一个数字。 */
-.wsrow__badge--init{color:var(--warning);background:var(--tint-wait)}
-
-/* ══════════ 需求页：两级（空间→模块 → 需求列表）══════════
-   一级是**目录**：空间是行，模块缩进挂在空间下（树形），功能点一律不画在这里 ——
-   需求一多，一级就会被功能点撑成长列表，什么结构都看不出来。
-   二级才是内容：点某个模块进去，看**该空间下所有模块**的需求列表。 */
-.reqtree__mod{position:relative;display:flex;align-items:center;gap:8px;width:100%;
-  padding:9px 10px 9px 30px;background:none;border:0;text-align:left;color:var(--ink)}
-.reqtree__mod:active{background:var(--subtle)}
-/* 连接线：从空间名垂下来的细线 + 每个模块前的一小截横线 —— 归属关系靠线说话，不靠缩进猜 */
-.reqtree__mod::before{content:"";position:absolute;left:14px;top:0;bottom:0;width:1px;background:var(--border)}
-.reqtree__mod::after{content:"";position:absolute;left:14px;top:50%;width:10px;height:1px;background:var(--border)}
-.reqtree__modname{flex:1;min-width:0;font-size:14px;font-weight:500;color:var(--ink);
-  overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.reqtree__modcount{flex:0 0 auto;font-size:12px;color:var(--muted);font-variant-numeric:tabular-nums}
-.reqtree__modgo{flex:0 0 auto;color:var(--faint);display:flex;align-items:center}
-/* 二级视图的分组小节：当前所在模块高亮，其余弱化 */
-.reqdetail__sec--cur .sechead{color:var(--primary-action)}
-.reqdetail__sec--cur .sechead__t{font-weight:800}
 /* 长按会话行的浮动菜单 */
 .rowmenu{position:fixed;z-index:1201;min-width:184px;background:var(--raised);border:1px solid var(--border);
   border-radius:14px;box-shadow:0 14px 34px -12px var(--app-shadow);padding:6px}
@@ -722,6 +723,9 @@ button.setrow{font-family:inherit}
 .qa-todo-ico{width:14px;height:14px;border-width:1.5px}
 .qa-todo-ico svg{width:9px;height:9px}
 .qa-todo-meta{font-size:11px;max-width:52%}
+.qa-todo-active{font-size:11px;max-width:56%}
+.qa-todo-st{font-size:11.5px}
+.qa-todo-dur{font-size:11.5px}
 .qa-todo-toggle{width:26px;height:26px}
 .qa-todo-toggle svg{width:14px;height:14px}
 
@@ -984,13 +988,20 @@ button.setrow{font-family:inherit}
           <button class="seg__b" data-v="serial">串行</button>
         </span>
       </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>
-      <div class="setrow"><span class="setrow__l">触感反馈</span><button class="tgl" id="tglHaptic" aria-label="触感反馈"></button></div>
+      <!-- 建议引擎 / 模型（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>
-      <div class="setrow"><span class="setrow__l">语言</span><span class="setrow__v">跟随系统</span></div>
       <button class="setrow" id="btnNotify"><span class="setrow__l">消息通知设置</span><span class="setrow__v" id="notifyState">—</span></button>
     </div>
     <!-- 团队模式（2026-10-21）：开关**按会话**给，放会话页右上角的运行设置里（与权限模式并排），
@@ -1037,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>
@@ -1049,35 +1061,19 @@ 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>
 
 <!-- ══════════ 需求（会话自动聚合成的功能点文档）══════════
-     数据全来自 GET /desk/requirements（core 的 --requirements，只读）。
-     **两级**（2026-10-22 用户定稿）：
-       一级 = 目录（空间 → 模块），**不画功能点** —— 一级只回答「这个空间有哪几块」；
-       二级 = 点某个模块进去，看**该空间下所有模块**的需求列表（当前模块高亮）。
-     点一行用既有的阅读器打开那篇 markdown。
-     ⚠️ 这里**不做筛选胶囊与搜索**：第一版只要「看得见 + 能点开」，多了反而没人用
-        （用户 2026-10-22 定稿）。 -->
-<div class="history" id="reqs" hidden>
-  <div class="history__top">
-    <span class="history__title">需求</span>
-    <button class="history__disconnect" id="btnReqSync" type="button">全部整理</button>
-  </div>
-  <div class="history__list" id="reqList"></div>
-</div>
+     **独立子页面**：内容、样式、逻辑都在 reqs.js / reqs.css，本文件只留两个空容器
+     （隐藏/显示由底部 tab 控制）。数据形状、两级口径见 reqs.js 文件头。 -->
+<div class="history" id="reqs" hidden></div>
 
-<!-- 需求的二级视图：某空间下所有模块的需求列表（从一级目录点模块进来） -->
-<div class="history" id="reqDetail" hidden>
-  <div class="history__top">
-    <button class="topbar__icon" id="btnReqDetailBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
-    <span class="history__title" id="reqDetailTitle">需求</span>
-    <button class="history__disconnect" id="btnReqDetailSync" type="button">整理</button>
-  </div>
-  <div class="history__list" id="reqDetailList"></div>
-</div>
+<!-- 需求的二级视图：只看所选模块的需求列表（从一级目录点模块进来；内容由 reqs.js 渲染） -->
+<div class="history" id="reqDetail" hidden></div>
 
 <!-- ══════════ 发现（浏览器 / 应用 / 插件 / SKILL）══════════ -->
 <div class="history" id="discover" hidden>
@@ -1203,7 +1199,7 @@ button.setrow{font-family:inherit}
 <nav class="tabbar" id="tabbar" hidden>
   <button class="tab" type="button" data-tab="tasks" aria-label="任务"><span class="icw"><svg width="25" height="25"><use href="#i-task"/></svg></span></button>
   <!-- 需求 tab 常驻：不做能力位控制（用户 2026-10-22：「移动端永远显示」）。
-       老 core 上点进来会由 loadRequirements 的 501 分支给出明确文案，
+       老 core 上点进来会由 reqs.js 的 501 分支给出明确文案，
        不会是一片空白 —— 入口固定比入口忽隐忽现更好理解。 -->
   <button class="tab" type="button" data-tab="reqs" aria-label="需求"><span class="icw"><svg width="25" height="25"><use href="#i-req"/></svg></span></button>
   <span class="tabfab">
@@ -1237,6 +1233,9 @@ button.setrow{font-family:inherit}
 <script src="shared/host-glue.js"></script>
 <script src="shared/conversation.js"></script>
 <script src="shared/transport-http.js"></script>
+<!-- 需求页（独立子页面模块）：只在这里加载并注册 window.MagicReqs，
+     真正的 DOM/逻辑都在 reqs.js，主 IIFE 末尾 mount 时把宿主能力注入进去。 -->
+<script src="reqs.js"></script>
 <script>
 (function () {
   'use strict';
@@ -1266,13 +1265,9 @@ button.setrow{font-family:inherit}
   var segTheme = document.getElementById('segTheme');
   var segFont = document.getElementById('segFont');
   var segMode = document.getElementById('segMode');
-  var tglHaptic = document.getElementById('tglHaptic');
   var tabbarEl = document.getElementById('tabbar');
   var reqsEl = document.getElementById('reqs');
-  var reqListEl = document.getElementById('reqList');
   var reqDetailEl = document.getElementById('reqDetail');
-  var reqDetailTitle = document.getElementById('reqDetailTitle');
-  var reqDetailListEl = document.getElementById('reqDetailList');
   var discoverEl = document.getElementById('discover');
   var teamPageEl = document.getElementById('teamPage');
   var runSettingsPageEl = document.getElementById('runSettingsPage');
@@ -1309,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）──
@@ -1432,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 用户：「移动端要支持环境切换 可以有多个连接」。
      一台手机可以记住多台桌面（家里 / 公司 / 另一台机器），任务页标题就是切换入口。
@@ -1643,8 +1721,9 @@ button.setrow{font-family:inherit}
      —— 内存态全部重新初始化，不留上一台机器的影子。
      ⚠️ 分桶键用 host:port 而不是 url|token：token 会随 App 重启变，按 token 分桶等于每次都丢现场。 */
   var ENV_SCOPE_KEYS = [
-    'magic.ws', 'magic.taskmode', 'magic.engine', 'magic.model',
-    'magic.theme', 'magic.font', 'magic.haptic', 'magic.notify',
+    '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',
     'magic.team.parallel', 'magic.team.split', 'magic.team.splitcode', 'magic.team.adaptive'
@@ -1697,9 +1776,10 @@ button.setrow{font-family:inherit}
      所以这组键以 `/desk/prefs` 为准，localStorage 只当离线缓存：
        · 连上后拉一次，远端是权威 → 有差异就覆盖本地并重载一次；
        · 本地任何一处改了，防抖推回远端。
-     纯设备偏好（主题/字体/触感/通知）**不同步** —— 那是手机自己的事。 */
+     纯设备偏好（主题/字体/通知）**不同步** —— 那是手机自己的事。 */
   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'
   ];
@@ -2071,23 +2151,23 @@ button.setrow{font-family:inherit}
     loadSessions();
   }
   function showSession(sub) { hideAll(); sessionEl.hidden = false; tabbarEl.hidden = false; setActive('tasks'); subtitleEl.textContent = (sub != null ? sub : histSubtitle) || ''; }
-  /* 需求页：进页面即拉一次清单（GET /desk/requirements，只读、不调模型）。
+  /* 需求页：内容与逻辑在 reqs.js（独立子页面模块），这里只负责切页。
+     进页面即拉一次清单（GET /desk/requirements，只读、不调模型）；
      「整理」按钮才触发归纳（POST /desk/requirements/consolidate）——
      两者代价差三个数量级，绝不能混成一个动作。 */
   function showReqs() {
     hideAll(); reqsEl.hidden = false; tabbarEl.hidden = false; setActive('reqs');
-    /* 从二级退回来时不要还卡在详情态：回到底栏「需求」这一页 = 回到一级目录。 */
-    REQ_DETAIL = null;
-    loadRequirements(false);
+    /* 从二级退回来时不要还卡在详情态：reqs.js 的 show() 会回一级目录并拉清单。 */
+    if (window.MagicReqs && window.MagicReqs.show) window.MagicReqs.show();
   }
   function showDiscover() { hideAll(); discoverEl.hidden = false; tabbarEl.hidden = false; setActive('discover'); }
   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);
-    tglHaptic.classList.toggle('is-on', PREFS.haptic !== 'off');
     paintRunPref();
     refreshVpn();
     /* 版本号：先用已拉到的值立刻画（列表页的 /desk/health 顺手带回来的），
@@ -2634,15 +2714,14 @@ button.setrow{font-family:inherit}
     });
   }
 
-  /* ══════════ 偏好：主题 / 字体 / 触感（本地持久化）══════════ */
+  /* ══════════ 偏好：主题 / 字体（本地持久化）══════════ */
   function loadPrefs() {
     try {
       return {
         theme: localStorage.getItem('magic.theme') || 'system',
-        font: localStorage.getItem('magic.font') || '1',
-        haptic: localStorage.getItem('magic.haptic') || 'on'
+        font: localStorage.getItem('magic.font') || '1'
       };
-    } catch (e) { return { theme: 'system', font: '1', haptic: 'on' }; }
+    } catch (e) { return { theme: 'system', font: '1' }; }
   }
   function savePref(k, v) { try { localStorage.setItem(k, v); } catch (e) {} }
   function applyThemePref(v) {
@@ -2651,24 +2730,149 @@ button.setrow{font-family:inherit}
   }
   /* 字体大小：组件尺寸是 px，改 root font-size 无效；用 body zoom 整体缩放（WebView 支持）。 */
   function applyFontPref(v) { try { document.body.style.zoom = (v && v !== '1') ? v : ''; } catch (e) {} }
-  function applyHapticPref(v) { window.MAGIC_HAPTICS = (v !== 'off'); }
   /* 任务模式：parallel（默认，全部并行）| serial（同一空间同时只跑一个新任务）。 */
   var TASK_MODE = 'parallel';
   try { TASK_MODE = localStorage.getItem('magic.taskmode') || 'parallel'; } 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); applyHapticPref(PREFS.haptic);
+  applyThemePref(PREFS.theme); applyFontPref(PREFS.font);
   paintRunPref();
   paintTeamPref();          // 团队配置卡片（能力位要到连上桌面后才亮，见 loadSessions）
 
   /* 挂 conversation：传输层由宿主注入，组件不连后端（见 CLIENT-CONTRACT.md 3.2.1）。
      sid 非空 = 打开该会话（组件会走 readSession 回放历史）；s = 该会话对象（标题取 prompt_head）；空 = 新会话。 */
+  /* 「同一个会话」要认 run_id ↔ session_id 的别名。
+     会话刚起（团队任务 / 新会话首轮）时清单里只有 run_id，session_id 是 core 首帧之后
+     才写回的；同一个会话因此会先后以两个 id 出现。只比字面会把「返回列表再点进来」
+     判成另一条会话 —— 组件被销毁、内存队列清空，排队的追问就整条消失
+     （2026-10-22 用户：「排队中的任务重新从会话列表进入就看不到了」）。 */
+  function sameConvId(a, b) {
+    if (!a || !b) return false;
+    a = String(a); b = String(b);
+    if (a === b) return true;
+    for (var i = 0; i < LAST_SESSIONS.length; i++) {
+      var s = LAST_SESSIONS[i];
+      var ids = [s.session_id, s.run_id].filter(Boolean).map(String);
+      if (ids.indexOf(a) >= 0 && ids.indexOf(b) >= 0) return true;
+    }
+    return false;
+  }
+  /* 这条会话里「已落库、还没轮到发」的条目，能接回组件的那些：
+       · owner==='conv' —— 组件内排队（见 queuePushed），主人就是组件；
+       · owner==='host' —— 重启恢复（restoreQueue）交给宿主的，但宿主**还没开始发**
+         （!p.dispatching）：用户这时点进会话，让组件接管更符合预期 ——
+         否则画布上永远不显示「排队中」，只有列表角标。
+     owner==='gate' 的绝不碰：那是串行门挡住的**当前这一轮**（气泡已由 fireTurn 画了），
+     由 beforeAsk 的 Promise 自己放行，接管会双发。 */
+  function pendingOfConv(sid) {
+    return PENDING.filter(function (p) {
+      if (p.gone || p.stalled || p.dispatching) return false;
+      if (p.owner !== 'conv' && p.owner !== 'host') return false;
+      return sameConvId(p.session, sid);
+    });
+  }
+  function adoptPendingFor(sid) {
+    if (!conv || typeof conv.adoptQueue !== 'function' || !sid) return 0;
+    /* ⚠️ 2026-10-23（用户：「排队的和自动建议发送串会话了」）：`p.session` **空**时不许接。
+       sameConvId('', sid) 这类「空串当通配」的匹配，正是把上一条会话的排队追问灌进
+       当前会话的入口 —— 新会话首句排队那一刻 state.session 还是空的，落库就是空串。
+       那种条目交给原主（enqueueDispatch 按 session 空 = 新会话下发），
+       不该被任何一条**已有 id 的会话**认领。 */
+    var list = pendingOfConv(sid).filter(function (p) { return !!p.session; });
+    if (!list.length) return 0;
+    var items = list.map(function (p) {
+      /* 接管：宿主那条 enqueueDispatch 在真正 fireQueued 之前会检查 owner，
+         看到它已归组件就放手（见 enqueueDispatch）—— 两边不会各发一次。 */
+      p.owner = 'conv';
+      /* 恢复出来的条目沿用**宿主持久化 id**：组件 take / drop 时回传的就是它，
+         宿主据此删对行（QPEND 里重新登记一次，值指向自己）。 */
+      QPEND[p.id] = p.id;
+      return {
+        id: p.id, prompt: p.prompt,
+        /* 归属会话要一并交给组件：它据此在发出前再核一次（见 flushQueue），
+           宿主这边的筛选只是第一道。 */
+        session: p.session,
+        attachments: (p.attachments || []).slice(),
+        atts: (p.atts || []).slice(),
+        hosted: !!p.hosted
+      };
+    });
+    try { return conv.adoptQueue(items) || 0; } catch (e) { return 0; }
+  }
+  function adoptAfterHistory(sid, s) {
+    var c = conv;
+    if (!c) return;
+    var p;
+    try { p = c.setSession(sid, s); } catch (e) { p = null; }
+    Promise.resolve(p).then(function () {
+      /* 迟到的历史：这期间用户可能已经切走 / 又换了会话 —— 不许把旧队列灌进新画布。 */
+      if (conv !== c || !sameConvId(sid, convSid)) return;
+      adoptPendingFor(sid);
+    });
+  }
+  /* 会话托管的开关：**按当前这条会话**落盘（用户 2026-10-23：「跟团队模式一样改成
+     挂在会话上，子会话继承，不再是全局」）。开关的权威值在这里，组件只执行。
+     reason 非空 = 组件自己暂停的（失败 / 被停 / 到上限 / 用户点了「托管中」标记），
+     这里要如实弹一句；宿主自己拨开关时由调用处给更具体的提示。 */
+  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) {
     /* 同一条会话、同一个空间：组件还活着，画面也还在 —— 直接把这一屏端回来。
        以前这里无条件 destroy() + create() + innerHTML=''，于是「返回列表 → 再点进来」
        每次都要重拉全量历史、重新建 DOM、重新回放（长会话 = 又慢又费流量）。
-       标题 / 引擎 / 模型交给组件的 setSession 同步（它对本会话是幂等的）。 */
-    if (conv && sid && sid === convSid && WS === convWs) {
-      try { conv.setSession(sid, s); } catch (e) {}
+       标题 / 引擎 / 模型交给组件的 setSession 同步（它对本会话是幂等的）。
+       ⚠️ 判「同一条会话」要认 run_id ↔ session_id 的别名（见 sameConvId）：
+          只比字面的话，团队任务/新会话在 session_id 回来前后拿到的是两个 id，
+          同一屏会被判成两条会话 → 销毁重建 → 内存里排队的追问连气泡一起消失
+          （2026-10-22 用户：「排队中的任务重新从会话列表进入就看不到了」）。 */
+    if (conv && sid && WS === convWs && sameConvId(sid, convSid)) {
+      convSid = sid;                    // 列表那边可能已经从 run_id 切到 session_id
+      /* 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;
     }
@@ -2677,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 用户：「非团队的串行排队也没落库」）：
@@ -2695,6 +2903,10 @@ button.setrow{font-family:inherit}
         onQueueTake: queueTaken,
         onQueueDrop: queueDropped,
         onPick: rememberRunPick,
+        /* 会话托管：开关初值按**这条会话**给（自己没有记录就沿父链继承，见 hostingOnFor）；
+           组件自己暂停时回调这里把这条会话的开关关掉。 */
+        hosting: hostingOnFor(sid, s),
+        onHostingChange: onHostingToggleFromConv,
         /* 团队模式：开关初值按**这条会话**给；配置是设备偏好（每轮现读，改配置立刻生效）。
            features 也给函数：能力清单是异步拉到的（/desk/health），
            查到之后开关才会亮出来，不必重新挂载组件。 */
@@ -2711,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先删除」）。现在点它给一句说明，而不是跳去一张只有一个占位符的页 ——
            原先那页的正文就是这句说明，页面本身没有承载任何数据。
@@ -2726,7 +2941,10 @@ button.setrow{font-family:inherit}
           }
         }
       });
-      if (sid) conv.setSession(sid, s);
+      /* 历史画完再把落库的排队条目接回画布（见 adoptPendingFor）：抢在回放之前插气泡，
+         会被组件的 clearThread 一起清掉；而且那一刻「这一轮还在不在跑」已经由
+         loadHistory / follow 落定，flush 的时机才是对的。 */
+      if (sid) adoptAfterHistory(sid, s);
       window.magicConv = conv;
     } catch (e) {
       var d = document.createElement('div');
@@ -2735,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; }` 会让「打开一条默认空间的会话」
@@ -2744,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 用户：「大的新建会话 空间应该是
@@ -2906,7 +3160,9 @@ button.setrow{font-family:inherit}
     });
   }
   /* ── 会话列表：**置顶 / 任务 / 空间** 三段（对齐截图）──
-     置顶：本地 pin（长按会话行切换）；任务：最近会话（默认前 8，可「展开更多」）；
+     置顶：本地 pin（长按会话行切换）+ **运行中自动临时置顶**（2026-10-22：跑着的那条
+           自己进「置顶」段，不写 PINNED，跑完自动归位；见 isAutoPinned）；
+     任务：最近会话（默认前 8，可「展开更多」）；
      空间：会话里出现过的 workspace（点行=按空间筛选任务，＋=在该空间新建）。 */
   var LAST_SESSIONS = [];
   var SEC_COLLAPSED = {};
@@ -2960,6 +3216,10 @@ button.setrow{font-family:inherit}
       return !(pk && pk !== sidOf(s));
     });
   }
+  /* 路径归一：只去尾部斜杠，不做 realpath —— 与 core 登记表里的 workspace 同一口径。
+     任务页 / 需求页共用（需求页已拆到 reqs.js，那边自带一份同名实现；这里留着
+     是因为 isRealSpaceDir / isTeamRunDir 还服务于任务页的空间分组）。 */
+  function reqNormDir(p) { return String(p || '').replace(/\/+$/, ''); }
   /* 一个目录算不算「空间」：得是**用户认得的工作区**。
      根目录 / 不是空间（哪怕历史上有会话在那儿跑过）—— 需求页显示它只会让人
      以为「/ 是个项目」（用户 2026-10-22：「没有空间的不需要」）。
@@ -3045,6 +3305,30 @@ button.setrow{font-family:inherit}
 
   function sidOf(s) { return s.session_id || s.run_id; }
   function isPinned(s) { return PINNED.indexOf(sidOf(s)) >= 0; }
+  /* 运行中会话**自动临时置顶**（2026-10-22 用户：「运行中的会话自动临时置顶」）：
+     判据只看当前是不是在跑（`statusOf === 'run'`），**不写 PINNED、不落 prefs** ——
+     跑完下一次 renderSessions 自然归位，用户自己的手动置顶关系一点不动。
+     子会话在跑也算：子行默认折叠在父块里，只提子行的话首屏根本看不见，
+     所以把父块一起提到「置顶」段（父行本身不跑时不画图钉，计数徽标会亮运行色，见 sessionRow）。
+     ⚠️ 与手动置顶分开判：手动置顶仍只认 PINNED，自动的只在排序 / 分段时叠加。 */
+  function isAutoPinned(s) {
+    if (!s) return false;
+    if (statusOf(s) === 'run') return true;
+    var kids = CHILD_OF[sidOf(s)] || [];
+    for (var i = 0; i < kids.length; i++) { if (statusOf(kids[i]) === 'run') return true; }
+    return false;
+  }
+  /* 列表分段用：手动置顶 ∪ 运行中自动置顶。 */
+  function isListPinned(s) { return isPinned(s) || isAutoPinned(s); }
+  /* 置顶段 / 搜索结果的排序：**人工置顶在前 → 运行中自动置顶 → 普通**，同类按 updated_at 倒序。
+     用户 2026-10-22 定稿：「应该在人工置顶的后面」—— 自动置顶只是临时把在跑的活提上来，
+     不能压过用户自己钉的会话；跑完 isAutoPinned 变 false，它回到普通分段。 */
+  function pinnedOrder(a, b) {
+    var ra = isPinned(a) ? 2 : (isAutoPinned(a) ? 1 : 0);
+    var rb = isPinned(b) ? 2 : (isAutoPinned(b) ? 1 : 0);
+    return (rb - ra)
+      || String(b.updated_at || b.started_at || '').localeCompare(String(a.updated_at || a.started_at || ''));
+  }
   function togglePin(s) {
     var id = sidOf(s), i = PINNED.indexOf(id);
     if (i >= 0) PINNED.splice(i, 1); else PINNED.unshift(id);
@@ -3090,10 +3374,46 @@ button.setrow{font-family:inherit}
       .then(function () { TITLES[id] = name; renderSessions(LAST_SESSIONS); })
       .catch(function (e) { window.alert('重命名失败：' + (e && e.message ? e.message : e)); });
   }
-  /* 删除：DELETE /desk/session/{id}（登记表记录 + 事件日志），然后刷新列表。 */
+  /* 删除一棵会话树：删主会话时，挂在它下面的**子任务会话**也要从本地列表一起消失。
+     服务端（session.Delete）已经级联删了登记记录 / 日志 / 标题 / 状态；这里只是不让
+     用户在看到下一次轮询刷新之前，还点得进那些已经不存在了的子行。
+     认亲按 run_id / session_id 双向别名折算（与 renderSessions 的 KEY2SID 同口径）：
+     子会话创建时主会话可能还没拿到 session_id，parent 指针里存的是 run_id。 */
+  function deleteClosureOf(id, list) {
+    var del = {};
+    del[id] = 1;
+    function mark(s) {
+      if (!s) return false;
+      var sid = sidOf(s);
+      if (!sid) return false;
+      var changed = !del[sid] || (s.run_id && !del[s.run_id]) || (s.session_id && !del[s.session_id]);
+      del[sid] = 1;
+      if (s.run_id) del[s.run_id] = 1;
+      if (s.session_id) del[s.session_id] = 1;
+      return changed;
+    }
+    (list || []).forEach(function (s) { if (del[sidOf(s)]) mark(s); });
+    var changed = true;
+    while (changed) {
+      changed = false;
+      (list || []).forEach(function (s) {
+        var sid = sidOf(s);
+        if (!sid || del[sid]) return;
+        var pk = parentKeyOf(s);
+        if (pk && del[pk]) changed = mark(s) || changed;
+      });
+    }
+    return del;
+  }
+  /* 删除：DELETE /desk/session/{id}（登记表记录 + 事件日志 + 子任务会话），然后刷新列表。 */
   function deleteSessionRow(s) {
     var id = sidOf(s);
-    if (!window.confirm('删除这个会话？此操作不可恢复。')) return;
+    /* 文案如实说明「会连子任务一起删」：这是物理删除，提示里不能只提主会话。 */
+    var kidCount = (CHILD_OF[id] || []).length;
+    var ask = kidCount
+      ? '删除这个会话及其 ' + kidCount + ' 个子任务会话？此操作不可恢复。'
+      : '删除这个会话？此操作不可恢复。';
+    if (!window.confirm(ask)) return;
     var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
     fetch(BASE + '/desk/session/' + encodeURIComponent(id), { method: 'DELETE', headers: hdr })
       .then(function (r) {
@@ -3101,10 +3421,11 @@ button.setrow{font-family:inherit}
         return r.json().catch(function () { return {}; });
       })
       .then(function () {
-        var i = PINNED.indexOf(id); if (i >= 0) { PINNED.splice(i, 1); savePinned(); }
-        if (TITLES[id]) { delete TITLES[id]; }
+        var del = deleteClosureOf(id, LAST_SESSIONS);
+        PINNED = PINNED.filter(function (pid) { return !del[pid]; }); savePinned();
+        Object.keys(TITLES).forEach(function (tid) { if (del[tid]) delete TITLES[tid]; });
         /* 本地移除 + 静默重绘：不走 loadSessions（那会先塞「读取中…」再重建 = 整页闪） */
-        LAST_SESSIONS = LAST_SESSIONS.filter(function (x) { return sidOf(x) !== id; });
+        LAST_SESSIONS = LAST_SESSIONS.filter(function (x) { return !del[sidOf(x)]; });
         renderSessions(LAST_SESSIONS);
       })
       .catch(function (e) { window.alert('删除失败：' + (e && e.message ? e.message : e)); });
@@ -3128,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"），其余**设备形状按来源端**
@@ -3215,20 +3548,30 @@ button.setrow{font-family:inherit}
   }
   /* 子会话（团队模式拆出的子任务，2026-10-22）：core 在 /desk/sessions 里给出
      parent_session_id / parent_run_id（见 internal/session 的 Record）。子任务是**普通会话**
-     （自己的登记 + 自己的日志，点进去看完整过程），列表里只做两件事：
+     （自己的登记 + 自己的日志，点进去看完整过程），列表里只做三件事：
        · 不占顶层一行 —— 缩进挂在主会话下面（CHILD_OF：父 key → 子会话数组）；
+       · 默认**折叠**（2026-10-23 用户：「列表中默认不展开显示子会话」）：父行只留一枚
+         计数徽标，点它才展开；展开状态按会话 id 记在 KIDS_OPEN 里，刷新列表不收回；
        · 不进「任务 / 空间」分组（它们的 workspace 是主会话里的任务目录，不该自成一个空间）。
      ⚠️ 父会话不在列表里（被删 / 老 core 没给父字段）→ 回落成顶层一行，
         宁可多一行也不能让子会话凭空消失。
      ⚠️ 主会话可能还没拿到 session_id，parent_session_id 同时给了 parent_run_id 兜底。 */
-  var CHILD_OF = {}, CHILD_IDS = {};
+  var CHILD_OF = {}, CHILD_IDS = {}, KIDS_OPEN = {};
   function parentKeyOf(s) { return (s && (s.parent_session_id || s.parent_run_id)) || ''; }
+  function kidsOpenOf(id) { return !!KIDS_OPEN[id]; }
+  function toggleKids(id) {
+    if (!id) return;
+    KIDS_OPEN[id] = !KIDS_OPEN[id];
+    renderSessions(LAST_SESSIONS);
+  }
   function sessionBlock(s) {
     var wrap = document.createElement('div');
     wrap.className = 'sblock';
     wrap.appendChild(s.pendingWait ? pendingRow(s) : sessionRow(s, !!CHILD_IDS[sidOf(s)]));
-    var kids = CHILD_OF[sidOf(s)] || [];
-    if (kids.length) {
+    var sid = sidOf(s);
+    var kids = CHILD_OF[sid] || [];
+    /* 默认不展开：只有用户点过父行上的计数徽标（KIDS_OPEN[sid]）才挂子行。 */
+    if (kids.length && kidsOpenOf(sid)) {
       var box = document.createElement('div');
       box.className = 'sblock__kids';
       kids.forEach(function (k) { box.appendChild(sessionRow(k, true)); });
@@ -3252,6 +3595,49 @@ button.setrow{font-family:inherit}
     col.appendChild(subEl);
     /* 排队与团队标记都不在这里做：两者都做在图标里（见 sessionIcon），行尾不再挂角标。 */
     b.appendChild(col);
+    /* 子会话计数徽标（默认折叠开关）：点一下展开 / 收回，**不触发打开会话**。
+       没有子会话的普通行不画它，保持列表干净；有子任务在跑时亮运行色 + 圆点，
+       这样折叠状态下也能看出「父会话下面还有活在跑」。 */
+    var kids = CHILD_OF[sid] || [];
+    if (!sub && kids.length) {
+      var kidsRunning = false;
+      for (var ki = 0; ki < kids.length; ki++) {
+        if (statusOf(kids[ki]) === 'run') { kidsRunning = true; break; }
+      }
+      var opened = kidsOpenOf(sid);
+      var chip = elSpan('srow__kids' + (opened ? ' is-open' : '') + (kidsRunning ? ' is-run' : ''));
+      chip.setAttribute('role', 'button');
+      chip.setAttribute('tabindex', '0');
+      chip.setAttribute('aria-expanded', opened ? 'true' : 'false');
+      chip.setAttribute('aria-label', (opened ? '收起 ' : '展开 ') + kids.length + ' 个子会话');
+      chip.title = kidsRunning
+        ? kids.length + ' 个子会话 · 有任务在跑（点' + (opened ? '收起' : '展开') + '）'
+        : kids.length + ' 个子会话（点' + (opened ? '收起' : '展开') + '）';
+      if (kidsRunning) chip.appendChild(elSpan('srow__kids-dot'));
+      chip.appendChild(elSpan('srow__kids-n', kids.length + ' 子会话'));
+      chip.appendChild(svgUse('#i-chev-r', 12));
+      var toggleKid = function (e) {
+        if (e) { e.preventDefault(); e.stopPropagation(); }
+        toggleKids(sid);
+      };
+      /* 父行有长按菜单与点击打开：徽标上的指针 / 点击事件都要截住，别让它们穿到父行。 */
+      chip.addEventListener('pointerdown', function (e) { e.stopPropagation(); });
+      chip.addEventListener('pointerup', function (e) { e.stopPropagation(); });
+      chip.addEventListener('click', toggleKid);
+      chip.addEventListener('keydown', function (e) {
+        if (e.key === 'Enter' || e.key === ' ') toggleKid(e);
+      });
+      b.appendChild(chip);
+    }
+    /* 运行中自动置顶的行带一枚小图钉（手动置顶由「置顶」分段说明，不重复画）：
+       只有**这行自己**在跑才画 —— 父行因某个子会话在跑而被提上来时，行上不画图钉
+       （计数徽标会亮运行色），否则会误读成「父会话在跑」。 */
+    if (run && !isPinned(s)) {
+      var autoPin = elSpan('srow__auto');
+      autoPin.title = '运行中 · 自动临时置顶（跑完自动归位）';
+      autoPin.appendChild(svgUse('#i-pin', 14));
+      b.appendChild(autoPin);
+    }
     var timeEl = elSpan('srow__time', run ? elapsedText(s) : fmtRel(s.updated_at || s.started_at));
     b.appendChild(timeEl);
     if (run) { RUN_ROWS[sid] = { subEl: subEl, timeEl: timeEl, s: s }; refreshProgress(sid); }
@@ -3373,7 +3759,10 @@ button.setrow{font-family:inherit}
 
     /* 搜索态：不分组、不出「分组视图」行，命中项平铺（对齐截图 2）。 */
     if (searching) {
-      var matched = query ? rows.filter(taskMatches) : rows;
+      var matched = (query ? rows.filter(taskMatches) : rows).slice();
+      /* 与分组列表同一口径：运行中的自动临时置顶排最前（搜索是临时态，跑完同样归位）。 */
+      /* 与分组列表同一口径：人工置顶在前，运行中的自动临时置顶紧随其后（搜索是临时态，跑完归位）。 */
+      matched.sort(pinnedOrder);
       if (!matched.length && query) {
         var miss = document.createElement('div'); miss.className = 'history__hint';
         miss.textContent = '没有匹配「' + TASK_QUERY + '」的任务。';
@@ -3389,9 +3778,11 @@ button.setrow{font-family:inherit}
       return;
     }
 
-    /* 置顶：只在这里显示；置顶项不再出现在「任务 / 空间」里（去重） */
-    var pinned = rows.filter(isPinned);
-    var rest = rows.filter(function (s) { return !isPinned(s); });
+    /* 置顶：手动 pin + **运行中自动临时置顶**（不写 PINNED，跑完归位）；
+       只在这里显示，置顶项不再出现在「任务 / 空间」里（去重）。 */
+    var pinned = rows.filter(isListPinned);
+    var rest = rows.filter(function (s) { return !isListPinned(s); });
+    pinned.sort(pinnedOrder);
 
     /* 任务：**不属于任何空间**的普通任务（且未置顶）+ 默认空间（不指定）的串行等待任务。
        显式选了空间的等待任务归到下面的「空间」组（用户 2026-10-20：「串行等待中的任务
@@ -3605,451 +3996,6 @@ button.setrow{font-family:inherit}
     if (e.key === 'Escape' && readerEl && !readerEl.hidden) { e.preventDefault(); closeReader(); }
   }, true);
 
-  /* ══════════ 需求页（会话自动聚合成的功能点文档）══════════
-     数据形状见 CLIENT-CONTRACT §3.4.1：{ok, root, workspaces[{id,dir,name,pending,memory,
-     modules:[{name,features:[{module,name,file,desc,points,conclusions,conclusion,
-     sources,has_final,final_preview,updated_at}]}],feature_count,last_consolidated_at,last_error}]}
-
-     三个口径（照抄契约，别自己发明）：
-       · 列表只读：`loadRequirements` 只打 GET /desk/requirements，**不触发归纳**；
-       · 「整理」才归纳：POST /desk/requirements/consolidate（可能跑几十秒，按钮态要变）；
-       · 一篇文档就是一个绝对路径：点行直接进既有阅读器（markdown，不另做渲染）。 */
-  var REQ_DATA = null;         // 最近一次清单（重画用，避免每次点都重新拉）
-  var REQ_BUSY = false;        // 「整理」进行中（防重复点击）
-  var REQ_BUSY_LABEL = '全部整理'; // 顶栏按钮的进行中文案（重渲染后要能恢复）
-  var REQ_OPEN = {};           // 工作区展开状态（key = 工作区 id），与会话列表的 WS_OPEN 同构
-  var REQ_ALIVE = null;        // 仍有会话的空间路径集合；null = 拿不到会话清单（不筛）
-  var REQ_DETAIL = null;       // 二级视图：{key: 工作区 key, mod: 模块名, ws: 工作区对象}
-  /* 路径归一：只去尾部斜杠，不做 realpath —— 与 core 登记表里的 workspace 同一口径。 */
-  function reqNormDir(p) { return String(p || '').replace(/\/+$/, ''); }
-
-  function reqFeatureRow(f) {
-    /* 一行 = 一个功能点，**照会话行的排布**做（图标 + 标题 / 副标题 / 右侧时间）：
-       标题（功能点名称）→ 归纳结论 / 需求描述 → 「N 需求点 · M 结论 · 来源 K」。
-       为什么优先结论：这一页要回答的是「这个功能定了什么」，不是「记录了多少条」。 */
-    var b = hEl('button', 'srow srow--req');
-    b.type = 'button';
-    var ico = hEl('span', 'srow__ico srow__ico--idle');
-    ico.appendChild(svgUse('#i-doc', 20));
-    b.appendChild(ico);
-    var col = hEl('span', 'srow__col');
-    col.appendChild(hEl('span', 'srow__t', f.name || '(未命名)'));
-    /* 先结论，再一句话描述，最后才是定稿预览。定稿预览是 markdown（可能带 `**目标**：`），
-       直接塞进这一行会把星号原样显示出来；有 desc 时它更适合当副标题。 */
-    var sub = f.conclusion || f.desc || f.final_preview || '';
-    if (sub) col.appendChild(hEl('span', 'srow__s', sub));
-    var meta = [];
-    if (f.points) meta.push(f.points + ' 需求点');
-    if (f.conclusions) meta.push(f.conclusions + ' 结论');
-    if (f.sources) meta.push('来源 ' + f.sources);
-    if (!f.has_final) meta.push('未定稿');
-    if (meta.length) col.appendChild(hEl('span', 'srow__s', meta.join(' · ')));
-    b.appendChild(col);
-    if (f.updated_at) {
-      var d = new Date(Number(f.updated_at) || 0);
-      if (!isNaN(d.getTime())) {
-        b.appendChild(hEl('span', 'srow__time',
-          (d.getMonth() + 1) + '-' + ('0' + d.getDate()).slice(-2)));
-      }
-    }
-    b.onclick = function () { openReader(f.file); };
-    return b;
-  }
-
-  /* 一级：空间目录。空间是行，模块缩进挂在空间下（树形），**功能点一律不画在这里**。
-     一级只回答「这个空间有哪几块、每块多少条」—— 需求一多时画功能点会把目录撑成长列表，
-     结构反而看不见了（2026-10-22 用户定稿：两级，一级只显示空间和模块）。
-     idx = 排序后的位次（0 = 需求条数最多的那个）。 */
-  function reqWorkspaceBlock(w, idx) {
-    var wrap = hEl('div', '');
-    var head = hEl('div', 'wsrow__head');
-    var key = w.id || w.dir || w.name || '';
-    var count = Number(w.feature_count) || 0;
-    /* 默认只展开**第一个**（需求条数最多的那个），其余折叠（用户 2026-10-22）：
-       空间一多，全展开就是一屏拉到底的长列表，什么结构都看不出来。
-       用户手动点过谁就按用户的来（REQ_OPEN 里有记录就不动它）。 */
-    var open = (REQ_OPEN[key] !== undefined) ? !!REQ_OPEN[key] : (idx === 0);
-    var tog = document.createElement('button');
-    tog.type = 'button'; tog.className = 'wsrow__open wsrow__open--req';
-    tog.appendChild(elSpan('wsrow__l', w.name || w.dir || w.id));
-    /* 模块数 + 功能点数：一行说清这个空间有多大，比只写空间名有用。
-       用**中性色**（不是 wsrow__badge 那枚 queued 紫）—— 那是「等待中」的语义色，
-       空间规模不是状态，套上会让人误以为这个空间在排队。 */
-    var mods = (w.modules || []).filter(function (m) { return (m.features || []).length; });
-    tog.appendChild(elSpan('wsrow__meta', mods.length + ' 模块 · ' + count + ' 条'));
-    /* 待整理条数做成徽标（与「等待中」同款）：折叠起来也看得见这个空间在长新需求。 */
-    if (w.pending > 0) tog.appendChild(elSpan('wsrow__badge', w.pending + ' 待整理'));
-    /* 未初始化 = 还没按空间目录生成过基线。老 core 不带 initialized 字段（undefined），
-       此时不提示 —— 不能把「不知道」画成「未初始化」。 */
-    if (w.initialized === false) tog.appendChild(elSpan('wsrow__badge wsrow__badge--init', '未初始化'));
-    var chev = elSpan('wsrow__chev' + (open ? ' is-open' : ''));
-    chev.appendChild(svgUse('#i-chev-r', 16));
-    tog.appendChild(chev);
-    tog.onclick = function () { REQ_OPEN[key] = !open; renderRequirements(); };
-    head.appendChild(tog);
-    /* 组头右侧的「整理」：只作用于这个空间（初始化它 / 归纳它的新会话）。 */
-    var sync = document.createElement('button');
-    sync.type = 'button'; sync.className = 'wsrow__sync'; sync.textContent = '整理';
-    sync.setAttribute('data-ws', key);
-    sync.onclick = function (ev) {
-      if (ev && ev.stopPropagation) ev.stopPropagation();
-      consolidateRequirements(w);
-    };
-    head.appendChild(sync);
-    wrap.appendChild(head);
-    if (!open) return wrap;
-
-    if (w.last_error) {
-      var err = hEl('div', 'history__hint', '上次整理失败：' + w.last_error);
-      err.style.color = 'var(--warning)';
-      wrap.appendChild(err);
-    }
-    var shown = 0;
-    (w.modules || []).forEach(function (m) {
-      var fs = (m.features || []);
-      if (!fs.length) return;
-      shown += fs.length;
-      /* 模块 = 目录里的一行（缩进 + 连接线归属到空间），点它进二级看需求列表。
-         未归类（name 为空）的老数据没有模块名可写 —— 这种情况直接不画这一行，
-         功能点仍能在二级里看到（core 把空 module 排在最后）。 */
-      if (!m.name) return;
-      var row = document.createElement('button');
-      row.type = 'button'; row.className = 'reqtree__mod';
-      row.appendChild(elSpan('reqtree__modname', m.name));
-      row.appendChild(elSpan('reqtree__modcount', String(fs.length)));
-      var go = elSpan('reqtree__modgo');
-      go.appendChild(svgUse('#i-chev-r', 16));
-      row.appendChild(go);
-      row.onclick = function () { openReqDetail(w, m.name); };
-      wrap.appendChild(row);
-    });
-    /* 空间还在但还没有文档：别画成一片空白，给出这一组的下一步（整理）。 */
-    if (!shown) {
-      var tip = Number(w.pending) > 0
-        ? '有 ' + w.pending + ' 条对话待整理'
-        : (w.initialized === false ? '还没有需求文档，点右侧「整理」按空间生成' : '还没有需求文档');
-      var hint = hEl('div', 'history__hint', tip);
-      hint.style.padding = '6px 12px 12px';
-      wrap.appendChild(hint);
-    }
-    return wrap;
-  }
-
-  /* 二级：某空间下**所有模块**的需求列表（用户 2026-10-22 定稿）。
-     进来的那个模块高亮，滚到它那儿；其余模块照常列出来 —— 需求之间有交叉，
-     只看当前模块会漏掉相关需求。 */
-  function reqDetailBlock(d) {
-    var w = d.ws;
-    var frag = document.createDocumentFragment();
-    (w.modules || []).forEach(function (m) {
-      var fs = (m.features || []);
-      if (!fs.length) return;
-      var sec = hEl('div', 'reqdetail__sec' + (m.name === d.mod ? ' reqdetail__sec--cur' : ''));
-      var mh = hEl('div', 'sechead');
-      mh.style.paddingLeft = '16px';
-      mh.appendChild(elSpan('sechead__t', (m.name || '未归类') + ' (' + fs.length + ')'));
-      sec.appendChild(mh);
-      fs.forEach(function (f) { sec.appendChild(reqFeatureRow(f)); });
-      frag.appendChild(sec);
-    });
-    if (!frag.childNodes.length) {
-      frag.appendChild(hEl('div', 'history__hint', '这个空间还没有需求文档'));
-    }
-    return frag;
-  }
-
-  /* 进二级：记下是哪个空间的哪个模块，渲染后滚到那个模块。 */
-  function openReqDetail(w, mod) {
-    var key = w.id || w.dir || w.name || '';
-    REQ_DETAIL = { key: key, mod: mod, ws: w };
-    renderRequirements();
-    /* 空间在两次渲染之间被删掉了（会话全删 → 空间联动消失）：
-       renderRequirements 会把 REQ_DETAIL 清空，这时别停在空白的二级页，退回目录。 */
-    if (!REQ_DETAIL) { hideAll(); reqsEl.hidden = false; tabbarEl.hidden = false; return; }
-    hideAll(); reqDetailEl.hidden = false; tabbarEl.hidden = true;
-    if (reqDetailTitle) reqDetailTitle.textContent = (w.name || w.dir || w.id) + ' · ' + mod;
-    /* 滚到当前模块：它高亮，但用户进来第一眼要看到的是自己点的那一块。 */
-    if (reqDetailListEl) {
-      var cur = reqDetailListEl.querySelector('.reqdetail__sec--cur');
-      if (cur && cur.scrollIntoView) cur.scrollIntoView({ block: 'start' });
-    }
-  }
-
-  /* 退二级回一级目录。 */
-  function closeReqDetail() {
-    REQ_DETAIL = null;
-    hideAll(); reqsEl.hidden = false; tabbarEl.hidden = false;
-    renderRequirements();
-  }
-
-  function renderRequirements() {
-    if (!reqListEl) return;
-    var data = REQ_DATA;
-    if (!data) return;
-    /* 空间清单与任务页对齐：**用与 collectSpaceKeys 同一套空间键过滤**
-       （用户 2026-10-22：「4个空间需求里显示的不一样」「会话中全部删除后需求中的空间还在
-       也要联动删除」）。没有文档的空间不再整块藏掉，而是留一个组头 + 「整理」按钮 ——
-       这样两页的空间数一致，也给了「这个空间还没生成需求」的入口。
-       拿不到会话/目录清单时（REQ_ALIVE=null）不筛。 */
-    var all = (data && data.workspaces) || [];
-    var list = all.filter(function (w) {
-      var dir = reqNormDir(w && w.dir);
-      /* 根目录 / 归一后是空串 —— 「!dir 就放行」的老写法会把它漏进来，
-         需求页于是出现一个叫「/」的假空间（用户 2026-10-22：「没有空间的不需要」）。
-         这里先卡一道：不是真空间目录的直接不画。 */
-      if (!isRealSpaceDir(dir)) return false;
-      return !REQ_ALIVE || !dir || !!REQ_ALIVE[dir];
-    });
-    /* 排序：**需求条数多的排前面**（用户 2026-10-22）。
-       core 给的顺序是「最后归纳时间倒序」，但那是给「最近在动的」用的；
-       需求页要回答的是「哪块需求最多」，条数多的才是用户要先看的那个。
-       条数一样时按名字排 —— 同一条数下顺序要稳定，不能每次刷新都在跳。 */
-    list.sort(function (a, b) {
-      var ca = Number(a && a.feature_count) || 0;
-      var cb = Number(b && b.feature_count) || 0;
-      if (ca !== cb) return cb - ca;
-      return String((a && a.name) || '').localeCompare(String((b && b.name) || ''));
-    });
-    /* 二级视图：只画这个空间的需求列表。空间可能已被会话删除联动掉
-       （list 里没有它）—— 那就退回一级目录，不要留一页空白。 */
-    if (REQ_DETAIL) {
-      var hit = null;
-      for (var i = 0; i < list.length; i++) {
-        if ((list[i].id || list[i].dir || list[i].name || '') === REQ_DETAIL.key) { hit = list[i]; break; }
-      }
-      if (!hit) { REQ_DETAIL = null; }
-      else {
-        REQ_DETAIL.ws = hit;
-        if (reqDetailTitle) reqDetailTitle.textContent = (hit.name || hit.dir || hit.id) + ' · ' + REQ_DETAIL.mod;
-        if (reqDetailListEl) reqDetailListEl.replaceChildren(reqDetailBlock(REQ_DETAIL));
-        if (REQ_BUSY) reqSetBusy(true, REQ_BUSY_LABEL);
-        return;
-      }
-    }
-    var frag = document.createDocumentFragment();
-    if (!list.length) {
-      /* 一个空间都没有（会话全删了 / 还没聊过）。 */
-      frag.appendChild(hEl('div', 'history__hint',
-        REQ_ALIVE
-          ? '还没有任何空间。在任务里聊几句，这里会按空间整理出功能点文档。'
-          : '还没有任何需求。在任务里聊几句，这里会自动整理出功能点文档。'));
-      reqListEl.replaceChildren(frag);
-      return;
-    }
-    /* 工作区顺序：上面已按需求条数排好（多的在前）。默认只展开第一个 ——
-       见 reqWorkspaceBlock 的 open 判定。 */
-    list.forEach(function (w, i) { frag.appendChild(reqWorkspaceBlock(w, i)); });
-    reqListEl.replaceChildren(frag);
-    /* 整理进行中切走再回来：新 DOM 的按钮默认是可点的，这里按当前状态重新置忙。 */
-    if (REQ_BUSY) reqSetBusy(true, REQ_BUSY_LABEL);
-  }
-
-  function loadRequirements(quiet) {
-    if (!reqListEl) return;
-    if (!quiet && !REQ_DATA) reqListEl.innerHTML = '<div class="history__hint">读取中…</div>';
-    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
-    var pReq = fetch(BASE + '/desk/requirements', { headers: hdr })
-      .then(function (r) {
-        if (r.status === 501) {
-          /* 老 core 没有这个能力位：**说清楚**，不要给一页空白
-             （空白看起来像「没有需求」，是最难查的一种）。 */
-          return r.json().then(function (e) { throw new Error((e && e.error) || '当前 core 不支持需求聚合'); });
-        }
-        if (!r.ok) throw new Error('HTTP ' + r.status);
-        return r.json();
-      });
-    /* 会话清单与空间目录：用来判断「这个空间在任务页还在不在」。
-       两者都允许失败 —— 拿不到就不筛空间（见 renderRequirements）。 */
-    var pSess = fetch(BASE + '/desk/sessions', { headers: hdr })
-      .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
-    var pDirs = fetch(BASE + '/desk/dirs', { headers: hdr })
-      .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
-    Promise.all([pReq, pSess, pDirs])
-      .then(function (a) {
-        var sess = a[1], dirs = (a[2] && a[2].dirs) || null;
-        if (Array.isArray(sess) || Array.isArray(dirs)) {
-          /* 与任务页**同一套空间键**（用户 2026-10-22：「4个空间需求里显示的不一样」
-             「会话中全部删除后需求中的空间还在 也要联动删除」「没有空间的不需要」）：
-               ① 根目录下的 magic-*   ② 自定义空间   ③ **顶层会话**的工作目录。
-             ⚠️ ③ 只能取**顶层**会话的 workspace：团队子代理的会话挂在父会话下面，
-             它们的工作目录是 /…/run-xxx/a1 这种临时目录 —— 任务页不把它们列成空间，
-             需求页照收就会多出一堆 a1/t1/tmp 假空间。
-             ⚠️ 根目录 / 与 /tmp 这类系统目录不是空间，哪怕历史上有会话在那儿跑过。 */
-          var alive = {};
-          (ROOT_DIRS || []).forEach(function (d) { if (d && d.path) alive[reqNormDir(d.path)] = 1; });
-          (dirs || []).forEach(function (d) {
-            if (d && d.path && String(d.name || '').indexOf('magic-') === 0) alive[reqNormDir(d.path)] = 1;
-          });
-          (CUSTOM_SPACES || []).forEach(function (p) { if (p) alive[reqNormDir(p)] = 1; });
-          topLevelSessions(sess).forEach(function (s) {
-            if (s && s.workspace && isRealSpaceDir(s.workspace)) alive[reqNormDir(s.workspace)] = 1;
-          });
-          REQ_ALIVE = alive;
-        } else {
-          REQ_ALIVE = null;   // 清单没拿到：不筛，宁可多显示
-        }
-        REQ_DATA = a[0] || { workspaces: [] };
-        renderRequirements();
-      })
-      .catch(function (e) {
-        if (quiet && REQ_DATA) return;      // 后台刷新失败不覆盖已有画面
-        reqListEl.innerHTML = '';
-        reqListEl.appendChild(hEl('div', 'history__hint', '读取需求失败：' + ((e && e.message) || e)));
-      });
-  }
-
-  /* 「整理」：手动触发一轮（POST /desk/requirements/consolidate）。
-     服务端按 state 判断走哪条路：
-       · 没初始化过 → 先按空间目录反推需求基线（首次可能跑几分钟，按钮要能等）；
-       · 已初始化   → 只消费上次整理之后的新会话。
-     入口有两个：
-       · 每个空间组头的「整理」——只整理这个空间（用户点哪个就是哪个，不猜）；
-       · 右上角「全部整理」——按空间逐个串行跑一遍，汇总结果（一键触发全部）。
-     两个入口都带「我的 → 默认引擎/模型」，服务端不再自动替换引擎。 */
-  function reqPostConsolidate(ws) {
-    var hdr = { 'Content-Type': 'application/json' };
-    if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
-    return fetch(BASE + '/desk/requirements/consolidate', {
-      method: 'POST', headers: hdr,
-      body: JSON.stringify({
-        workspace: ws || '',
-        engine: RUN_PREF.engine || '',
-        model: (RUN_PREF.engine && RUN_PREF.model) || ''
-      })
-    })
-      .then(function (r) { return r.json().then(function (d) { return { ok: r.ok, d: d }; }); })
-      .then(function (x) {
-        var d = x.d || {};
-        if (!x.ok) throw new Error(d.error || ('HTTP ' + (x.d && x.d.status)));
-        if (d.error) throw new Error(d.error);
-        return d;
-      });
-  }
-
-  /* 统一置忙：顶部主按钮 + 所有空间组头的「整理」一起禁用。
-     label 只改顶部；组头统一显示「整理中…」/「整理」，不各自变文案。
-     二级页那枚「整理」也跟着禁用 —— 归纳期间它和组头一样不能重复点。 */
-  function reqSetBusy(on, label) {
-    if (on) { if (label !== undefined) REQ_BUSY_LABEL = label; }
-    else REQ_BUSY_LABEL = '全部整理';
-    var btn = document.getElementById('btnReqSync');
-    if (btn) {
-      btn.disabled = !!on;
-      if (label !== undefined) btn.textContent = label;
-    }
-    var dbtn = document.getElementById('btnReqDetailSync');
-    if (dbtn) {
-      dbtn.disabled = !!on;
-      dbtn.textContent = on ? '整理中…' : '整理';
-    }
-    Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
-      b.disabled = !!on;
-      b.textContent = on ? '整理中…' : '整理';
-    });
-  }
-
-  function consolidateRequirements(target) {
-    if (REQ_BUSY || !target) return;
-    var ws = target.dir || target.id || '';
-    if (!ws) return;
-    var firstTime = target.initialized === false;
-    REQ_BUSY = true;
-    reqSetBusy(true, firstTime ? '初始化中…' : '整理中…');
-    var targetKey = target.id || target.dir || '';
-    var groupBtn = null;
-    Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
-      if (!groupBtn && targetKey && b.getAttribute('data-ws') === targetKey) groupBtn = b;
-    });
-    /* 点的是哪个空间，就只让哪个组头显示「初始化中…」；其它组头保持「整理中…」。 */
-    if (groupBtn) groupBtn.textContent = firstTime ? '初始化中…' : '整理中…';
-    reqPostConsolidate(ws)
-      .then(function (d) {
-        if (d.bootstrap) {
-          if (d.created || d.updated) toast('已按空间目录生成需求：新建 ' + (d.created || 0) + ' · 更新 ' + (d.updated || 0));
-          else toast('已按空间目录初始化：暂未识别到功能点');
-        }
-        else if (d.noop) toast('没有新的对话需要整理');
-        else if (d.updated || d.created) toast('整理完成：更新 ' + (d.updated || 0) + ' · 新建 ' + (d.created || 0));
-        else toast('整理完成');
-        loadRequirements(true);   // 后台刷新（不闪「读取中」）
-      })
-      .catch(function (e) { toast('整理失败：' + ((e && e.message) || e)); })
-      .then(function () {
-        REQ_BUSY = false;
-        reqSetBusy(false, '全部整理');
-      });
-  }
-
-  /* 全部整理：按空间串行跑，避免多个初始化同时读目录把机器拖垮。
-     顺序 = 有待整理的 → 未初始化的 → 其它（最近动过的仍在前），先做便宜/该做的。
-     每个空间单独一次 HTTP（各自 10 分钟超时）；某个失败不影响后面的。 */
-  function reqAllWorkspaces() {
-    var seen = {};
-    var list = ((REQ_DATA && REQ_DATA.workspaces) || []).filter(function (w) {
-      var key = w.dir || w.id || '';
-      if (!key || seen[key]) return false;
-      /* 会话已全部删除的空间不参与「全部整理」：否则又会把它重新生成出来。 */
-      var dir = reqNormDir(w.dir);
-      if (REQ_ALIVE && dir && !REQ_ALIVE[dir]) return false;
-      seen[key] = true;
-      return true;
-    });
-    function rank(w) {
-      if (Number(w.pending) > 0) return 0;
-      if (w.initialized === false) return 1;
-      return 2;
-    }
-    return list.sort(function (a, b) { return rank(a) - rank(b); });
-  }
-
-  function consolidateAllRequirements() {
-    if (REQ_BUSY) return;
-    var list = reqAllWorkspaces();
-    if (!list.length) {
-      toast('还没有可整理的空间');
-      return;
-    }
-    REQ_BUSY = true;
-    reqSetBusy(true, '整理中 0/' + list.length);
-    var i = 0, ok = 0, fail = 0, created = 0, updated = 0, firstErr = '';
-    function done() {
-      REQ_BUSY = false;
-      reqSetBusy(false, '全部整理');
-      loadRequirements(true);
-      if (fail) {
-        toast('全部整理完成：成功 ' + ok + ' · 失败 ' + fail + (firstErr ? '（' + firstErr + '）' : ''));
-      } else {
-        toast('全部整理完成：' + ok + ' 个空间 · 新建 ' + created + ' · 更新 ' + updated);
-      }
-    }
-    function step() {
-      if (i >= list.length) { done(); return; }
-      var w = list[i++];
-      REQ_BUSY_LABEL = '整理中 ' + i + '/' + list.length;
-      var btn = document.getElementById('btnReqSync');
-      if (btn) btn.textContent = REQ_BUSY_LABEL;
-      reqPostConsolidate(w.dir || w.id || '')
-        .then(function (d) {
-          ok++;
-          created += Number(d.created) || 0;
-          updated += Number(d.updated) || 0;
-        })
-        .catch(function (e) {
-          fail++;
-          if (!firstErr) firstErr = (e && e.message) || String(e);
-        })
-        .then(step);
-    }
-    step();
-  }
-  on('btnReqSync', function () { consolidateAllRequirements(); });
-  /* 二级视图的两个动作：返回一级目录 / 整理**当前这个空间**（不是全部空间 ——
-     二级页的作用域就是这个空间，标成「全部整理」会让人以为还是全局动作）。 */
-  on('btnReqDetailBack', function () { closeReqDetail(); });
-  on('btnReqDetailSync', function () {
-    if (!REQ_DETAIL || !REQ_DETAIL.ws) return;
-    consolidateRequirements(REQ_DETAIL.ws);
-  });
 
   function openHostSheet(title, build) {
     closeHostSheet();
@@ -4104,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');
@@ -4173,7 +4124,20 @@ 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 用它把排队气泡原样画回来 —— 只存路径的话恢复出来会丢图。 */
+              atts: (info.atts || []).slice(),
+              /* owner：谁负责把这一条真正发出去。
+                   'gate' = 串行门（gateAsk，放行后由这一轮自己下发）
+                   'host' = 宿主（restoreQueue / 重启恢复，见 enqueueDispatch）
+                   'conv' = 会话组件（组件内排队，轮到它时组件自己 flush）
+                 组件被销毁重建后，它的 owner='conv' 条目还留在 PENDING 里，由
+                 adoptPendingFor 接回新实例 —— 状态只能落在条目上，不能只存在组件内存。 */
+              owner: info.owner || 'gate',
               hide: !!hide, dev: devKey(), at: Date.now() };
     PENDING.push(p); saveQueue();
     if (!hide) renderSessions(LAST_SESSIONS);
@@ -4194,11 +4158,12 @@ button.setrow{font-family:inherit}
      （2026-10-21 用户：「非团队的串行排队也没落库」）。
      这里把它接进同一个 PENDING：进队即写 magic.serial.queue.v1、轮到就删行、取消就清盘。
      重开 App 后由 restoreQueue 直接下发（不挂会话页面，事件仍进会话日志，点开可回放）。 */
-  var QPEND = {};              // 组件条目 id（q…）→ 本端 PENDING id（p…）
+  var QPEND = {};              // 组件条目 id（q… / 重新接管后的 p…）→ 本端 PENDING id（p…）
   function queuePushed(info) {
     if (!info || !info.id || !info.prompt || QPEND[info.id]) return;
     /* hide：用户此刻就在会话里，气泡已经画出来了 —— 列表那条「等待中」延后
        PENDING_SHOW_MS 再出现（与 gateAsk 同一口径：空间本来就空闲时不会闪一条假排队）。 */
+    info.owner = 'conv';
     var p = addPending(wsKey(info.workspace), info, true);
     QPEND[info.id] = p.id;
     setTimeout(function () {
@@ -4243,7 +4208,10 @@ button.setrow{font-family:inherit}
                session: p.session || '',
                prompt: p.prompt || '', engine: p.engine || '', model: p.model || '',
                permission: p.permission || '', team: p.team || null,
-               attachments: p.attachments || [],
+               attachments: p.attachments || [], atts: p.atts || [],
+               /* owner 刻意不落盘：重启后所有残留条目都由 restoreQueue 交给宿主
+                  （enqueueDispatch），语义与 'host' 一致 —— 存下来反而会让「上次是
+                  组件排队」的那条永远等不到组件接管。 */
                dev: p.dev, at: p.at };
     });
     try { localStorage.setItem(QUEUE_KEY, JSON.stringify(others.concat(mineRows))); } catch (e) {}
@@ -4330,6 +4298,35 @@ button.setrow{font-family:inherit}
       check();
     });
   }
+  /* 宿主下发的**追问**要等原会话这一轮收尾（同一条会话不许并发两轮）。
+     与 waitForSlot 的区别：那条按**空间**串行、且只看 TASK_MODE；这条按**会话**，
+     并行模式也生效 —— 恢复一条「排在上一轮后面的追问」时，正是它在挡住并发。
+     sid 为空（新任务）直接放行；清单拿不到 / 会话已不在 / 等超上限也放行：
+     排队是**保护**不是**闸门**，不能因为探测失败把用户的任务永久卡住。 */
+  var SESSION_WAIT_MAX_MS = 30 * 60 * 1000;
+  function waitSessionIdle(sid) {
+    if (!sid) return Promise.resolve();
+    var t0 = Date.now();
+    return new Promise(function (resolve) {
+      function check() {
+        var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
+        fetch(BASE + '/desk/sessions', { headers: hdr })
+          .then(function (r) { return r.ok ? r.json() : null; })
+          .then(function (list) {
+            if (!Array.isArray(list)) { resolve(); return; }
+            var row = null;
+            for (var i = 0; i < list.length; i++) {
+              var s = list[i];
+              if (sidOf(s) === sid || s.session_id === sid || s.run_id === sid) { row = s; break; }
+            }
+            if (!row || !serialBusy(row) || Date.now() - t0 >= SESSION_WAIT_MAX_MS) { resolve(); return; }
+            setTimeout(check, SLOT_POLL_MS);
+          })
+          .catch(function () { resolve(); });
+      }
+      check();
+    });
+  }
   /* 排队行的出现时机：**进队即落库**（关 App 也不能丢，这是用户报障的正题）；
      列表上那条「等待中」行则由**是否真的要等**决定可见性（见 gateAsk 的 markWaiting）。
      这个常量只剩一处用处：组件内排队（queuePushed，同一会话上一轮还没收尾）在
@@ -4452,6 +4449,9 @@ button.setrow{font-family:inherit}
     var list = loadQueue();
     if (!list.length) return;
     list.sort(function (a, b) { return (a.at || 0) - (b.at || 0); });   // 按当时进队顺序
+    /* 重启恢复的条目一律归宿主下发：它们的主人（会话组件）已经不在了，
+       再标成 'conv' 就没人会认领（见 adoptPendingFor 的判据）。 */
+    list.forEach(function (p) { p.owner = 'host'; });
     PENDING = list;
     renderSessions(LAST_SESSIONS);
     list.forEach(function (p) { enqueueDispatch(p); });
@@ -4461,11 +4461,20 @@ button.setrow{font-family:inherit}
     var q = serialQ(ws);
     /* 重新尝试（用户点「未能启动」那条）：先把红字连原因一起摘掉，回到正常的排队态。 */
     if (p.stalled) { p.stalled = false; p.stalledReason = ''; renderSessions(LAST_SESSIONS); }
-    var mine = q.tail.then(function () { return waitForSlot(ws, q); }).then(function () {
-      /* 断线 / 还没配对：**留在队列里**，等下次连上再发 —— 不能当成「已下发」删掉。 */
-      if (!connected()) return false;
-      return fireQueued(p);
-    });
+    var mine = q.tail.then(function () { return waitForSlot(ws, q); })
+      /* 同一条会话同时只能跑一轮：宿主下发的「追问」必须等这一轮真的收尾。
+         并行模式（waitForSlot 直接放行）下尤其重要 —— 否则新进程和还在跑的那一轮
+         会同时往同一份会话日志里写，正文与思考区交错，是最难查的一类脏数据。 */
+      .then(function () { return waitSessionIdle(p.session); })
+      .then(function () {
+        /* 断线 / 还没配对：**留在队列里**，等下次连上再发 —— 不能当成「已下发」删掉。 */
+        if (!connected()) return false;
+        /* 等待期间用户点进了这条会话，组件已经把它接管回去了（adoptPendingFor 把 owner
+           改回 'conv'）→ 让组件自己 flush，宿主这里放手。不检查的话同一条会被发两次。 */
+        if (p.owner !== 'host') return false;
+        p.dispatching = true;        // 已交给 fireQueued：此后不许组件再接管（防双发）
+        return fireQueued(p);
+      });
     q.tail = mine.catch(function () { return false; });
     return mine.then(function (sent) {
       if (!sent) return;   // 没落盘：留在队列里（stalled），不删
@@ -4496,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();
@@ -4765,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 {
@@ -5140,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() {
@@ -5172,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');
@@ -5181,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 + ' 个模型') : '引擎默认'));
@@ -5206,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);
       });
     }
@@ -5316,11 +5430,46 @@ 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 () {
     if (!runSettingsPageEl.hidden) paintRunSettings();
   });
+  /* 需求页（reqs.js）：内容与逻辑不在本文件，这里只注入宿主能力并挂载一次。
+     getter 形式传 BASE/TOKEN/空间清单 —— 切环境后这些值会变，不能传快照。 */
+  if (window.MagicReqs && window.MagicReqs.mount) {
+    window.MagicReqs.mount({
+      rootEl: reqsEl,
+      detailEl: reqDetailEl,
+      hEl: hEl,
+      elSpan: elSpan,
+      svgUse: svgUse,
+      toast: toast,
+      openReader: openReader,
+      hideAll: hideAll,
+      setActive: setActive,
+      showRoot: function () {
+        hideAll();
+        reqsEl.hidden = false;
+        tabbarEl.hidden = false;
+        setActive('reqs');
+      },
+      showDetail: function () {
+        hideAll();
+        reqDetailEl.hidden = false;
+        tabbarEl.hidden = true;
+      },
+      getBase: function () { return BASE; },
+      getToken: function () { return TOKEN; },
+      getRootDirs: function () { return ROOT_DIRS; },
+      getCustomSpaces: function () { return CUSTOM_SPACES; },
+      getRunPref: function () { return RUN_PREF; },
+      isRealSpaceDir: isRealSpaceDir,
+      topLevelSessions: topLevelSessions
+    });
+  }
   Array.prototype.forEach.call(tabbarEl.querySelectorAll('.tab'), function (b) {
     b.onclick = function () {
       var t = b.getAttribute('data-tab');
@@ -5352,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);
@@ -5362,11 +5513,10 @@ button.setrow{font-family:inherit}
   if (segTheme) takeSeg(segTheme, 'magic.theme', function (v) { PREFS.theme = v; applyThemePref(v); });
   if (segFont) takeSeg(segFont, 'magic.font', function (v) { PREFS.font = v; applyFontPref(v); });
   if (segMode) takeSeg(segMode, 'magic.taskmode', function (v) { TASK_MODE = v; });
-  if (tglHaptic) tglHaptic.onclick = function () {
-    PREFS.haptic = (PREFS.haptic === 'off') ? 'on' : 'off';
-    savePref('magic.haptic', PREFS.haptic); applyHapticPref(PREFS.haptic);
-    tglHaptic.classList.toggle('is-on', PREFS.haptic !== 'off');
-  };
+
+  /* 会话托管（2026-10-23 起按会话）：入口在会话页 → 任务运行设置（见 btnRsHosting）。
+     「我的」里不再有全局开关 —— 曾经那枚 `tglHosting` 写的是设备级 `magic.hosting`，
+     改一条会话会把所有会话都改掉（用户 2026-10-23：「跟团队模式一样…不再是全局」）。 */
 
   /* ══════════ 网络代理（VPN 隧道）══════════
      把整机流量经隧道送到桌面端的 SOCKS5 出口：TUN → 内核 → 桌面端 → 互联网。