magic-agent 1.0.49 → 1.0.109

package/client-ui-mobile/index.html

@@ -41,6 +41,12 @@
   --ink:#F9FAFB; --ink-soft:#E5E7EB; --muted:#CBD5E1; --faint:#94A3B8;
   --border:rgba(255,255,255,.10); --subtle:#374151; --raised:#1F2937;
   --primary-action:#93C5FD; --on-primary-action:#111827;               /* primary = BrandBlueDark / onPrimary */
+  /* 底栏「＋」凹槽的两件套，**必须按主题分别给**（`--fab-well` 槽底，`--fab-notch` 接触影满强度色）：
+     槽底不能用 `--canvas` —— 那是「页面底色」，暗色下 #111827 比栏面 #1F2937 暗 14 阶，
+     整圈会读成一道黑箍（比浮起来更假）。槽底该是**栏面稍暗一档**的同一个色系：
+     暗色 #1F2937 → #1B2432（同色相压 4 阶），浅色 #FFFFFF → #EEF2F7（同色相压 8 阶，必须够，
+     因为 248/250/252 与 255 只差 7 阶，直接用 canvas 等于没画）。 */
+  --fab-well:#1B2432; --fab-notch:rgba(0,0,0,.22);
   --app-shadow:rgba(0,0,0,.45);
 
   /* 用户气泡 = surface/foreground：ZCode 的用户消息是**中性表面**不是品牌色气泡 */
@@ -60,11 +66,19 @@
   --tint-queued:rgba(139,92,246,.18); --queued:#8B5CF6;
 
   /* ── 掌天瓶绿液（可选令牌，shared/conversation.css 用 `var(--q-bottle*, 兜底)` 取）──
-     兜底那套绿是共享样式自带的，之所以这里还显式给一份：移动端的绿要跟 --running 同族的
-     鲜绿（#22C55E），而兜底那份偏薄荷（#34D27B），在深色底上会显得发灰。 */
-  --q-bottle-hi:#7DF3A8; --q-bottle:#22C55E; --q-bottle-lo:#0F7B3C;
-  --q-bottle-line:#94A3B8; --q-bottle-cork:#94A3B8;
-  --q-bottle-glow:rgba(34,197,94,.30); --q-bottle-shell:rgba(255,255,255,.03);
+     瓶是**玉**不是玻璃（见 conversation.js 的形制说明），所以颜色分两组：
+       · 玉胎 `--q-bottle-jade-hi / jade / jade-lo`：整只瓶的底色，**空处也是绿的**（薄玉）。
+         这三个是 rgba，浅底上必须更浓才不发白 —— 所以下面两套主题各给一份。
+       · 灵液 `--q-bottle-hi / / lo / deep`：液位以下的浓翠。
+       · `--q-bottle-line` 是轮廓（比玉胎深一档的绿）、`--q-bottle-rim` 是边光/液面亮线/气泡
+         （必须比 hi 更白，否则整只瓶会「发光过度」）、`--q-bottle-cork` 是木塞。
+     移动端的绿跟 --running 同族（#22C55E），兜底那份偏薄荷（#2ECB80），深色底上会发灰。 */
+  --q-bottle-hi:#7DF3A8; --q-bottle:#22C55E; --q-bottle-lo:#0F7B3C; --q-bottle-deep:#06371F;
+  --q-bottle-line:#43A06E; --q-bottle-rim:#D9FBE8; --q-bottle-cork:#8A7659;
+  --q-bottle-glow:rgba(34,197,94,.30);
+  --q-bottle-jade-hi:rgba(120,232,175,.44);
+  --q-bottle-jade:rgba(52,192,124,.46);
+  --q-bottle-jade-lo:rgba(8,96,60,.58);
 
   --r-card:16px; --r:12px; --r-full:999px;
   --font:-apple-system,BlinkMacSystemFont,"PingFang SC","Noto Sans CJK SC","Segoe UI",Roboto,system-ui,sans-serif;
@@ -83,6 +97,7 @@
     --ink:#111827; --ink-soft:#1F2937; --muted:#64748B; --faint:#94A3B8;
     --border:#E2E8F0; --subtle:#F1F5F9; --raised:#FFFFFF;
     --primary-action:#2563EB; --on-primary-action:#FFFFFF;
+    --fab-well:#EEF2F7; --fab-notch:rgba(15,23,42,.22);
     --app-shadow:rgba(15,23,42,.12);
     --bubble:#FFFFFF; --bubble-text:#111827;
     --code:#F1F5F9; --status-neutral:#E2E8F0; --status-neutral-text:#475569;
@@ -93,6 +108,13 @@
     --accent:#2563EB; --warning:#D97706; --success:#16A34A;
     --error-surface:#FEF2F2; --error-border:#FECACA; --error-text:#B91C1C; --error-icon:#DC2626;
     --running:#16A34A; --transitioning:#2563EB; --active:#D97706;
+    --running:#16A34A; --transitioning:#2563EB; --active:#D97706;
+    /* 浅底上玉胎要更浓：`.42` 那档实测会被冲成白瓷，读不出「翠」。浓到 .66 又像实心塑料。 */
+    --q-bottle-jade-hi:rgba(146,231,184,.62);
+    --q-bottle-jade:rgba(96,205,152,.60);
+    --q-bottle-jade-lo:rgba(40,152,104,.66);
+    --q-bottle-line:#37955F; --q-bottle-rim:#FFFFFF;
+    --q-bottle-glow:rgba(45,200,120,.20);
   }
 }
 /* 手动主题：在「我的」页显式选了才生效（属性选择器优先级高于上面的 :root / media） */
@@ -101,6 +123,7 @@ html[data-theme="light"]{color-scheme:light;
   --ink:#111827; --ink-soft:#1F2937; --muted:#64748B; --faint:#94A3B8;
   --border:#E2E8F0; --subtle:#F1F5F9; --raised:#FFFFFF;
   --primary-action:#2563EB; --on-primary-action:#FFFFFF;
+  --fab-well:#EEF2F7; --fab-notch:rgba(15,23,42,.22);
   --app-shadow:rgba(15,23,42,.12);
   --bubble:#FFFFFF; --bubble-text:#111827;
   --code:#F1F5F9; --status-neutral:#E2E8F0; --status-neutral-text:#475569;
@@ -111,12 +134,19 @@ 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;
+  /* 浅底上玉胎要更浓（同上一条注释） */
+  --q-bottle-jade-hi:rgba(146,231,184,.62);
+  --q-bottle-jade:rgba(96,205,152,.60);
+  --q-bottle-jade-lo:rgba(40,152,104,.66);
+  --q-bottle-line:#37955F; --q-bottle-rim:#FFFFFF;
+  --q-bottle-glow:rgba(45,200,120,.20);
 }
 html[data-theme="dark"]{color-scheme:dark;
   --canvas:#111827;
   --ink:#F9FAFB; --ink-soft:#E5E7EB; --muted:#CBD5E1; --faint:#94A3B8;
   --border:rgba(255,255,255,.10); --subtle:#374151; --raised:#1F2937;
   --primary-action:#93C5FD; --on-primary-action:#111827;
+  --fab-well:#1B2432; --fab-notch:rgba(0,0,0,.22);
   --app-shadow:rgba(0,0,0,.45);
   --bubble:#1F2937; --bubble-text:#F9FAFB;
   --code:#0F172A; --status-neutral:#374151; --status-neutral-text:#CBD5E1;
@@ -138,7 +168,18 @@ html[data-theme="dark"]{color-scheme:dark;
 /* ⚠️ 锁死视口高度而不是 min-height：否则滚动条落到 document 上，对话区不滚。 */
 html,body{margin:0;height:100%;overflow:hidden}
 body{background:var(--canvas);color:var(--ink);font:16px/1.5 var(--font);
-     overscroll-behavior:none;display:flex;flex-direction:column}
+     overscroll-behavior:none;display:flex;flex-direction:column;position:relative}
+/* 不显示滚动条（2026-10-22 用户：「不需要显示滚动条」）。
+   手机上没有常驻滚动条（系统只在滑动时浮出指示、停手即隐）；但本页也会进桌面那扇手机尺寸的
+   小窗（magic-test 悬浮球面板，Chromium），macOS 接了鼠标或设成「始终显示滚动条」时，
+   对话区 / 列表右缘各多出一根带轨道描边的 15px 竖条。这里与真机对齐：一律隐藏，
+   滚动能力不丢（滚轮 / 触控板 / 触摸照常）。
+   两套写法都写：scrollbar-width 管标准属性（Chromium 里它优先于 webkit 伪元素），
+   ::-webkit-scrollbar 兜不认标准属性的旧内核 / WebView。
+   ⚠️ !important 不能省：共享皮肤里有元素级的 `scrollbar-width:thin`（提问卡停靠位 .qa-askdock），
+   通配符的优先级压不过它，不加就会剩一根细条。 */
+*{scrollbar-width:none!important}
+*::-webkit-scrollbar{display:none!important;width:0!important;height:0!important}
 button{font:inherit;color:inherit;background:none;border:0;padding:0;cursor:pointer}
 svg{display:block}
 textarea{font:inherit}
@@ -150,6 +191,11 @@ textarea{font:inherit}
   padding:calc(env(safe-area-inset-top) + 20px) 20px calc(20px + env(safe-area-inset-bottom))}
 /* headlineSmall ≈ 24sp */
 .launcher__title{font-size:24px;font-weight:400;line-height:32px;margin:0;color:var(--ink)}
+/* 从「切换环境 → 添加连接」进来时的返回键：已连着桌面就别把用户困在启动页 */
+.launcher__back{position:absolute;top:calc(env(safe-area-inset-top) + 10px);left:12px;
+  display:flex;align-items:center;gap:2px;height:40px;padding:0 10px;border-radius:var(--r-full);
+  color:var(--primary-action);font-size:15px;font-weight:500}
+.launcher__back:active{background:var(--subtle)}
 /* 说明 bodyMedium（onSurfaceVariant） */
 .launcher__desc{margin:8px 0 0;font-size:14px;line-height:20px;color:var(--muted)}
 /* OutlinedTextField：1dp 描边 · 4dp 圆角（Material3 默认） */
@@ -167,15 +213,19 @@ textarea{font:inherit}
 .btn--filled{margin-top:12px;background:var(--primary-action);color:var(--on-primary-action)}
 .btn--outlined{margin-top:8px;border:1px solid var(--border);color:var(--primary-action)}
 .btn:active{opacity:.9}
-/* 最近连接列表：标题 outline + 每条 OutlinedButton（标题 bodyMedium + 副标题 labelSmall） */
+/* 已保存的连接（2026-10-22：由「最近连接」升级而来，可保存多台桌面并逐个删除） */
 .recent{margin-top:20px}
 .recent__head{display:flex;align-items:center}
 .recent__title{flex:1;font-size:14px;font-weight:600;color:var(--ink)}
 .recent__clear{color:var(--primary-action);font-size:13px;font-weight:600;padding:8px 12px}
-.recent__item{display:flex;flex-direction:column;gap:2px;width:100%;margin-top:8px;text-align:left;
+.recent__row{display:flex;align-items:stretch;gap:8px;margin-top:8px}
+.recent__item{display:flex;flex-direction:column;gap:2px;flex:1;min-width:0;text-align:left;
   border:1px solid var(--border);border-radius:20px;padding:10px 16px}
 .recent__t{font-size:14px;line-height:20px;color:var(--ink);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
 .recent__s{font-size:12px;line-height:16px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.recent__del{flex:0 0 auto;width:44px;border-radius:20px;border:1px solid var(--border);
+  display:flex;align-items:center;justify-content:center;color:var(--muted)}
+.recent__del:active{background:var(--subtle);color:var(--error-text)}
 
 /* ══════════ 会话页 RemoteControlWebViewScreen + TopBar（:517-644）══════════ */
 .session{flex:1;min-height:0;display:flex;flex-direction:column}
@@ -203,13 +253,28 @@ textarea{font:inherit}
   padding:calc(env(safe-area-inset-top) + 10px) 16px 8px}
 .history__title{flex:1;min-width:0;font-size:22px;font-weight:700;color:var(--ink);
   white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+/* 环境切换（2026-10-22 用户：「移动端要支持环境切换 可以有多个连接」）：
+   任务页标题本身就是切换入口 —— 点标题弹出已保存的环境，选中即切过去。
+   标题装的是**当前连接**的名字（扫码时带的 name > 桌面 health 报的 app > host）。 */
+.history__title--btn{display:flex;align-items:center;gap:6px;text-align:left}
+.history__title--btn>span{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.history__title-chev{flex:0 0 auto;color:var(--muted);transition:transform .15s}
+.history__title--btn.is-open .history__title-chev{transform:rotate(180deg)}
 .history__disconnect{color:var(--primary-action);font-size:14px;font-weight:500;padding:8px 10px}
+.history__disconnect:disabled{color:var(--muted);opacity:.6}
 .history__list{flex:1;min-height:0;overflow-y:auto;padding:4px 10px calc(96px + env(safe-area-inset-bottom))}
 .history__group{padding:12px 8px 6px;font-size:12px;font-weight:700;color:var(--muted)}
 .history__hint{padding:22px 12px;color:var(--muted);font-size:14px;text-align:center}
 .srow{display:flex;align-items:center;gap:12px;width:100%;padding:12px 8px;border-radius:14px;text-align:left}
 .srow:active{background:var(--subtle)}
 .srow--pending{cursor:default}
+/* 排队任务没能启动（core 起不来 / 被拒 / 迟迟没落盘）：不再呼吸，改成可点重试。
+   2026-10-21 用户：「团队模式会话没存档吗 刷新就没了」—— 从前这种情况条目会被静默删掉，
+   任务凭空消失；现在留在列表里，点一下就重新下发。 */
+.srow--stalled{cursor:pointer}
+.srow--stalled .srow__ico{background:var(--tint-wait);color:var(--warning)}
+.srow--stalled .srow__ico--queued::after{display:none}
+.srow--stalled .srow__s{color:var(--warning)}
 .srow__ico{flex:0 0 auto;width:44px;height:44px;border-radius:50%;background:var(--subtle);
   display:flex;align-items:center;justify-content:center;color:var(--ink);position:relative}
 /* 会话状态：用颜色区分（无角标、无描边） */
@@ -217,8 +282,19 @@ textarea{font:inherit}
 .srow__ico--wait{background:var(--tint-wait);color:var(--warning)}
 .srow__ico--done{background:var(--tint-done);color:var(--success)}
 .srow__ico--idle{background:var(--subtle);color:var(--muted)}
-/* 等待中（串行模式排队的新任务）：紫色，区别于其它状态 */
+/* 等待中（串行排队）：紫色 + 一圈**呼吸**的环。
+   与「运行中」的扫光刻意分开 —— 扫光在转（在动），这圈只明暗（在等）；
+   光靠颜色区分的话，绿色（已完成）与紫色（排队）在小屏上容易看混，
+   加一层「慢呼吸」就有了第二种线索。
+   ⚠️ 只有**一种**等待样式：新任务排队、以及会话有追问在排队，用的都是它
+   （2026-10-21 用户：「排队标志在会话左边的图标里设计 1 个等待样式即可」）。 */
 .srow__ico--queued{background:var(--tint-queued);color:var(--queued)}
+.srow__ico--queued::after{content:"";position:absolute;inset:-2px;border-radius:50%;pointer-events:none;
+  border:2px solid var(--queued);animation:srow-breathe 2.2s ease-in-out infinite}
+@keyframes srow-breathe{
+  0%,100%{opacity:.15}
+  50%{opacity:.55}}
+@media (prefers-reduced-motion: reduce){.srow__ico--queued::after{animation:none;opacity:.4}}
 /* 进行中：图标外围一圈圆形扫光（conic 渐隐光带，mask 挖空成环） */
 .srow__ico--run::after{content:"";position:absolute;inset:-3px;border-radius:50%;pointer-events:none;
   background:conic-gradient(from 0turn, transparent, var(--primary-action));
@@ -229,9 +305,49 @@ textarea{font:inherit}
 @media (prefers-reduced-motion: reduce){.srow__ico--run::after{animation:none}}
 .srow__col{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px}
 .srow__t{font-size:15px;font-weight:600;color:var(--ink);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.srow__s{font-size:12px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+/* 副标题：设备无关的一行文字（工程名或 引擎 · 模型），过长省略。 */
+.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）：**缩进挂在主会话下面**，不占顶层一行。
+   左侧一道竖线 + 小一档图标 —— 读起来是「这条主会话拆出去的活」；点开仍是它自己
+   那份完整过程（自己的日志）。行本身可点、可长按（重命名 / 删除同普通会话）。 */
+.sblock{min-width:0}
+.sblock__kids{margin:0 8px 6px 30px;padding-left:8px;border-left:2px solid var(--border)}
+.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}
+.srow--sub .srow__t{font-size:14px;font-weight:500}
+.srow--sub .srow__s,.srow--sub .srow__time{font-size:11px}
+/* 团队会话的标志（2026-10-21）：core 在 /desk/sessions 里给 mode:"team"。
+   不标的话，一条跑过 4 个子任务的会话在列表上与普通会话长得一模一样，
+   点进去却是一堆委派卡 —— 用户无从预期。
+   标志**就是图标本身**：团队会话的圆里换成「双人」图形，不再叠角标 ——
+   与排队标记同一套设计语言（一枚 20px 线图标 + 状态 tint 底，没有额外底色块），
+   --run / --queued 的外围状态环照旧生效。 */
+/* 任务页页头（2026-10-21）：标题 + 右侧搜索/头像胶囊 */
+.tasks__tools{display:flex;align-items:center;gap:2px;flex:0 0 auto;padding:3px;
+  border-radius:var(--r-full);background:var(--subtle)}
+.tasks__tools .topbar__icon{width:40px;height:40px}
+/* 「我的」头像是截图里那枚金色圆头像：比搜索键小一圈，仍是 40px 点击区里的 34px 视觉圆。 */
+.tasks__tools #btnTaskMe{width:34px;height:34px;margin:0 3px;border-radius:50%;
+  background:#E8DCB0;color:#4A3F1E}
+/* 搜索态：输入框 + 关闭（搜索时隐藏快捷入口与分组行，结果平铺） */
+.tasks__search{display:flex;align-items:center;gap:8px;flex:0 0 auto;padding:2px 16px 8px}
+/* 搜索态就是截图 2 那一屏：标题行让位给搜索框（✕ 在框外，与截图一致）。 */
+#history.is-searching .history__top{display:none}
+#history.is-searching .tasks__search{padding-top:calc(env(safe-area-inset-top) + 8px)}
+#history.is-searching .history__actions{display:none}
+.tasks__searchbox{flex:1;display:flex;align-items:center;gap:8px;min-width:0;height:46px;
+  padding:0 14px;border-radius:var(--r-full);background:var(--subtle);color:var(--muted)}
+/* 原生 search 的清空叉会和右侧的关闭按钮打架，藏掉（清空由用户自己退格）。 */
+.tasks__searchbox input::-webkit-search-cancel-button{-webkit-appearance:none;appearance:none}
+.tasks__searchbox input{flex:1;min-width:0;border:0;background:transparent;color:var(--ink);
+  font-family:inherit;font-size:16px;outline:none}
+.tasks__searchbox input::placeholder{color:var(--muted)}
+.tasks__searchx{flex:0 0 auto;width:44px;height:44px;border-radius:var(--r-full);
+  display:flex;align-items:center;justify-content:center;color:var(--ink)}
+.tasks__searchx:active{background:var(--subtle)}
 .history__actions{padding:2px 16px 8px}
 .newtask{display:flex;align-items:center;justify-content:center;gap:8px;width:100%;height:44px;border:1px solid var(--border);border-radius:var(--r-full);background:var(--raised);color:var(--ink);font-size:15px;font-weight:500}
 .newtask:active{background:var(--subtle)}
@@ -241,8 +357,6 @@ textarea{font:inherit}
 .sechead__chev.is-open{transform:rotate(90deg)}
 .sechead__x{color:var(--muted);font-size:12px;padding:0 4px}
 .more{padding:10px 8px;color:var(--primary-action);font-size:13px;font-weight:500;text-align:left}
-.srow__pin{flex:0 0 auto;color:var(--faint);display:inline-flex}
-.srow__pin.is-on{color:var(--primary-action)}
 .wsrow__head{display:flex;align-items:center;gap:4px;padding:2px 0}
 .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)}
@@ -254,6 +368,15 @@ 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)}
 /* 长按会话行的浮动菜单 */
 .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}
@@ -262,6 +385,30 @@ textarea{font:inherit}
 .rowmenu__item:active{background:var(--subtle)}
 .rowmenu__item--danger{color:var(--error-text)}
 .rowmenu__l{flex:1;min-width:0}
+/* 环境切换菜单（挂在任务页标题下）：已保存的连接 + 「添加连接」。
+   与会话行长按菜单同一套浮层范式（scrim 挡住下层，点空白即关）。 */
+.envmenu{position:fixed;z-index:1201;width:min(320px,calc(100vw - 24px));
+  background:var(--raised);border:1px solid var(--border);border-radius:18px;
+  box-shadow:0 18px 44px -14px var(--app-shadow);padding:6px}
+.envmenu__scrim{position:fixed;inset:0;z-index:1200}
+.envmenu__head{padding:10px 12px 6px;font-size:12px;font-weight:700;letter-spacing:.04em;color:var(--muted)}
+.envmenu__item{display:flex;align-items:center;gap:12px;width:100%;padding:11px 12px;
+  border-radius:12px;text-align:left}
+.envmenu__item:active{background:var(--subtle)}
+.envmenu__ico{flex:0 0 auto;width:38px;height:38px;border-radius:50%;background:var(--subtle);
+  display:flex;align-items:center;justify-content:center;color:var(--ink)}
+.envmenu__col{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px}
+.envmenu__t{display:flex;align-items:center;gap:8px;min-width:0;font-size:15px;font-weight:600;color:var(--ink)}
+.envmenu__name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.envmenu__badge{flex:0 0 auto;padding:1px 8px;border-radius:var(--r-full);
+  font-size:11px;font-weight:600;line-height:17px;color:var(--primary-action);background:var(--subtle)}
+.envmenu__s{font-size:12px;line-height:16px;color:var(--muted);
+  white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.envmenu__check{flex:0 0 auto;color:var(--primary-action)}
+.envmenu__sep{height:1px;margin:6px 4px;background:var(--border)}
+.envmenu__add{display:flex;align-items:center;gap:10px;width:100%;padding:12px;border-radius:12px;
+  font-size:15px;font-weight:500;color:var(--primary-action);text-align:left}
+.envmenu__add:active{background:var(--subtle)}
 /* toast（没有通知能力时的兜底提示） */
 .toast{position:fixed;left:50%;bottom:calc(92px + env(safe-area-inset-bottom));transform:translateX(-50%);
   max-width:82vw;padding:10px 14px;border-radius:12px;background:var(--raised);color:var(--ink);
@@ -313,6 +460,22 @@ button.setrow{font-family:inherit}
 .setrow__l{flex:1;min-width:0;font-size:15px;color:var(--ink)}
 .setrow__v{flex:0 0 auto;font-size:14px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:50%}
 .setrow--danger{color:var(--error-text)}
+.setrow--danger .setrow__l,.setrow--danger .setrow__v{color:var(--error-text)}
+/* 两行式配置行（团队模式）：左列是「名字 + 这条适合什么」，右列是引擎。
+   规则描述必须常显 —— 用户要的是「每类适合什么」一眼可见，而不是藏进详情页。 */
+.setrow__main{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px}
+.setrow__sub{font-size:12px;color:var(--faint);line-height:1.45;display:-webkit-box;-webkit-line-clamp:2;
+  -webkit-box-orient:vertical;overflow:hidden}
+/* 团队规则编辑：抽屉里的文本框（textarea 不继承 .history__hint 的行高/颜色） */
+.teamedit{width:100%;min-height:76px;margin:6px 0 8px;padding:10px 12px;border-radius:10px;resize:vertical;
+  background:var(--subtle);border:1px solid var(--border);color:var(--ink);
+  font:13px/1.55 -apple-system,BlinkMacSystemFont,"PingFang SC",sans-serif;-webkit-appearance:none}
+.teamedit::placeholder{color:var(--faint)}
+.teamedit__acts{display:flex;gap:8px;margin-bottom:10px}
+/* 团队抽屉里的分区标题（规则 / 交给谁）与行尾箭头：点开才有的配置必须看得出「这里能点」。 */
+.pick__cap--team{padding:10px 4px 4px;font-size:11px;font-weight:700;letter-spacing:.04em;color:var(--muted)}
+.setrow__chev{flex:0 0 auto;color:var(--faint);font-size:16px;line-height:1}
+.pick__cols--team{height:min(36vh,36dvh,300px)}
 .seg{display:inline-flex;background:var(--subtle);border-radius:var(--r-full);padding:2px;gap:2px}
 .seg__b{height:28px;padding:0 12px;border-radius:var(--r-full);font-size:13px;color:var(--muted)}
 .seg__b.is-on{background:var(--raised);color:var(--ink);font-weight:600}
@@ -322,14 +485,121 @@ button.setrow{font-family:inherit}
 .tgl.is-on::after{left:23px}
 
 /* ══════════ 底部 Tab ══════════ */
-.tabbar{flex:0 0 auto;display:flex;border-top:1px solid var(--border);background:var(--raised);
+/* 底栏**浮在内容之上**（2026-10-22 用户：「tab 跟会话列表一样是浮在上面」「不要挤压对话框」）：
+   不再作为 flex 子项占位，改成 absolute 覆盖层 —— 内容（会话列表 / 对话）一直铺到屏幕底，
+   从栏背滚过去，靠半透明 + 18px 模糊透出来。这样栏高不进布局，会话页的输入框也不用被它顶上去。
+
+   代价是**每一页自己留出底部安全距离**，否则最后一行会被压在栏下面：
+     · `.history__list` 已有 96px（够 74 + 34 safe-area）
+     · 会话页由 composer 的下内边距负责，见下面的 `#conv .composer`
+     · 启动页不显示底栏（showLauncher 里 hidden），无需留白
+
+   min-height 而不是 height：底栏还要吞 safe-area（34px），
+   border-box 下固定 height 会让内部 tab 被压到 26px 高、图标文字挤成一团。
+   **74**（2026-10-22 定稿）：68 时图标 23 + 选中浅底 28 + 标签 12 ≈ 50，上下只剩 18px；
+   74 给到上下各约 21px，选中浅底才有完整的一圈呼吸，不会被栏边切掉。 */
+.tabbar{position:absolute;left:0;right:0;bottom:0;z-index:60;
+  display:flex;align-items:stretch;
+  min-height:74px;
+  background:color-mix(in srgb,var(--raised) 86%,transparent);
+  -webkit-backdrop-filter:blur(18px) saturate(1.4);backdrop-filter:blur(18px) saturate(1.4);
+  box-shadow:0 -1px 0 var(--border),0 -14px 30px -26px var(--app-shadow);
   padding-bottom:env(safe-area-inset-bottom)}
 .tab{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:3px;
-  height:56px;color:var(--muted);font-size:11px}
+  padding:6px 0;
+  color:var(--muted);font-size:10.5px;letter-spacing:.02em;transition:color .16s}
 .tab.is-on{color:var(--primary-action)}
-.tab svg{display:block}
-/* 有底部 tab 时，composer 不再自己叠加安全区（tab 已承担） */
-#conv .composer{padding-bottom:14px}
+/* 选中态不只换颜色，还给一块 38×28 的浅底（`--activity` 是现成的品牌色低透明令牌）：
+   颜色是给"看得清"的，形状是给"摸得到"的 —— 暗色下主色是浅蓝，光靠颜色区分太弱。 */
+.tab .icw{display:grid;place-items:center;width:38px;height:28px;border-radius:9px;
+  transition:background .18s ease}
+.tab.is-on .icw{background:var(--activity)}
+.tab .lb{line-height:1.15;transition:font-weight .16s}
+.tab.is-on .lb{font-weight:600}
+.tab svg{display:block;transition:transform .16s}
+.tab:active svg{transform:scale(.92)}
+/* ── 「快速新建」：**半嵌入**底栏的圆形主按钮（2026-10-22 定稿）
+   用户看完实机截图后的原话：「半嵌入式才对 要融合感更强」。
+
+   先说清楚「嵌」在视觉上到底靠什么成立 —— 这是前七版全部翻车的地方：
+   它**不是**靠按钮长得像半个（拱门/布片都不像），也**不是**靠给按钮加阴影
+   （外投影=浮起来，最典型的反效果），更**不是**靠按钮外面套一圈比它大的洞
+   （那是「放在一个盘子里」，不是「坐进槽里」）。
+
+   唯一成立的条件是一条：**按钮和底栏的接触边缘，必须比四周暗。**
+   光从上方来 → 按钮挡住光 → 它和槽壁相贴的那一圈落在阴影里；
+   阴影从接触处向**外**逐渐淡掉。方向反了就一定是光晕：
+   前几版用 `inset` 阴影，把亮度峰值放在了紧贴按钮的一圈（实测像素 246→220 由亮到暗），
+   于是看起来像按钮自带发光轮廓。
+
+   实现：
+     ① **洞**：`::before` 是一块悬在栏顶边界内的半圆（宽 38*2 / 高 38，下两角半径 38），
+        填槽底 `--fab-well`，在底栏上边缘切出一个半圆缺口。
+        高度只到 38，**不侵入上方内容**（试过 78px 整圆，会盖住列表底部）。
+     ② **嵌**：按钮直径 60，圆心落在栏顶边线上（上露 30 / 下沉 30），
+        于是下半实打实坐进洞里。圆心压边线而不是抬高，是「嵌」与「放」的分界。
+     ③ **接触影**：`radial-gradient` 把暗环**锚定在 r=30（按钮半径）**上，
+        从 29.5px 起最暗、到 33px 淡完。这是唯一能精确控制「暗在哪一圈」的写法 ——
+        `box-shadow: inset` 的暗边永远从元素边界向内，管不到元素外的那道槽。
+        实测梯度（正下方）：浅色 189→237→255，暗色 21→27→31，两端都单调、无回亮。
+   几何全用相对量（`bottom:calc(100% - 30px)`、`top:0`），安全区变化时洞和按钮一起走。 */
+.tabfab{flex:0 0 76px}
+/* 洞 = 半圆 + 接触影。
+   槽底是 `--fab-well`（栏面稍暗一档的**同色系**），不是 `--canvas`：
+   用页面底色在暗色下会成黑箍，在浅色下又几乎看不见 —— 两头都不对。
+   接触影必须画在槽底**之上**，且暗环两端用硬锚点，
+   避免模糊半径把亮度峰值推到按钮外面（那正是前几版读成光晕的原因）。
+
+   **露出的槽宽只有 3px**（洞半径 33 − 按钮半径 30）。曾经用 38（露 8px）：
+   那圈灰色槽底读作「按钮下面垫了个盘子」，正是用户否掉的形态。
+   3px 只够出一条接触缝 —— 看得见槽、看不清槽底，就等于"切出来的"。
+   洞的高也取 33 而不是更深：槽只要在栏顶边界内切出缺口，深了只是浪费。 */
+.tabbar::before{content:"";position:absolute;z-index:1;pointer-events:none;
+  left:50%;top:0;transform:translateX(-50%);
+  width:66px;height:33px;
+  border-radius:0 0 33px 33px;
+  background:
+    radial-gradient(circle 33px at 50% 0,
+      var(--fab-notch) 29.5px,
+      var(--fab-notch) 30.5px,
+      color-mix(in srgb,var(--fab-notch) 35%,transparent) 32px,
+      transparent 33px),
+    var(--fab-well)}
+.tabfab__b{position:absolute;z-index:2;
+  left:50%;bottom:calc(100% - 30px);              /* 圆心钉在栏顶边线上：上露 30 / 下沉 30 */
+  transform:translateX(-50%);
+  width:60px;height:60px;
+  display:flex;align-items:center;justify-content:center;
+  color:var(--on-primary-action);
+  background:linear-gradient(178deg,rgba(255,255,255,.14),rgba(255,255,255,0) 60%),var(--primary-action);
+  border:0;border-radius:50%;
+  box-shadow:
+    inset 0 -7px 13px -7px rgba(15,23,42,.50),     /* 下半圈内侧暗边：光从上来 → 这一圈在阴影里 */
+    inset 0 3px 3px -2px rgba(255,255,255,.34);    /* 上半圈内侧亮边：受光面 */
+                                                  /* 没有外投影：嵌进去的东西不在平面上留影子 */
+  transition:transform .14s ease, box-shadow .14s ease}
+.tabfab__b:active{transform:translateX(-50%) translateY(2px);
+  box-shadow:inset 0 -6px 12px -7px rgba(15,23,42,.56), inset 0 2px 3px -2px rgba(255,255,255,.26)}
+.tabfab__b svg{display:block;stroke-width:2.4;transform:translateY(-1px)}
+/* 会话页（2026-10-22 用户：「不要挤压对话框」「tab 跟会话列表一样是浮在上面」）：
+   底栏浮起后不再占位，composer 只需让出「栏高 + 安全区 + 12px 呼吸」——
+   输入框贴着栏上沿 12px。原来 composer 下留 60（= ＋上探 30 + 呼吸 30），再叠上占位的 68 栏，
+   屏幕底到输入框一共 162；现在 74 + 34 + 12 = 120，对话区多出 42px，也再没有那段死区。
+   74 必须与 .tabbar 的 min-height 对齐（改栏高要一起改）。
+   **只叠一次**：safe-area 由这里一次性算进来，别再给 .composer 的基础 padding 加一遍。 */
+#conv .composer{padding-bottom:calc(12px + 74px + env(safe-area-inset-bottom))}
+
+/* 会话页的「＋」收进槽里（不上浮）：
+   输入框离栏只剩 12px，骑在边线上的 ＋ 会顶到输入框下沿；而且这一屏已经有 composer
+   左侧的附件「＋」，两个浮起的圆会让"哪个是新建"含混。
+   只改**高度关系**，不改颜色 / 水平位置：圆仍钉在正中，从"骑在边线上"变成"坐在栏里"。
+   直径 60 → 56 是跟着 74 的栏高走的（上下各留 9px），不是"缩小来躲"。 */
+body.is-conv .tabbar::before{display:none}
+body.is-conv .tabfab__b{width:56px;height:56px;bottom:calc(env(safe-area-inset-bottom) + 9px);
+  box-shadow:
+    inset 0 -6px 11px -6px rgba(15,23,42,.42),
+    inset 0 2px 2px -2px rgba(255,255,255,.28),
+    0 6px 14px -8px rgba(15,23,42,.35)}
 
 /* 组件挂载点：占满剩余高度 */
 #conv{flex:1;min-height:0;display:flex}
@@ -387,6 +657,21 @@ button.setrow{font-family:inherit}
 .notice{border-radius:12px}
 .conv__empty{font-size:14px;line-height:1.75}
 
+/* 任务列表卡（团队模式一条应答里唯一那块，见 shared/conv 的 todoList）：
+   共用皮肤给的是桌面字阶（10–11.5px 的汇总头与行），手机上偏小 —— 本壳按自己
+   14 / 13.5px 那一档抬一档；结构与状态色仍归 shared/conv/conv.css。 */
+.qa-todo-panel{border-radius:14px;background:var(--raised)}
+.qa-todo-panel .qa-todo-hd{height:42px;padding:0 12px;gap:8px}
+.qa-todo-tt{font-size:14px;font-weight:600}
+.qa-todo-sum{font-size:11.5px}
+.qa-todo-list{padding:8px 12px 10px}
+.qa-todo-row{gap:9px;padding:5px 0;font-size:13.5px;line-height:1.5}
+.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-toggle{width:26px;height:26px}
+.qa-todo-toggle svg{width:14px;height:14px}
+
 /* 底部安全区：iPhone 的 home indicator 会压住输入框 */
 .composer{padding-bottom:calc(16px + env(safe-area-inset-bottom))}
 
@@ -410,33 +695,72 @@ button.setrow{font-family:inherit}
 /* 阅读页比对话流再大一号（手机上看文档，12.5px 偏小） */
 .reader__body .md-body{font-size:14px;line-height:1.75}
 
+/* 图片大图浮层：缩略图（移动端只取 480 宽）点开看原图。
+   黑底单张 contain、点任意处关闭 —— 手机上看细节的默认动作就是「点开、再点走」。
+   z-index 压过 .reader(1100)：从文档里点图也要能盖上去。 */
+.imgview{position:fixed;inset:0;z-index:1250;background:rgba(0,0,0,.94);
+  display:flex;align-items:center;justify-content:center;
+  padding:calc(12px + env(safe-area-inset-top)) 8px calc(12px + env(safe-area-inset-bottom))}
+.imgview[hidden]{display:none}
+.imgview img{max-width:100%;max-height:100%;width:auto;height:auto;object-fit:contain;
+  -webkit-user-select:none;user-select:none;-webkit-touch-callout:none}
+.imgview__x{position:absolute;top:calc(10px + env(safe-area-inset-top));right:12px;
+  width:36px;height:36px;border:none;border-radius:50%;background:rgba(255,255,255,.16);
+  color:#fff;font-size:16px;line-height:1}
+.imgview__nm{position:absolute;left:0;right:0;bottom:calc(14px + env(safe-area-inset-bottom));
+  padding:0 24px;text-align:center;color:rgba(255,255,255,.72);font-size:12px;
+  overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+
 /* ══════════ 启动闪屏：掌天瓶灌绿液（2026-10-20 用户：「app 启动动画也要有绿液」）══════════
    盖住整页，瓶居中，绿雾在后。灌满后整屏淡出（`.is-out`），由下面的 JS 在最迟 1.6s 摘掉。
    只用 transform / opacity：出现时主线程正在跑首屏初始化，动 layout 会把自己卡住。
    `pointer-events:none` 写在 `.splash` 上：闪屏是动画不是弹窗，不能拦掉点击。 */
-.splash{position:fixed;inset:0;z-index:2000;display:flex;flex-direction:column;
-  align-items:center;justify-content:center;gap:18px;pointer-events:none;
+/* ══════════ 启动闪屏：掌天瓶灌绿液 ══════════
+   **瓶身必须与原生启动屏逐像素对齐**，否则两段动画之间会"腰斩"：
+   原生那帧画 52×84dp 的瓶子，WebView 接上来只有一半大 —— 看起来像瓶子猛地缩了一下。
+   （2026-10-22 用户：「启动动画非常奇怪」。实测 170px → 85px，正好 2 倍：
+     原生 launch_screen.xml 是 52×84dp，这里被前几轮「再小一倍」改成了 26×42。）
+   现在两边都锚在 **26×42**：原生 drawable 缩到 26×42dp，这里保持 26×42 CSS px，
+   WebView 默认 1 CSS px = 1 dp，于是交接处**首尾同尺寸、同位置**。
+
+   定位也一起对齐：原生用 `gravity="center"` 把瓶子放在**屏幕正中**。
+   原来这里用 `flex-direction:column` + `gap`，瓶子会被下方名字顶上去 ~9px；
+   所以瓶子和雾都改成绝对定位到 (50%,50%)，名字脱离文档流放在瓶子下面 ——
+   名字浮出来时瓶子一动不动，原生那帧和网页这帧的瓶心才是同一个点。 */
+.splash{position:fixed;inset:0;z-index:2000;pointer-events:none;
   background:var(--canvas);opacity:1;transition:opacity .38s ease}
 /* 淡出后彻底撤掉（display:none 不够：要让它不再参与合成层） */
 .splash[hidden]{display:none}
 .splash.is-out{opacity:0}
 
 /* 绿雾：比 loading 里那团更大更亮 —— 启动这一屏只有这一件东西，绿要当主角 */
-.splash__glow{position:absolute;left:50%;top:50%;width:320px;height:320px;
-  margin:-160px 0 0 -160px;border-radius:50%;pointer-events:none;
-  background:radial-gradient(circle,var(--q-bottle-glow, rgba(52,210,123,.30)) 0%,transparent 70%);
+/* 光晕跟着瓶身缩（瓶 26 宽 → 雾圈 60）：不缩的话小瓶子会陷进一大团绿雾里 */
+.splash__glow{position:absolute;left:50%;top:50%;width:60px;height:60px;
+  margin:-30px 0 0 -30px;border-radius:50%;pointer-events:none;
+  background:radial-gradient(circle,var(--q-bottle-glow, rgba(45,200,120,.30)) 0%,transparent 70%);
   animation:splashGlow 2.4s ease-in-out infinite}
 
-.splash__bottle{position:relative;width:132px;height:165px;flex:none;
-  color:var(--q-bottle-line, var(--muted))}
-.splash__bottle .qbottle{display:block;width:132px;height:165px}
+/* 尺寸与 viewBox 同比例（64:104）：26×42 才不留空白，见 shared/conversation.css。
+   **这个数值必须与 android 的 launch_screen.xml / ic_splash_bottle.xml 一致** ——
+   两段动画交接时尺寸一变就读作"瓶子突然缩小"（2026-10-22 实测踩到，见文件顶部说明）。
+   绝对定位到屏幕正中：与原生 `gravity="center"` 同一个锚点，名字浮出来也不顶动它。 */
+.splash__bottle{position:absolute;left:50%;top:50%;width:26px;height:42px;
+  margin:-21px 0 0 -13px;
+  color:var(--q-bottle-line, #43A06E)}
+.splash__bottle .qbottle{display:block;width:26px;height:42px}
 
-/* 名字：等绿液灌到一半才浮出来（它在给「灌满了」这件事做收尾） */
-.splash__name{position:relative;font-family:'AA Caveat',cursive;font-size:19px;letter-spacing:.12em;
+/* 名字：等绿液灌到一半才浮出来（它在给「灌满了」这件事做收尾）。
+   绝对定位在瓶子下方 —— 它出现/位移都不能影响瓶子的位置，否则两段动画的瓶心会错开。 */
+.splash__name{position:absolute;left:50%;top:50%;transform:translateX(-50%);
+  margin-top:30px;
+  font-family:'AA Caveat',cursive;font-size:19px;letter-spacing:.12em;
   color:var(--muted);opacity:0;animation:splashName .5s ease .55s forwards}
 
 @keyframes splashGlow{0%,100%{opacity:.5;transform:scale(.92)}50%{opacity:.95;transform:scale(1.06)}}
-@keyframes splashName{from{opacity:0;transform:translateY(4px)}to{opacity:1;transform:none}}
+/* ⚠️ 名字用 translateX(-50%) 水平居中，所以关键帧里**只能写垂直位移**，
+   不能写 transform:none —— 那会把水平居中一起抹掉、名字跳到右边半屏。
+   用 margin-top 做上浮量（不动 transform 的 x 分量）。 */
+@keyframes splashName{from{opacity:0;margin-top:34px}to{opacity:1;margin-top:30px}}
 
 /* 用户开了「减弱动态效果」：不留空瓶子干等，直接给满瓶、不淡出不闪 —— 但**还是要出现**
    （它是 App 的身份动作）。灌液动画与呼吸都关掉。 */
@@ -473,14 +797,31 @@ button.setrow{font-family:inherit}
   <symbol id="i-doc" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M14 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V8z"/><path d="M14 3v5h5"/></symbol>
   <symbol id="i-list" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M4 7h16M4 12h16M4 17h16"/></symbol>
   <symbol id="i-tune" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M4 7h8M18 7h2M4 17h2M12 17h8"/><circle cx="15" cy="7" r="2.2"/><circle cx="9" cy="17" r="2.2"/></symbol>
-  <symbol id="i-user" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="8.5" r="3.6"/><path d="M5 20a7 7 0 0 1 14 0"/></symbol>
-  <symbol id="i-chat" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 12a7 7 0 0 1-7 7H9l-4 3v-4.6A7 7 0 0 1 5 12a7 7 0 0 1 7-7h1a7 7 0 0 1 7 7z"/></symbol>
+  <symbol id="i-user" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="8.4" r="3.6"/><path d="M4.9 20.2a7.3 7.3 0 0 1 14.2 0"/></symbol>
+  <!-- 底栏「任务」= 两行勾选清单（无外框）。
+       不用对话气泡：气泡的语义是「聊天」，跟这里本来就有的会话概念重复；
+       清单能直接读出"待办/已完成"，且**没有外框**，与「需求」的文档轮廓先分家。
+       24 网格 · 20 安全区 · 1.75 描边（2026-10-22 定稿） -->
+  <symbol id="i-task" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M3.6 8.4 5.8 10.6 10.3 5.9"/><path d="M13 8.3h7.4"/>
+    <path d="M3.6 17.5 5.8 19.7 10.3 15"/><path d="M13 17.4h7.4"/>
+  </symbol>
+  <!-- 底栏「需求」= 有折角、有正文的规格文档（与上面的 i-doc 区分：那个是列表里的小图标，
+       可以留空壳；底栏这枚必须有"内容"，否则读作占位符） -->
+  <symbol id="i-req" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M13.7 3.6H7.9A3.3 3.3 0 0 0 4.6 6.9v10.2a3.3 3.3 0 0 0 3.3 3.3h8.2a3.3 3.3 0 0 0 3.3-3.3V9.5Z"/>
+    <path d="M13.7 3.6v4.3a1.6 1.6 0 0 0 1.6 1.6h4.3"/>
+    <path d="M8.3 13.1h7.4"/><path d="M8.3 16.8h4.8"/>
+  </symbol>
   <symbol id="i-clock" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="8"/><path d="M12 8v4.3l3 1.8"/></symbol>
-  <symbol id="i-compass" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="8"/><path d="M15.5 8.5l-2 5-5 2 2-5z"/></symbol>
+  <symbol id="i-compass" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="8.6"/><path d="M15.2 8.8 13.4 13.4 8.8 15.2 10.6 10.6Z"/></symbol>
   <symbol id="i-cpu" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"><rect x="7" y="7" width="10" height="10" rx="2"/><path d="M10 3.5v3M14 3.5v3M10 17.5v3M14 17.5v3M3.5 10h3M3.5 14h3M17.5 10h3M17.5 14h3"/></symbol>
   <symbol id="i-pin" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M7 4.5h10a1 1 0 0 1 1 1V20l-6-3.6L6 20V5.5a1 1 0 0 1 1-1z"/></symbol>
   <symbol id="i-folder" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7a2 2 0 0 1 2-2h3.2l1.6 2H18a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2z"/></symbol>
   <symbol id="i-chev-r" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m9 5 7 7-7 7"/></symbol>
+  <symbol id="i-chev-d" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m6 9 6 6 6-6"/></symbol>
+  <symbol id="i-search" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round"><circle cx="11" cy="11" r="6.4"/><path d="m15.8 15.8 4 4"/></symbol>
+  <symbol id="i-x" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M6 6l12 12M18 6L6 18"/></symbol>
   <symbol id="i-edit" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M4 20h4L19 9a2 2 0 0 0 0-3l-1-1a2 2 0 0 0-3 0L4 16z"/><path d="M14 6l4 4"/></symbol>
   <symbol id="i-trash" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7h16M9 7V5a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2M6 7l1 13a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1l1-13"/></symbol>
   <symbol id="i-laptop" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><rect x="5" y="6" width="14" height="9" rx="1.6"/><path d="M3 18.5h18"/></symbol>
@@ -496,11 +837,15 @@ button.setrow{font-family:inherit}
   <symbol id="i-star" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round"><path d="M12 4.5l2.4 4.9 5.4.8-3.9 3.8.9 5.4-4.8-2.5-4.8 2.5.9-5.4-3.9-3.8 5.4-.8z"/></symbol>
   <symbol id="i-refresh" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M19.5 12a7.5 7.5 0 1 1-2.2-5.3"/><path d="M19.5 3.5v3.7h-3.7"/></symbol>
   <symbol id="i-share" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><circle cx="6.5" cy="12" r="2.4"/><circle cx="17" cy="6" r="2.4"/><circle cx="17" cy="18" r="2.4"/><path d="M8.7 10.9l6.1-3.6M8.7 13.1l6.1 3.6"/></symbol>
+  <symbol id="i-team" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M16 21v-1.8a4 4 0 0 0-4-4H7a4 4 0 0 0-4 4V21"/><circle cx="9.5" cy="7.5" r="3.6"/><path d="M21 21v-1.8a4 4 0 0 0-3-3.87"/><path d="M16 3.9a3.6 3.6 0 0 1 0 7.2"/></symbol>
   <symbol id="i-home" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4.5 11.5L12 4.5l7.5 7"/><path d="M6.5 10v9.5h11V10"/></symbol>
 </svg>
 
 <!-- ══════════ 启动页 ══════════ -->
 <div class="launcher" id="launcher" hidden>
+  <button class="launcher__back" id="btnLauncherBack" type="button" hidden>
+    <svg width="18" height="18"><use href="#i-back"/></svg><span>返回</span>
+  </button>
   <h1 class="launcher__title">magic-agent · 远程控制</h1>
   <p class="launcher__desc">打开桌面配对页里的连接地址，远程继续你的会话。</p>
 
@@ -518,17 +863,32 @@ button.setrow{font-family:inherit}
 
   <div class="recent" id="recent" hidden>
     <div class="recent__head">
-      <span class="recent__title">最近连接</span>
+      <span class="recent__title">已保存的连接</span>
       <button class="recent__clear" id="btnClear">清空</button>
     </div>
     <div id="recentList"></div>
   </div>
 </div>
 
-<!-- ══════════ 历史会话列表 ══════════ -->
+<!-- ══════════ 任务列表（页头右侧：搜索 + 我的）══════════ -->
 <div class="history" id="history" hidden>
   <div class="history__top">
-    <span class="history__title" id="historyTitle">任务</span>
+    <!-- 标题即环境切换入口：点开列出已保存的多台桌面（2026-10-22） -->
+    <button class="history__title history__title--btn" type="button" id="btnEnvSwitch" aria-label="切换环境">
+      <span id="historyTitle">任务</span>
+      <svg class="history__title-chev" width="16" height="16"><use href="#i-chev-d"/></svg>
+    </button>
+    <span class="tasks__tools">
+      <button class="topbar__icon" type="button" id="btnTaskSearch" aria-label="搜索任务"><svg width="21" height="21"><use href="#i-search"/></svg></button>
+      <button class="topbar__icon" type="button" id="btnTaskMe" aria-label="我的"><svg width="21" height="21"><use href="#i-user"/></svg></button>
+    </span>
+  </div>
+  <div class="tasks__search" id="taskSearchBar" hidden>
+    <label class="tasks__searchbox">
+      <svg width="19" height="19"><use href="#i-search"/></svg>
+      <input id="taskSearchInput" type="search" placeholder="搜索任务" autocomplete="off" enterkeyhint="search">
+    </label>
+    <button class="tasks__searchx" type="button" id="btnTaskSearchClose" aria-label="关闭搜索"><svg width="22" height="22"><use href="#i-x"/></svg></button>
   </div>
   <div class="history__actions">
     <button class="newtask" id="btnNewTask"><svg width="18" height="18"><use href="#i-plus"/></svg><span>新建任务</span></button>
@@ -575,7 +935,18 @@ button.setrow{font-family:inherit}
       <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）：开关**按会话**给，放会话页右上角的运行设置里（与权限模式并排），
+         所以这里不展示全局面板状态；这里只放**这台设备的配置**入口 —— 具体每类任务交给谁
+         进子页面（#teamPage）再配，不在「我的」里铺五行。 -->
+    <div class="setcard" id="teamCard">
+      <button class="setrow" id="btnTeamPage"><span class="setrow__l">团队模式</span><span class="setrow__v" id="teamSummary">跟随主引擎</span></button>
+    </div>
     <div class="setcard">
+      <!-- 版本号（2026-10-22 用户：「移动端我的tab中显示版本号」）。
+           值由 /desk/health 的 version 给（= core 的 `--version`）—— 移动端界面是
+           桌面端 /m/ 远程加载的、本身不带版本，用户要看的是「连着的这份是哪一版」。
+           老 core 不给 version 时保持「—」，不写死。 -->
+      <div class="setrow"><span class="setrow__l">版本</span><span class="setrow__v" id="mineVersion">—</span></div>
       <button class="setrow" id="btnUpgrade"><span class="setrow__l">检查更新</span><span class="setrow__v" id="upgradeState">重新加载</span></button>
     </div>
     <div class="setcard">
@@ -584,14 +955,56 @@ button.setrow{font-family:inherit}
   </div>
 </div>
 
-<!-- ══════════ 定时任务 ══════════ -->
-<div class="history" id="sched" hidden>
-  <div class="history__top"><span class="history__title">定时任务</span></div>
+<!-- ══════════ 我的 → 团队模式（计划 + 7 类子任务）══════════
+     从「我的」那一行点进来。这里配的全都是**设备级偏好**（开关本身按会话，在会话页运行设置里）。
+     **只有一套划分**：计划 + 7 个角色（writer / researcher / reviewer / coder / designer /
+     director / builder）共 8 行，行内直接写清「这类适合什么」—— 不再并列「6 个类别」那一层
+     （用户 2026-10-22：「只需要计划+7类子任务即可 描述好每一类适合的规则 规则、引擎都可配置」）。
+     每行点开 = 引擎/模型 + 规则：计划配拆解粒度与两个开关，角色配「这类任务适合什么」
+     （写进 core 的拆解提示词，--team-rule role:<name>=…）。 -->
+<div class="history" id="teamPage" hidden>
+  <div class="history__top">
+    <button class="topbar__icon" id="btnTeamBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
+    <span class="history__title">团队模式</span>
+  </div>
   <div class="history__list">
-    <div class="history__hint">magic-agent 当前没有“定时任务清单”接口。<br>需要的话我可以按 core 的自动化能力接上。</div>
+    <div class="history__group">计划与 7 类子任务</div>
+    <div class="setcard" id="teamRouteCard"></div>
+    <div class="history__hint" style="text-align:left">点一行配置引擎与规则。留空 = 跟随主引擎 / 使用内置描述。</div>
   </div>
 </div>
 
+<!-- ══════════ 会话页 → 任务运行设置（独立子页面）══════════
+     会话页右上角的调节键点进来（2026-10-21 用户：「运行设置在任务对话框里 不也应该是独立页面吗」）。
+     四项都是**当前这条会话**的运行参数：设备只读，其余三项点开还是原来的选择器（选择器只有一份）。 -->
+<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>
+    <span class="history__title">任务运行设置</span>
+  </div>
+  <div class="history__list">
+    <div class="setcard">
+      <div class="setrow"><span class="setrow__l">设备</span><span class="setrow__v" id="rsDevice">本机</span></div>
+      <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>
+    </div>
+  </div>
+</div>
+
+<!-- ══════════ 需求（会话自动聚合成的功能点文档）══════════
+     数据全来自 GET /desk/requirements（core 的 --requirements，只读）。
+     按「工作区 → 模块 → 功能点」两级分组；点一行用既有的阅读器打开那篇 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>
+
 <!-- ══════════ 发现（浏览器 / 应用 / 插件 / SKILL）══════════ -->
 <div class="history" id="discover" hidden>
   <div class="history__top"><span class="history__title">发现</span></div>
@@ -698,12 +1111,30 @@ button.setrow{font-family:inherit}
   <div class="reader__body" id="rdBody"></div>
 </div>
 
-<!-- ══════════ 底部 Tab ══════════ -->
+<!-- ══════════ 图片大图浮层（缩略图点开看原图）══════════ -->
+<div class="imgview" id="imgview" hidden>
+  <img id="imgviewImg" alt="" draggable="false">
+  <button class="imgview__x" id="imgviewClose" type="button" aria-label="关闭">✕</button>
+  <span class="imgview__nm" id="imgviewName"></span>
+</div>
+
+<!-- ══════════ 底部 Tab ══════════
+     五个槽位：任务 · 需求 ·「＋」· 发现 · 我的。
+     「定时任务」那个 tab 已删（2026-10-22 用户：「定时任务tab先删除」）——
+     功能本身没删：会话菜单里的「定时任务」仍然能唤起，只是不再占一个底部入口
+     （那一页本来也只有一句「还没有这个接口」的说明，占着导航反而误导）。
+     中间那枚「＋」不是 tab：它没有 data-tab、不参与 setActive，点了就是新建会话。 -->
 <nav class="tabbar" id="tabbar" hidden>
-  <button class="tab" type="button" data-tab="tasks"><svg width="22" height="22"><use href="#i-chat"/></svg><span>任务</span></button>
-  <button class="tab" type="button" data-tab="sched"><svg width="22" height="22"><use href="#i-clock"/></svg><span>定时任务</span></button>
-  <button class="tab" type="button" data-tab="discover"><svg width="22" height="22"><use href="#i-compass"/></svg><span>发现</span></button>
-  <button class="tab" type="button" data-tab="mine"><svg width="22" height="22"><use href="#i-user"/></svg><span>我的</span></button>
+  <button class="tab" type="button" data-tab="tasks"><span class="icw"><svg width="23" height="23"><use href="#i-task"/></svg></span><span class="lb">任务</span></button>
+  <!-- 需求 tab 常驻：不做能力位控制（用户 2026-10-22：「移动端永远显示」）。
+       老 core 上点进来会由 loadRequirements 的 501 分支给出明确文案，
+       不会是一片空白 —— 入口固定比入口忽隐忽现更好理解。 -->
+  <button class="tab" type="button" data-tab="reqs"><span class="icw"><svg width="23" height="23"><use href="#i-req"/></svg></span><span class="lb">需求</span></button>
+  <span class="tabfab">
+    <button class="tabfab__b" type="button" id="btnFabNew" aria-label="新建会话"><svg width="26" height="26"><use href="#i-plus"/></svg></button>
+  </span>
+  <button class="tab" type="button" data-tab="discover"><span class="icw"><svg width="23" height="23"><use href="#i-compass"/></svg></span><span class="lb">发现</span></button>
+  <button class="tab" type="button" data-tab="mine"><span class="icw"><svg width="23" height="23"><use href="#i-user"/></svg></span><span class="lb">我的</span></button>
 </nav>
 <!-- 第三方库归口 shared/vendor（与内核共用一份）：markdown 渲染栈要用 marked + DOMPurify；
      highlight.js 由内核按需加载，地址在下面给（内核自己不知道页面的相对根；
@@ -750,15 +1181,21 @@ button.setrow{font-family:inherit}
   var historyEl = document.getElementById('history');
   var historyList = document.getElementById('historyList');
   var historyTitle = document.getElementById('historyTitle');
+  var taskSearchBar = document.getElementById('taskSearchBar');
+  var taskSearchInput = document.getElementById('taskSearchInput');
   var mineEl = document.getElementById('mine');
   var mineDevice = document.getElementById('mineDevice');
+  var mineVersion = document.getElementById('mineVersion');
   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 schedEl = document.getElementById('sched');
+  var reqsEl = document.getElementById('reqs');
+  var reqListEl = document.getElementById('reqList');
   var discoverEl = document.getElementById('discover');
+  var teamPageEl = document.getElementById('teamPage');
+  var runSettingsPageEl = document.getElementById('runSettingsPage');
   var pluginsEl = document.getElementById('plugins');
   var pluginListEl = document.getElementById('pluginList');
   var pluginDetailEl = document.getElementById('pluginDetail');
@@ -781,6 +1218,9 @@ button.setrow{font-family:inherit}
   /* ── 当前连接：连上后由它驱动 transport ── */
   var BASE = '', TOKEN = '';
   var conv = null;
+  /* 当前组件里装着哪条会话 / 哪个空间：同一条会话再次打开时直接复用这一屏
+     （见 mountConversation）。返回列表只是 hideAll()，组件与画面本来就还在。 */
+  var convSid = null, convWs = null;
   var WS = '';   // 当前工作空间（'' = 默认，不传 -w）
   /* 工作空间要跨重启记住（与引擎 / 模型同一口径）：只放内存的话，App 重启后
      「任务运行设置」里选的空间就回到默认，用户会以为没保存。 */
@@ -790,48 +1230,332 @@ button.setrow{font-family:inherit}
      提前到这里声明：首屏 paintRunPref 会读它，晚于 PREFS 初始化赋值就会踩 undefined。 */
   var RUN_PREF = loadRunPref();
   var ENGINES = [];          // 最近一次从 /desk/engines?models=1 拿到的清单
-
-  /* ══════════ 最近连接（对应 ZCode RemoteControlRecentLinksStore：最多 5 条）══════════ */
-  var LS_KEY = 'magic.remote.recent.v1', MAX_RECENT = 5;
-  function loadRecent() {
+  var ENGINES_STALE_AT = '';  // 非空 = 这份清单是插件侧的兜底缓存（探测超时/失败），值是缓存时间
+  /* ── 团队模式（2026-10-21）──
+     开关**跟着会话**（用户 2026-10-21：「团队模式开关是跟着会话的 不是改了所有会话都改了」）：
+     `sessions` 是 sid → 开/关 的映射，每条会话一份；`fresh` 只临时装「新会话还没拿到
+     session_id 时」的开关（首帧带回 id 就落到 `sessions` 上，见 bindFreshTeam）。
+     ROUTES：计划阶段与每类子任务各交给谁 ——
+     `{plan:{engine,model}|null, text:…, code:…, image:…, video:…, game:…}`，null / 空引擎 = 跟随主引擎
+     （五类一致，core 侧同一套语义：不单独指定就用主引擎 + 主模型）。
+     路由与并行度才是**这台设备的偏好**；开关不是 —— 它属于某条会话。 */
+  /* 团队配置子页面的 8 行 = 计划 + 7 个角色（角色清单见下面的 teamRoleList）。
+     不再有「6 个类别」那一层：类别是角色的派生属性，界面上直接按角色配（用户 2026-10-22：
+     「只需要计划+7类子任务即可」）。 */
+  var TEAM_KIND_LABELS = { plan: '计划', text: '文本', code: '代码', image: '图像', video: '视频', game: '游戏' };
+  /* ── 按角色指定路由（2026-10-22）──
+     键是 `role:<name>`（core 的 --team-route 同口径），与上面的类别键共用一个
+     `magic.team.routes.v1` —— teamConfig() 原样下发，不需要第二份配置。
+     角色清单优先用 /desk/health 的 teamRoles（core 上报，客户端不硬编码）；
+     老 core 没有这个字段 → 空 → 回落到下面这份内置表（与 internal/team 一致）。 */
+  var TEAM_ROLE_LABELS = {
+    writer: '写作', researcher: '调研', reviewer: '评审', coder: '编码',
+    designer: '视觉', director: '影像', builder: '工程'
+  };
+  var TEAM_ROLE_BUILTIN = [
+    { name: 'writer', kind: 'text', duty: '把材料写成结构清晰、可直接交付的文档' },
+    { name: 'researcher', kind: 'text', duty: '查证事实、比对方案，给出有依据的结论' },
+    { name: 'reviewer', kind: 'text', duty: '按验收标准挑问题，不重写别人的产出' },
+    { name: 'coder', kind: 'code', duty: '把复杂代码改动落到可构建、可测试的文件上' },
+    { name: 'designer', kind: 'image', duty: '产出可直接使用的画面资产' },
+    { name: 'director', kind: 'video', duty: '把脚本 / 分镜变成可播放的影像' },
+    { name: 'builder', kind: 'game', duty: '交付能跑起来的工程与可复现的启动方式' }
+  ];
+  var TEAM_ROLES = [];   // core 上报的角色清单；空 = 老 core（或还没连上）→ 用内置表
+  function teamRoleList() { return TEAM_ROLES.length ? TEAM_ROLES : TEAM_ROLE_BUILTIN; }
+  /* 路由键 → 界面文案（toast / 选择器标题共用）。 */
+  function teamRouteLabel(key) {
+    if (String(key).indexOf('role:') === 0) {
+      var n = String(key).slice(5);
+      return '角色「' + (TEAM_ROLE_LABELS[n] || n) + '」';
+    }
+    if (key === 'plan') return '计划任务';
+    return TEAM_KIND_LABELS[key] + '类任务';
+  }
+  var TEAM = loadTeamPref();
+  /* 行签名（8 行文案 + 引擎）：不变就不重建，避免 5s 轮询时闪。 */
+  var TEAM_ROLE_SIG = '';
+  /* core 的能力位清单（/desk/health 的 features）。团队开关要不要显示就看它 ——
+     **连上桌面后才有**，所以首屏是空数组（= 不支持 = 卡片藏起来）。
+     ⚠️ 声明必须与 TEAM 同批：首屏 paintTeamPref() 会读它，放到后面虽能靠 var 提升
+        取到 undefined，但一取 .indexOf 就抛异常，整个页面初始化会在这里断掉。 */
+  var CORE_FEATURES = [];
+  function teamSupported() { return CORE_FEATURES.indexOf('feature.session.team') >= 0; }
+  function loadTeamPref() {
+    var o = { sessions: {}, fresh: false, routes: {}, rules: {}, parallel: 4, split: 'standard', splitCode: false, adaptive: true };
     try {
-      var raw = localStorage.getItem(LS_KEY);
-      var list = raw ? JSON.parse(raw) : [];
-      return Array.isArray(list) ? list : [];
-    } catch (e) { return []; }
+      var m = JSON.parse(localStorage.getItem('magic.team.sessions.v1') || '{}');
+      if (m && typeof m === 'object' && !Array.isArray(m)) {
+        Object.keys(m).forEach(function (sid) { o.sessions[sid] = !!m[sid]; });
+      }
+    } catch (e) {}
+    /* 旧版是全设备一个 `magic.team.on` —— 正是「改一条会话，所有会话都变」的来源。
+       不迁移：把全局值抄给每条会话等于把 bug 换个地方；直接清掉，新会话默认关。 */
+    try { localStorage.removeItem('magic.team.on'); } catch (e) {}
+    try {
+      var r = JSON.parse(localStorage.getItem('magic.team.routes.v1') || '{}');
+      if (r && typeof r === 'object') o.routes = r;
+    } catch (e) {}
+    /* 角色规则覆盖（「这类任务适合什么」）：键 role:<name>，留空/缺项 = 用 core 内置描述。 */
+    try {
+      var ru = JSON.parse(localStorage.getItem('magic.team.rules.v1') || '{}');
+      if (ru && typeof ru === 'object' && !Array.isArray(ru)) {
+        Object.keys(ru).forEach(function (k) {
+          var v = String(ru[k] || '').replace(/\s+/g, ' ').trim();
+          if (v) o.rules[k] = v;
+        });
+      }
+    } catch (e) {}
+    try {
+      var n = parseInt(localStorage.getItem('magic.team.parallel') || '', 10);
+      if (n > 0) o.parallel = n;
+    } catch (e) {}
+    /* 拆解规则：三档只认 core 的三个值，脏值留在 standard（不让坏数据把请求打成 400）。 */
+    try {
+      var sp = localStorage.getItem('magic.team.split');
+      if (sp === 'coarse' || sp === 'standard' || sp === 'fine') o.split = sp;
+    } catch (e) {}
+    try { o.splitCode = localStorage.getItem('magic.team.splitcode') === '1'; } catch (e) {}
+    try { if (localStorage.getItem('magic.team.adaptive') === '0') o.adaptive = false; } catch (e) {}
+    return o;
+  }
+  function saveTeamPref() {
+    /* 最多留 400 条，别让 localStorage 随会话数无限长（超出按 key 顺序丢，只影响容量）。 */
+    var ids = Object.keys(TEAM.sessions || {});
+    if (ids.length > 400) {
+      ids.slice(0, ids.length - 400).forEach(function (sid) { delete TEAM.sessions[sid]; });
+    }
+    try { localStorage.setItem('magic.team.sessions.v1', JSON.stringify(TEAM.sessions || {})); } catch (e) {}
+    try { localStorage.setItem('magic.team.routes.v1', JSON.stringify(TEAM.routes || {})); } catch (e) {}
+    try { localStorage.setItem('magic.team.rules.v1', JSON.stringify(TEAM.rules || {})); } catch (e) {}
+    try { localStorage.setItem('magic.team.parallel', String(TEAM.parallel || 4)); } catch (e) {}
+    try { localStorage.setItem('magic.team.split', TEAM.split || 'standard'); } catch (e) {}
+    try { localStorage.setItem('magic.team.splitcode', TEAM.splitCode ? '1' : '0'); } catch (e) {}
+    try { localStorage.setItem('magic.team.adaptive', TEAM.adaptive === false ? '0' : '1'); } catch (e) {}
+    paintTeamPref();
+  }
+  /* 这条会话的开关：本地记过就用本地；没记过 → 跟会话自己的运行模式（core 的 `mode:"team"`）。
+     新会话（还没有 sid）用 `fresh` —— 它**不跨会话继承**：每次新建任务都从「关」起。 */
+  function teamOnFor(sid, s) {
+    if (sid) {
+      if (Object.prototype.hasOwnProperty.call(TEAM.sessions, sid)) return !!TEAM.sessions[sid];
+      return !!(s && s.mode === 'team');
+    }
+    return !!TEAM.fresh;
+  }
+  /* 新会话的开关要等 core 给出 session_id 才落得下来（见 mountConversation 的 onEvent）。 */
+  function bindFreshTeam(sid) {
+    if (!TEAM.fresh || !sid) return;
+    TEAM.sessions[String(sid)] = true;
+    TEAM.fresh = false;
+    saveTeamPref();
+  }
+
+  /* ══════════ 环境（多连接）══════════
+     2026-10-22 用户：「移动端要支持环境切换 可以有多个连接」。
+     一台手机可以记住多台桌面（家里 / 公司 / 另一台机器），任务页标题就是切换入口。
+     键 = 地址 + 令牌：令牌是 magic-client 落盘复用、跨重启不变的机器身份（与排队队列的
+     devKey 同一口径），地址会随 IP / 热点变化，所以不能只用地址。 */
+  var CONN_KEY = 'magic.remote.conns.v1', CONN_MAX = 8;
+  var LS_KEY = 'magic.remote.recent.v1';   // 旧版「最近连接」：只在首次升级时搬一次
+  var ACTIVE_ID = '';
+
+  function connHost(url) {
+    try { return new URL(url).host; }
+    catch (e) { return String(url || '').replace(/^https?:\/\//, '').replace(/\/.*$/, ''); }
+  }
+  function connIdOf(t) { return String(t.url || '') + '|' + String(t.token || ''); }
+  function loadConns() {
+    var list;
+    try { list = JSON.parse(localStorage.getItem(CONN_KEY) || '[]'); } catch (e) { list = []; }
+    if (!Array.isArray(list)) list = [];
+    list = list.filter(function (c) { return c && c.url; });
+    if (!list.length) {
+      /* 老版本只记最近 5 条连接：升级后并过来，用户不必重新扫一次码。 */
+      try {
+        var old = JSON.parse(localStorage.getItem(LS_KEY) || '[]');
+        if (Array.isArray(old) && old.length) {
+          list = old.filter(function (c) { return c && c.url; }).map(function (c) {
+            return { id: connIdOf(c), url: c.url, token: c.token || '', name: c.name || '',
+                     host: connHost(c.url), app: '', at: c.at || 0 };
+          });
+          saveConns(list);
+        }
+      } catch (e) {}
+    }
+    return list;
+  }
+  function saveConns(list) {
+    try { localStorage.setItem(CONN_KEY, JSON.stringify((list || []).slice(0, CONN_MAX))); } catch (e) {}
   }
-  function saveRecent(list) { try { localStorage.setItem(LS_KEY, JSON.stringify(list)); } catch (e) {} }
-  function recordRecent(t) {
-    var list = loadRecent().filter(function (x) { return x.url !== t.url; });
-    list.unshift({ url: t.url, token: t.token, name: t.name, at: Date.now() });
-    saveRecent(list.slice(0, MAX_RECENT));
+  function findConn(id) {
+    var list = loadConns();
+    for (var i = 0; i < list.length; i++) if (list[i].id === id) return list[i];
+    return null;
+  }
+  /* 记一条连接（连过就记住）：扫码带的 name 与 health 报的 app 都比地址更适合当名字。 */
+  function upsertConn(t) {
+    var id = connIdOf(t);
+    var old = findConn(id) || {};
+    var list = loadConns().filter(function (c) { return c.id !== id; });
+    var next = {
+      id: id, url: t.url || '', token: t.token || '',
+      name: (t.name != null && t.name !== '') ? t.name : (old.name || ''),
+      host: connHost(t.url), app: old.app || '', at: Date.now()
+    };
+    list.unshift(next);
+    saveConns(list);
+    return next;
+  }
+  function removeConn(id) { saveConns(loadConns().filter(function (c) { return c.id !== id; })); }
+  function clearConns() { saveConns([]); }
+
+  /* 当前连接：先按地址 + 令牌找；App 壳注入的连接还没落盘时给一条临时记录，
+     这样标题与菜单里仍然看得见「现在连的是谁」。 */
+  function activeConn() {
+    var list = loadConns(), i;
+    for (i = 0; i < list.length; i++) {
+      if (list[i].url === BASE && String(list[i].token || '') === String(TOKEN || '')) return list[i];
+    }
+    for (i = 0; i < list.length; i++) if (ACTIVE_ID && list[i].id === ACTIVE_ID) return list[i];
+    if (BASE || TOKEN) {
+      return { id: connIdOf({ url: BASE, token: TOKEN }), url: BASE, token: TOKEN, name: '', host: connHost(BASE), app: '' };
+    }
+    return null;
+  }
+  /* 环境显示名：扫码带的 name > 桌面 health 报的 app > host。 */
+  function connLabel(c) {
+    if (!c) return '';
+    return c.name || c.app || c.host || connHost(c.url);
+  }
+  function envLabel() { return connLabel(activeConn()) || histSubtitle || ''; }
+
+  /* 桌面 health 回来的应用名（app）补进当前连接：它比 host 更像「这台设备是谁」。 */
+  function noteActiveMeta(meta) {
+    var c = activeConn();
+    if (!c || !c.id) return;
+    var list = loadConns(), changed = false;
+    for (var i = 0; i < list.length; i++) {
+      if (list[i].id !== c.id) continue;
+      if (meta.app && list[i].app !== meta.app) { list[i].app = meta.app; changed = true; }
+      if (!list[i].host) { list[i].host = connHost(list[i].url); changed = true; }
+    }
+    if (!changed) return;
+    saveConns(list);
+    if (!historyEl.hidden) historyTitle.textContent = envLabel() || '任务';
   }
-  function clearRecent() { saveRecent([]); }
 
   function fmtTime(ms) {
     try { return new Date(ms).toLocaleString(); } catch (e) { return ''; }
   }
   function renderRecent() {
-    var list = loadRecent();
+    var list = loadConns();
     recentListEl.innerHTML = '';
     if (!list.length) { recentEl.hidden = true; return; }
     recentEl.hidden = false;
     list.forEach(function (item) {
-      var host = '';
-      try { host = new URL(item.url).host; } catch (e) { host = item.url; }
+      var row = document.createElement('div');
+      row.className = 'recent__row';
       var b = document.createElement('button');
       b.type = 'button';
       b.className = 'recent__item';
-      var t = document.createElement('span');
-      t.className = 'recent__t';
-      t.textContent = item.name || host;
-      var s = document.createElement('span');
-      s.className = 'recent__s';
-      s.textContent = host + ' · ' + fmtTime(item.at);
-      b.appendChild(t); b.appendChild(s);
-      b.onclick = function () { connect({ url: item.url, token: item.token, name: item.name, host: host }); };
-      recentListEl.appendChild(b);
+      b.appendChild(elSpan('recent__t', connLabel(item) || item.host || item.url));
+      b.appendChild(elSpan('recent__s', (item.host || connHost(item.url)) + ' · ' + fmtTime(item.at)));
+      b.onclick = function () { connect({ url: item.url, token: item.token, name: item.name, host: item.host || connHost(item.url) }); };
+      /* 多台机器就必然要能删：删掉只是忘掉这条记录，不打断当前连接。 */
+      var del = document.createElement('button');
+      del.type = 'button';
+      del.className = 'recent__del';
+      del.setAttribute('aria-label', '删除连接');
+      del.appendChild(svgUse('i-trash', 18));
+      del.onclick = function () { removeConn(item.id); renderRecent(); };
+      row.appendChild(b); row.appendChild(del);
+      recentListEl.appendChild(row);
+    });
+  }
+
+  /* ── 环境切换菜单（任务页标题点开）── */
+  var envMenuEl = null, envScrimEl = null;
+  function closeEnvMenu() {
+    if (envMenuEl) { envMenuEl.remove(); envMenuEl = null; }
+    if (envScrimEl) { envScrimEl.remove(); envScrimEl = null; }
+    var btn = document.getElementById('btnEnvSwitch');
+    if (btn) btn.classList.remove('is-open');
+  }
+  /* 换环境 = 换一台桌面：对话、轮询、运行态都属于旧连接，必须一起收掉。
+     排队任务按令牌分别落库（见 QUEUE_KEY），旧环境那批留在原地，切回来再接着跑。 */
+  function switchEnv(c) {
+    if (!c) return;
+    if (c.url === BASE && String(c.token || '') === String(TOKEN || '')) {
+      toast('已在「' + (connLabel(c) || '当前环境') + '」');
+      return;
+    }
+    if (conv) { try { conv.destroy(); } catch (e) {} conv = null; }
+    convEl.innerHTML = '';
+    stopPoll();
+    PENDING = []; ASK_WAITING = []; SERIAL = {}; QUEUE_RESTORED = false;
+    SERVER_VERSION = ''; CORE_FEATURES = []; TEAM_ROLES = []; ENGINES = []; ENGINES_STALE_AT = '';
+    TITLES = {}; LAST_SESSIONS = []; DW = ''; DW_READY = false; ROOT_DIRS = [];
+    /* 工作空间属于某台机器的目录树：沿用旧路径会落到不存在的目录，一律回到默认。 */
+    WS = '';
+    saveWs();
+    connect({ url: c.url, token: c.token, name: c.name, host: c.host || connHost(c.url) });
+    toast('已切换到「' + (connLabel(c) || connHost(c.url)) + '」');
+  }
+  function openEnvMenu() {
+    if (envMenuEl) { closeEnvMenu(); return; }
+    var cur = activeConn();
+    var list = loadConns();
+    if (cur && !list.some(function (c) { return c.id === cur.id; })) list = [cur].concat(list);
+    envScrimEl = document.createElement('div');
+    envScrimEl.className = 'envmenu__scrim';
+    envScrimEl.onclick = closeEnvMenu;
+    envMenuEl = document.createElement('div');
+    envMenuEl.className = 'envmenu';
+    envMenuEl.appendChild(elSpan('envmenu__head', '切换环境'));
+    list.forEach(function (c) {
+      var active = !!(cur && c.id === cur.id);
+      var b = document.createElement('button');
+      b.type = 'button';
+      b.className = 'envmenu__item';
+      var ico = document.createElement('span');
+      ico.className = 'envmenu__ico';
+      ico.appendChild(svgUse('i-laptop', 20));
+      b.appendChild(ico);
+      var col = document.createElement('span');
+      col.className = 'envmenu__col';
+      var tl = document.createElement('span');
+      tl.className = 'envmenu__t';
+      tl.appendChild(elSpan('envmenu__name', connLabel(c) || c.host || '未命名'));
+      if (c.app) tl.appendChild(elSpan('envmenu__badge', c.app));
+      col.appendChild(tl);
+      col.appendChild(elSpan('envmenu__s', (c.host || connHost(c.url)) + (active ? ' · 当前' : '')));
+      b.appendChild(col);
+      if (active) {
+        var ck = document.createElement('span');
+        ck.className = 'envmenu__check';
+        ck.appendChild(svgUse('i-check', 18));
+        b.appendChild(ck);
+      }
+      b.onclick = function () { closeEnvMenu(); switchEnv(c); };
+      envMenuEl.appendChild(b);
     });
+    envMenuEl.appendChild(elSpan('envmenu__sep', ''));
+    var add = document.createElement('button');
+    add.type = 'button';
+    add.className = 'envmenu__add';
+    add.appendChild(svgUse('i-plus', 18));
+    add.appendChild(elSpan('', '添加连接'));
+    add.onclick = function () { closeEnvMenu(); showLauncher(); };
+    envMenuEl.appendChild(add);
+    document.body.appendChild(envScrimEl);
+    document.body.appendChild(envMenuEl);
+    var btn = document.getElementById('btnEnvSwitch');
+    var r = btn.getBoundingClientRect();
+    var mw = envMenuEl.offsetWidth;
+    envMenuEl.style.top = (r.bottom + 8) + 'px';
+    envMenuEl.style.left = Math.max(12, Math.min(r.left, window.innerWidth - mw - 12)) + 'px';
+    btn.classList.add('is-open');
   }
 
   /* ══════════ 解析 + 校验连接地址 ══════════
@@ -861,21 +1585,33 @@ button.setrow{font-family:inherit}
   }
 
   /* ══════════ 视图：启动页 → 会话列表 → 会话 ══════════ */
-  function hideAll() { launcherEl.hidden = true; historyEl.hidden = true; mineEl.hidden = true; schedEl.hidden = true; discoverEl.hidden = true; pluginsEl.hidden = true; pluginDetailEl.hidden = true; sessionEl.hidden = true; }
+  /* 离开会话页要摘掉 is-conv，否则底栏的「＋」会一直保持"收进槽里"的形态 */
+  function hideAll() { document.body.classList.remove('is-conv'); launcherEl.hidden = true; historyEl.hidden = true; mineEl.hidden = true; reqsEl.hidden = true; discoverEl.hidden = true; teamPageEl.hidden = true; runSettingsPageEl.hidden = true; pluginsEl.hidden = true; pluginDetailEl.hidden = true; sessionEl.hidden = true; }
   function setActive(name) {
     Array.prototype.forEach.call(tabbarEl.querySelectorAll('.tab'), function (b) {
       b.classList.toggle('is-on', b.getAttribute('data-tab') === name);
     });
   }
-  function showLauncher() { hideAll(); launcherEl.hidden = false; tabbarEl.hidden = true; renderRecent(); }
+  function showLauncher() {
+    hideAll(); launcherEl.hidden = false; tabbarEl.hidden = true; renderRecent();
+    /* 已连着桌面时进来（切换环境 → 添加连接）必须有路可退，否则用户被困在启动页。 */
+    var back = document.getElementById('btnLauncherBack');
+    if (back) back.hidden = !(BASE || TOKEN);
+  }
   function showHistory(address) {
     hideAll(); historyEl.hidden = false; tabbarEl.hidden = false; setActive('tasks');
     if (address != null) histSubtitle = address;
-    historyTitle.textContent = histSubtitle || '任务';
+    historyTitle.textContent = envLabel() || '任务';
     loadSessions();
   }
-  function showSession(sub) { hideAll(); sessionEl.hidden = false; tabbarEl.hidden = false; setActive('tasks'); subtitleEl.textContent = (sub != null ? sub : histSubtitle) || ''; }
-  function showSched() { hideAll(); schedEl.hidden = false; tabbarEl.hidden = false; setActive('sched'); }
+  function showSession(sub) { hideAll(); document.body.classList.add('is-conv'); sessionEl.hidden = false; tabbarEl.hidden = false; setActive('tasks'); subtitleEl.textContent = (sub != null ? sub : histSubtitle) || ''; }
+  /* 需求页：进页面即拉一次清单（GET /desk/requirements，只读、不调模型）。
+     「整理」按钮才触发归纳（POST /desk/requirements/consolidate）——
+     两者代价差三个数量级，绝不能混成一个动作。 */
+  function showReqs() {
+    hideAll(); reqsEl.hidden = false; tabbarEl.hidden = false; setActive('reqs');
+    loadRequirements(false);
+  }
   function showDiscover() { hideAll(); discoverEl.hidden = false; tabbarEl.hidden = false; setActive('discover'); }
   function showMine() {
     hideAll(); mineEl.hidden = false; tabbarEl.hidden = false; setActive('mine');
@@ -886,6 +1622,50 @@ button.setrow{font-family:inherit}
     tglHaptic.classList.toggle('is-on', PREFS.haptic !== 'off');
     paintRunPref();
     refreshVpn();
+    /* 版本号：先用已拉到的值立刻画（列表页的 /desk/health 顺手带回来的），
+       再补一次请求 —— 用户可能一连上就直接点「我的」，那时列表那次还没回来。 */
+    paintMineVersion();
+    refreshMineVersion();
+  }
+
+  /* ══════════ 版本号（「我的」）══════════
+     来源：桌面端 `GET /desk/health` 的 `version`（= core 的 `--version`，ldflags 注入）。
+     为什么不是移动端自己写死一个常量：这份界面是桌面端 `/m/` 远程加载的，页面文件跟着
+     桌面端一起升级；只有服务端报的版本才是「用户此刻连着的这份」。
+     health 没有 version（插件是旧构建、但磁盘上的 core 已经是新的）时，再问一次
+     `/desk/contract` —— 它原样代理 core 的 envelope，新 core 里带 version。这样
+     **不必重启正在跑的服务**就能显示真实版本。仍然没有（老 core）就保持「—」，不编。 */
+  var SERVER_VERSION = '';
+  function paintMineVersion() {
+    if (!mineVersion) return;
+    mineVersion.textContent = SERVER_VERSION ? ('v' + SERVER_VERSION) : '—';
+  }
+  function refreshMineVersion() {
+    if (!TOKEN) { paintMineVersion(); return; }
+    var hdr = { 'X-Magic-Token': TOKEN };
+    fetch(BASE + '/desk/health', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .then(function (h) {
+        if (h && typeof h.version === 'string' && h.version) { SERVER_VERSION = h.version; return; }
+        return fetch(BASE + '/desk/contract', { headers: hdr })
+          .then(function (r) { return r.ok ? r.json() : null; })
+          .then(function (c) {
+            if (c && typeof c.version === 'string' && c.version) SERVER_VERSION = c.version;
+          })
+          .catch(function () {});
+      })
+      .then(paintMineVersion)
+      .catch(function () { paintMineVersion(); });   // 网络抖动：保留旧值，不把「—」又闪回来
+  }
+  /* 「我的」→ 团队模式：整块配置进子页面（与插件列表同一套子页面范式）。 */
+  function showTeamPage() {
+    hideAll(); teamPageEl.hidden = false; tabbarEl.hidden = true;
+    paintTeamPref();
+  }
+  /* 会话页 → 任务运行设置：同一条子页面范式（返回键 + 标题 + 卡片），不再用底部抽屉。 */
+  function showRunSettings() {
+    hideAll(); runSettingsPageEl.hidden = false; tabbarEl.hidden = true;
+    paintRunSettings();
   }
   function markSeg(seg, v) {
     Array.prototype.forEach.call(seg.children, function (b) {
@@ -1332,20 +2112,73 @@ button.setrow{font-family:inherit}
   var PREFS = loadPrefs();
   applyThemePref(PREFS.theme); applyFontPref(PREFS.font); applyHapticPref(PREFS.haptic);
   paintRunPref();
+  paintTeamPref();          // 团队配置卡片（能力位要到连上桌面后才亮，见 loadSessions）
 
   /* 挂 conversation：传输层由宿主注入，组件不连后端（见 CLIENT-CONTRACT.md 3.2.1）。
      sid 非空 = 打开该会话（组件会走 readSession 回放历史）；s = 该会话对象（标题取 prompt_head）；空 = 新会话。 */
   function mountConversation(sid, s) {
+    /* 同一条会话、同一个空间：组件还活着，画面也还在 —— 直接把这一屏端回来。
+       以前这里无条件 destroy() + create() + innerHTML=''，于是「返回列表 → 再点进来」
+       每次都要重拉全量历史、重新建 DOM、重新回放（长会话 = 又慢又费流量）。
+       标题 / 引擎 / 模型交给组件的 setSession 同步（它对本会话是幂等的）。 */
+    if (conv && sid && sid === convSid && WS === convWs) {
+      try { conv.setSession(sid, s); } catch (e) {}
+      window.magicConv = conv;
+      return;
+    }
     if (conv) { try { conv.destroy(); } catch (e) {} conv = null; }
     convEl.innerHTML = '';
+    convSid = sid || null;
+    convWs = WS;
+    /* 每次重建组件都丢掉「上一条还没落定的新会话」的临时开关 —— 否则用户在新会话里
+       开了团队但没发消息，转去打开一条历史会话时，那条会话的首帧会把开关误记成开启。
+       老会话的开关由 teamOnFor 从它自己那份记录里取；新会话从「关」起。 */
+    TEAM.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,
         showPermission: false, showAttach: true, beforeAsk: gateAsk,
+        onInterrupt: cancelWaitingAsk,
+        /* 组件内排队也要落库（2026-10-21 用户：「非团队的串行排队也没落库」）：
+           会话正在跑、或第一句还压在串行门里时又提交的那一句，原先只在组件内存里，
+           刷新就消失。这三个钩子把它接进下面同一套 PENDING（magic.serial.queue.v1），
+           重开 App 由 restoreQueue 接着发。 */
+        onQueuePush: queuePushed,
+        onQueueTake: queueTaken,
+        onQueueDrop: queueDropped,
         onPick: rememberRunPick,
-        onMenu: function (key) { if (key === 'scheduled') showSched(); }
+        /* 团队模式：开关初值按**这条会话**给；配置是设备偏好（每轮现读，改配置立刻生效）。
+           features 也给函数：能力清单是异步拉到的（/desk/health），
+           查到之后开关才会亮出来，不必重新挂载组件。 */
+        team: teamOnFor(sid, s),
+        onTeamChange: onTeamToggleFromConv,
+        teamConfig: function () {
+          return {
+            routes: TEAM.routes || {},
+            rules: TEAM.rules || {},
+            parallel: TEAM.parallel,
+            split: TEAM.split || 'standard',
+            splitCode: !!TEAM.splitCode,
+            adaptive: TEAM.adaptive !== false
+          };
+        },
+        features: function () { return CORE_FEATURES; },
+        /* 新会话的开关先记在 TEAM.fresh：core 的首帧带回 session_id 时，当场绑到这条会话上
+           （否则返回列表再点进来就找不到它了）。 */
+        onEvent: function (ev) { bindFreshTeam(ev && ev.session_id); },
+        /* 菜单里的「定时任务」还在，但底部那个 tab 已经删了（2026-10-22 用户：
+           「定时任务tab先删除」）。现在点它给一句说明，而不是跳去一张只有一个占位符的页 ——
+           原先那页的正文就是这句说明，页面本身没有承载任何数据。
+           core 补上清单接口后，这里换成真正的调度页即可。 */
+        onMenu: function (key) {
+          if (key === 'scheduled') {
+            /* openComingSheet 走 textContent（不是 innerHTML），所以这里给纯文本，别塞 <br>。 */
+            openComingSheet('定时任务',
+              'magic-agent 当前没有「定时任务清单」接口。需要的话可以按 core 的自动化能力接上。');
+          }
+        }
       });
       if (sid) conv.setSession(sid, s);
       window.magicConv = conv;
@@ -1357,25 +2190,52 @@ button.setrow{font-family:inherit}
     }
   }
   function openSession(sid, s) {
-    if (s && s.workspace) { WS = s.workspace; saveWs(); }
+    /* ⚠️ 一律以会话自己的归属为准，**不能**只在其有 workspace 时才改 WS（2026-10-21）：
+       原写法 `if (s && s.workspace) { WS = s.workspace; }` 会让「打开一条默认空间的会话」
+       保留上一条会话的空间 —— 于是点进默认会话、发追问，实际跑在了上一个空间里，
+       而设置面板显示的空间名也跟着串。空 workspace = 默认，同样要写回（写成 ''）。 */
+    WS = (s && s.workspace) || '';
+    saveWs();
     showSession(s && s.workspace ? basename(s.workspace) : histSubtitle);
     mountConversation(sid, s);
   }
-  function newConversation() { showSession(); mountConversation(null); }
+  /* ws：不传 = 默认（不属于任何空间）；传字符串 = 在该空间里新建（列表里空间组的「＋」）。
+     ⚠️ 「新建任务」大按钮必须从**默认**起（2026-10-21 用户：「大的新建会话 空间应该是
+        默认 不是上一次历史的空间选择」）。WS 是跨会话记忆的：打开过某个空间的会话后，
+        它就一直粘在 WS 上，于是下一次点「新建任务」会静默落进上次那个空间 —— 用户完全
+        没有选过它，却拿到了别的目录。归属只在两种情况下确定：显式选空间，或点空间组的「＋」。 */
+  function newConversation(ws) {
+    WS = ws || '';
+    saveWs();
+    showSession();
+    mountConversation(null);
+  }
 
   function connect(target) {
     BASE = target.url || '';
     TOKEN = target.token || '';
-    recordRecent(target);
+    var c = upsertConn(target);
+    ACTIVE_ID = c.id;
     showError('');
-    showHistory(target.host || '');
+    showHistory(c.host || '');
     startPoll();
+    restoreQueue();          // 上次没轮到的排队任务：连上就接着排（见 restoreQueue）
   }
   function disconnect() {
     stopPoll();
+    closeEnvMenu();
     if (conv) { try { conv.destroy(); } catch (e) {} conv = null; }
     convEl.innerHTML = '';
     BASE = ''; TOKEN = '';
+    ACTIVE_ID = '';
+    SERVER_VERSION = '';   // 版本号属于「那一条连接」：断开就清掉，避免下次连到别的机器还显示旧值
+    /* 排队任务**不跟着断连消失**（它们已经落库）：只清内存里的等待态，下次连上由
+       restoreQueue 从磁盘接回来。串行门的 FIFO 也一并重置 —— 里面的 tail 是挂在一条
+       已废弃页面上的 promise，留着会让新连接的第一条永远排在它后面。 */
+    PENDING = [];
+    ASK_WAITING = [];
+    SERIAL = {};
+    QUEUE_RESTORED = false;
     showLauncher();
   }
 
@@ -1399,8 +2259,12 @@ button.setrow{font-family:inherit}
      进度那一列不靠重绘：RUN_TICK 每 3s 就地刷「第 N 步」与时长（见 tickRunning）。 */
   var LIST_POLL = null;
   function sessionSig(list) {
+    /* 带 status：会话级状态变化（status 变了、row 的 state 可能没变）要能触发重绘。
+       父字段也要比：子会话**挂在哪条主会话下面**是结构信息，父会话晚到/换 id 时
+       清单若判「没变」就不重绘，子会话会一直留在顶层或挂错地方。 */
     return (list || []).map(function (s) {
-      return sidOf(s) + ':' + (s.state || '') + ':' + (s.updated_at || '');
+      return sidOf(s) + ':' + (s.status || '') + ':' + (s.state || '') + ':' + (s.updated_at || '')
+        + ':' + (s.parent_session_id || '') + ':' + (s.parent_run_id || '');
     }).join('|');
   }
   function startListPoll() {
@@ -1437,9 +2301,28 @@ button.setrow{font-family:inherit}
     Promise.all([pList, pTitles, pHealth, pDirs]).then(function (a) {
       TITLES = a[1] || {};
       DW = (a[2] && a[2].defaultWorkspace) || '';
+      DW_READY = true;
       SPACES_ROOT = (a[2] && a[2].workspacesRoot) || '';
+      /* core 版本（2026-10-22）：/desk/health 的 version，顺手缓存，「我的」页打开即用。
+         老 core 没有该字段 → 不覆盖已有值（可能刚由 refreshMineVersion 拿到）。 */
+      if (a[2] && a[2].version) SERVER_VERSION = a[2].version;
+      if (!mineEl.hidden) paintMineVersion();
+      /* core 能力位（feature.*）：团队开关要不要显示就看它。连上桌面后才有，
+         所以「我的」那张卡片与运行设置里的那一行都要在这里刷一次。 */
+      CORE_FEATURES = ((a[2] && a[2].features) || []);
+      /* 连接的身份（app）：连着哪台设备就记到哪条连接上，环境菜单里当类型标签用。 */
+      if (a[2] && a[2].app) noteActiveMeta({ app: a[2].app });
+      /* 团队角色清单（2026-10-22）：core 上报什么就画什么，客户端不硬编码角色名。
+         老 core 没有 teamRoles → 空数组 → paintTeamPref 用内置表兜底。 */
+      TEAM_ROLES = ((a[2] && a[2].teamRoles) || []).filter(function (r) {
+        return r && r.name;
+      });
+      paintTeamPref();
       ROOT_DIRS = (((a[3] && a[3].dirs) || [])).filter(function (d) { return String(d.name).indexOf('magic-') === 0; });
       renderSessions(Array.isArray(a[0]) ? a[0] : []);
+      /* 排队任务的接续要等 DW 到手（空间键靠它归一）—— 首次列表到手正是这个时刻。
+         幂等：QUEUE_RESTORED 保证只接一次。之前若因 DW 未就绪被跳过，这里补上。 */
+      restoreQueue();
       /* 给**还没归纳过**的会话补一次（core 幂等，已有的直接回 cached 不重复调 LLM）。
          判定认 core 的 `title_summarized`，**不能**认「title 为空」——
          core 的 title 恒非空（没归纳就回落 prompt_head），拿空判会永远不触发
@@ -1460,23 +2343,31 @@ button.setrow{font-family:inherit}
   var SEC_COLLAPSED = {};
   var TASKS_EXPANDED = false;
   var WS_OPEN = {};
+  /* 任务页分组口径：置顶 / 任务 / 空间分段；搜索态（TASK_QUERY 非空）恒为平铺 ——
+     跨分组找同一条任务才有意义。 */
+  var TASK_QUERY = '';
   var PINNED = [];
   try { PINNED = JSON.parse(localStorage.getItem('magic.pinned') || '[]') || []; } catch (e) { PINNED = []; }
   function savePinned() { try { localStorage.setItem('magic.pinned', JSON.stringify(PINNED)); } catch (e) {} }
   var TITLES = {};   // 服务端标题覆盖表（GET /desk/titles），重命名用
   var DW = '';       // 桌面默认工作空间（GET /desk/health 的 defaultWorkspace = core 的 cwd）
+  var DW_READY = false;   // DW 是否已从 health 落定（空间键归一依赖它，见 restoreQueue）
   var SPACES_ROOT = '';   // 工作空间根（health.workspacesRoot）
   var ROOT_DIRS = [];     // 根目录下 magic-* 目录（GET /desk/dirs）
   var CUSTOM_SPACES = [];
   try { CUSTOM_SPACES = JSON.parse(localStorage.getItem('magic.spaces') || '[]') || []; } catch (e) { CUSTOM_SPACES = []; }
   function saveSpaces() { try { localStorage.setItem('magic.spaces', JSON.stringify(CUSTOM_SPACES)); } catch (e) {} }
-  /* 空间候选 = 根目录下的 magic-* + 自定义 + 会话里出现过的 workspace（去重、保序）。 */
+  /* 空间候选 = 根目录下的 magic-* + 自定义 + 会话里出现过的 workspace（去重、保序）。
+     ⚠️ 会话的 workspace 为空时**不要**拿 DW 顶上（原写法 `s.workspace || DW`）：
+        那样「默认（不指定）」与「默认目录名」会变成两行同名选项，一个落「任务」段、
+        一个落「空间」段，用户点哪个都说不清（2026-10-21 报「无法选择默认」）。
+        没有 workspace 的会话本来就属于「默认」，不该在候选里再出现一次。 */
   function collectSpaceKeys() {
     var seen = {}, out = [];
     function add(p) { if (p && !seen[p]) { seen[p] = 1; out.push(p); } }
     (ROOT_DIRS || []).forEach(function (d) { add(d.path); });
     CUSTOM_SPACES.forEach(add);
-    (LAST_SESSIONS || []).forEach(function (s) { add(s.workspace || DW); });
+    (LAST_SESSIONS || []).forEach(function (s) { add(s && s.workspace); });
     return out;
   }
   /* 会话标题：**以 core 给的 title 为准**（2026-10-15，用户「应该 magic-agent 统一归纳作为
@@ -1486,6 +2377,31 @@ button.setrow{font-family:inherit}
      TITLES 仍作为**兜底**：老版本 core 的 --sessions 没有 title 字段。 */
   function titleOf(s) { return s.title || TITLES[sidOf(s)] || s.prompt_head || String(sidOf(s)).slice(0, 8); }
 
+  /* ── 任务页：工程名（用于「分组视图」与搜索命中）──
+     工程名取会话 workspace 的目录名；没有 workspace 的会话用桌面默认工作空间 DW 顶上
+     （它确实跑在那儿：core 用调用方 cwd）。 */
+  function projectOf(s) {
+    var w = (s && s.workspace) || DW || '';
+    return w ? basename(w) : '';
+  }
+  /* 搜索口径：标题 / 工程名 / 引擎 / 模型 / 首问，任一处命中即可（大小写不敏感）。 */
+  function taskMatches(s) {
+    if (!TASK_QUERY) return true;
+    var hay = [titleOf(s), projectOf(s), s.engine || '', qaModelText(s.model) || '', s.prompt_head || '']
+      .join(' ').toLowerCase();
+    return hay.indexOf(TASK_QUERY) >= 0;
+  }
+  /* 搜索态：隐藏分组行，结果平铺（对齐截图 2）。关掉时清空词并回到原口径。 */
+  function setTaskSearch(on) {
+    taskSearchBar.hidden = !on;
+    var box = document.getElementById('history');
+    if (box) box.classList.toggle('is-searching', !!on);
+    TASK_QUERY = '';
+    taskSearchInput.value = '';
+    renderSessions(LAST_SESSIONS);
+    if (on) { try { taskSearchInput.focus(); } catch (e) {} }
+  }
+
   /* ── 让 core 归纳标题（POST /desk/session/{id}/title/summarize）──
      为什么需要它：归纳口径已收进 core，但**要有人去触发**。桌面端有客户端在触发，
      移动端此前没有 —— 于是从手机发起的会话永远没人替它归纳，只能显示首问原文
@@ -1604,18 +2520,27 @@ button.setrow{font-family:inherit}
     }
     return h;
   }
-  /* 会话状态：由 /desk/sessions 的 state / alive 映射（running / waiting_approval / done / 其它）。 */
+  /* 会话状态：由 /desk/sessions 的 status（会话级统一状态，见 core 的 session-status.json）
+     映射；老版本 CLI 不给 status 时回落 state。running / waiting_approval / done / 其它。 */
   function statusOf(s) {
-    var st = String(s.state || '');
+    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';
     return 'idle';
   }
-  /* 会话行图标：**设备形状按来源端**（mobile=手机 / 其它=电脑），状态用颜色区分（无角标）。 */
+  /* 会话行图标：团队会话=双人图形（mode:"team"），其余**设备形状按来源端**
+     （mobile=手机 / 其它=电脑）；状态一律用颜色区分（无角标）。
+     这条会话有追问在排队时（FUP 里有它），图标切到 queued 这一种等待样式 ——
+     排队标记**只做在图标里**，行尾不再挂角标
+     （2026-10-21 用户：「排队标志在会话左边的图标里设计 1 个等待样式即可」）。
+     团队标记同理：直接换图形，不再叠小圆角标。 */
   function sessionIcon(s) {
-    var ico = elSpan('srow__ico srow__ico--' + statusOf(s));
-    ico.appendChild(svgUse(String(s && s.source) === 'mobile' ? '#i-phone' : '#i-laptop', 20));
+    var st = (FUP[sidOf(s)] || []).length ? 'queued' : statusOf(s);
+    var ico = elSpan('srow__ico srow__ico--' + st);
+    var glyph = (s && s.mode === 'team') ? '#i-team'
+      : (String(s && s.source) === 'mobile' ? '#i-phone' : '#i-laptop');
+    ico.appendChild(svgUse(glyph, 20));
     return ico;
   }
   /* ── 运行中任务的**真实进度** ──
@@ -1633,7 +2558,10 @@ button.setrow{font-family:inherit}
     var m = Math.floor(sec / 60), ss = sec % 60;
     return m >= 60 ? (Math.floor(m / 60) + ':' + pad2(m % 60) + ':' + pad2(ss)) : (m + ':' + pad2(ss));
   }
-  function runningSub(s, steps) { return steps ? ('运行中 · 第 ' + steps + ' 步') : '运行中'; }
+  function runningSub(s, steps) {
+    var p = projectOf(s);
+    return (steps ? '运行中 · 第 ' + steps + ' 步' : '运行中') + (p ? ' · ' + p : '');
+  }
   /* 取「已跑到第几步」。**读过的部分不再重读**（2026-10-20）：
      原来每 3s 对每条 running 会话拉一次全量 `/messages`，只为数 tool_use 的条数 ——
      长会话下等于让手机每 3 秒解析一遍几百 MB 的历史（列表页的主要卡顿来源）。
@@ -1678,20 +2606,45 @@ button.setrow{font-family:inherit}
   function ensureTicker() {
     if (!RUN_TICK && Object.keys(RUN_ROWS).length) RUN_TICK = setInterval(tickRunning, 3000);
   }
-  function sessionRow(s) {
+  /* 子会话（团队模式拆出的子任务，2026-10-22）：core 在 /desk/sessions 里给出
+     parent_session_id / parent_run_id（见 internal/session 的 Record）。子任务是**普通会话**
+     （自己的登记 + 自己的日志，点进去看完整过程），列表里只做两件事：
+       · 不占顶层一行 —— 缩进挂在主会话下面（CHILD_OF：父 key → 子会话数组）；
+       · 不进「任务 / 空间」分组（它们的 workspace 是主会话里的任务目录，不该自成一个空间）。
+     ⚠️ 父会话不在列表里（被删 / 老 core 没给父字段）→ 回落成顶层一行，
+        宁可多一行也不能让子会话凭空消失。
+     ⚠️ 主会话可能还没拿到 session_id，parent_session_id 同时给了 parent_run_id 兜底。 */
+  var CHILD_OF = {}, CHILD_IDS = {};
+  function parentKeyOf(s) { return (s && (s.parent_session_id || s.parent_run_id)) || ''; }
+  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 box = document.createElement('div');
+      box.className = 'sblock__kids';
+      kids.forEach(function (k) { box.appendChild(sessionRow(k, true)); });
+      wrap.appendChild(box);
+    }
+    return wrap;
+  }
+  function sessionRow(s, sub) {
     var b = document.createElement('button');
-    b.type = 'button'; b.className = 'srow';
+    b.type = 'button'; b.className = 'srow' + (sub ? ' srow--sub' : '');
     b.setAttribute('data-sid', sidOf(s));   // ensureTitle 就地改标题时要按 id 找这一行
     var run = statusOf(s) === 'run';
     b.appendChild(sessionIcon(s));
     var col = elSpan('srow__col');
     col.appendChild(elSpan('srow__t', titleOf(s)));
     var sid = sidOf(s);
+    /* 副标题 = 引擎 · 模型；运行中换成「运行中 · 第 N 步」。
+       进度只改这一个文本节点（RUN_ROWS.subEl 指向它）。 */
     var subEl = elSpan('srow__s', run ? runningSub(s, RUN_STEPS[sid] || 0)
-                                       : [s.engine || '', s.model || ''].filter(Boolean).join(' · '));
+                                       : [s.engine || '', qaModelText(s.model)].filter(Boolean).join(' · '));
     col.appendChild(subEl);
-    var pin = elSpan('srow__pin' + (isPinned(s) ? ' is-on' : '')); pin.appendChild(svgUse('#i-pin', 16));
-    b.appendChild(col); b.appendChild(pin);
+    /* 排队与团队标记都不在这里做：两者都做在图标里（见 sessionIcon），行尾不再挂角标。 */
+    b.appendChild(col);
     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); }
@@ -1703,6 +2656,10 @@ button.setrow{font-family:inherit}
     b.addEventListener('pointerup', cancel);
     b.addEventListener('pointerleave', cancel);
     b.addEventListener('pointercancel', cancel);
+    /* 桌面端把「右键」当「长按」：PC 上没有长按习惯，右键必须能出同一个菜单
+       （2026-10-22 用户：「桌面这个没有兼容pc端 比如右键无法出选择」）。
+       顺手 preventDefault 掉系统菜单，免得和浮动菜单一起冒出来。 */
+    b.addEventListener('contextmenu', function (e) { e.preventDefault(); cancel(); openRowMenu(b, s); });
     b.onclick = function () { if (lp) { lp = false; return; } openSession(sidOf(s), s); };
     return b;
   }
@@ -1727,10 +2684,10 @@ button.setrow{font-family:inherit}
     tog.onclick = function () { WS_OPEN[key] = !open; renderSessions(LAST_SESSIONS); };
     var add = document.createElement('button'); add.type = 'button'; add.className = 'wsrow__add';
     add.setAttribute('aria-label', '在此空间新建会话'); add.appendChild(svgUse('#i-plus', 16));
-    add.onclick = function () { WS = key; newConversation(); };
+    add.onclick = function () { newConversation(key); };
     head.appendChild(tog); head.appendChild(add);
     wrap.appendChild(head);
-    if (open) list.forEach(function (s) { wrap.appendChild(s.pendingWait ? pendingRow(s) : sessionRow(s)); });
+    if (open) list.forEach(function (s) { wrap.appendChild(sessionBlock(s)); });
     return wrap;
   }
   function renderSessions(list) {
@@ -1746,12 +2703,60 @@ button.setrow{font-family:inherit}
     rows.sort(function (a, b) {
       return String(b.updated_at || b.started_at || '').localeCompare(String(a.updated_at || a.started_at || ''));
     });
+    /* 子会话归类（团队模式）：父会话在列表里的，子会话从顶层摘走、改挂到父会话下面；
+       父会话不在列表里的（被删 / 父字段缺失）留作顶层一行 —— 不能凭空消失。
+       子会话内部按 started_at 正序（与任务列表 t1..tn 同序，倒序会看得莫名其妙）。 */
+    /* ⚠️ 认父要**按 id 别名**认，不能只按 sidOf 比字面：子会话创建时父会话还没拿到
+       session_id，core 只能把 parent_run_id 写进登记（见 internal/session 的 Record）——
+       等父会话的 session_id 回来，sidOf(父) 就变成 session_id 了，而子会话手里仍是 run_id，
+       字面比对必然失配 → 子会话掉回顶层、又被当成 workspace 自成一个「空间」。
+       KEY2SID 把 session_id 与 run_id 都指向同一个规范 key（sidOf），认父时统一折算。 */
+    var KEY2SID = {};
+    rows.forEach(function (s) {
+      var sid = sidOf(s);
+      if (!sid) return;
+      KEY2SID[sid] = sid;
+      if (s.run_id) KEY2SID[s.run_id] = sid;
+      if (s.session_id) KEY2SID[s.session_id] = sid;
+    });
+    CHILD_OF = {}; CHILD_IDS = {};
+    var top = [];
+    rows.forEach(function (s) {
+      var pk = KEY2SID[parentKeyOf(s)] || '';
+      if (pk && pk !== sidOf(s)) {
+        (CHILD_OF[pk] = CHILD_OF[pk] || []).push(s);
+        CHILD_IDS[sidOf(s)] = 1;
+      } else top.push(s);
+    });
+    Object.keys(CHILD_OF).forEach(function (k) {
+      CHILD_OF[k].sort(function (a, b) {
+        return String(a.started_at || '').localeCompare(String(b.started_at || ''));
+      });
+    });
+    rows = top;
+    /* ⚠️ **追问排队不占一行**（2026-10-21 用户：「追问排队不要出现一个新会话啊」）：
+       带 session 的排队条目属于它那条会话，行还在的话只在那一行上加个「追问排队中」角标
+       （见 sessionRow 里的 FUP 判断）。否则列表凭空多出一条「新任务」，看着像用户自己
+       又开了一个会话 —— 而这恰恰是串行门要防的误会。
+       只有**那条会话暂时不在列表里**（刚建、列表还没刷新）时才退回成独立一行，
+       宁可多一行也不能让排队的任务从界面上消失（那正是上次报障「排队任务丢了」）。
+       ⚠️ 这段必须排在**渲染置顶之前**：置顶行也是 sessionRow，算晚了角标就丢了。 */
+    var PEND_VIS = PENDING.filter(function (p) { return !p.hide; });
+    var rowIds = {};
+    FUP = {};                     // 模块级：sessionRow 要用（见其上方注释）
+    rows.forEach(function (s) { rowIds[sidOf(s)] = 1; });
+    PEND_VIS.forEach(function (p) {
+      if (p.session && rowIds[p.session]) (FUP[p.session] = FUP[p.session] || []).push(p);
+    });
+    var PEND_ROWS = PEND_VIS.filter(function (p) { return !p.session || !rowIds[p.session]; });
     /* 一次性构建到 DocumentFragment，最后 replaceChildren 单次替换 —— 无「先清空」的中间空态，
        所以删除、折叠、展开等重绘都不闪。 */
     var frag = document.createDocumentFragment();
-    if (!rows.length && !PENDING.length) {
+    var searching = !taskSearchBar.hidden;
+    var query = TASK_QUERY.trim();
+    if (!rows.length && !PEND_VIS.length) {
       var hint = document.createElement('div'); hint.className = 'history__hint';
-      hint.textContent = '还没有会话。点上面「新建任务」开一个。';
+      hint.textContent = searching ? '还没有任务。' : '还没有会话。点上面「新建任务」开一个。';
       frag.appendChild(hint);
       historyList.replaceChildren(frag);
       ensureTicker();
@@ -1759,26 +2764,47 @@ button.setrow{font-family:inherit}
       return;
     }
 
+    /* 搜索态：不分组、不出「分组视图」行，命中项平铺（对齐截图 2）。 */
+    if (searching) {
+      var matched = query ? rows.filter(taskMatches) : rows;
+      if (!matched.length && query) {
+        var miss = document.createElement('div'); miss.className = 'history__hint';
+        miss.textContent = '没有匹配「' + TASK_QUERY + '」的任务。';
+        frag.appendChild(miss);
+      } else {
+        /* 没输入词时，刚建还没进列表的排队任务也要看得见（与下面分组口径一致）。 */
+        if (!query) PEND_ROWS.forEach(function (p) { frag.appendChild(pendingRow(p)); });
+        matched.forEach(function (s) { frag.appendChild(sessionBlock(s)); });
+      }
+      historyList.replaceChildren(frag);
+      ensureTicker();
+      if (!Object.keys(RUN_ROWS).length && RUN_TICK) { clearInterval(RUN_TICK); RUN_TICK = null; }
+      return;
+    }
+
     /* 置顶：只在这里显示；置顶项不再出现在「任务 / 空间」里（去重） */
     var pinned = rows.filter(isPinned);
     var rest = rows.filter(function (s) { return !isPinned(s); });
-    if (pinned.length) {
-      frag.appendChild(secHead('置顶', pinned.length, false, 'pin'));
-      if (!SEC_COLLAPSED.pin) pinned.forEach(function (s) { frag.appendChild(sessionRow(s)); });
-    }
 
     /* 任务：**不属于任何空间**的普通任务（且未置顶）+ 默认空间（不指定）的串行等待任务。
        显式选了空间的等待任务归到下面的「空间」组（用户 2026-10-20：「串行等待中的任务
        现在没有显示在所属 workspace 中」）—— 它们还没真正下发、没有 session_id，不能走
-       sessionRow，所以带 pendingWait 标记混进空间组，由 workspaceGroup 分流渲染。 */
-    var pendingTasks = PENDING.filter(function (p) { return !p.explicit; });
+       sessionRow，所以带 pendingWait 标记混进空间组，由 workspaceGroup 分流渲染。
+       ⚠️ 只在列表里画**可见**的排队条目：hide 的那批是刚进队、还在等一次探测才知道要不要
+       真等的（见 gateAsk 的 markWaiting）；但它们在磁盘上已经存在，关 App 也不丢。
+       PEND_ROWS = 需要**自己占一行**的排队条目（上面已算好：新任务，或那条会话暂时不在列表里）。 */
+    var pendingTasks = PEND_ROWS.filter(function (p) { return !p.explicit; });
     var tasks = rest.filter(function (s) { return !s.workspace; });
+    if (pinned.length) {
+      frag.appendChild(secHead('置顶', pinned.length, false, 'pin'));
+      if (!SEC_COLLAPSED.pin) pinned.forEach(function (s) { frag.appendChild(sessionBlock(s)); });
+    }
     if (tasks.length || pendingTasks.length) {
       frag.appendChild(secHead('任务', tasks.length + pendingTasks.length, true, 'tasks'));
       if (!SEC_COLLAPSED.tasks) {
         pendingTasks.forEach(function (p) { frag.appendChild(pendingRow(p)); });
         var limit = TASKS_EXPANDED ? tasks.length : Math.min(8, tasks.length);
-        tasks.slice(0, limit).forEach(function (s) { frag.appendChild(sessionRow(s)); });
+        tasks.slice(0, limit).forEach(function (s) { frag.appendChild(sessionBlock(s)); });
         if (tasks.length > limit) {
           var more = document.createElement('button'); more.type = 'button'; more.className = 'more';
           more.textContent = '展开更多 (' + (tasks.length - limit) + ')';
@@ -1796,8 +2822,9 @@ button.setrow{font-family:inherit}
     });
     /* 等待中的新任务：显式空间 → 放进该空间组**最上面**（状态最需要被看见）。
        不能只靠上面的 rest 建 key：某空间只有排队任务、还没有任何会话时，bySpace 里
-       本来没有它，下面的 sKeys 就不会出现这个空间 —— 这正是「没显示在所属 workspace」的另一半。 */
-    PENDING.forEach(function (p) {
+       本来没有它，下面的 sKeys 就不会出现这个空间 —— 这正是「没显示在所属 workspace」的另一半。
+       用 PEND_ROWS 而不是 PEND_VIS：并进原会话行的追问不该再在空间组里插一行。 */
+    PEND_ROWS.forEach(function (p) {
       if (!p.explicit || !p.ws) return;
       (bySpace[p.ws] = bySpace[p.ws] || []).unshift(p);
     });
@@ -1849,6 +2876,46 @@ button.setrow{font-family:inherit}
     if (b < 1024 * 1024) return (b / 1024).toFixed(b < 10240 ? 1 : 0) + ' KB';
     return (b / 1024 / 1024).toFixed(1) + ' MB';
   }
+  /* ══════════ 图片大图（缩略图点开看原图）══════════
+     缩略图在移动端按 480 宽取（transport-http 的 thumbQuery），细节看不清；
+     点一下换成**同一条回读地址去掉 w 参数**的原图（服务端 /desk/media 不带 w 就发原文件）。
+     浮层黑底 contain、点任意处关闭 —— 与 PC 端 #shot-viewer 同一套语义。
+     ⚠️ 必须**去掉 w**而不是另拼一条地址：路径 / 令牌 / 编码都在缩略图地址里，
+        重拼一份只会漏掉其中某一截（旧令牌、base 前缀都是这么踩过的）。 */
+  var imgViewEl = document.getElementById('imgview');
+  var imgViewImg = document.getElementById('imgviewImg');
+  var imgViewName = document.getElementById('imgviewName');
+  function bigSrc(src) {
+    if (!src) return '';
+    try {
+      var u = new URL(src, location.href);
+      if (!u.searchParams.has('w')) return u.href;
+      u.searchParams.delete('w');
+      return u.href;
+    } catch (e) { return src; }
+  }
+  function closeImgView() {
+    if (!imgViewEl || imgViewEl.hidden) return;
+    imgViewEl.hidden = true;
+    imgViewImg.removeAttribute('src');       // 原图别一直占着内存
+  }
+  function openImgView(src, name) {
+    if (!imgViewEl || !src) return;
+    imgViewImg.src = bigSrc(src);
+    imgViewImg.alt = name || '';
+    imgViewName.textContent = name || '';
+    imgViewEl.hidden = false;
+  }
+  if (imgViewEl) {
+    imgViewEl.addEventListener('click', function (e) {
+      e.preventDefault(); e.stopPropagation();
+      closeImgView();
+    });
+  }
+  document.addEventListener('keydown', function (e) {
+    if (e.key === 'Escape' && imgViewEl && !imgViewEl.hidden) { e.preventDefault(); closeImgView(); }
+  }, true);
+
   function closeReader() { if (readerEl) readerEl.hidden = true; }
   function openReader(p) {
     if (!readerEl) return;
@@ -1883,7 +2950,7 @@ button.setrow{font-family:inherit}
         try { box.innerHTML = mdToHtmlOnly(text); } catch (e) { box.textContent = text; }
         rdBody.appendChild(box);
         if (typeof highlightIn === 'function') { try { highlightIn(box); } catch (e) {} }
-        /* 文档里的本机图片：换成回读地址（移动端 fileUrl 自带 w=720，慢网也出得来）。 */
+        /* 文档里的本机图片：换成回读地址（移动端 fileUrl 自带 w=480，慢网也出得来）。 */
         if (window.desk && typeof window.desk.mediaUrl === 'function') {
           Array.prototype.forEach.call(box.querySelectorAll('img[src]'), function (im) {
             var src = im.getAttribute('src') || '';
@@ -1905,6 +2972,14 @@ button.setrow{font-family:inherit}
   }
   document.addEventListener('click', function (e) {
     var t = e.target;
+    /* 图片：缩略图（产物卡 / 正文截图 / 输入框附件条）点开看原图 —— 优先于下面的产物卡分支，
+       因为图片卡本身也是 .qa-art（走到那里只会被判成「不是文件档」而放过）。 */
+    var im = (t && t.closest) ? t.closest('.qa-art-image img, .qa-atts img, .ag-att .thumb, .qa-t img') : null;
+    if (im) {
+      e.preventDefault(); e.stopPropagation();
+      openImgView(im.getAttribute('src'), im.getAttribute('alt'));
+      return;
+    }
     var card = (t && t.closest) ? t.closest('.qa-art') : null;
     if (!card) return;
     if (card.querySelector('video,audio')) return;      // 音视频：让原生控件自己处理
@@ -1922,6 +2997,308 @@ button.setrow{font-family:inherit}
   document.addEventListener('keydown', function (e) {
     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 同构
+
+  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;
+  }
+
+  /* 工作区组：与会话列表的 workspaceGroup 同一套骨架（可折叠的组头 + 组内行）。
+     差别只有两点：组头右侧没有「+ 新建」，行是需求文档不是会话。 */
+  function reqWorkspaceBlock(w) {
+    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;
+    var open = (REQ_OPEN[key] !== undefined) ? !!REQ_OPEN[key] : true;   // 需求页默认全展开
+    var tog = document.createElement('button');
+    tog.type = 'button'; tog.className = 'wsrow__open';
+    tog.appendChild(elSpan('wsrow__l', w.name || w.dir || w.id));
+    /* 待整理条数做成徽标（与「等待中」同款）：折叠起来也看得见这个空间在长新需求。 */
+    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);
+    }
+    (w.modules || []).forEach(function (m) {
+      /* 模块（大功能点）用一条小节标题，形状与「置顶 / 任务 / 空间」的 sechead 一致：
+         名字 + 条数。未归类（name 为空）不标题、直接平铺 ——
+         老数据是平铺目录，硬给它编个「未归类」反而像出了错。 */
+      var fs = (m.features || []);
+      if (!fs.length) return;
+      if (m.name) {
+        var mh = hEl('div', 'sechead');
+        mh.style.paddingLeft = '16px';
+        mh.appendChild(elSpan('sechead__t', m.name + ' (' + fs.length + ')'));
+        wrap.appendChild(mh);
+      }
+      fs.forEach(function (f) { wrap.appendChild(reqFeatureRow(f)); });
+    });
+    return wrap;
+  }
+
+  function renderRequirements() {
+    if (!reqListEl) return;
+    var data = REQ_DATA;
+    if (!data) return;
+    /* 只画**有文档**的工作区（用户 2026-10-22：「没有的空间不显示」）。
+       feature_count 是 core 给的真值；老 core 不给时退化成数一遍模块里的行数。 */
+    var all = (data && data.workspaces) || [];
+    var list = all.filter(function (w) {
+      if (Number(w.feature_count) > 0) return true;
+      return (w.modules || []).some(function (m) { return (m.features || []).length > 0; });
+    });
+    var frag = document.createDocumentFragment();
+    if (!list.length) {
+      /* 一个功能点都还没有：说清「是没聊过」还是「聊过但没整理」——
+         后者要引导用户点「整理」，否则这一页看起来永远长不出东西。 */
+      var pend = 0, uninit = 0;
+      all.forEach(function (w) {
+        pend += Number(w.pending) || 0;
+        if (w.initialized === false) uninit++;
+      });
+      frag.appendChild(hEl('div', 'history__hint',
+        pend > 0
+          ? '有 ' + pend + ' 条对话还没整理成需求。点空间右侧「整理」只处理这个空间；右上角「全部整理」一次跑完所有空间。'
+          : (uninit > 0
+            ? '还没有需求。点空间右侧「整理」会先按空间目录生成一版需求基线；右上角「全部整理」一次处理所有空间。'
+            : '还没有任何需求。在任务里聊几句，这里会自动整理出功能点文档。')));
+      reqListEl.replaceChildren(frag);
+      return;
+    }
+    /* 工作区顺序照 core 给的（最后归纳时间倒序）—— 最近在动的排最前，
+       用户打开这一页多半是想看「刚聊的那些变成什么了」。 */
+    list.forEach(function (w) { frag.appendChild(reqWorkspaceBlock(w)); });
+    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 } : {};
+    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();
+      })
+      .then(function (d) {
+        REQ_DATA = d || { 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;
+    }
+    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;
+      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(); });
+
   function openHostSheet(title, build) {
     closeHostSheet();
     hostScrim = hEl('div', 'pick-scrim'); hostScrim.onclick = closeHostSheet;
@@ -1937,8 +3314,11 @@ button.setrow{font-family:inherit}
     document.addEventListener('keydown', onHostKey, true);
     build(body);
   }
-  function hRow(body, label, value, onClick, danger) {
+  /* selected：当前生效项打勾。**必须画出来**——底部抽屉关掉再开只需要一眼，不需要
+     用户记住上次点了哪一行；没有勾时「点了没反应」和「点了已生效」长得一模一样。 */
+  function hRow(body, label, value, onClick, danger, selected) {
     var b = hEl('button', 'pick__row'); b.type = 'button';
+    if (selected) { b.setAttribute('aria-selected', 'true'); b.appendChild(hEl('span', 'pick__ck', '✓')); }
     var l = hEl('span', 'pick__l', label); l.style.flex = '1'; l.style.minWidth = '0';
     b.appendChild(l);
     if (value != null) {
@@ -1951,71 +3331,570 @@ button.setrow{font-family:inherit}
     body.appendChild(b);
   }
   function applyWs() { if (conv && conv.setWorkspace) conv.setWorkspace(WS); }
-  function openRunSettings() {
-    openHostSheet('任务运行设置', function (body) {
-      hRow(body, '设备', histSubtitle || '本机', null);
-      hRow(body, '工作空间', basename(WS || DW) || '默认', function () { openWorkspacePicker(); });
-      var label = (conv && conv.permissionLabel) ? conv.permissionLabel() : '沿用默认';
-      var danger = !!(conv && conv.permissionTier && conv.permissionTier() === 'full');
-      hRow(body, '权限模式', label, function () {
-        closeHostSheet();
-        if (conv && conv.openPermissionPicker) conv.openPermissionPicker();
-      }, danger);
-    });
+  /* 工作空间值的显示：WS 为空 = 默认（不传 -w，core 用调用方 cwd）。
+     ⚠️ **绝不显示目录名**（2026-10-21 用户：「默认就是要不属于任何空间目录」）。
+        两次踩坑都在这句：`basename(WS || DW)` 让默认显示成目录名；改成「默认 · 目录名」
+        仍然在说「你这个默认就是那个目录」。而 client 进程的 cwd 本身就在某个 magic-* 里，
+        那个目录又同时是空间列表的一项 —— 文案一带上名字，用户立刻读成「我把那个空间
+        选成了默认」。这里是一条**归属**声明，不是路径提示：默认 = 不属于任何空间。 */
+  function wsLabel() { return WS ? (basename(WS) || WS) : '默认（不属于任何空间）'; }
+  /* 运行设置页的四个值：设备只读；工作空间来自 WS；权限 / 团队读当前会话组件。
+     组件没挂载时给「沿用默认 / 关闭」，不编造。 */
+  function paintRunSettings() {
+    var d = document.getElementById('rsDevice');
+    if (d) d.textContent = histSubtitle || '本机';
+    var w = document.getElementById('rsWorkspace');
+    if (w) w.textContent = wsLabel();
+    var p = document.getElementById('rsPermission');
+    if (p) p.textContent = (conv && conv.permissionLabel) ? conv.permissionLabel() : '沿用默认';
+    /* 全权限在本页也用红色行（与抽屉里 hRow 的 danger 同一口径）。 */
+    var permBtn = document.getElementById('btnRsPermission');
+    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-21：「团队模式开关在界面右上角跟权限模式一样」）。
+       core 没有这个能力位时**不显示**这一行 —— 显示一个点了必然失败的开关是最坏的做法。 */
+    var showTeam = !conv || typeof conv.featureOn !== 'function' || conv.featureOn('feature.session.team');
+    var teamBtn = document.getElementById('btnRsTeam');
+    if (teamBtn) teamBtn.hidden = !showTeam;
   }
   /* ── 任务模式门（串行）──
-     serial：同一空间同时只跑**一个新任务**；新任务若发现该空间已有任务在跑，就每 3 秒轮询
-     `/desk/sessions` 等它跑完再触发，并在列表里以「等待中」状态（紫色）显示。
-     历史会话的追问 isNew=false，永远不等待。 */
-  var PENDING = [];   // 等待中的新任务（本地，未真正下发）
-  function gateAsk(info) {
-    if (TASK_MODE !== 'serial' || !info || !info.isNew) return Promise.resolve();
-    var ws = info.workspace || DW;
-    var pendId = null;
-    function mark() {
-      if (pendId != null) return;
-      pendId = 'p' + Date.now() + '-' + Math.floor(Math.random() * 1000);
-      /* explicit：**显式选了空间**才归进「空间」段；默认（不指定）落「任务」段 ——
-         与 renderSessions 里会话按 `workspace` 是否为空分组的判定保持一致。
-         只存 ws=DW 不够：DW 本身也可能被显式选成空间。 */
-      PENDING.push({ id: pendId, ws: ws, explicit: !!info.workspace, pendingWait: true,
-                     prompt: info.prompt || '', engine: info.engine || '', at: Date.now() });
+     serial：同一空间同时只跑**一个新任务**；新任务若发现该空间已有任务在跑，就排队等待，
+     并在列表里以「等待中」状态（紫色）显示。
+     历史会话的追问 isNew=false，永远不等待。
+
+     ⚠️ 2026-10-21 修「串行模式下还是并行多个在跑」（用户报障）：旧实现里**每个**
+     beforeAsk 各自每 3s 打一次 /desk/sessions 判「有没有 running」。它有两个必然的并发口子：
+       ① 同一刻都判空闲 → 一起放行（连发两个新任务）；
+       ② 同一刻都判忙 → 3 秒后同一拍一起放行 —— 排队者之间**没有任何互斥**，
+          它们只是在各自和「正在跑的那条」比，谁也没看别人。
+     现在每个 workspace 一条 FIFO（SERIAL[ws]）：只有队首能检查，其余在原地看着「等待中」。
+     队首放行后也还不能立刻轮到下一条 —— core 起进程 + Begin 写登记表有窗口期，这期间
+     /desk/sessions 里看不到它，下一条会误判空闲照样并行。所以放行时先 held++ 占位，
+     等登记表真的出现该空间的 running 再 held--（probeLanded，带超时兜底）。
+     ⚠️ 口径仍是**按空间**串行：不同空间之间并行（这是原设计，见上面的注释）。
+
+     ⚠️ 2026-10-21 队列落库（用户报障「串行中任务关闭app再打开就丢失了 没落库」）：
+     排队条目原先只活在内存数组里，关掉 App 就整条消失 —— 连「它存在过」都不留痕。
+     现在 PENDING 与 localStorage('magic.serial.queue.v1') **同源**：进队即写、放行即删。
+     重开 App 后 restoreQueue() 把残留条目按原顺序重新排进队列，轮到就用 transport 直接
+     下发（不挂会话页面）—— 与「关掉 App 时正在跑的任务」同一口径：连接断了不等于取消，
+     事件照常落进会话日志，点开会话能回放。
+     每条都带 dev（桌面端地址）：只恢复发给**同一台机器**的条目，否则换个桌面连上去，
+     上次的排队任务会被打到另一台电脑上。 */
+  var SERIAL = {};              // ws → { tail: Promise, held: number, waiters: number }
+  var SLOT_POLL_MS = 3000;      // 排队中：多久再看一眼
+  var PROBE_MS = 700;           // 已放行：多久确认一次它落盘了（这段要快，用户正在等）
+  var LAND_TIMEOUT_MS = 20000;  // 放行后等它落盘的上限（超过就认为这条没跑起来，放行下一条）
+  var PENDING = [];             // 等待中的新任务（本地，未真正下发）
+  /* renderSessions 每帧算一次：session_id → 该会话**排队中的追问**列表。
+     sessionRow 渲染时从这里取角标（追问不另起一行，见 renderSessions 里的说明）。 */
+  var FUP = {};
+
+  /* 空间的归一键：**空 workspace 与桌面默认空间是同一个空间**（core 不传 -w 时用 cwd，
+     登记表里那条记录的 workspace 就是空 —— 两边必须归一到同一个键，否则「默认空间里
+     已经有一条在跑」会被判成另一空间而照样并行）。 */
+  function wsKey(w) { return w || DW; }
+  function wsOf(s) { return wsKey(s && s.workspace); }
+  /* 「这个空间有任务在跑」的判据。waiting_approval **不算**（沿用旧口径）：
+     它卡在等审批 / 等回答上，用户可能一直不理，算进去就等于把整个空间永久锁死；
+     代价是审批期间可能多起一个进程 —— 这是有意的取舍，不是遗漏。
+     跑没跑只认**会话级** status（同一条会话各轮一个记录，只看 state 会挑中旧轮得出
+     「还在跑」，追问就一直排队）；没有 status 的老 CLI 回落 state。 */
+  function serialBusy(s) { return (s.status || s.state) === 'running' || s.alive === true; }
+  function serialQ(ws) {
+    return SERIAL[ws] || (SERIAL[ws] = { tail: Promise.resolve(), held: 0, waiters: 0 });
+  }
+  function addPending(ws, info, hide) {
+    /* explicit：**显式选了空间**才归进「空间」段；默认（不指定）落「任务」段 ——
+       与 renderSessions 里会话按 `workspace` 是否为空分组的判定保持一致。
+       w 存**原始** workspace（空 = 不指定）：恢复时原样下发给 core，归组仍按 explicit 判。 */
+    var p = { id: 'p' + Date.now() + '-' + Math.floor(Math.random() * 1000),
+              ws: ws, w: info.workspace || '', explicit: !!info.workspace, pendingWait: true,
+              /* session：**历史会话的追问**要带着原会话 id 排队（2026-10-21 用户：
+                 「历史会话追问也要串行」）。不带的话，这条排队任务一旦经过重启恢复，
+                 就会被当成「一段新会话」发出去 —— 追问落到新会话里，原会话里什么都没有。
+                 （gateAsk 只用它来标记条目，下发给 core 走 fireQueued。） */
+              session: info.session || '',
+              prompt: info.prompt || '', engine: info.engine || '',
+              model: info.model || '', permission: info.permission || '',
+              /* team：重发时原样还原团队配置（见 fireQueued）——
+                 丢了它这条排队任务就会从「团队」静默降级成单任务。 */
+              team: info.team || null,
+              attachments: (info.attachments || []).slice(),
+              hide: !!hide, dev: devKey(), at: Date.now() };
+    PENDING.push(p); saveQueue();
+    if (!hide) renderSessions(LAST_SESSIONS);
+    return p;
+  }
+  function dropPending(id) {
+    if (id == null) return;
+    var n = PENDING.length;
+    PENDING = PENDING.filter(function (p) { return p.id !== id; });
+    purgeQueue(id);
+    if (PENDING.length !== n) renderSessions(LAST_SESSIONS);
+  }
+  /* ── 组件内排队 → 落库 ──
+     组件在**同一轮还没收尾**时会把新提交的追问压在自己内存里的队列（conversation.js
+     的 state.queue）。它和串行门是两条不同的队：串行门挡「还没开始的一轮」（跨会话/空间），
+     组件队排「同一会话上一轮还没结束的追问」。用户看到的都是「等待中 · 上一个完成后
+     自动开始」，但后者原先**一点都没落盘** —— 刷新/关 App 就整条消失
+     （2026-10-21 用户：「非团队的串行排队也没落库」）。
+     这里把它接进同一个 PENDING：进队即写 magic.serial.queue.v1、轮到就删行、取消就清盘。
+     重开 App 后由 restoreQueue 直接下发（不挂会话页面，事件仍进会话日志，点开可回放）。 */
+  var QPEND = {};              // 组件条目 id（q…）→ 本端 PENDING id（p…）
+  function queuePushed(info) {
+    if (!info || !info.id || !info.prompt || QPEND[info.id]) return;
+    /* hide：用户此刻就在会话里，气泡已经画出来了 —— 列表那条「等待中」延后
+       PENDING_SHOW_MS 再出现（与 gateAsk 同一口径：空间本来就空闲时不会闪一条假排队）。 */
+    var p = addPending(wsKey(info.workspace), info, true);
+    QPEND[info.id] = p.id;
+    setTimeout(function () {
+      if (PENDING.indexOf(p) < 0 || p.gone) return;
+      p.hide = false;
       renderSessions(LAST_SESSIONS);
+    }, PENDING_SHOW_MS);
+  }
+  function queueTaken(id) {
+    var pid = QPEND[id];
+    if (!pid) return;
+    delete QPEND[id];
+    dropPending(pid);
+  }
+  function queueDropped(id) {
+    var pid = QPEND[id];
+    if (!pid) return;
+    delete QPEND[id];
+    cancelPending(pid);          // 标取消 + 从 PENDING 与磁盘上一并删掉
+  }
+  /* ── 队列落库 ──
+     键用**令牌**而不是地址：令牌是这台桌面的身份（magic-client 把它落盘复用，跨重启不变），
+     而地址会变 —— 手机从 Wi-Fi 切到热点、桌面换了 IP、端口变了，用地址当键就等于把上次的
+     排队任务判成「另一台机器的」而整批丢掉。换一台桌面来配对时令牌不同，自然互不干扰。
+     loadQueue 只认当前令牌那批，别的**留在原地不动**（那台机器再连上来时还能用）——
+     所以这里是读改写，不是整体覆盖。 */
+  var QUEUE_KEY = 'magic.serial.queue.v1';
+  function devKey() { return String(TOKEN || '').slice(0, 12) || String(BASE || ''); }
+  function readQueueAll() {
+    try {
+      var a = JSON.parse(localStorage.getItem(QUEUE_KEY) || '[]');
+      return Array.isArray(a) ? a : [];
+    } catch (e) { return []; }
+  }
+  function saveQueue() {
+    var mine = devKey(), others = readQueueAll().filter(function (p) { return p.dev !== mine; });
+    /* 只落**持久**字段：hide / gone 是这一次页面会话里的显示态，存下去会让「关掉 App 时
+       正好还没到 300ms」的那条永远隐藏 —— 队列里有它、列表上却看不见，最难查的一种。
+       id 保留：恢复时据此与内存里已有的条目去重。 */
+    var mineRows = PENDING.map(function (p) {
+      return { id: p.id, ws: p.ws, w: p.w || '', explicit: !!p.explicit, pendingWait: true,
+               session: p.session || '',
+               prompt: p.prompt || '', engine: p.engine || '', model: p.model || '',
+               permission: p.permission || '', team: p.team || null,
+               attachments: p.attachments || [],
+               dev: p.dev, at: p.at };
+    });
+    try { localStorage.setItem(QUEUE_KEY, JSON.stringify(others.concat(mineRows))); } catch (e) {}
+  }
+  function loadQueue() {
+    var mine = devKey();
+    return readQueueAll().filter(function (p) { return p && p.dev === mine && p.prompt; });
+  }
+  /* 某条排队任务被用户放弃（划掉 / 删除）：磁盘上也要删，否则下次启动它又冒出来。 */
+  function purgeQueue(id) {
+    try {
+      var rest = readQueueAll().filter(function (p) { return p.id !== id; });
+      localStorage.setItem(QUEUE_KEY, JSON.stringify(rest));
+    } catch (e) {}
+  }
+  /* 占位何时能还：等登记表里该空间真的出现这一条（= 它的 core 已落盘）。
+     判据不能只看 `running`：几十毫秒就收工的任务，落盘那一刻起就不是 running 了，
+     只看 running 会一直等不到、白占满整个超时窗。所以「出现了一条 t0 之后开始的记录」
+     也算落盘 —— 记录一旦看得见，下一条本来就该按 running 判定自己要不要等。
+     等不到（core 起不来 / 秒挂）就超时还位 —— 宁可退化成「放行了但没看到」，
+     也不能把后面所有任务永久锁死在这道门里。 */
+  function startedAfter(s, t0) {
+    var d = new Date(String((s && s.started_at) || '').replace(' ', 'T'));
+    return !isNaN(d.getTime()) && d.getTime() >= t0 - 2000;   // 容 2s 时钟/取整偏差
+  }
+  function probeLanded(ws, q) {
+    var t0 = Date.now(), settled = false;
+    function release() {
+      if (settled) return;
+      settled = true;
+      q.held = Math.max(0, q.held - 1);
     }
-    function clear() {
-      if (pendId == null) return;
-      PENDING = PENDING.filter(function (p) { return p.id !== pendId; });
-      pendId = null; renderSessions(LAST_SESSIONS);
+    (function tick() {
+      if (settled || q.held <= 0) return;
+      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) {
+          var seen = Array.isArray(list) && list.some(function (s) {
+            return wsOf(s) === ws && (serialBusy(s) || startedAfter(s, t0));
+          });
+          if (seen || Date.now() - t0 >= LAND_TIMEOUT_MS) { release(); return; }
+          setTimeout(tick, PROBE_MS);
+        })
+        .catch(release);
+    })();
+  }
+  /* 队首的等待：服务端该空间没有 running，且本端没有「已放行但还没落盘」的占位。
+     isCancelled：排队期间用户点了停止 —— 每一拍先看它，取消后立刻退出，
+     不能等到「空间空了」才发现不该发（那期间它一直占着队首，后面的任务全被它挡住）。
+     onWait：**真的**要等（占位没还 / 探到该空间在跑）时回调一次，用来把「排队中」标到
+     气泡上（见 gateAsk）。⚠️ 必须由这里判、不能按时间猜：空间本来空闲时这条门一个往返
+     就放行，按时间盖标记就是 2026-10-22 那个「没排队也先显示排队状态再切回」。 */
+  function waitForSlot(ws, q, isCancelled, onWait) {
+    var told = false;
+    function waiting() {
+      if (told) return;
+      told = true;
+      if (typeof onWait === 'function') { try { onWait(); } catch (e) {} }
     }
     return new Promise(function (resolve) {
       function check() {
+        if (isCancelled && isCancelled()) { resolve(); return; }
+        if (TASK_MODE !== 'serial') { resolve(); return; }   // 用户中途改回并行：别再挡着
+        if (q.held > 0) { waiting(); setTimeout(check, SLOT_POLL_MS); return; }
         var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
-        fetch(BASE + '/desk/sessions', { headers: hdr }).then(function (r) { return r.ok ? r.json() : []; })
+        fetch(BASE + '/desk/sessions', { headers: hdr })
+          .then(function (r) { return r.ok ? r.json() : null; })
           .then(function (list) {
-            var busy = (Array.isArray(list) ? list : []).some(function (s) {
-              return ((s.workspace || DW) === ws) && (s.state === 'running' || s.alive === true);
-            });
-            if (!busy) { clear(); resolve(); } else { mark(); setTimeout(check, 3000); }
+            /* 拿不到清单（网关旧版 / 网络抖动）：放行。串行是**保护**不是**闸门**，
+               宁可这一条失去排队保障，也不要把用户的任务永久卡在门里。 */
+            if (!Array.isArray(list)) { resolve(); return; }
+            var busy = list.some(function (s) { return wsOf(s) === ws && serialBusy(s); });
+            if (busy) { waiting(); setTimeout(check, SLOT_POLL_MS); return; }
+            /* 放行前最后确认一次没被取消：上面这个请求有往返时间，用户可能就在这期间
+               点了停止 —— 此时再 held++ 会凭空占掉一个名额，下一条白白多等一轮。 */
+            if (isCancelled && isCancelled()) { resolve(); return; }
+            q.held++;                    // 占位：本条已放行，直到登记表看得见它
+            probeLanded(ws, q);
+            resolve();
           })
-          .catch(function () { clear(); resolve(); });
+          .catch(function () { resolve(); });
       }
       check();
     });
   }
+  /* 排队行的出现时机：**进队即落库**（关 App 也不能丢，这是用户报障的正题）；
+     列表上那条「等待中」行则由**是否真的要等**决定可见性（见 gateAsk 的 markWaiting）。
+     这个常量只剩一处用处：组件内排队（queuePushed，同一会话上一轮还没收尾）在
+     那一刻**一定**是在等，但它和串行门是两条队，仍留一点延时避免连发时闪一下。
+     hide=true 的条目在列表里不画（见 renderSessions 的过滤）。 */
+  var PENDING_SHOW_MS = 300;
+  /* 组件的「打断」打过来时，要知道撤哪一条：这一轮还没下发（没有 askId），
+     唯一能标识它的就是 gateAsk 里刚登记的那条 PENDING。多个对话框可能同时
+     各挂一条，所以用栈；finish 时按 id 摘掉自己那条。 */
+  var ASK_WAITING = [];
+  /* ── 串行门 ──
+     口径：**同一空间同时只有一个轮次在跑**，不分新任务还是历史会话追问。
+     （2026-10-21 用户：「历史会话追问也要串行」。此前 `!info.isNew` 直接放行 ——
+       理由是「追问不受限」，但它恰恰是同一条会话最需要排队的场合：一句话还没回完
+       就再追一句，两个进程会同时往同一份会话日志里写，画面也会互相踩。）
+     返回 false = 用户在排队期间取消了这一轮（见 conversation.js 的 beforeAsk 契约）。 */
+  function gateAsk(info) {
+    if (TASK_MODE !== 'serial' || !info) return Promise.resolve(true);
+    var ws = wsKey(info.workspace);
+    var q = serialQ(ws);
+    /* 落库是同步写，很便宜；而「点了发送、网还没回、用户退出了」正是丢任务的高危窗口，
+       所以不等任何延时，先进队列进磁盘。 */
+    var pend = addPending(ws, info, true);
+    ASK_WAITING.push(pend);
+    /* 「等待中」什么时候露面：**只在真的在等的时候**。
+       ⚠️ 2026-10-22 用户：「现在串行没有排队的也会先显示排队状态再切回 直接进入对话就行」：
+         原先这里是无条件 setTimeout(PENDING_SHOW_MS) 翻可见 —— 空间本来就空闲时，
+         这道门一个探测往返就放行，那 300ms 里列表先闪一条紫色「等待中」再消失，
+         气泡上也闪一句「排队中」（见 conversation.js 的 markQueued）。
+         现在两个条件之一成立才露面：① 进队时前面已经有人；② waitForSlot 探到该空间在跑
+         / 本端还有没落盘的占位。空闲直通的那条从头到尾不出现排队态。 */
+    var revealed = false;
+    function markWaiting() {
+      if (!revealed && !pend.gone) {
+        revealed = true;
+        pend.hide = false;
+        renderSessions(LAST_SESSIONS);
+      }
+      if (typeof info.queued === 'function') { try { info.queued(true); } catch (e) {} }
+    }
+    function cancelled() { return !!pend.cancelled; }
+    /* 队里**前面真有人**就当场算「要等」：不必等一个探测往返，慢那一下用户就白等了。
+       队首（前面没人）的情况交给 waitForSlot 的 onWait —— 探到该空间在跑才盖。
+       ⚠️ 判据是进队时的**在队人数** `q.waiters`，不能写成「q.tail 已经 resolve 过」——
+         Promise 看不出这个；也不能用累计编号（编号只增不减，第二句之后永远 >1）。 */
+    var ahead = q.waiters > 0;
+    q.waiters++;
+    if (ahead) markWaiting();
+    var mine = q.tail.then(function () {
+      if (cancelled()) return false;
+      return waitForSlot(ws, q, cancelled, markWaiting).then(function () { return !cancelled(); });
+    });
+    q.tail = mine.catch(function () { return false; });   // 出错也不能让后面永久挂起
+    return mine.then(finish, finish);
+    function finish(go) {
+      q.waiters = Math.max(0, q.waiters - 1);
+      pend.gone = true;
+      ASK_WAITING = ASK_WAITING.filter(function (x) { return x.id !== pend.id; });
+      dropPending(pend.id);
+      /* 轮到它了：摘掉气泡上的「排队中」（放行后就不该再挂着那句话）。
+         ⚠️ 与上面 queued(true) 成对 —— 组件的 beforeAsk 只管标/摘，时序由宿主说话。 */
+      if (typeof info.queued === 'function') { try { info.queued(false); } catch (e) {} }
+      return go !== false;
+    }
+    /* 取消入口挂在条目上：会话页的「中断」按钮在**这一轮还没下发**时就是打给它 ——
+       组件那边拿不到 askId，control() 会回报「还没拿到轮次 id」并什么都不做，
+       于是排队中的那一轮根本停不下来。见下面的 cancelPending。 */
+  }
+  /* 用户点了停止：把排队中的这一轮撤出队列。
+     ⚠️ 队首与队尾都要能撤 —— 队首正在 check()，它每一拍会看 cancelled 标记自己退出；
+     队尾的更简单，轮到它时第一句就返回 false。撤完必须 saveQueue/purge，
+     否则下次启动它又冒出来。 */
+  function cancelPending(id) {
+    var hit = null;
+    PENDING.forEach(function (p) { if (p.id === id) hit = p; });
+    if (!hit) return false;
+    hit.cancelled = true;
+    hit.gone = true;
+    dropPending(id);
+    renderSessions(LAST_SESSIONS);
+    return true;
+  }
+  /* 「这一轮还在排队吗」——组件问宿主：真在排队就别去调 control（那条路没有 askId）。 */
+  function pendingOf(prompt) {
+    for (var i = 0; i < PENDING.length; i++) {
+      if (!PENDING[i].gone && PENDING[i].prompt === prompt) return PENDING[i];
+    }
+    return null;
+  }
+  /* 组件点了打断，而这一轮**还没下发**（没有 askId）：撤掉它自己的那条排队。
+     只认 ASK_WAITING（gateAsk 亲手登记、还没 finish 的），不从 PENDING 里瞎猜 ——
+     重启恢复出来的条目同样在 PENDING 里，但它们的所有者是 enqueueDispatch，
+     撤了之后那条 Promise 还会把结果当成「已取消」走完，两边都记账容易漏发。
+     倒序找：同一句 prompt 连发两次时，用户要停的显然是最后那条。 */
+  function cancelWaitingAsk(prompt) {
+    for (var i = ASK_WAITING.length - 1; i >= 0; i--) {
+      var p = ASK_WAITING[i];
+      if (p.gone) continue;
+      if (prompt && p.prompt !== prompt) continue;
+      return cancelPending(p.id);
+    }
+    return false;
+  }
 
-  /* 等待中任务的列表行（不可点开，纯状态展示）。 */
+  /* ── 队列接续（重开 App 后把上次没轮到的排队任务接回去）──
+     ⚠️ 与「关掉 App 时正在跑的任务」同一口径：连接断了不等于取消。所以恢复出来的条目
+     照常排队、轮到就用 transport 直接下发（**不挂会话页面**），事件仍落进会话日志，
+     点开会话能回放。用户不必因为「手机锁屏了一下」就重新发一遍。
+     ⚠️ 只恢复发给**当前这台桌面**的条目（见 devKey）：换了配对地址就别把旧任务打过去。 */
+  var QUEUE_RESTORED = false;
+  /* 「已连接」判据：**同源调试时 BASE 本来就是空串**（base='' 表示打当前 origin），
+     所以不能只看 BASE —— 那样在浏览器里打开时整个接续逻辑会被静默跳过。 */
+  function connected() { return !!(BASE || TOKEN); }
+  function restoreQueue() {
+    /* ⚠️ 必须等 DW 落定：空间键 wsKey(w)=w||DW，DW 是 /desk/health 回来的。
+       抢在它之前恢复，队首排进 '' 这个键，而后续检查按 DW 算键 —— 两边对不上，
+       串行门等于被绕过（正是这次要修的那种并行）。 */
+    if (QUEUE_RESTORED || !connected() || !DW_READY) return;
+    QUEUE_RESTORED = true;
+    var list = loadQueue();
+    if (!list.length) return;
+    list.sort(function (a, b) { return (a.at || 0) - (b.at || 0); });   // 按当时进队顺序
+    PENDING = list;
+    renderSessions(LAST_SESSIONS);
+    list.forEach(function (p) { enqueueDispatch(p); });
+  }
+  function enqueueDispatch(p) {
+    var ws = wsKey(p.w);
+    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);
+    });
+    q.tail = mine.catch(function () { return false; });
+    return mine.then(function (sent) {
+      if (!sent) return;   // 没落盘：留在队列里（stalled），不删
+      dropPending(p.id);
+      /* 条目刚删掉、会话行还没被 5s 轮询拉到 —— 立刻刷一次，避免列表出现空档。 */
+      if (typeof loadSessions === 'function') loadSessions(true);
+    }, function () { /* 没发出去：保留，下次连上重试 */ });
+  }
+  /* 真正下发一条排队任务：只发、不收画面（事件进会话日志，点开会话可回放）。
+     ⚠️ **收到 open 不等于任务跑起来了** —— open 只说明连上了 `/desk/ask`，core 可能
+     紧接着就起不来 / 被拒（引擎不存在、参数不对）。从前这里 onOpen 就判成功、队列条目
+     当场删掉，那种秒挂的任务既没有会话行、也没有排队行，用户看到的是「发完就凭空消失」
+     （2026-10-21：「团队模式会话没存档吗 刷新就没了」）。
+     现在改判据：**会话登记表里真的看见这一条**才算下发成功（新任务看 t0 之后的新记录，
+     追问看 session_id 一致）。确认之后立刻掐掉 SSE：服务端拿 context.WithoutCancel 跑 core，
+     断连只意味着「没人看直播」，任务照跑到终态（见 service.go 的 handleAsk）；不掐的话，
+     排队的每一条都会在后台挂着长连接读自己的事件流，白耗流量。
+     确认不到（超过 LAND_TIMEOUT_MS）→ 返回 false，条目留在队列里标成「未能启动 · 点按重试」。 */
+  function fireQueued(p) {
+    if (!window.MagicTransportHttp) return Promise.resolve(false);
+    var transport = window.MagicTransportHttp({ base: BASE, token: TOKEN, client: 'mobile' });
+    var payload = { engine: p.engine, prompt: p.prompt };
+    if (p.model) payload.model = p.model;
+    if (p.w) payload.workspace = p.w;
+    /* 带上原会话 id 才是「追问」；不带就是新起一段会话（见 addPending 里 session 的注释）。 */
+    if (p.session) payload.session = p.session;
+    if (p.permission) payload.permission = p.permission;
+    /* 团队配置是在发送那一刻快照下来的（见 addPending）：重发必须带上，
+       否则这条排队任务会被当成普通单任务跑。 */
+    if (p.team) payload.team = p.team;
+    if (p.attachments && p.attachments.length) payload.attachments = p.attachments;
+    return new Promise(function (resolve) {
+      var done = false, handle = null, t0 = Date.now();
+      /* why = 失败原因（人话）。以前判失败只留一个布尔，用户只能看到「未能启动」四个字，
+         无从判断是路由配错、core 崩了还是隧道断了（2026-10-21：「未能启动 为什么」）。 */
+      var why = '';
+      function fin(ok) {
+        if (done) return;
+        done = true;
+        try { if (ok && handle && handle.cancel) handle.cancel(); } catch (e) {}
+        if (!ok) {
+          /* 没跑起来：留在队列里、给出可见的「点按重试」，绝不静默删条目。 */
+          p.stalled = true;
+          p.stalledReason = why || '服务端没有返回原因';
+          if (PENDING.indexOf(p) >= 0) renderSessions(LAST_SESSIONS);
+        } else {
+          p.stalledReason = '';
+        }
+        resolve(!!ok);
+      }
+      /* end 帧带 code + stderr（服务端 internal/client/service.go 的 send("end", …) 早就在发，
+         是这里一直丢掉了）。core 的 usage error 会往 stderr 打一行 JSON
+         （{"engine":…,"error":"未知引擎：text→xxx"}，见 internal/cli/team.go），
+         优先取里面的 error/reason 当人话；解析不了就退回最后一行原文。
+         比「退出码 2」对用户有用得多。 */
+      function endReason(code, ev) {
+        var lines = String((ev && ev.stderr) || '').split('\n')
+          .map(function (x) { return x.trim(); }).filter(Boolean);
+        for (var i = lines.length - 1; i >= 0; i--) {
+          var t = lines[i];
+          if (t.charAt(0) === '{') {
+            try {
+              var j = JSON.parse(t);
+              if (j && (j.error || j.reason)) return String(j.error || j.reason);
+            } catch (e) {}
+          }
+          return t;
+        }
+        return code ? 'core 退出码 ' + code : '';
+      }
+      var seenAt = 0;   // 事件流收尾的时刻；0 = 还在跑
+      var grace = 0;    // 收尾后额外等待（onError 给 4s；只增不减，见下）
+      /* seen：这一条是否已在登记表里。收尾之后还要再等 grace —— 事件流断掉不等于 core
+         没起来（App 切后台 / 隧道瞬断时最容易误判成失败）。总窗封在 LAND_TIMEOUT_MS。 */
+      function seenInRegistry(graceMs) {
+        if (done) return;
+        /* 只增不减：onError 之后再来的 onEnd(null) 不能把宽限期压回 0，否则刚许的 4s 白给。 */
+        if (typeof graceMs === 'number' && graceMs > grace) grace = graceMs;
+        var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
+        function again() {
+          if (done) return;
+          var now = Date.now();
+          if (seenAt && now - seenAt >= grace) { fin(false); return; }
+          if (now - t0 >= LAND_TIMEOUT_MS) {
+            why = why || '20 秒内没有出现在会话登记表（core 没起来或请求没到服务端）';
+            fin(false);
+            return;
+          }
+          setTimeout(function () { seenInRegistry(grace); }, PROBE_MS);
+        }
+        fetch(BASE + '/desk/sessions', { headers: hdr })
+          .then(function (r) { return r.ok ? r.json() : null; })
+          .then(function (list) {
+            if (done) return;
+            var seen = Array.isArray(list) && list.some(function (s) {
+              if (wsOf(s) !== wsKey(p.w)) return false;
+              if (p.session) return String(sidOf(s) || '') === String(p.session);
+              return startedAfter(s, t0);
+            });
+            if (seen) fin(true); else again();
+          })
+          .catch(again);
+      }
+      try {
+        handle = transport.ask(payload, {
+          onOpen: function () { seenInRegistry(0); },
+          /* 事件里一旦带出 session_id，说明 core 已经跑起来并登记了 —— 不必再查表。 */
+          onEvent: function (ev) { if (ev && ev.session_id) fin(true); },
+          /* code 非空 = 这一轮以失败收尾；若登记表里也没有它，就是没跑起来。
+             原因取自 end 帧（stderr），不是猜的。 */
+          onEnd: function (code, ev) {
+            seenAt = seenAt || Date.now();
+            if (code) why = endReason(code, ev) || why;
+            /* code=0（正常收尾）却没查到记录：给 1.5s 让登记表落盘，别一收尾就判死。 */
+            seenInRegistry(code ? 0 : 1500);
+          },
+          /* 网络层失败：记下真实原因（api() 已把 4xx/5xx 正文的 {"error":…} 拼进来），
+             再给 4s 宽限继续查登记表 —— 已经起步的任务不该被断开连接判死。 */
+          onError: function (e) {
+            why = (e && (e.detail || e.message)) || '连接中断';
+            seenAt = Date.now();
+            seenInRegistry(4000);
+          }
+        });
+        /* 兜底：整个确认窗内既没有 open 也没有事件。 */
+        setTimeout(function () {
+          if (done) return;
+          why = why || '20 秒内没有等到服务端的任何响应';
+          fin(false);
+        }, LAND_TIMEOUT_MS);
+      } catch (e) {
+        why = (e && e.message) || '发送失败';
+        fin(false);
+      }
+    });
+  }
+
+  /* 等待中任务的列表行（不可点开，纯状态展示）。
+     带 session 的是**历史会话的追问**（串行门对追问一视同仁，见 gateAsk）：
+     副标题说清楚「追问」二字，否则用户会以为自己在原会话里排队，列表上却凭空多出
+     一条「新任务」，看起来像发重了。 */
   function pendingRow(p) {
-    var b = document.createElement('div'); b.className = 'srow srow--pending';
-    var ico = elSpan('srow__ico srow__ico--queued'); ico.appendChild(svgUse('#i-laptop', 20));
+    var b = document.createElement('div');
+    b.className = 'srow srow--pending' + (p.stalled ? ' srow--stalled' : '');
+    var ico = elSpan('srow__ico srow__ico--queued');
+    /* 团队任务排队时也用双人图形，别先闪一下电脑再换（与 sessionIcon 同一规则）。 */
+    ico.appendChild(svgUse(p.team ? '#i-team' : '#i-laptop', 20));
     b.appendChild(ico);
     var col = elSpan('srow__col');
     col.appendChild(elSpan('srow__t', String(p.prompt || '新任务').slice(0, 40)));
-    col.appendChild(elSpan('srow__s', '等待中 · 上一个完成后自动开始'));
+    var sub = elSpan('srow__s');
+    /* stalled：上一次下发没在会话登记表里看见它（core 起不来 / 被拒）——
+       条目留在列表里并给重试入口，绝不能因为「没发出去」就从界面上消失。
+       后面拼上**真实原因**（end 帧 stderr / HTTP 正文 / 超时），否则用户只知道失败、
+       不知道是路由配错还是服务没起（2026-10-21：「未能启动 为什么」）。 */
+    var reason = p.stalled ? String(p.stalledReason || '').trim() : '';
+    var text = p.stalled ? '未能启动' + (reason ? '：' + shortReason(reason, 40) : '') + ' · 点按重试'
+             : (p.session ? '追问排队中 · ' : '等待中 · ') + '上一个完成后自动开始';
+    sub.appendChild(elSpan('srow__stext', text));
+    col.appendChild(sub);
     b.appendChild(col);
     b.appendChild(elSpan('srow__time', ''));
+    if (p.stalled) {
+      /* 行内只放得下截断版，完整原因挂 title：长按/悬停能看到 core 的原始报错。 */
+      if (reason) b.title = reason;
+      b.onclick = function () {
+        if (b.dataset.busy === '1') return;
+        b.dataset.busy = '1';
+        enqueueDispatch(p);
+      };
+    }
     return b;
   }
 
+  /* 单行原因：压掉换行/连续空白（core 的日志常带缩进），超长截断加省略号。 */
+  function shortReason(s, max) {
+    var one = String(s || '').replace(/\s+/g, ' ').trim();
+    if (one.length <= max) return one;
+    return one.slice(0, max - 1) + '…';
+  }
+
   /* ── 通知：配置 + 真触发 ──
      优先级：Capacitor LocalNotifications（App 内系统通知）→ Web Notification（浏览器已授权）→ 应用内 toast。
      ⚠️ App 关闭时 JS 不跑、触发不了；「任务完成 / 待确认」通知需要 App 在运行。 */
@@ -2094,7 +3973,8 @@ button.setrow{font-family:inherit}
     fetch(BASE + '/desk/sessions', { headers: hdr }).then(function (r) { return r.ok ? r.json() : []; })
       .then(function (list) {
         (Array.isArray(list) ? list : []).forEach(function (s) {
-          var id = sidOf(s), st = String(s.state || ''), prev = PREV_STATE[id];
+          /* 通知按**会话级** status 判（同一条会话各轮一个记录，只看 state 会拿旧轮误报）。 */
+          var id = sidOf(s), st = String((s.status || s.state) || ''), prev = PREV_STATE[id];
           if (!FIRST_POLL && prev !== undefined && prev !== st) {
             if (st === 'done') notify('result', '任务完成', titleOf(s));
             else if (st === 'waiting_approval') notify('confirm', '任务待确认', titleOf(s));
@@ -2105,21 +3985,25 @@ button.setrow{font-family:inherit}
       }).catch(function () {});
   }
 
-  /* 工作空间选择：默认 / 根目录下 magic-* / 自定义 / 会话里出现过的，一行一个，外加「自定义路径…」。 */
+  /* 工作空间选择：默认 / 根目录下 magic-* / 自定义 / 会话里出现过的，一行一个，外加「自定义路径…」。
+     ⚠️ 当前生效的那一条要打勾（hRow 的 selected）：抽屉里没有任何选中标记时，
+        点完「默认」看不出变化，用户无从判断到底选没选上（2026-10-21 报「无法选择默认」）。
+     ⚠️ 首项文案 = 「默认（不属于任何空间）」：默认的语义是**不归属任何空间目录**，
+        不是「用某个默认目录」。写「不指定」容易被读成「没选」，写目录名更会被读成「选了那个目录」。 */
   function openWorkspacePicker() {
     var keys = collectSpaceKeys();
     openHostSheet('选择工作空间', function (body) {
-      hRow(body, '默认（不指定）', null, function () { WS = ''; saveWs(); applyWs(); closeHostSheet(); openRunSettings(); });
+      hRow(body, '默认（不属于任何空间）', null, function () { WS = ''; saveWs(); applyWs(); closeHostSheet(); paintRunSettings(); }, false, !WS);
       keys.forEach(function (w) {
         var isCustom = CUSTOM_SPACES.indexOf(w) >= 0;
-        hRow(body, basename(w), isCustom ? '自定义' : null, function () { WS = w; saveWs(); applyWs(); closeHostSheet(); openRunSettings(); });
+        hRow(body, basename(w), isCustom ? '自定义' : null, function () { WS = w; saveWs(); applyWs(); closeHostSheet(); paintRunSettings(); }, false, WS === w);
       });
       hRow(body, '自定义路径…', '＋', function () {
         var p = window.prompt('输入工作空间的绝对路径', SPACES_ROOT || DW || '');
         if (p == null) return;
         p = p.trim(); if (!p) return;
         if (CUSTOM_SPACES.indexOf(p) < 0) { CUSTOM_SPACES.push(p); saveSpaces(); }
-        WS = p; saveWs(); applyWs(); closeHostSheet(); loadSessions(); openRunSettings();
+        WS = p; saveWs(); applyWs(); closeHostSheet(); loadSessions(); paintRunSettings();
       });
     });
   }
@@ -2149,42 +4033,390 @@ button.setrow{font-family:inherit}
     var e = document.getElementById('defaultEngine');
     var m = document.getElementById('defaultModel');
     if (e) e.textContent = RUN_PREF.engine || '自动（首个可用）';
-    if (m) m.textContent = RUN_PREF.engine ? (RUN_PREF.model || '引擎默认') : '跟随引擎';
+    if (m) m.textContent = RUN_PREF.engine ? (qaModelText(RUN_PREF.model) || '引擎默认') : '跟随引擎';
   }
-  /* 引擎清单：走 client 的 /desk/engines（= core --engines 的原样 JSON，含 models）。
-     ⚠️ 这个请求会真的起各引擎的只读子命令探测模型，慢（秒级），所以只在打开选择器时拉，
-     「我的」页本身不请求 —— 显示的是已记住的值，打开选择器才现探测。 */
-  function fetchEngines() {
-    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
-    return fetch(BASE + '/desk/engines?models=1', { headers: hdr }).then(function (r) {
-      if (!r.ok) throw new Error('HTTP ' + r.status);
-      return r.json();
-    }).then(function (list) {
-      ENGINES = (Array.isArray(list) ? list : []).filter(function (x) { return x && x.engine; });
-      return ENGINES;
+
+  /* 团队模式配置（「我的」）══════════
+     开关不在这里（按会话，在会话页右上角的运行设置里，与权限模式并排）；这里配的是
+     **每类子任务交给谁** —— 也就是「我的」那一份设备偏好。
+     core 没有团队能力（老版本）时整张卡片藏起来：显示一组点了必然失败的配置项
+     比不显示更糟。 */
+  /* 「我的」只留一个入口行，右侧摘要给出「几项单独指定过」；明细全在子页面里。
+     子页面是**计划 + 7 个角色**（用户 2026-10-22：「只需要计划+7类子任务即可」）：
+     计划行 + 角色行都由 paintTeamRoles 渲染，不再有并列的「N 个类别」那一层。 */
+  function paintTeamPref() {
+    var card = document.getElementById('teamCard');
+    if (card) card.hidden = !teamSupported();
+    /* 摘要与子页面同一口径：计划 + 7 个角色里单独配过引擎**或规则**的项数。
+       旧版按类别配过的路由仍然生效（core 仍认），但不在界面上重复计数。 */
+    var custom = 0;
+    if (((TEAM.routes || {}).plan || {}).engine) custom++;
+    teamRoleList().forEach(function (r) {
+      var rt = (TEAM.routes || {})['role:' + r.name];
+      if ((rt && rt.engine) || ((TEAM.rules || {})['role:' + r.name])) custom++;
     });
+    paintTeamRoles(teamRoleList());
+    var sum = document.getElementById('teamSummary');
+    if (sum) sum.textContent = custom ? (custom + ' 项已单独指定') : '跟随主引擎';
   }
-  function openDefaultEnginePicker() {
-    openHostSheet('默认引擎 / 模型', function (body) {
+  /* 团队模式子页面 = 计划行 + 7 个角色行，全部进同一个 #teamRouteCard（只有一套路由配置）。
+     每行常显「这类适合什么」（角色 = 规则 / 计划 = 拆解口径），右侧是引擎 ——
+     用户要的是「描述好每一类适合的规则」，所以描述不藏进详情页。
+     签名含行文案与引擎：变了才重建，避免 5s 轮询时闪。 */
+  function paintTeamRoles(roles) {
+    var card = document.getElementById('teamRouteCard');
+    if (!card) return;
+    var show = teamSupported();
+    var plan = (TEAM.routes || {}).plan || {};
+    var planSub = '拆解：' + ({ coarse: '少', standard: '标准', fine: '细' }[TEAM.split] || '标准')
+      + (TEAM.adaptive !== false ? ' · 自动补任务' : '')
+      + (TEAM.splitCode ? ' · 简单代码也拆' : '');
+    var sig = (show ? '1' : '0') + '|plan|' + planSub + '|' + (plan.engine || '') + '|' + (plan.model || '') + '|'
+      + roles.map(function (r) {
+        var rt = (TEAM.routes || {})['role:' + r.name] || {};
+        return r.name + '|' + teamRoleDuty(r) + '|' + (rt.engine || '') + '|' + (rt.model || '');
+      }).join(',');
+    if (sig === TEAM_ROLE_SIG) return;
+    TEAM_ROLE_SIG = sig;
+    card.innerHTML = '';
+    if (!show) return;
+    addTeamRow(card, 'plan', '计划任务', planSub);
+    roles.forEach(function (r) {
+      addTeamRow(card, 'role:' + r.name, TEAM_ROLE_LABELS[r.name] || r.name, teamRoleDuty(r));
+    });
+  }
+  /* 一行：名字 + 规则描述 + 右侧引擎。点开 = 引擎与规则（见 openTeamRoutePicker）。 */
+  function addTeamRow(card, key, label, sub) {
+    var rt = (TEAM.routes || {})[key] || {};
+    var b = hEl('button', 'setrow');
+    b.type = 'button';
+    var main = hEl('span', 'setrow__main');
+    main.appendChild(hEl('span', 'setrow__l', label));
+    if (sub) main.appendChild(hEl('span', 'setrow__sub', sub));
+    b.appendChild(main);
+    b.appendChild(hEl('span', 'setrow__v',
+      rt.engine ? (rt.engine + (rt.model ? ' · ' + qaModelText(rt.model) : '')) : '跟随主引擎'));
+    b.appendChild(hEl('span', 'setrow__chev', '›'));
+    b.onclick = function () {
+      openTeamRoutePicker(key,
+        String(key).indexOf('role:') === 0 ? (label + '：适合做什么、交给谁') : '计划任务：怎么拆、交给谁',
+        teamRoleKindOf(key));
+    };
+    card.appendChild(b);
+  }
+  function teamRoleKindOf(key) {
+    if (String(key).indexOf('role:') !== 0) return 'plan';
+    var n = String(key).slice(5);
+    var info = teamRoleList().filter(function (r) { return r.name === n; })[0];
+    return (info && info.kind) || '';
+  }
+  /* 「这类任务适合什么」：用户改过的优先，没改过用 core 上报的职责（duty）。 */
+  function teamRoleDuty(r) {
+    var ov = (TEAM.rules || {})['role:' + r.name];
+    return (ov && String(ov).trim()) || r.duty || '';
+  }
+  /* 点一行 → 抽屉：先「规则」，再「引擎 · 模型」，与「默认引擎」那套同一个交互。
+     计划行：拆解粒度 + 简单代码 / 自动补任务（--team-split / --team-split-code /
+     --team-adaptive）；角色行：「这类任务适合什么」（--team-rule role:<name>=…）。
+     首项 = 不单独指定 / 跟随主引擎。
+     2026-10-21 口径（用户：「图像视频不是说需要生成 是擅长做 比如有一个带了视频 skill 的引擎」）：
+     这里问的是「这类活谁擅长」，所以不写「交给 core 自动路由」—— 说「自动」会让人以为
+     不配也能跑，而实际语义是「跟主引擎一致」。 */
+  function openTeamRoutePicker(key, title, kind) {
+    var isRole = String(key).indexOf('role:') === 0;
+    if (!kind) kind = key;   // 计划键时 kind 就是键本身
+    openHostSheet(title, function (body) {
       var hint = hEl('div', 'history__hint', '正在探测引擎与模型…');
       hint.style.textAlign = 'left';
       body.appendChild(hint);
+      /* 规则控件放在引擎清单**之前**：规则是这一行的主内容，引擎是「交给谁」。
+         它们与探测无关，引擎清单拉失败也照样能改。分区标题必须显式给出 ——
+         用户 2026-10-22：「入口在哪里 不能配置规则」：控件在，但没标题就读不出这里是配置区。 */
+      body.appendChild(hEl('div', 'pick__cap pick__cap--team', '规则'));
+      if (isRole) body.appendChild(buildTeamRuleEditor(key));
+      else if (kind === 'plan') body.appendChild(buildTeamSplitControls());
       fetchEngines().then(function (list) {
         if (hint.parentNode) hint.remove();
         var avail = list.filter(function (x) { return x.ok; });
         if (!avail.length) {
-          var d = hEl('div', 'history__hint',
-            '没有可用引擎：先在这台机器上装一个（终端跑 magic-agent --engines 会给出每个引擎的一键安装命令）。');
+          var d = hEl('div', 'history__hint', '没有可用引擎：先在桌面上装一个（magic-agent --engines 会给出安装命令）。');
           d.style.textAlign = 'left';
           body.appendChild(d);
           return;
         }
-        buildEngineCascade(body, avail);
+        var stale = enginesStaleHint();
+        if (stale) body.appendChild(stale);
+        var cur = (TEAM.routes || {})[key] || {};
+        var curEng = avail.filter(function (en) { return en.engine === cur.engine; })[0] || avail[0];
+        /* 选谁不看「会不会生成」，看它擅不擅长这类活。这一行是给用户的判据，
+           不是给 core 的配置（core 只认 engine / model）。
+           ⚠️ 必须建在 paint() **外面**：paint 每次切引擎都会重画两列，放里面会一行行堆起来
+              （2026-10-21 实测：点两次引擎，抽屉底部就多出三段同样的说明）。 */
+        var tipText;
+        if (isRole) {
+          var info = teamRoleList().filter(function (r) { return 'role:' + r.name === key; })[0];
+          tipText = '这个角色内置的职责：' + ((info && info.duty) || '—')
+            + '。上面写的规则会替掉它，进计划提示词；这里留空 = 跟随主引擎。';
+        } else {
+          tipText = '计划阶段负责把任务拆成子任务，交给更擅长规划、上下文更长的引擎更稳。';
+        }
+        body.appendChild(hEl('div', 'pick__cap pick__cap--team', '交给谁'));
+        var tip = hEl('div', 'history__hint', tipText);
+        tip.style.textAlign = 'left';
+        body.appendChild(tip);
+        var wrap = hEl('div', 'pick__cols pick__cols--team');
+        var left = hEl('div', 'pick__col');
+        var right = hEl('div', 'pick__col pick__col--r');
+        wrap.appendChild(left); wrap.appendChild(right); body.appendChild(wrap);
+        function paint() {
+          left.innerHTML = ''; right.innerHTML = '';
+          var auto = hEl('button', 'pick__citem' + (!cur.engine ? ' is-on' : ''));
+          auto.type = 'button';
+          auto.appendChild(hEl('span', 'pick__cl', '跟随主引擎'));
+          auto.appendChild(hEl('span', 'pick__cd', kind === 'plan' ? '计划阶段走主引擎' : '不单独指定，和主引擎一致'));
+          auto.onclick = function () { setTeamRoute(key, '', ''); };
+          left.appendChild(auto);
+
+          avail.forEach(function (en) {
+            var b = hEl('button', 'pick__citem'
+              + (cur.engine === en.engine ? ' is-on' : '')
+              + (en.engine === curEng.engine && cur.engine !== en.engine ? ' is-cur' : ''));
+            b.type = 'button';
+            b.appendChild(hEl('span', 'pick__cl', en.engine));
+            b.appendChild(hEl('span', 'pick__cd', (en.models || []).length ? ((en.models || []).length + ' 个模型') : '引擎默认'));
+            b.onclick = function () { curEng = en; paint(); };
+            left.appendChild(b);
+          });
+
+          var d = hEl('button', 'pick__citem' + (cur.engine === curEng.engine && !cur.model ? ' is-on' : ''));
+          d.type = 'button';
+          d.appendChild(hEl('span', 'pick__cl', '引擎默认'));
+          d.appendChild(hEl('span', 'pick__cd', '不指定模型，由引擎自己挑'));
+          d.onclick = function () { setTeamRoute(key, curEng.engine, ''); };
+          right.appendChild(d);
+
+          (curEng.models || []).forEach(function (mm) {
+            var b = hEl('button', 'pick__citem' + (cur.engine === curEng.engine && cur.model === mm ? ' is-on' : ''));
+            b.type = 'button';
+            modelItem(b, curEng.engine, mm);
+            b.onclick = function () { setTeamRoute(key, curEng.engine, mm); };
+            right.appendChild(b);
+          });
+        }
+        paint();
       }, function (e) {
         hint.textContent = '拉取引擎清单失败：' + ((e && e.message) || e);
       });
     });
   }
+  /* 角色行的「规则」：一句话写清这类任务适合什么。**默认值直接填内置职责**（用户
+     2026-10-22：「也没看到默认规则啊」—— placeholder 在手机上几乎看不见），保存后覆盖它
+     （core 的 --team-rule role:<name>=…）；改回内置值等于没改，不落覆盖。 */
+  function buildTeamRuleEditor(key) {
+    var box = hEl('div', 'teamedit__box');
+    var lab = hEl('div', 'history__hint', '这类任务适合什么（写进拆解提示词）');
+    lab.style.textAlign = 'left';
+    box.appendChild(lab);
+    var sub = hEl('div', 'history__hint', '下面填的就是内置默认规则，可直接改；改完点保存才生效。');
+    sub.style.textAlign = 'left';
+    sub.style.padding = '0 12px 2px';
+    sub.style.fontSize = '12px';
+    box.appendChild(sub);
+    var ta = hEl('textarea', 'teamedit');
+    var name = String(key).slice(5);
+    var info = teamRoleList().filter(function (r) { return r.name === name; })[0] || {};
+    var builtin = String(info.duty || '').trim();
+    ta.placeholder = builtin || '用一句话写清这类任务承接什么';
+    ta.value = String((TEAM.rules || {})[key] || '').trim() || builtin;
+    box.appendChild(ta);
+    var acts = hEl('div', 'teamedit__acts');
+    var save = hEl('button', 'btn btn--filled', '保存规则');
+    save.type = 'button';
+    save.onclick = function () {
+      var v = String(ta.value || '').replace(/\s+/g, ' ').trim();
+      /* 500 字上限与 core 同口径（core 会再判一次，这里是提前拦，省一次往返）。 */
+      if (v.length > 500) { toast('规则最多 500 字'); return; }
+      TEAM.rules = TEAM.rules || {};
+      if (!v || v === builtin) delete TEAM.rules[key];
+      else TEAM.rules[key] = v;
+      saveTeamPref();
+      toast((v && v !== builtin) ? '规则已保存' : '已使用内置规则');
+    };
+    acts.appendChild(save);
+    var reset = hEl('button', 'btn btn--outlined', '恢复默认');
+    reset.type = 'button';
+    reset.onclick = function () {
+      if (TEAM.rules) delete TEAM.rules[key];
+      ta.value = builtin;
+      saveTeamPref();
+      toast('已恢复内置规则');
+    };
+    acts.appendChild(reset);
+    box.appendChild(acts);
+    return box;
+  }
+  /* 计划行的「规则」：拆解粒度 + 两个开关，与 core 的 --team-split / --team-split-code /
+     --team-adaptive 一一对应。改完立刻落盘（配置每轮现读，见 mountConversation 的 teamConfig）。 */
+  function buildTeamSplitControls() {
+    var box = hEl('div', '');
+    var lab = hEl('div', 'history__hint', '怎么拆：粒度决定最多拆几个子任务');
+    lab.style.textAlign = 'left';
+    box.appendChild(lab);
+    var row = hEl('div', 'setrow');
+    row.appendChild(hEl('span', 'setrow__l', '拆解粒度'));
+    var seg = hEl('span', 'seg');
+    [['coarse', '少'], ['standard', '标准'], ['fine', '细']].forEach(function (p) {
+      var b = hEl('button', 'seg__b' + (TEAM.split === p[0] ? ' is-on' : ''), p[1]);
+      b.type = 'button';
+      b.onclick = function () {
+        TEAM.split = p[0];
+        saveTeamPref();
+        markSeg(seg, p[0]);
+      };
+      seg.appendChild(b);
+    });
+    row.appendChild(seg);
+    box.appendChild(row);
+    box.appendChild(teamToggleRow('简单代码也拆',
+      function () { return !!TEAM.splitCode; },
+      function () { TEAM.splitCode = !TEAM.splitCode; }));
+    box.appendChild(teamToggleRow('自动补任务',
+      function () { return TEAM.adaptive !== false; },
+      function () { TEAM.adaptive = (TEAM.adaptive === false); }));
+    return box;
+  }
+  function teamToggleRow(label, isOn, toggle) {
+    var row = hEl('div', 'setrow');
+    row.appendChild(hEl('span', 'setrow__l', label));
+    var t = hEl('button', 'tgl' + (isOn() ? ' is-on' : ''));
+    t.type = 'button';
+    t.onclick = function () { toggle(); saveTeamPref(); t.classList.toggle('is-on', isOn()); };
+    row.appendChild(t);
+    return row;
+  }
+  function setTeamRoute(key, engine, model) {
+    TEAM.routes = TEAM.routes || {};
+    if (!engine) delete TEAM.routes[key];
+    else TEAM.routes[key] = model ? { engine: engine, model: model } : { engine: engine };
+    saveTeamPref();
+    applyTeamToLive();
+    closeHostSheet();
+    var r = (TEAM.routes || {})[key];
+    var label = teamRouteLabel(key);
+    toast(r ? (label + '交给 ' + r.engine + (r.model ? ' · ' + qaModelText(r.model) : ''))
+            : (label + '：跟随主引擎'));
+  }
+  /* 配置改了要同步到活着的组件（组件每轮现读 teamConfig，改完下一轮就生效）。
+     ⚠️ 这里**不碰开关**：开关是每条会话自己的状态，改「哪类任务交给谁」不该顺手把
+        当前会话的团队模式打开/关掉。 */
+  function applyTeamToLive() {
+    paintTeamPref();
+    paintRunSettings();
+  }
+  /* 用户在**组件自己的**团队面板里改了开关 → 回写到**当前这条会话**。
+     面板只是入口，权威状态在宿主的按会话表里（`TEAM.sessions[sid]`）；
+     不回传的话组件一重建，刚开的开关就没了。
+     新会话还没有 session_id：先记在 TEAM.fresh，首帧带回 id 时由 bindFreshTeam 落到会话上。 */
+  function onTeamToggleFromConv(on) {
+    var sid = (conv && conv.state && conv.state.session) || '';
+    if (sid) {
+      TEAM.sessions[String(sid)] = !!on;
+      TEAM.fresh = false;
+    } else {
+      TEAM.fresh = !!on;
+    }
+    saveTeamPref();
+    paintRunSettings();
+  }
+  /* 一行模型（左名字、右倍率）：名字过长只挤自己，倍率列不会跟着抖
+     （`.pick__crow` 样式见 shared/conversation.css）。
+     倍率本身不在宿主里再算一遍 —— 直接用内核的 qaModelCredit（它认 core 原样
+     snake_case 与 PC 归一后的 camelCase，且**没数据就返回空串**，不编「×1」）。 */
+  function modelItem(b, engine, id) {
+    var row = hEl('span', 'pick__crow');
+    row.appendChild(hEl('span', 'pick__cl', qaModelText(id)));
+    var credit = qaModelCredit(ENGINES, engine, id);
+    if (credit) row.appendChild(hEl('span', 'pick__cr', credit));
+    b.appendChild(row);
+  }
+  /* 引擎清单：走 client 的 /desk/engines（= core --engines 的原样 JSON，含 models）。
+     ⚠️ 这个请求会真的起各引擎的只读子命令探测模型，慢（秒级），所以只在打开选择器时拉，
+     「我的」页本身不请求 —— 显示的是已记住的值，打开选择器才现探测。 */
+  /* 探测引擎要真起 CLI（单引擎模型探测上限 30s，插件侧 45s），所以这里给 50s 硬超时：
+     没有它的话，请求一旦不返回（core 被祖先进程握管道杀掉、网络半断），弹层就永远
+     停在「正在探测引擎与模型…」—— 2026-10-21 实测过。 */
+  var ENGINES_TIMEOUT_MS = 50000;
+  function fetchEngines() {
+    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
+    var opts = { headers: hdr };
+    var ctrl = (typeof AbortController !== 'undefined') ? new AbortController() : null;
+    var timer = null;
+    if (ctrl) {
+      opts.signal = ctrl.signal;
+      timer = setTimeout(function () { ctrl.abort(); }, ENGINES_TIMEOUT_MS);
+    }
+    function stopTimer() { if (timer) { clearTimeout(timer); timer = null; } }
+    return fetch(BASE + '/desk/engines?models=1', opts).then(function (r) {
+      if (!r.ok) throw new Error('HTTP ' + r.status);
+      /* 插件侧探测失败/超时但存有上次成功的清单时，会带这个头把缓存回给我们：
+         值 = 缓存时间。看到它就说明「这份清单不是刚探测的」，选择器里要讲清楚。 */
+      ENGINES_STALE_AT = r.headers.get('X-Magic-Engines-Stale') || '';
+      return r.json();
+    }).then(function (list) {
+      stopTimer();
+      ENGINES = (Array.isArray(list) ? list : []).filter(function (x) { return x && x.engine; });
+      return ENGINES;
+    }, function (e) {
+      stopTimer();
+      if (e && (e.name === 'AbortError' || e.code === 20)) {
+        throw new Error('探测超时（' + Math.round(ENGINES_TIMEOUT_MS / 1000) + 's 内没返回，引擎 CLI 可能卡住了）');
+      }
+      throw e;
+    });
+  }
+  /* 缓存提示（stale-while-revalidate：插件立刻回上次的清单，同时在后台重探）。无缓存返回 null。 */
+  function enginesStaleHint() {
+    if (!ENGINES_STALE_AT) return null;
+    var d = new Date(ENGINES_STALE_AT);
+    var when = isNaN(d.getTime()) ? ENGINES_STALE_AT
+      : (d.getMonth() + 1) + '月' + d.getDate() + '日 '
+        + ('0' + d.getHours()).slice(-2) + ':' + ('0' + d.getMinutes()).slice(-2);
+    var el = hEl('div', 'history__hint',
+      '这是 ' + when + ' 的探测结果，正在后台刷新（下次打开就是最新的）。');
+    el.style.textAlign = 'left';
+    return el;
+  }
+  function openDefaultEnginePicker() {
+    openHostSheet('默认引擎 / 模型', function (body) {
+      function load() {
+        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.ok; });
+          if (!avail.length) {
+            var d = hEl('div', 'history__hint',
+              '没有可用引擎：先在这台机器上装一个（终端跑 magic-agent --engines 会给出每个引擎的一键安装命令）。');
+            d.style.textAlign = 'left';
+            body.appendChild(d);
+            return;
+          }
+          buildEngineCascade(body, avail);
+        }, function (e) {
+          hint.textContent = '拉取引擎清单失败：' + ((e && e.message) || e);
+          var retry = hEl('button', 'pick__citem', '重试');
+          retry.type = 'button';
+          retry.onclick = load;
+          body.appendChild(retry);
+        });
+      }
+      load();
+    });
+  }
   /* 二列级联（左引擎 · 右该引擎的模型），与对话框里那套同构：
      点左列只切右列，点右列才落定 —— 避免「引擎换了、模型还挂在旧引擎下」。 */
   function buildEngineCascade(body, avail) {
@@ -2230,7 +4462,9 @@ button.setrow{font-family:inherit}
       (cur.models || []).forEach(function (mm) {
         var b = hEl('button', 'pick__citem' + (RUN_PREF.engine === cur.engine && RUN_PREF.model === mm ? ' is-on' : ''));
         b.type = 'button';
-        b.appendChild(hEl('span', 'pick__cl', mm));
+        /* 显示剥掉 `custom-local:` 前缀（`mm` 本身是完整 id，选中时原样存进 RUN_PREF），
+           倍率挂同行右侧。 */
+        modelItem(b, cur.engine, mm);
         b.onclick = function () { pickRunPref(cur.engine, mm); };
         right.appendChild(b);
       });
@@ -2244,7 +4478,7 @@ button.setrow{font-family:inherit}
     applyRunPrefToLive();
     closeHostSheet();
     toast(RUN_PREF.engine
-      ? ('默认引擎：' + RUN_PREF.engine + ' · ' + (RUN_PREF.model || '引擎默认模型'))
+      ? ('默认引擎：' + RUN_PREF.engine + ' · ' + (qaModelText(RUN_PREF.model) || '引擎默认模型'))
       : '默认引擎：自动（首个可用）');
   }
   /* 改默认值只同步**还没发过任务的新会话**；历史会话保持它自己的引擎，
@@ -2302,21 +4536,47 @@ button.setrow{font-family:inherit}
     connect(target);
   };
   addrEl.addEventListener('input', function () { showError(''); });
-  on('btnClear', function () { clearRecent(); renderRecent(); });
+  on('btnClear', function () { clearConns(); renderRecent(); });
+  /* 任务页标题 = 环境切换菜单（多连接）。已连着桌面时，从启动页进来也能退回去。 */
+  on('btnEnvSwitch', openEnvMenu);
+  on('btnLauncherBack', function () { if (BASE || TOKEN) showHistory(); });
   /* 别处起的任务要能自己冒出来（列表页可见时静默轮询；见 startListPoll 的注释） */
   startListPoll();
   on('btnList', function () { showHistory(); });
+  /* 任务页：页头右上角搜索 + 我的；搜索态平铺。 */
   on('btnNewTask', function () { newConversation(); });
-  on('btnSettings', function () { openRunSettings(); });
+  on('btnTaskSearch', function () { setTaskSearch(true); });
+  on('btnTaskSearchClose', function () { setTaskSearch(false); });
+  on('btnTaskMe', showMine);
+  taskSearchInput.addEventListener('input', function () {
+    TASK_QUERY = String(taskSearchInput.value || '').trim().toLowerCase();
+    renderSessions(LAST_SESSIONS);
+  });
+  /* 会话页右上角 → 运行设置**独立子页面**（不再是底部抽屉），返回回会话。 */
+  on('btnSettings', showRunSettings);
+  on('btnRunSettingsBack', function () { showSession(); });
+  on('btnRsWorkspace', function () { openWorkspacePicker(); });
+  /* 权限 / 团队沿用会话组件里那唯一一份选择器（浮层盖在本页之上）；选完就地重画。 */
+  on('btnRsPermission', function () { if (conv && conv.openPermissionPicker) conv.openPermissionPicker(); });
+  on('btnRsTeam', function () { if (conv && conv.openTeamPicker) conv.openTeamPicker(); });
+  /* 选择器由会话组件管理、没有回调通知宿主，所以用一次点击兜底重画：
+     本页可见时任何一次点击（包括选择器里点中一行）之后重读状态。 */
+  document.addEventListener('click', function () {
+    if (!runSettingsPageEl.hidden) paintRunSettings();
+  });
   Array.prototype.forEach.call(tabbarEl.querySelectorAll('.tab'), function (b) {
     b.onclick = function () {
       var t = b.getAttribute('data-tab');
       if (t === 'tasks') showHistory();
-      else if (t === 'sched') showSched();
+      else if (t === 'reqs') showReqs();
       else if (t === 'discover') showDiscover();
       else if (t === 'mine') showMine();
     };
   });
+  /* 中间那枚「＋」= 快速新建会话（不是 tab，不换页签）。
+     走 newConversation() 而**不传空间**：与「新建任务」大按钮同一条口径 ——
+     归属只在用户显式选空间时确定，不能让上一次的 WS 悄悄粘过来。 */
+  on('btnFabNew', function () { newConversation(); });
   on('btnMineBack', function () { showHistory(); });
   on('dscBrowser', function () { openBrowser(HOME_URL); });
   on('dscApps', function () { openComingSheet('应用', '暂无可用应用。桌面端发布的应用会出现在这里。'); });
@@ -2335,6 +4595,10 @@ button.setrow{font-family:inherit}
   on('btnNotify', openNotifySettings);
   on('btnDefaultEngine', openDefaultEnginePicker);
   on('btnDefaultModel', openDefaultEnginePicker);
+  /* 团队模式配置（「我的」→ 子页面）：计划 + 7 个角色，行由 paintTeamRoles 动态渲染，
+     行的点击在渲染时绑定（见 addTeamRow / openTeamRoutePicker），这里只留入口与返回。 */
+  on('btnTeamPage', showTeamPage);
+  on('btnTeamBack', showMine);
   on('btnLogout', disconnect);
   on('btnUpgrade', reloadApp);
   if (segTheme) takeSeg(segTheme, 'magic.theme', function (v) { PREFS.theme = v; applyThemePref(v); });
@@ -2440,6 +4704,7 @@ button.setrow{font-family:inherit}
     if (injectedToken || injectedBase) {
       BASE = injectedBase; TOKEN = injectedToken;
       showHistory(injectedBase ? injectedBase.replace(/^https?:\/\//, '') : '本机');
+      restoreQueue();      // App 重启：上次没轮到的排队任务接着排（见 restoreQueue）
     } else {
       showLauncher();
     }