magic-agent 2.4.2 → 2.6.0

package/client-ui-mobile/index.html

@@ -35,42 +35,69 @@
 <!-- 需求页（「需求」tab）是独立子页面：样式在 reqs.css、结构/逻辑在 reqs.js。
      本文件只给两个空容器与一次 mount，不再混入这一页的实现。 -->
 <link rel="stylesheet" href="reqs.css">
+<!-- 脚本页（「发现 → 脚本」）是独立子页面：样式在 scripts.css、结构/逻辑在 scripts.js。
+     本文件只给两个空容器与一次 mount，不再混入这一页的实现。 -->
+<link rel="stylesheet" href="scripts.css">
 <style>
-/* ===== 令牌：ZCode 安卓端那一套，映射到共享组件的颜色契约 =====
-   ⚠️ 默认 = 暗色：跟 ZCode 的 DarkColorScheme 逐字段对齐。 */
+/* ===== 令牌：几何/字阶照 ZCode 安卓端；颜色契约见下 =====
+   ⚠️ 默认 = 暗色。浅色仍逐字段对齐 ZCode Color.kt；
+      暗色自 2026-10-24 起改为掌天瓶墨绿系（用户：「这个深色跟掌天瓶主色不搭」）。 */
 :root{
   color-scheme:dark;
-  --canvas:#111827;                                   /* background = NeutralDarkBackground */
-  --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 */
+  /* 2026-10-24 用户定稿：「这个深色跟掌天瓶主色不搭」——
+     暗色不再照抄 ZCode 的中性蓝灰（#111827/#1F2937），整套换成**掌天瓶墨绿系**：
+     页面底色 = 近乎黑的墨绿，卡片往上提一档，分界线带一层淡玉光。
+     色相统一压在绿（H≈158°），亮度层级与原来一致，只换色相，不动对比关系。 */
+  --canvas:#0B1512;                                   /* background = 掌天瓶墨绿底 */
+  --ink:#F2FBF5; --ink-soft:#DCEAE2; --muted:#A7BFB2; --faint:#7C9488;
+  --border:rgba(167,243,208,.12); --subtle:#20322A; --raised:#14211C;
+  --primary-action:#6EE7A8; --on-primary-action:#07130E;               /* primary = 掌天瓶玉青（原 ZCode 品牌蓝） */
   /* 底栏「＋」凹槽的两件套，**必须按主题分别给**（`--fab-well` 槽底，`--fab-notch` 接触影满强度色）：
-     槽底不能用 `--canvas` —— 那是「页面底色」，暗色下 #111827 比栏面 #1F2937 暗 14 阶，
+     槽底不能用 `--canvas` —— 那是「页面底色」，暗色下 #0B1512 比栏面 #14211C 暗 14 阶，
      整圈会读成一道黑箍（比浮起来更假）。槽底该是**栏面稍暗一档**的同一个色系：
-     暗色 #1F2937 → #1B2432（同色相压 4 阶），浅色 #FFFFFF → #EEF2F7（同色相压 8 阶，必须够，
+     暗色 #14211C → #0F1B17（同色相压 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);
+  --fab-well:#0F1B17; --fab-notch:rgba(0,0,0,.22);
+  --app-shadow:rgba(0,0,0,.5);
 
   /* 用户气泡 = surface/foreground：ZCode 的用户消息是**中性表面**不是品牌色气泡 */
-  --bubble:#1F2937; --bubble-text:#F9FAFB;
-  --code:#0F172A; --status-neutral:#374151; --status-neutral-text:#CBD5E1;
-  --activity:rgba(147,197,253,.12);
-
-  --md-body:#F9FAFB; --md-muted:#CBD5E1; --md-border:#374151; --md-code-bg:#1E293B;
-  --link:#93C5FD; --prompt:#93C5FD; --shimmer:#FFFFFF;
-  --panel:#1F2937; --panel-border:#374151;
-
-  --accent:#93C5FD; --warning:#FBBF24; --success:#22C55E;
+  --bubble:#15231E; --bubble-text:#F2FBF5;
+  --code:#070F0D; --status-neutral:#20322A; --status-neutral-text:#A7BFB2;
+  --activity:rgba(67,201,138,.14);
+  /* 底栏选中态 = 玉青（2026-10-24 用户定稿「修仙器物图标 + 玉青选中」）：
+     与掌天瓶绿同源但比 --q-bottle 亮一档，暗底上才压得住；浅底用沉一档的玉青。 */
+  --tab-on:#6EE7A8; --tab-on-bg:rgba(34,197,94,.16);
+  --tab-off:#A7BFB2;
+  /* 底栏图标的双色点缀（2026-10-24「大胆设计」）：鎏金 + 丹血朱。
+     25px 上颜色本身就是最强的辨识信号 —— 单色描边怎么调都读不出「法器」。 */
+  --q-gold:#E8C77A; --q-blood:#E23B2E;
+
+  --md-body:#F2FBF5; --md-muted:#A7BFB2; --md-border:#25392F; --md-code-bg:#182720;
+  --link:#6EE7A8; --prompt:#6EE7A8; --shimmer:#F2FBF5;
+  --panel:#14211C; --panel-border:#25392F;
+
+  /* 语义三态必须互相区分的（2026-10-25 深色配色量化发现）：
+     `--running` 绿 / `--queued` 金 / `--warning` 琥珀 三个在屏幕上是**并排出现**的
+     （列表行状态、需求页「待整理」徽标 + 「上次整理失败」横幅），但原来
+     warning 与 queued 同是橙金族（H43 S96 L56 vs H42 S71 L69），对比度只有 **1.02**
+     —— 等于同一个颜色，用户分不出「排队等跑」和「出问题了」。
+     现在把 warning 压成深琥珀 #D97706（H32 S95 L44）：明度落到 gold 的 6 折，
+     两者拉开到 1.95（色相差也从 1° 拉到 10°）；同时对页底仍有 5.83 —— 警告文字照读不误。
+     这也顺带治好了需求页那一整块 #FBBF24 淡底横幅（占屏 13.7% 像素）的刺眼问题。 */
+  --accent:#6EE7A8; --warning:#D97706; --success:#22C55E;
   --error-surface:#3B1113; --error-border:#7F1D1D; --error-text:#FCA5A5; --error-icon:#F87171;
-  --running:#22C55E; --transitioning:#60A5FA; --active:#FBBF24;
-  /* 状态色底（半透明叠加色，明暗主题通用） */
-  --tint-run:rgba(59,130,246,.18); --tint-wait:rgba(245,158,11,.20); --tint-done:rgba(34,197,94,.18);
-  --tint-queued:rgba(139,92,246,.18); --queued:#8B5CF6;
+  --running:#22C55E; --transitioning:#6EE7A8; --active:#FBBF24;
+  /* 状态色底（半透明叠加色）：暗色「运行中」用玉青底跟主色同族；
+     浅色另给一份蓝底（见下面两个浅色块），保持 ZCode 那份观感不变。 */
+  --tint-run:rgba(45,212,191,.18); --tint-wait:rgba(217,119,6,.20); --tint-done:rgba(34,197,94,.18);
+  /* 排队 = 蓄势待发 → 鎏金（同浅色那份）。原来用紫 #8B5CF6，
+     在墨绿底上没有任何亲缘色，一眼就是异物。 */
+  --tint-queued:rgba(232,199,122,.16); --queued:#E8C77A;
   /* 异常终态两档（2026-10-23 用户：「现在没有异常状态的颜色」）：
-       · 失败（failed / gone）→ 红：这条没跑完就没了，要人看一眼；
-       · 已取消 / 已打断（cancelled / interrupted）→ 石褐：人为收工，不是故障，
-         所以不上红，但也绝不能和「正常结束」的绿或兜底的白同色。 */
+       · 失败（failed）→ 红：引擎报错结束，这条没跑完就没了，要人看一眼；
+       · 已取消 / 已打断 / 断连（cancelled / interrupted / gone）→ 石褐：人为收工或进程
+         被外部带走（服务重启、终端关闭），不是故障，所以不上红 —— 但也绝不能和
+         「正常结束」的绿或兜底的白同色。 */
   --tint-fail:rgba(239,68,68,.18); --fail:#F87171;
   --tint-stop:rgba(120,113,108,.24); --stop:#A8A29E;
 
@@ -98,6 +125,15 @@
      皮肤三端一份，基线各端给自己的 —— 这两个值就是 tests/check-ui-spec.mjs 里钉的那两条。 */
   --qa-bubble-r:12px 4px 12px 12px;   /* ConversationUserInputBubble.tsx:27 rounded-xl + rounded-tr-xs */
   --qa-body-lh:28px;                  /* ai-elements/message.tsx MessageResponse leading-[1.75] */
+
+  /* 中间 FAB 的「深玉盘 + 金环」材质（2026-10-25 深色配色；与 html[data-theme="dark"] 同一份）。
+     这里是**默认深色**（无 data-theme、系统也不是浅色时走这里），所以也得给一份，
+     否则系统深色下 FAB 会退回平涂亮绿 —— 那就只有「手动选深色」才生效了。
+     浅色两个块都不给这两项 → 落到 .tabfab__b 的兜底值 = 原样。 */
+  --fab-sheen:linear-gradient(178deg,rgba(255,255,255,.20),rgba(255,255,255,0) 52%);
+  --fab-base:radial-gradient(circle at 50% 28%,#3FAE79 0%,#1B7449 44%,#093720 100%);
+  --fab-ring:rgba(232,199,122,.42); --fab-ring-w:1.5px;
+  --fab-halo:rgba(63,174,121,.12);
 }
 @media (prefers-color-scheme:light){
   :root{
@@ -111,14 +147,17 @@
     --bubble:#FFFFFF; --bubble-text:#111827;
     --code:#F1F5F9; --status-neutral:#E2E8F0; --status-neutral-text:#475569;
     --activity:rgba(37,99,235,.08);
+    /* 玉青选中（浅底沉一档，太浅会读不出「选中」） */
+    --tab-on:#0C8F5C; --tab-on-bg:rgba(16,163,90,.10);
+    /* 浅底：鎏金要压暗一档才看得清，丹血朱提亮一点 */
+    --q-gold:#B98A2E; --q-blood:#D13A2C;
     --md-body:#111827; --md-muted:#64748B; --md-border:#E2E8F0; --md-code-bg:#F1F5F9;
     --link:#2563EB; --prompt:#2563EB; --shimmer:#0F172A;
     --panel:#FFFFFF; --panel-border:#E2E8F0;
     --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;
-    /* 浅底上异常终态要更重（半透明红 / 石褐在 #F8FAFC 上否则会糊成灰） */
+    --tint-run:rgba(59,130,246,.18);
     --tint-fail:rgba(220,38,38,.13); --fail:#DC2626;
     --tint-stop:rgba(120,113,108,.16); --stop:#78716C;
     /* 浅底上玉胎要更浓：`.42` 那档实测会被冲成白瓷，读不出「翠」。浓到 .66 又像实心塑料。 */
@@ -127,6 +166,28 @@
     --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);
+    /* 中间 FAB 材质：浅色**钉回原样**（平涂亮绿、无金环、无外晕）。
+       不钉的话会从 :root 继承到深色那份「深玉盘 + 金环」—— 浅色就被改了。
+       2026-10-25 用户：「浅色皮肤不变 改深色皮肤配色」。 */
+    --fab-sheen:linear-gradient(178deg,rgba(255,255,255,.16),rgba(255,255,255,0) 60%);
+    --fab-base:#22C55E;
+    --fab-ring:transparent; --fab-ring-w:0;
+    --fab-halo:transparent;
+    /* ── 浅色**保持不变**（2026-10-25 用户：「浅色皮肤不变 改深色皮肤配色」）──
+       下面四项是这一轮新加的令牌，取值刻意等于「改动前浅色实际渲染出来的那个颜色」，
+       所以浅色一个像素都不变，只是从「继承深色新值」改回「自己钉住旧值」：
+         --tab-off     = 旧的 --muted（底栏未选中原本就用 --muted 画）
+         --gem-facet   = 旧的 --q-gold（灵石刻面原本是鎏金线）
+         --btn-me-bg/fg= 顶栏头像的「金底 + 墨绿元婴」，与原公式 color-mix(q-gold 34%, raised) / #12211A 等值
+         --queued      = 旧的排队紫（原本从 :root 继承；深色已改鎏金，浅色仍用紫） */
+    --tab-off:#64748B;
+    --gem-facet:#B98A2E;
+    --btn-me-bg:color-mix(in srgb,var(--q-gold) 34%,var(--raised)); --btn-me-fg:#12211A;
+    --queued:#8B5CF6; --tint-queued:rgba(139,92,246,.18);
+    /* --tint-wait 也得钉住：浅色块原来没写它（一直从 :root 继承 #F59E0B 那份），
+       这一轮深色把它改成深琥珀了，不钉就会连带把浅色的「待整理」徽标底色改深。
+       --tint-done / --q-bottle* 同样没写，但那几个 :root 的值这轮没动，无需重复钉。 */
+    --tint-wait:rgba(245,158,11,.20);
   }
 }
 /* 手动主题：在「我的」页显式选了才生效（属性选择器优先级高于上面的 :root / media） */
@@ -140,13 +201,16 @@ html[data-theme="light"]{color-scheme:light;
   --bubble:#FFFFFF; --bubble-text:#111827;
   --code:#F1F5F9; --status-neutral:#E2E8F0; --status-neutral-text:#475569;
   --activity:rgba(37,99,235,.08);
+  /* 玉青选中（同 prefers-color-scheme:light 那一份） */
+  --tab-on:#0C8F5C; --tab-on-bg:rgba(16,163,90,.10);
+  --q-gold:#B98A2E; --q-blood:#D13A2C;
   --md-body:#111827; --md-muted:#64748B; --md-border:#E2E8F0; --md-code-bg:#F1F5F9;
   --link:#2563EB; --prompt:#2563EB; --shimmer:#0F172A;
   --panel:#FFFFFF; --panel-border:#E2E8F0;
   --accent:#2563EB; --warning:#D97706; --success:#16A34A;
   --error-surface:#FEF2F2; --error-border:#FECACA; --error-text:#B91C1C; --error-icon:#DC2626;
   --running:#16A34A; --transitioning:#2563EB; --active:#D97706;
-  /* 浅底上异常终态要更重（同 prefers-color-scheme:light 那一份） */
+  --tint-run:rgba(59,130,246,.18);
   --tint-fail:rgba(220,38,38,.13); --fail:#DC2626;
   --tint-stop:rgba(120,113,108,.16); --stop:#78716C;
   /* 浅底上玉胎要更浓（同上一条注释） */
@@ -155,23 +219,73 @@ html[data-theme="light"]{color-scheme:light;
   --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);
+  /* 与 prefers-color-scheme:light 那一份逐值相同 —— 浅色保持不变。 */
+  --tab-off:#64748B;
+  --gem-facet:#B98A2E;
+  --btn-me-bg:color-mix(in srgb,var(--q-gold) 34%,var(--raised)); --btn-me-fg:#12211A;
+  --queued:#8B5CF6; --tint-queued:rgba(139,92,246,.18);
+  /* --tint-wait 钉回原值（理由见 prefers-color-scheme:light 那份） */
+  --tint-wait:rgba(245,158,11,.20);
+  /* 中间 FAB 材质：浅色钉回原样（同 prefers-color-scheme:light 那份） */
+  --fab-sheen:linear-gradient(178deg,rgba(255,255,255,.16),rgba(255,255,255,0) 60%);
+  --fab-base:#22C55E;
+  --fab-ring:transparent; --fab-ring-w:0;
+  --fab-halo:transparent;
 }
+/* 手动主题：在「我的」页显式选了才生效（属性选择器优先级高于上面的 :root / media）。
+   ⚠️ 这一块**必须把颜色令牌补全**（2026-10-25 实测发现的结构性 bug）：
+   原来只写了 43 个令牌，比浅色块少了 30 个颜色令牌。系统偏好是**浅色**时手动选深色，
+   漏掉的令牌不会回落到 :root（:root 本身也在 media 浅色块里被覆盖了），
+   而是继续用浅色的值 —— 于是深色下出现蓝底头像（--tint-run 蓝）、暖米黄头像
+   （--btn-me-bg 硬编码米黄）、紫排队（--queued 紫）。补全后两套手动主题都自洽。 */
 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;
-  --activity:rgba(147,197,253,.12);
-  --md-body:#F9FAFB; --md-muted:#CBD5E1; --md-border:#374151; --md-code-bg:#1E293B;
-  --link:#93C5FD; --prompt:#93C5FD; --shimmer:#FFFFFF;
-  --panel:#1F2937; --panel-border:#374151;
-  --accent:#93C5FD; --warning:#FBBF24; --success:#22C55E;
+  --canvas:#0B1512;
+  --ink:#F2FBF5; --ink-soft:#DCEAE2; --muted:#A7BFB2; --faint:#7C9488;
+  --border:rgba(167,243,208,.12); --subtle:#20322A; --raised:#14211C;
+  --primary-action:#6EE7A8; --on-primary-action:#07130E;
+  --fab-well:#0F1B17; --fab-notch:rgba(0,0,0,.22);
+  --app-shadow:rgba(0,0,0,.5);
+  --bubble:#15231E; --bubble-text:#F2FBF5;
+  --code:#070F0D; --status-neutral:#20322A; --status-neutral-text:#A7BFB2;
+  --activity:rgba(67,201,138,.14);
+  /* 玉青选中（同 :root 默认暗色那一份） */
+  --tab-on:#6EE7A8; --tab-on-bg:rgba(34,197,94,.16);
+  --tab-off:#A7BFB2;
+  --q-gold:#E8C77A; --q-blood:#E23B2E;
+  --md-body:#F2FBF5; --md-muted:#A7BFB2; --md-border:#25392F; --md-code-bg:#182720;
+  --link:#6EE7A8; --prompt:#6EE7A8; --shimmer:#F2FBF5;
+  --panel:#14211C; --panel-border:#25392F;
+  /* warning 压成深琥珀 —— 理由见 :root 里那段注释（与 queued 的 1.02 区分度问题） */
+  --accent:#6EE7A8; --warning:#D97706; --success:#22C55E;
   --error-surface:#3B1113; --error-border:#7F1D1D; --error-text:#FCA5A5; --error-icon:#F87171;
-  --running:#22C55E; --transitioning:#60A5FA; --active:#FBBF24;
+  --running:#22C55E; --transitioning:#6EE7A8; --active:#FBBF24;
+  /* ── 以下 30 个是「补齐原先漏写的深色值」（同 :root 那份，逐值相同）──
+     分四组：状态 tint / 招标示 / 底栏法器 / 顶栏头像。 */
+  --tint-run:rgba(45,212,191,.18); --tint-wait:rgba(217,119,6,.20); --tint-done:rgba(34,197,94,.18);
+  --tint-queued:rgba(232,199,122,.16); --queued:#E8C77A;
+  --tint-fail:rgba(239,68,68,.18); --fail:#F87171;
+  --tint-stop:rgba(120,113,108,.24); --stop:#A8A29E;
+  --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);
+  --gem-facet:var(--canvas);
+  --btn-me-bg:color-mix(in srgb,var(--q-gold) 34%,var(--raised)); --btn-me-fg:#12211A;
+  /* 中间 FAB（蜂云剑阵）的材质 —— 深色专属（2026-10-25 用户：「浅色皮肤不变 改深色皮肤配色」）。
+     原来 FAB 是 `--q-bottle` = #22C55E 的**平涂实心圆**：在墨绿底上 H145/S71/L45，
+     同一个色相却高出 35 阶明度、40 阶饱和，读起来是一只**发光的塑料球**，
+     也是整屏最刺眼的一处（截图实测，1.68 万像素是这个色）。
+     深色改成「深玉盘」：径向从玉心 (#3FAE79) 落到墨底 (#093720)，明度压在
+     底栏栏面 (#14211C, L10) 与选中图标 (#6EE7A8, L67) 之间；
+     再补一圈 **1.5px 鎏金环** —— 主按钮的「这是可点的」不能靠更亮更大声，
+     而是靠金环这个**形状**（金与墨绿是这套配色的互补对，底栏法器纹样本来就有点金）。
+     玉光 halo 收到 .12：原来 .30 的 22px 绿晕是「发光」的另外一半原因。 */
+  --fab-sheen:linear-gradient(178deg,rgba(255,255,255,.20),rgba(255,255,255,0) 52%);
+  --fab-base:radial-gradient(circle at 50% 28%,#3FAE79 0%,#1B7449 44%,#093720 100%);
+  --fab-ring:rgba(232,199,122,.42); --fab-ring-w:1.5px;
+  --fab-halo:rgba(63,174,121,.12);
 }
 
 *{box-sizing:border-box;-webkit-tap-highlight-color:transparent}
@@ -284,6 +398,20 @@ textarea{font:inherit}
 .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}
+/* 会话列表加载失败（连不上桌面端）的失败态：不再是一行灰字，给图标 + 人话原因 +
+   可复制地址 + 重试/编辑环境入口（2026-10-25：「失败时的界面显示要设计一下」）。
+   颜色全走变量，暗/亮主题自动跟随；图标与排队/失败行同一套「一枚图标 + 状态 tint」。 */
+.netfail{display:flex;flex-direction:column;align-items:center;gap:6px;padding:44px 24px 12px;text-align:center}
+.netfail__ico{width:56px;height:56px;border-radius:50%;background:var(--tint-fail);color:var(--fail);
+  display:flex;align-items:center;justify-content:center;margin-bottom:6px}
+.netfail__t{font-size:15px;font-weight:600;color:var(--ink)}
+.netfail__why{font-size:13px;line-height:1.6;color:var(--muted)}
+.netfail__addr{max-width:100%;margin-top:2px;padding:5px 12px;border-radius:var(--r-full);
+  background:var(--subtle);color:var(--muted);font-size:12px;
+  white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.netfail__addr:active{opacity:.7}
+.netfail__acts{display:flex;flex-direction:column;gap:8px;width:200px;margin-top:14px}
+.netfail__acts .btn{margin-top:0}
 .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}
@@ -302,7 +430,8 @@ textarea{font:inherit}
 .srow__ico--done{background:var(--tint-done);color:var(--success)}
 /* 异常终态：以前和 idle 一起落在灰白兜底档，用户看不出「这条是挂了 / 被停了，
    还是只是没跑过」（2026-10-23 用户：「现在没有异常状态的颜色」）。
-   失败（failed / gone）= 红；已取消 / 已打断（cancelled / interrupted）= 石褐。 */
+   失败（failed）= 红；已取消 / 已打断 / 断连（cancelled / interrupted / gone）= 石褐
+   （2026-10-24 用户：「会话全部断连 红色」—— 服务重启把进程带走的那些不该算故障）。 */
 .srow__ico--fail{background:var(--tint-fail);color:var(--fail)}
 .srow__ico--stop{background:var(--tint-stop);color:var(--stop)}
 .srow__ico--idle{background:var(--subtle);color:var(--muted)}
@@ -337,12 +466,22 @@ textarea{font:inherit}
    手动置顶靠「置顶」分段表达，不重复画；跑完 statusOf 不再是 run，图钉随之消失。 */
 .srow__auto{flex:0 0 auto;display:flex;align-items:center;color:var(--primary-action);opacity:.75}
 /* 子会话（团队模式拆出的子任务，2026-10-22）：**缩进挂在主会话下面**，不占顶层一行。
-   左侧一道竖线 + 小一档图标 —— 读起来是「这条主会话拆出去的活」；点开仍是它自己
-   那份完整过程（自己的日志）。行本身可点、可长按（重命名 / 删除同普通会话）。
+   左侧用**树形折线**（├─ / └─）接出来，不是一根通到底的竖线（2026-10-24 用户：
+   「团队模式的子会话的线设计成树状 不要一条竖线」）—— 多个子任务读起来是一棵树，
+   只有一个子任务时就是一条 └─。
+   点开仍是它自己那份完整过程（自己的日志）；行本身可点、可长按（重命名 / 删除同普通会话）。
    ⚠️ 默认**折叠**（2026-10-23 用户：「列表中默认不展开显示子会话」）：父行只留一枚
    计数徽标（有几个子会话 / 是否有子任务在跑），点它才展开。 */
 .sblock{min-width:0}
-.sblock__kids{margin:0 8px 6px 30px;padding-left:8px;border-left:2px solid var(--border)}
+/* 竖线分段画在每个子行自己的伪元素上：非末行整段，末行只画到中点（收口成 └）。 */
+.sblock__kids{margin:0 8px 6px 26px}
+.sblock__kid{position:relative;padding-left:16px}
+.sblock__kid::before{content:"";position:absolute;left:0;top:0;bottom:0;width:2px;
+  background:var(--border);border-radius:1px}
+.sblock__kid:last-child::before{bottom:calc(50% - 1px)}
+/* 横向短线：从竖线拐进这一行（折线的「肘」）。 */
+.sblock__kid::after{content:"";position:absolute;left:0;top:calc(50% - 1px);width:12px;height:2px;
+  background:var(--border);border-radius:0 1px 1px 0}
 .srow__kids{flex:0 0 auto;display:inline-flex;align-items:center;gap:3px;height:20px;padding:0 5px;
   border:1px solid var(--border);border-radius:999px;background:var(--subtle);color:var(--muted);
   font-size:11px;font-weight:600;line-height:1;cursor:pointer;user-select:none;-webkit-user-select:none}
@@ -369,7 +508,10 @@ textarea{font:inherit}
 .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}
+  /* 金底 + 深褐元婴：底色/元婴色都走令牌（--btn-me-bg / --btn-me-fg）——
+     浅色主题钉住原来那套暖米黄 #E8DCB0 / 深褐 #4A3F1E，一个像素都不动；
+     深色主题给鎏金淡面 + 墨绿黑，跟底栏法器纹样同源。 */
+  background:var(--btn-me-bg);color:var(--btn-me-fg)}
 /* 搜索态：输入框 + 关闭（搜索时隐藏快捷入口与分组行，结果平铺） */
 .tasks__search{display:flex;align-items:center;gap:8px;flex:0 0 auto;padding:2px 16px 8px}
 /* 搜索态就是截图 2 那一屏：标题行让位给搜索框（✕ 在框外，与截图一致）。 */
@@ -406,6 +548,11 @@ 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)}
+/* 空间选择行里的行内小动作（自定义空间的「✎ 改名」）：行本身是 <button>，
+   里面不能再塞按钮（HTML 不允许嵌套按钮），所以是 span + role=button。 */
+.pick__act{flex:0 0 auto;display:inline-flex;align-items:center;justify-content:center;
+  min-width:30px;height:30px;border-radius:var(--r-full);color:var(--muted);font-size:15px}
+.pick__act:active{background:var(--subtle)}
 /* 长按会话行的浮动菜单 */
 .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}
@@ -473,6 +620,9 @@ button.setrow{font-family:inherit}
 .pbadge{flex:0 0 auto;padding:2px 8px;border-radius:var(--r-full);font-size:11px;line-height:16px;white-space:nowrap}
 .pbadge--on{color:var(--success);background:var(--tint-done)}
 .pbadge--off{color:var(--muted);background:var(--subtle)}
+/* 「可升级」：主色 + 描边（不用底色 —— 底色会和「已安装」的绿撞）。
+   语义是「有新版可装」，所以不能长成「已完成」的样子。 */
+.pbadge--new{color:var(--primary-action);background:transparent;border:1px solid var(--primary-action);font-weight:600}
 /* 详情页 */
 .pd{padding:0 16px calc(28px + env(safe-area-inset-bottom));font-size:14px;line-height:1.7;color:var(--ink)}
 .pd__head{display:flex;align-items:center;gap:10px;padding:6px 0 2px}
@@ -497,6 +647,13 @@ button.setrow{font-family:inherit}
 .setrow+.setrow{border-top:1px solid var(--border)}
 .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%}
+/* 主备值：主一行、备一行（右上对齐）。挤成「主 ｜ 备 …」会被省略号吃掉后半截
+   （2026-10-24 用户：「没显示出来」），所以这里允许换行、两行各自省略。 */
+.setrow__v--pair{display:flex;flex-direction:column;align-items:flex-end;gap:1px;
+  max-width:62%;white-space:normal;overflow:visible}
+.setrow__v--pair .setrow__pair-main{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.setrow__v--pair .setrow__pair-fb{font-size:12px;color:var(--muted);opacity:.9;
+  max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 /* 有新版本时这一格变成可点的「升级」提示（2026-10-22 用户：「版本现在也没点击升级的地方」） */
 .setrow__v.is-upgradable{color:var(--primary-action);font-weight:600}
 .setrow--danger{color:var(--error-text)}
@@ -566,20 +723,59 @@ button.setrow{font-family:inherit}
 .tabbar{position:absolute;left:0;right:0;bottom:0;z-index:60;
   display:flex;align-items:stretch;
   min-height:calc(56px + env(safe-area-inset-bottom));
-  background:color-mix(in srgb,var(--raised) 86%,transparent);
-  -webkit-backdrop-filter:blur(18px) saturate(1.4);backdrop-filter:blur(18px) saturate(1.4);
+  /* ⚠️ 必须是**不透明**的栏面：86% 半透 + blur 在真机上够用，
+     但在列表滚到底时下面那行「magic-stock · codebuddy」会透上来压在图标上
+     （2026-10-25 截图实测，深浅两主题都会）。玻璃感靠上面的飞檐和投影做，
+     不靠让文字透过来 —— 图标才是底栏唯一要读的东西。 */
+  background:var(--raised);
   box-shadow:0 -1px 0 var(--border),0 -14px 30px -26px var(--app-shadow);
   padding-bottom:env(safe-area-inset-bottom)}
+/* 上边框 = 「飞檐翘角」（2026-10-25 用户先要弧形上缘，看过中间拱起的版本后：
+   「弧度反了」→ 反过来 —— 不是中间拱，而是**两角上翘、中段落低**的飞檐：
+   中式檐角向上挑，正中半嵌的 FAB 像檐下悬月，也更贴修仙主题）：
+     ① 一对 <i class="eave"> 贴在栏顶上方（bottom:100%）：120×15 的方块只留
+        「顶角大圆弧」（border-top-right-radius 120px 15px，恰好占满整块），
+        剪影 = 角上 15px、向内 120px 平滑落回栏顶 —— 侧看正是一片上翘的檐角。
+     ② hairline 两笔：檐弧 = eave 的 border-top + 弧形 border-right/left（border 跟圆角走，
+        1px 矢量清晰）；中段直线 = 栏本体 box-shadow 0 -1px 0（檐块 86% 同色半透，
+        压在直线上只剩残影，肉眼不可见），两笔在弧线落点（距角 120px）相接。
+     ③ 檐块与栏体同 fill（86% raised），不加 blur —— 14% 透差在纯色栏面上读不出接缝；
+        pointer-events:none 不吃点击；FAB 槽（::before）被 clip-path 钉在栏内，互不越界。 */
+.eave{position:absolute;bottom:100%;width:120px;height:15px;z-index:0;pointer-events:none;
+  /* 与栏面同色（实色）—— 栏面改成不透明后，檐块若仍是 86% 半透就会比栏面浅一档，
+     两者相接处露一道色差，像贴了块补丁。 */
+  background:var(--raised);
+  border-top:1px solid var(--border)}
+.eave-l{left:0;border-top-right-radius:120px 15px;border-right:1px solid var(--border)}
+.eave-r{right:0;border-top-left-radius:120px 15px;border-left:1px solid var(--border)}
 /* 只有图标：文案从底栏拿掉（2026-10-22 用户），语义交给 aria-label，不靠视觉标签。
    命中区仍是 flex:1 × 56，比"图标 + 文字"那版更高更宽，点起来更稳。 */
 .tab{flex:1;display:flex;align-items:center;justify-content:center;
-  color:var(--muted);transition:color .16s}
-.tab.is-on{color:var(--primary-action)}
-/* 选中态不只换颜色，还给一块 44×34 的浅底（`--activity` 是现成的品牌色低透明令牌）：
-   没有文字之后，颜色是唯一的语义线索，必须再补一个形状 —— 暗色下主色是浅蓝，光靠颜色区分太弱。 */
+  /* 未选中用 --tab-off 而不是 --muted：--muted 是「次要文字」的档位，
+     拿来画 25px 的器物剪影偏淡 —— 浅色下在白栏面上只有 5.1:1，
+     而剪影全靠实心面积撑辨识度，实测比正文更吃对比（正文有字重兜底，剪影没有）。
+     浅色下压到 #3D5348（8.3:1），深色下保持 #A7BFB2（8.5:1）。 */
+  color:var(--tab-off);transition:color .16s}
+/* 选中态 = 玉青（--tab-on，与掌天瓶绿同源；2026-10-24 修仙器物套组定稿），不再借主色蓝。
+   选中再给一圈「灵光」（drop-shadow 用选中色本色，浅色主题自动变淡）：
+   粗玉器物 + 灵光才是「修仙」，光换颜色读不出「法器被唤醒」。 */
+.tab.is-on{color:var(--tab-on)}
+/* 灵光：26px 的图标上 6px / 55% 的晕几乎看不见（2026-10-25 截图实测）。
+   浅色那份**保持原值 7px / 32%**（墨绿选中的晕再浓就会把图标糊成一团）；
+   深色提高到 9px / 85%，才读得出「法器被唤醒」。
+   两个值都只在各自主题生效 —— 2026-10-25 用户：「浅色皮肤不变 改深色皮肤配色」。 */
+.tab.is-on svg{filter:drop-shadow(0 0 9px color-mix(in srgb,var(--tab-on) 85%,transparent))}
+html[data-theme="light"] .tab.is-on svg,
+html:not([data-theme="dark"]) .tab.is-on svg{
+  filter:drop-shadow(0 0 7px color-mix(in srgb,var(--tab-on) 32%,transparent))}
+@media (prefers-color-scheme:dark){
+  html:not([data-theme]) .tab.is-on svg{filter:drop-shadow(0 0 9px color-mix(in srgb,var(--tab-on) 85%,transparent))}
+}
+/* 选中态不只换颜色，还给一块 44×34 的浅底：
+   没有文字之后，颜色是唯一的语义线索，必须再补一个形状 —— 光靠颜色区分太弱。 */
 .tab .icw{display:grid;place-items:center;width:44px;height:34px;border-radius:11px;
   transition:background .18s ease}
-.tab.is-on .icw{background:var(--activity)}
+.tab.is-on .icw{background:var(--tab-on-bg)}
 .tab svg{display:block;transition:transform .16s}
 .tab:active svg{transform:scale(.92)}
 /* ── 「快速新建」：**半嵌入**底栏的圆形主按钮（2026-10-22 定稿）
@@ -636,7 +832,6 @@ button.setrow{font-family:inherit}
   width:68px;height:68px;
   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),     /* 下半圈内侧暗边：光从上来 → 这一圈在阴影里 */
@@ -645,7 +840,187 @@ button.setrow{font-family:inherit}
   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)}
+/* 按下时也要留住金环（否则深色下按下瞬间环消失，像按钮掉了层壳） */
+html[data-theme="dark"] .tabfab__b:active{
+  box-shadow:inset 0 -6px 12px -7px rgba(15,23,42,.56), inset 0 2px 3px -2px rgba(255,255,255,.26),
+    0 0 0 1.5px var(--fab-ring,rgba(232,199,122,.42)), 0 0 14px 2px var(--fab-halo,rgba(63,174,121,.12))}
+@media (prefers-color-scheme:dark){
+  html:not([data-theme]) .tabfab__b:active{
+    box-shadow:inset 0 -6px 12px -7px rgba(15,23,42,.56), inset 0 2px 3px -2px rgba(255,255,255,.26),
+      0 0 0 1.5px var(--fab-ring,rgba(232,199,122,.42)), 0 0 14px 2px var(--fab-halo,rgba(63,174,121,.12))}
+}
 .tabfab__b svg{display:block;stroke-width:2.4;transform:translateY(-1px)}
+/* ── 丹炉炼丹动画（2026-10-24 用户：「中间的丹炉做炼丹动画效果」→「火焰动画重新设计」→「丹炉到第一个去」）──
+   丹炉已从中间 FAB 挪到**底栏第一格**（任务 tab 的图标位），动画类选择器随之从 #btnFabNew
+   改挂在 .furnsvg 上（中间 FAB 换成修行动画，见下面 medRing 段）。
+   火是**一群各自为政的舌**，不是一块整体在晃 —— 所以按「谁在动」分层，而不是按「整簇动」：
+     ① 整组缓摇（.fabfire）：一炉火整体缓慢起伏，幅度极小，只负责「这一炉火是活的」；
+     ② 三舌异速舔动（.fabflame）：中/左/右三舌各有**不同周期**（1.05 / 1.37 / 1.19s）与不同
+        相位的关键帧 —— 周期互质 ⇒ 三舌永不同步，不再是「一块贴纸在上下抖」；
+        每舌**火根钉死**（transform-origin 落在舌根），只有舌尖摆动；
+     ③ 火根护栏（.fabat-root）：灶口一道暗影压住舌根，任何帧都看不见火浮在炉外；
+     ④ 内芯（.fabcore）：黄芯最快最碎（0.83s），是火最活跃处；
+     ⑤ 火星：焰尖窜出、钻回炉腹；⑥ 炉内灵液沸腾；⑦ 呼吸光晕。
+   铁律：全部只动 transform / opacity（回放大日志会占死主线程，见 conversation.js bottleSVG 注释）。 */
+.tabfab__b{
+  /* 材质走令牌 `--fab-sheen` / `--fab-base`（2026-10-25 深色配色）：
+     浅色主题**不给这两项** → 落到兜底（= 原来的平涂亮绿 + 顶部那层柔光），一个像素不变。
+     深色主题在 html[data-theme="dark"] 里换成「深玉盘 + 金环」，见那边的注释。
+     注意 var() 的兜底不能塞逗号列表（`var(--a, b, c)` 的 `b, c` 会被当成一个值），
+     所以面光与底色拆成两个令牌，在这里用逗号拼成背景层。 */
+  background:var(--fab-sheen,linear-gradient(178deg,rgba(255,255,255,.16),rgba(255,255,255,0) 60%)),
+             var(--fab-base,var(--q-bottle,#22C55E))}
+/* 深色专属：鎏金环 + 玉光。
+   ⚠️ 单独一条规则、**不用令牌兜底**（2026-10-25）：写成
+   `box-shadow: …inset…, 0 0 0 var(--fab-ring-w,0) var(--fab-ring,transparent)`
+   时，浅色下这一项会算成 `rgba(0,0,0,0) 0px 0px 0px 0px` —— 视觉上等价，
+   但计算样式与原来不一致（逐样式比对能看出来）。浅色这一轮要求「一个像素都不变」，
+   所以环只在深色出现，浅色的 box-shadow 保持 HEAD 那两条 inset 原样。 */
+html[data-theme="dark"] .tabfab__b{
+  box-shadow:
+    inset 0 -7px 13px -7px rgba(15,23,42,.50),
+    inset 0 3px 3px -2px rgba(255,255,255,.34),
+    0 0 0 1.5px var(--fab-ring,rgba(232,199,122,.42)),
+    0 0 14px 2px var(--fab-halo,rgba(63,174,121,.12))}
+@media (prefers-color-scheme:dark){
+  html:not([data-theme]) .tabfab__b{
+    box-shadow:
+      inset 0 -7px 13px -7px rgba(15,23,42,.50),
+      inset 0 3px 3px -2px rgba(255,255,255,.34),
+      0 0 0 1.5px var(--fab-ring,rgba(232,199,122,.42)),
+      0 0 14px 2px var(--fab-halo,rgba(63,174,121,.12))}
+}
+/* ① 整组缓摇：幅度小、周期长 */
+@keyframes fabFire{
+  0%{transform:translateY(0) scale(1,1)}
+  33%{transform:translateY(-.16px) scale(.985,1.02)}
+  66%{transform:translateY(.12px) scale(1.012,.985)}
+  100%{transform:translateY(0) scale(1,1)}}
+.furnsvg .fabfire{transform-box:fill-box;transform-origin:50% 100%;
+  animation:fabFire 2.9s cubic-bezier(.4,0,.6,1) infinite}
+/* ② 三舌异速：中舌最高最快，两侧低而慢 —— 三条曲线互不重合 */
+@keyframes fabTongueMid{
+  0%{transform:scale(1,1) skewX(0)}
+  22%{transform:scale(.86,1.16) skewX(-4deg)}
+  46%{transform:scale(1.1,.9) skewX(3.5deg)}
+  71%{transform:scale(.93,1.09) skewX(-2deg)}
+  100%{transform:scale(1,1) skewX(0)}}
+@keyframes fabTongueL{
+  0%{transform:scale(1,1) skewX(0)}
+  31%{transform:scale(1.12,.88) skewX(3deg)}
+  58%{transform:scale(.88,1.14) skewX(-3.5deg)}
+  82%{transform:scale(1.05,.94) skewX(1.5deg)}
+  100%{transform:scale(1,1) skewX(0)}}
+@keyframes fabTongueR{
+  0%{transform:scale(1,1) skewX(0)}
+  19%{transform:scale(.9,1.12) skewX(-2.5deg)}
+  47%{transform:scale(1.09,.92) skewX(3deg)}
+  76%{transform:scale(.94,1.07) skewX(-1.8deg)}
+  100%{transform:scale(1,1) skewX(0)}}
+.furnsvg .fabflame{transform-box:fill-box;transform-origin:50% 100%}
+.furnsvg .fabflame:nth-of-type(1){animation:fabTongueMid 1.05s cubic-bezier(.45,0,.55,1) infinite}
+.furnsvg .fabflame:nth-of-type(2){animation:fabTongueL 1.37s cubic-bezier(.4,0,.6,1) infinite}
+.furnsvg .fabflame:nth-of-type(3){animation:fabTongueR 1.19s cubic-bezier(.5,0,.5,1) infinite}
+/* ③ 丹鼎本体：**实心剪影**（2026-10-24「效果不好」→ 重画）—— 白描边空心炉在 27px 下偏细、
+     换成 currentColor 实填炉体：耳朵（描边弯角）+ 鼓腹 + 深色炉膛（火从膛里冒出来，
+     于是「在炉里烧」成立）+ 鎏金口沿 + 三足。实心 + 亮火在深色栏上对比最足。 */
+.furnsvg .fabpot{fill:currentColor;stroke:none}
+.furnsvg .fablear{stroke:currentColor;stroke-width:2.2;fill:none}
+.furnsvg .fabmouth{fill:var(--q-bottle-deep,#06371F);stroke:none}
+.furnsvg .fabrim{stroke:var(--q-gold,#E8C77A);stroke-width:1.1;fill:none}
+.furnsvg .fableg{stroke:currentColor;stroke-width:2.2;fill:none}
+/* ④ 青烟：两缕从敞口升起、慢慢飘散淡出（青烟不是火，别用火的那套配色） */
+@keyframes fabSmoke{
+  0%{opacity:0;transform:translate(0,1.2px)}
+  30%{opacity:.55}
+  100%{opacity:0;transform:translate(.5px,-1.4px)}}
+.furnsvg .fabsmoke{opacity:0;animation:fabSmoke 3.1s ease-out infinite}
+.furnsvg .fabsmoke path:nth-child(2){animation-delay:1.15s;animation-duration:3.6s}
+/* ⑥ 内芯：最快最碎 */
+@keyframes fabCore{
+  0%{transform:scale(1,1) skewX(0)}
+  19%{transform:scale(.82,1.22) skewX(5deg)}
+  44%{transform:scale(1.16,.84) skewX(-5.5deg)}
+  70%{transform:scale(.9,1.12) skewX(2.5deg)}
+  100%{transform:scale(1,1) skewX(0)}}
+.furnsvg .fabcore{transform-box:fill-box;transform-origin:50% 100%;
+  animation:fabCore .83s cubic-bezier(.4,0,.6,1) infinite}
+/* ⑤ 火星：焰尖出生 → 上飘（各带一点横向漂移，--sx 每枚不同）→ 消散 */@keyframes fabSpark{
+  0%{transform:translate(0,0) scale(.3);opacity:0}
+  15%{opacity:.95}
+  70%{opacity:.55}
+  100%{transform:translate(var(--sx,.8px),-3.6px) scale(.9);opacity:0}}
+.furnsvg .fabspk circle{animation:fabSpark 1.4s linear infinite}
+.furnsvg .fabspk circle:nth-child(1){--sx:.9px}
+.furnsvg .fabspk circle:nth-child(2){--sx:-.7px;animation-delay:.5s;animation-duration:1.6s}
+.furnsvg .fabspk circle:nth-child(3){--sx:1.3px;animation-delay:.95s;animation-duration:1.3s}
+@keyframes fabBub{
+  0%{transform:translateY(0);opacity:0}
+  30%{opacity:.9}
+  100%{transform:translateY(-3.4px);opacity:0}}
+.furnsvg .fabbub circle{animation:fabBub 1.6s linear infinite}
+.furnsvg .fabbub circle:nth-child(2){animation-delay:.55s;animation-duration:1.9s}
+.furnsvg .fabbub circle:nth-child(3){animation-delay:1.05s;animation-duration:1.75s}
+@keyframes fabGlow{0%,100%{opacity:.28}50%{opacity:.75}}
+.tabfab__b::after{content:"";position:absolute;inset:-7px;border-radius:50%;
+  box-shadow:0 0 22px 7px var(--q-bottle-glow,rgba(34,197,94,.30));opacity:.28;
+  animation:fabGlow 2.4s ease-in-out infinite;pointer-events:none}
+/* ── 中间 FAB 蜂云剑阵动画（2026-10-24 用户：「剑没动画 可以横竖两个像加号」
+     →「两个剑颜色不要一样 也不要这么动画」→「剑不要旋转再细长一些 动画设计其他效果」
+     →「两个剑柄不要连一起」→「剑再长一些 动画效果明显一点」
+     →「剑体动画不需要 形状现在也不够精致圆滑」）──
+   横竖双剑 ✚ 细长（竖深横玉青），**不转不摆**。动画三路（只动 transform / opacity）：
+   ① 剑鸣灵气四射：四枚光点从交叉点沿四个剑向飞出 9.2px（周期 1.5~2.1s 互质、错相）
+   ② 两口鎏金护手交替明灭（1→.22，1.4s 对半错相）
+   ③ 中心剑气环：方环由中心炸开淡出（1.5s）—— 一眼能看出「剑在鸣」
+   **剑身上不再挂扫掠动画**（用户：「剑体动画不需要」）：贴在刃上的色块在 26~34px 上
+   既看不清、又会把刃的轮廓弄脏；动画只发生在**剑之外**（飞出的灵气、炸开的环），
+   剑本体保持干净。 */
+@keyframes swdQiUp{0%{transform:translate(0,0) scale(.25);opacity:0}15%{opacity:1}100%{transform:translate(0,-9.2px) scale(1.15);opacity:0}}
+@keyframes swdQiDn{0%{transform:translate(0,0) scale(.25);opacity:0}15%{opacity:1}100%{transform:translate(0,9.2px) scale(1.15);opacity:0}}
+@keyframes swdQiLf{0%{transform:translate(0,0) scale(.25);opacity:0}15%{opacity:1}100%{transform:translate(-9.2px,0) scale(1.15);opacity:0}}
+@keyframes swdQiRt{0%{transform:translate(0,0) scale(.25);opacity:0}15%{opacity:1}100%{transform:translate(9.2px,0) scale(1.15);opacity:0}}
+.swdsvg .qi-up{animation:swdQiUp 1.9s ease-out infinite}
+.swdsvg .qi-dn{animation:swdQiDn 1.5s ease-out infinite;animation-delay:.6s}
+.swdsvg .qi-lf{animation:swdQiLf 2.1s ease-out infinite;animation-delay:1s}
+.swdsvg .qi-rt{animation:swdQiRt 1.7s ease-out infinite;animation-delay:.3s}
+@keyframes swdRing{0%{transform:scale(.2);opacity:.85}100%{transform:scale(1.5);opacity:0}}
+.swdsvg .swdring{transform-box:view-box;transform-origin:12px 12px;
+  animation:swdRing 1.5s ease-out infinite}
+/* ── 其余三枚也各有一个小动画（2026-10-24 用户：「除了第一个全部换」→ 同轮重画；
+     「灵石看不出动画」→ 灵石加强：整石轻晃 + 刻面强闪 + 右上星芒明灭；
+     「元婴还没动画」→ 元婴加强：颠幅 -0.7→-1px（再大顶髻顶会冒出 viewBox 被裁）
+     2026-10-25 「元婴是凡人修仙传的概念」→ 改盘坐打坐 + 结印托金丹，删摇头）──
+   symbol 的 <use> 影子 DOM 选不中内部子路径，所以底栏全部是**内联 SVG**：
+     灵石 · 轻晃 + 鎏金刻面强闪 + 星芒（.gemsvg）
+     星盘 · 外圈刻度环缓转 + 盘心血石明灭（.starsvg）
+     元婴 · 盘坐打坐 + 金丹/顶髻明灭 + 偶尔眨眼（.yysvg）
+   顶栏右上角「我的」与底栏同款内联元婴（21px，class 共用 .yysvg，一起动）。 */
+@keyframes gemFloat{0%,100%{transform:translateY(0)}50%{transform:translateY(-.6px)}}
+.gemsvg{animation:gemFloat 2.4s ease-in-out infinite}
+@keyframes gemShine{0%,100%{opacity:1}45%{opacity:.1}}
+.gemsvg .gemspk{animation:gemShine 2.2s ease-in-out infinite}
+@keyframes gemStar{0%,100%{transform:scale(.3);opacity:0}40%{transform:scale(1);opacity:1}70%{transform:scale(.5);opacity:.4}}
+.gemsvg .gemstar{transform-box:fill-box;transform-origin:50% 50%;
+  animation:gemStar 1.9s ease-in-out infinite}
+@keyframes starSpin{0%{transform:rotate(0deg)}100%{transform:rotate(360deg)}}
+.starsvg .staring{transform-box:view-box;transform-origin:12px 12px;
+  animation:starSpin 6s linear infinite}
+@keyframes starBlink{0%,100%{opacity:1}50%{opacity:.45}}
+.starsvg .starcore{transform-box:fill-box;transform-origin:50% 50%;
+  animation:starBlink 1.8s ease-in-out infinite}
+@keyframes yyBob{0%,100%{transform:translateY(0)}50%{transform:translateY(-1px)}}
+.yysvg .yybaby{animation:yyBob 2.2s ease-in-out infinite}
+@keyframes yyPill{0%,100%{opacity:.55}50%{opacity:1}}
+.yysvg .yypill{animation:yyPill 2.2s ease-in-out infinite}
+@keyframes yyKnot{0%,100%{opacity:1}50%{opacity:.3}}
+.yysvg .yyknot{animation:yyKnot 2.2s ease-in-out infinite}
+/* 五官（2026-10-24 用户：「元婴要有五官」）：眼帘同色盖眼孔 = 眨眼。
+   周期取 4.7s（与其他动画互质）：绝大部分时间睁眼，第 3.9s 附近快速眨两下。 */
+@keyframes yyBlink{0%,92%{opacity:0}94%{opacity:1}96%{opacity:0}97.5%{opacity:1}100%{opacity:0}}
+.yysvg .yylid{animation:yyBlink 4.7s linear infinite}
+@keyframes yyBlush{0%,100%{opacity:.55}50%{opacity:.9}}
+.yysvg .yyblush{animation:yyBlush 2.2s ease-in-out infinite}
 /* 会话页（2026-10-22 用户：「不要挤压对话框」「两个效果要一致」「圆可以更大」「再下沉一些 注意保留间距」）：
    底栏浮起后不占位，「＋」在**两页都上露 24**（68 直径、圆心在栏顶下方 10），所以 composer 只需让出
    「上露 24 + 呼吸 12 + 栏高 56」—— 输入框落在凸出圆弧上方 12px，不遮不压。
@@ -679,8 +1054,6 @@ button.setrow{font-family:inherit}
   background:var(--raised);border-bottom:1px solid var(--border)}
 .browser__bar{flex:1;min-width:0;display:flex;align-items:center;gap:8px;height:40px;
   padding:0 8px 0 12px;border-radius:12px;background:var(--subtle)}
-.browser__shield{flex:0 0 auto;display:inline-flex;color:var(--success)}
-.browser__shield.is-plain{color:var(--faint)}
 .browser__addrwrap{flex:1;min-width:0;display:flex;margin:0}
 .browser__addr{flex:1;min-width:0;font-size:14px;color:var(--ink);
   border:none;outline:none;background:transparent;padding:0;
@@ -704,6 +1077,41 @@ button.setrow{font-family:inherit}
   align-items:center;justify-content:center;border:2px solid var(--ink);
   border-radius:8px;font-size:13px;font-weight:700;color:var(--ink)}
 
+/* ── 内置浏览器悬浮形态（2026-10-24 用户：「内置浏览器支持类似的悬浮效果」）──
+   .browser.is-float：全屏浮层缩成**卡片**。占屏 **90vw**，整卡（含顶栏）**16:9**
+   （2026-10-25 用户：「占整个屏幕的90%，扣除菜单栏维持16:9」—— 顶栏那行菜单
+   **不算进比例**：卡高由 16:9 的内容区（90vw*9/16）+ 顶栏自然高度叠成）。
+   再受高度约束 min(...,62vh) —— 保证 16:9 内容区 + 顶栏在矮屏里放得下
+   （放不下时按高度收窄，比例不变形）。
+   iframe 的 src 不动 —— 只是几何变化，页面不重载；
+   悬浮态收掉底部导航，顶栏变成拖拽把手（touch-action:none）。
+   .browser__fonly：只在悬浮态出现的迷你钮（展开回全屏 / 缩成悬浮球）。
+   .brball 悬浮球：缩到最小后的「恢复」入口。z-index 90 —— 高于 tabbar(60)、
+   低于扫码(400)与共享抽屉(1000)，不打断别的浮层。位置由 JS 内联写入。 */
+.browser.is-float{inset:auto;width:min(90vw,calc(62vh * 16 / 9 - 40px));
+  height:auto;border-radius:16px;overflow:hidden;
+  box-shadow:0 18px 48px rgba(15,23,42,.30),0 2px 10px rgba(15,23,42,.18)}
+.browser.is-float .browser__top{padding:6px 8px;touch-action:none;flex:0 0 auto}
+.browser.is-float .browser__nav{display:none}
+.browser.is-float .browser__app{display:none}
+.browser.is-float .browser__addrwrap{pointer-events:none}
+.browser.is-float #brStar,.browser.is-float #brRefresh,.browser.is-float #brShare,.browser.is-float #brFloat{display:none}
+.browser__fonly{display:none}
+.browser.is-float .browser__fonly{display:inline-flex}
+/* 内容舞台：全屏时就是 iframe 的普通容器；悬浮时它扛 **16:9 比例**（卡宽的
+   9/16 —— 顶栏菜单行不算进比例），顶栏叠在上面；裁切缩放后的页面。 */
+.browser__stage{flex:1;min-height:0;position:relative;overflow:hidden;background:#fff}
+.browser__frame{position:absolute;left:0;top:0;width:100%;height:100%;border:0;background:#fff}
+.browser.is-float .browser__stage{flex:0 0 auto;aspect-ratio:16/9;width:100%}
+.browser.is-float .browser__frame{transform-origin:0 0;overflow:hidden;scrollbar-width:none}
+.browser.is-float .browser__frame::-webkit-scrollbar{display:none}
+.brball{position:fixed;z-index:90;width:46px;height:46px;border-radius:50%;
+  display:flex;align-items:center;justify-content:center;border:none;
+  background:var(--raised);color:var(--primary-action);
+  box-shadow:0 4px 14px rgba(15,23,42,.22),inset 0 0 0 1px var(--border);
+  touch-action:none;padding:0}
+.brball:active{transform:scale(.94)}
+
 /* ── 本壳自己的那几件（对话区内部）──
    ⚠️ 气泡（旧 `.ubub`）、正文（旧 `.md`）、思考块（旧 `.rsn`）、工具卡（旧 `.tool` / `.cmdbar`）
       的样式**不在这里** —— 那些 DOM 现在由对话内核画，皮肤在共用的一份
@@ -852,27 +1260,37 @@ button.setrow{font-family:inherit}
   <symbol id="i-plus" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M12 5.5v13M5.5 12h13"/></symbol>
   <symbol id="i-scan" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 9V6a2 2 0 0 1 2-2h3M15 4h3a2 2 0 0 1 2 2v3M20 15v3a2 2 0 0 1-2 2h-3M9 20H6a2 2 0 0 1-2-2v-3M4 12h16"/></symbol>
   <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-shot" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 8h3l1.4-2.2a1 1 0 0 1 .84-.45h5.52a1 1 0 0 1 .84.45L17 8h3a1.6 1.6 0 0 1 1.6 1.6v7.8A1.6 1.6 0 0 1 20 19H4a1.6 1.6 0 0 1-1.6-1.6V9.6A1.6 1.6 0 0 1 4 8z"/><circle cx="12" cy="13" r="3.4"/></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.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>
+  <!-- ── 底栏五枚 = 韩立的物（2026-10-24 用户：「除了第一个全部换」定稿）──
+       题材：《凡人修仙传》主角韩立相关的实物/意象
+         任务 · 丹鼎（腹内丹火 + 青烟 + 火星，第一格，.furnsvg）
+         需求 · 灵石（实心宝石 + 鎏金刻面流光，.gemsvg）
+        ＋   · 青竹蜂云剑阵（细长双剑交叉 ✚ + 灵气四射，.swdsvg）
+         发现 · 星盘（刻度环缓转 + 盘心血石明灭，.starsvg）
+         我的 · 元婴（盘坐打坐小人 + 鎏金顶髻/金丹，.yysvg）
+
+       **双色是这一版的核心**：前几版全是单色描边，所以怎么调都是"平庸"。
+       25px 上实心块比线条读得清楚，**颜色本身就是最强的辨识信号**：
+         --q-gold（鎏金）= 法器上的錾金/灵石/刻面
+         --q-blood（丹血朱）= 星盘盘心血石
+       主体仍走 currentColor（跟选中态联动），只有点缀用固定色。
+
+       这一版仍是按「25px 实际渲染」逐轮淘汰出来的（每轮截图目检）：
+       · 双层剪影（器物叠人物）在 25px 全糊 —— 一枚只放一件事。
+       · 玉简、血玉蛛、韩立像、掌天瓶都试过，最终用户定「除了第一个全部换」。 -->
+
+  <!-- 底栏五枚全部内联（symbol 的 <use> 影子 DOM 选不中内部子路径做不了局部动画）：
+       丹炉 .furnsvg / 灵石 .gemsvg / 蜂云剑阵 .swdsvg / 星盘 .starsvg / 元婴 .yysvg。
+       静态 symbol 版（i-req 玉简 / i-compass 星盘 / i-user 半身像）已删，别处没有引用。 -->
+  <!-- 丹炉改为 FAB 内联 SVG（带炼丹动画，见 .tabfab__b 那段 CSS）：
+       symbol 没法从宿主页选中内部子路径做动画，所以这里不再留静态 i-furnace，
+       免得两份炉身漂移。别处的「＋」仍走 i-plus。 -->
   <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.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-db" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="6" rx="7" ry="3"/><path d="M5 6v6c0 1.7 3.1 3 7 3s7-1.3 7-3V6"/><path d="M5 12v6c0 1.7 3.1 3 7 3s7-1.3 7-3v-6"/></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>
@@ -890,7 +1308,6 @@ button.setrow{font-family:inherit}
   <symbol id="i-grid" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><rect x="4.5" y="4.5" width="6" height="6" rx="1.5"/><rect x="13.5" y="4.5" width="6" height="6" rx="1.5"/><rect x="4.5" y="13.5" width="6" height="6" rx="1.5"/><rect x="13.5" y="13.5" width="6" height="6" rx="1.5"/></symbol>
   <symbol id="i-plug" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M9 3.5V8M15 3.5V8"/><path d="M7 8h10v3.2a5 5 0 0 1-3.6 4.8L12 16.5l-1.4-.5A5 5 0 0 1 7 11.2z"/><path d="M12 16.5v4"/></symbol>
   <symbol id="i-spark" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round"><path d="M12 3.5l2.1 5.4 5.4 2.1-5.4 2.1-2.1 5.4-2.1-5.4-5.4-2.1 5.4-2.1z"/></symbol>
-  <symbol id="i-shield" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M12 3.5l7 2.6v5.2c0 4.6-3 8-7 9.2-4-1.2-7-4.6-7-9.2V6.1z"/><path d="M9 11.8l2.1 2.1 4-4"/></symbol>
   <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>
@@ -942,7 +1359,48 @@ button.setrow{font-family:inherit}
     </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>
+      <button class="topbar__icon" type="button" id="btnTaskMe" aria-label="我的"><svg class="yysvg" width="23" height="23" viewBox="1.6 0.7 20.8 20.8" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+        <!-- 与底栏「我的」同款元婴（2026-10-24 用户：「我的图标右上角要跟着改」；
+             「元婴要有五官」→ 头部开孔镂空五官）：
+             class 共用 .yysvg，轻颠/金丹明灭/眨眼动画一起生效。**标记与底栏那份保持一致**。 -->
+                                <g class="yybaby">
+                  <!-- 元婴打坐 · 定稿（2026-10-25「完全不行」→ 四案比选，F 案胜出）：
+                     一体剪影（肩窄→袖外张→盘腿宽平底），盘腿上缘走浅玉弧线，
+                     两端金手搭膝，丹田金丹+灵光环；莲花座案因花瓣糊成金坨被否。 -->
+                  <g class="yyhead">
+                    <path d="M12 3.9a4.0 4.0 0 1 0 0 8.0 4.0 4.0 0 1 0 0-8.0z
+                             M10.5 6.05a.6 .6 0 1 0 0 1.2 .6 .6 0 1 0 0-1.2z
+                             M13.5 6.05a.6 .6 0 1 0 0 1.2 .6 .6 0 1 0 0-1.2z
+                             M10.75 9.35Q12 11.6 13.25 9.35Q12 10.25 10.75 9.35Z"
+                          fill="currentColor" fill-rule="evenodd" stroke="none"/>
+                    <circle cx="7.8" cy="7.7" r=".48" fill="currentColor" stroke="none"/>
+                    <circle cx="16.2" cy="7.7" r=".48" fill="currentColor" stroke="none"/>
+                    <ellipse class="yyblush" cx="8.95" cy="8.9" rx=".7" ry=".42" fill="var(--q-blood,#E23B2E)" stroke="none" opacity=".42"/>
+                    <ellipse class="yyblush" cx="15.05" cy="8.9" rx=".7" ry=".42" fill="var(--q-blood,#E23B2E)" stroke="none" opacity=".42"/>
+                    <circle cx="12" cy="5.2" r=".27" fill="var(--q-blood,#E23B2E)" stroke="none" opacity=".9"/>
+                    <rect class="yylid" x="9.65" y="6.15" width="4.7" height="1.8" rx=".65" fill="currentColor" stroke="none" opacity="0"/>
+                    <circle class="yyknot" cx="12" cy="2.85" r=".9" fill="var(--q-gold,#E8C77A)" stroke="none"/>
+                  </g>
+                                                                        <path d="M12 11.9c-1.95 0-3.25 1.15-3.85 2.9-.42 1.25-.95 2.3-1.9 3.0v2.05h11.5v-2.05c-.95-.7-1.48-1.75-1.9-3.0-.6-1.75-1.9-2.9-3.85-2.9z" fill="currentColor" stroke="none"/>
+                                    <circle cx="7.0" cy="18.45" r="2.15" fill="currentColor" stroke="none"/>
+                                    <circle cx="17.0" cy="18.45" r="2.15" fill="currentColor" stroke="none"/>
+                                    <rect x="7.0" y="17.6" width="10.0" height="2.9" fill="currentColor" stroke="none"/>
+<!-- 禅定印 · canvas 细线（2026-10-25 配色定稿）：
+             两条掌缘弧 + 拇指三角，用 --canvas 描线而不是填金/填孔 ——
+             填金在选中绿上只有 1.29，填孔在 28px 下糊成一团黑；
+             细线两头都不犯：暗底当亮线、亮底当暗线，且不占体积。
+             金丹垫 canvas 暗衬后才立得住（朱 vs 绿 2.0 → 朱 vs 暗衬 4.0）。 -->
+                  <g fill="none" stroke="var(--canvas,#0B1512)" stroke-width=".62" stroke-linecap="round">
+                    <path d="M9.15 16.45q.55 2.4 2.85 2.4"/>
+                    <path d="M14.85 16.45q-.55 2.4-2.85 2.4"/>
+                    <path d="M10.45 16.15 12 14.5 13.55 16.15"/>
+                  </g>
+                  <!-- 金丹：卧在印心，外面垫一圈 canvas 暗衬 —— 朱在绿身上只有 2.0，
+                       垫了暗衬才有 4.0（深）/ 4.5（浅），28px 才立得住；明灭 = 吐纳 -->
+                  <circle cx="12" cy="16.15" r=".78" fill="var(--canvas,#0B1512)" stroke="none"/>
+                  <circle class="yypill" cx="12" cy="16.15" r=".5" fill="var(--q-blood,#E23B2E)" stroke="none"/>
+                </g>
+      </svg></button>
     </span>
   </div>
   <div class="tasks__search" id="taskSearchBar" hidden>
@@ -993,13 +1451,11 @@ button.setrow{font-family:inherit}
            所以这里**没有**全局开关 —— 与团队模式同一处入口：会话页右上角 → 任务运行设置。 -->
       <!-- 默认引擎 / 模型：新建任务的初值（会话里输入框上方的级联切换会回写这里）。
            两行点开的是同一个「引擎 → 模型」二列选择器，模型必须挂在引擎下。 -->
-      <button class="setrow" id="btnDefaultEngine"><span class="setrow__l">默认引擎</span><span class="setrow__v" id="defaultEngine">自动（首个可用）</span></button>
-      <button class="setrow" id="btnDefaultModel"><span class="setrow__l">默认模型</span><span class="setrow__v" id="defaultModel">跟随引擎</span></button>
-      <!-- 建议引擎 / 模型（2026-10-23 用户：「是选择引擎和模型 跟默认引擎那种抽屉一样」）。
-           两行点开同一个「引擎 → 模型」二列抽屉；**默认不开启**：引擎空 = 组件不请求
-           /desk/suggest、不画建议、不补历史建议、托管不自动跑。选了引擎才启用。 -->
-      <button class="setrow" id="btnSuggestEngine"><span class="setrow__l">建议引擎</span><span class="setrow__v" id="suggestEngine">不开启</span></button>
-      <button class="setrow" id="btnSuggestModel"><span class="setrow__l">建议模型</span><span class="setrow__v" id="suggestModel">跟随引擎</span></button>
+      <!-- 默认引擎（主 + 备一屏配完，2026-10-24 用户：「这样布局太浪费了，要在一次点击里面设置两个」）。
+           一行显示「主 · 模型 ｜ 备 …」；点开抽屉顶部切 主/备，选完**不关**，接着配另一档。 -->
+      <button class="setrow" id="btnDefaultEngine"><span class="setrow__l">默认引擎</span><span class="setrow__v setrow__v--pair" id="defaultEngine">自动（首个可用）</span></button>
+      <!-- 建议引擎同口径：主备一个抽屉里配，默认不开启（引擎空 = 不请求 /desk/suggest）。 -->
+      <button class="setrow" id="btnSuggestEngine"><span class="setrow__l">建议引擎</span><span class="setrow__v setrow__v--pair" id="suggestEngine">不开启</span></button>
       <!-- 2026-10-22 用户：「触感反馈 / 语言」这两项不需要 —— 已移除（设备级偏好只剩主题/字体）。 -->
       <div class="setrow"><span class="setrow__l">网络代理</span><button class="tgl" id="tglVpn" aria-label="网络代理"></button></div>
       <button class="setrow" id="btnNotify"><span class="setrow__l">消息通知设置</span><span class="setrow__v" id="notifyState">—</span></button>
@@ -1020,6 +1476,12 @@ button.setrow{font-family:inherit}
         <span class="setrow__l">版本</span><span class="setrow__v" id="mineVersion">—</span>
       </button>
       <button class="setrow" id="btnUpgrade"><span class="setrow__l">重新加载界面</span><span class="setrow__v" id="upgradeState">重新加载</span></button>
+      <!-- 重启桌面端服务（2026-10-24 用户：「在移动端我的中增加1个重启按钮 点击后触发magic-client重启」）。
+           走 POST /desk/restart：桌面端先答再由一个脱离终端的助手停旧起新，端口 / 令牌沿用。
+           ⚠️ 会中断桌面端**正在跑的所有会话** —— 点击前必须二次确认。 -->
+      <button class="setrow" id="btnRestartClient" type="button">
+        <span class="setrow__l">重启服务</span><span class="setrow__v" id="restartClientState">重启</span>
+      </button>
     </div>
     <div class="setcard">
       <button class="setrow setrow--danger" id="btnLogout">断开连接</button>
@@ -1048,7 +1510,8 @@ button.setrow{font-family:inherit}
 
 <!-- ══════════ 会话页 → 任务运行设置（独立子页面）══════════
      会话页右上角的调节键点进来（2026-10-21 用户：「运行设置在任务对话框里 不也应该是独立页面吗」）。
-     五项都是**当前这条会话**的运行参数：设备只读，其余点开还是原来的选择器（选择器只有一份）。
+     六项都是**当前这条会话**的运行参数：设备只读，其余点开还是原来的选择器（选择器只有一份）。
+     思考模式（2026-10-24）默认最高，按会话记档（magic.reasoning.sessions.v1）。
      会话托管（2026-10-23）也在这里：它跟团队模式一样**属于这条会话**，不再是「我的」里的全局开关。 -->
 <div class="history" id="runSettingsPage" hidden>
   <div class="history__top">
@@ -1060,10 +1523,11 @@ button.setrow{font-family:inherit}
       <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="btnRsReasoning"><span class="setrow__l">思考模式</span><span class="setrow__v" id="rsReasoning">最高（默认）</span></button>
       <button class="setrow" id="btnRsTeam"><span class="setrow__l">团队模式</span><span class="setrow__v" id="rsTeam">关闭</span></button>
       <button class="setrow" id="btnRsHosting"><span class="setrow__l">会话托管</span><span class="setrow__v" id="rsHosting">关闭</span></button>
     </div>
-    <div class="history__hint" style="text-align:left">会话托管：每轮成功结束自动发送最合适的建议（最多连续 12 轮）。只作用于当前会话；团队子会话默认继承主会话的开关。</div>
+    <div class="history__hint" style="text-align:left">会话托管：每轮成功结束自动发送最合适的建议（最多连续 12 轮）。只作用于当前会话；团队子会话默认继承主会话的开关。思考模式默认最高，只对支持推理档位的引擎（claude / codebuddy / codex 等）生效。</div>
   </div>
 </div>
 
@@ -1100,9 +1564,28 @@ button.setrow{font-family:inherit}
       <span class="srow__col"><span class="srow__t">SKILL</span><span class="srow__s">技能包，扩展 AI 能力</span></span>
       <span class="srow__time" style="color:var(--faint)"><svg width="16" height="16"><use href="#i-chev-r"/></svg></span>
     </button>
+    <button class="srow" id="dscScripts" type="button">
+      <span class="srow__ico"><svg width="22" height="22"><use href="#i-cpu"/></svg></span>
+      <span class="srow__col"><span class="srow__t">脚本</span><span class="srow__s">登记脚本，可启动 / 停止、看日志</span></span>
+      <span class="srow__time" style="color:var(--faint)"><svg width="16" height="16"><use href="#i-chev-r"/></svg></span>
+    </button>
+    <button class="srow" id="dscKnowledge" type="button">
+      <span class="srow__ico"><svg width="22" height="22"><use href="#i-db"/></svg></span>
+      <span class="srow__col"><span class="srow__t">知识库</span><span class="srow__s">OpenViking 上下文数据库</span></span>
+      <span class="srow__time" style="color:var(--faint)"><svg width="16" height="16"><use href="#i-chev-r"/></svg></span>
+    </button>
   </div>
 </div>
 
+<!-- ══════════ 发现 → 脚本（用户登记的脚本清单）══════════
+     **独立子页面**：内容、样式、逻辑都在 scripts.js / scripts.css，本文件只留两个空容器。
+     脚本在**这台桌面**上跑（不是手机上），服务端负责 spawn / 杀进程组 / 收日志。
+     数据形状与端点见 CLIENT-CONTRACT §2（/desk/scripts）。 -->
+<div class="history" id="scripts" hidden></div>
+
+<!-- 脚本的二级视图：详情 + 启停按钮 + 实时日志（内容由 scripts.js 渲染） -->
+<div class="history" id="scriptDetail" hidden></div>
+
 <!-- ══════════ 发现 → 插件（工程 CLI 目录）══════════
      列表与详情都是**服务端宣布什么就显示什么**（GET /desk/plugins）。 -->
 <div class="history" id="plugins" hidden>
@@ -1121,6 +1604,29 @@ button.setrow{font-family:inherit}
   <div class="history__list" id="pluginDetailBody"></div>
 </div>
 
+<!-- ══════════ 发现 → 知识库（OpenViking 上下文数据库）══════════
+     列表与详情都是**服务端宣布什么就显示什么**（GET /desk/knowledge）：
+     装没装、本机版本多少、PyPI 最新版本多少，都由桌面端探测后宣布。
+     本页不自己判断状态 —— 那样两端会各说一套（「手机上显示已安装、装的时候说没装」最难查）。
+
+     安装/升级走 `POST /desk/knowledge/{id}/{action}` 的 SSE：命令是**服务端写死的**，
+     手机只传 id 与动作；输出逐行回来，所以看得见在动，失败也能把 stderr 摊出来。 -->
+<div class="history" id="knowledge" hidden>
+  <div class="history__top">
+    <button class="topbar__icon" id="btnKnowledgeBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
+    <span class="history__title">知识库</span>
+  </div>
+  <div class="history__list" id="knowledgeList"></div>
+</div>
+
+<div class="history" id="knowledgeDetail" hidden>
+  <div class="history__top">
+    <button class="topbar__icon" id="btnKnowledgeDetailBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
+    <span class="history__title" id="knowledgeDetailTitle">知识库</span>
+  </div>
+  <div class="history__list" id="knowledgeDetailBody"></div>
+</div>
+
 <!-- ══════════ 会话页 ══════════ -->
 <div class="session" id="session" hidden>
   <header class="topbar">
@@ -1147,17 +1653,25 @@ button.setrow{font-family:inherit}
 <div class="browser" id="browser" hidden>
   <header class="browser__top">
     <div class="browser__bar">
-      <span class="browser__shield" id="brShield"><svg width="16" height="16"><use href="#i-shield"/></svg></span>
+      <button class="browser__ib" id="brRelay" type="button" aria-label="桌面端中转" title="桌面端中转"><svg width="17" height="17"><use href="#i-laptop"/></svg></button>
       <form class="browser__addrwrap" id="brForm" novalidate>
         <input class="browser__addr" id="brAddr" type="url" inputmode="url" enterkeyhint="go" autocomplete="off" spellcheck="false" placeholder="输入网址">
       </form>
+      <!-- 截图：只有需求页的「页面完成情况」流程走中转时才出现（reqshot.js 打开它）。
+           默认 hidden —— 平时内置浏览器就是浏览器，多一枚按钮只会让人以为是别的功能。 -->
+      <button class="browser__ib" id="brShot" type="button" aria-label="截图" title="截图（需求页的页面完成情况）" hidden><svg width="18" height="18"><use href="#i-shot"/></svg></button>
       <button class="browser__ib" id="brStar" type="button" aria-label="收藏"><svg width="18" height="18"><use href="#i-star"/></svg></button>
       <button class="browser__ib" id="brRefresh" type="button" aria-label="刷新"><svg width="18" height="18"><use href="#i-refresh"/></svg></button>
       <button class="browser__ib" id="brShare" type="button" aria-label="分享"><svg width="18" height="18"><use href="#i-share"/></svg></button>
+      <button class="browser__ib" id="brFloat" type="button" aria-label="悬浮显示"><svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="5" width="18" height="14" rx="2"/><rect x="12" y="12" width="7" height="5" rx="1" fill="currentColor" stroke="none"/></svg></button>
+      <button class="browser__ib browser__fonly" id="brExpand" type="button" aria-label="展开回全屏"><svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M9 3H3v6M15 3h6v6M9 21H3v-6M15 21h6v-6"/></svg></button>
+      <button class="browser__ib browser__fonly" id="brMin" type="button" aria-label="缩成悬浮球"><svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M5 12h14"/></svg></button>
     </div>
     <button class="browser__app" id="brClose" type="button" aria-label="关闭浏览器">✕</button>
   </header>
-  <iframe class="browser__frame" id="brFrame" src="about:blank" referrerpolicy="no-referrer" allow="fullscreen"></iframe>
+  <div class="browser__stage" id="brStage">
+    <iframe class="browser__frame" id="brFrame" src="about:blank" referrerpolicy="no-referrer" allow="fullscreen"></iframe>
+  </div>
   <nav class="browser__nav">
     <button class="browser__nb" id="brBack" type="button" aria-label="返回"><svg width="22" height="22"><use href="#i-back"/></svg></button>
     <button class="browser__nb" id="brSites" type="button" aria-label="快捷站点"><svg width="22" height="22"><use href="#i-grid"/></svg></button>
@@ -1167,6 +1681,9 @@ button.setrow{font-family:inherit}
   </nav>
 </div>
 
+<!-- 浏览器悬浮球：浏览器缩到最小后的恢复入口（点按恢复悬浮卡片，拖动换位置） -->
+<button class="brball" id="brBall" hidden aria-label="恢复浏览器"><svg width="22" height="22"><use href="#i-globe"/></svg></button>
+
 <!-- ══════════ 产物阅读浮层（文本 / Markdown 产物卡「查看」）══════════ -->
 <div class="reader" id="reader" hidden>
   <header class="reader__top">
@@ -1189,24 +1706,192 @@ button.setrow{font-family:inherit}
 </div>
 
 <!-- ══════════ 底部 Tab ══════════
-     五个槽位：任务 · 需求 ·「＋」· 发现 · 我的。
+     五个槽位：任务(丹炉) · 需求(灵石) ·「蜂云剑阵✚」· 发现(星盘) · 我的(元婴)。
+     （2026-10-24 用户：「都不行」→ 整套重设计并附专业审查；设计规范见 sprite 注释。
+     「我的图标再换」→ 斗笠→酒葫芦→元婴（盘坐打坐小人）。）
+     **每枚都有动画**（2026-10-24 用户：「每个图标都有动画」）：
+       丹炉 · 三舌异速丹火 + 青烟 + 火星（.furnsvg，第一格）
+       灵石 · 整石轻晃 + 刻面强闪 + 星芒（.gemsvg）
+       蜂云剑阵 · 细长双剑 ✚ 不转不摆 + 剑鸣灵气四射（.swdsvg，中间 FAB）
+       星盘 · 刻度环缓转 + 盘心血石明灭（.starsvg）
+       我的 · 元婴 盘坐打坐 + 金丹/顶髻明灭 + 偶尔眨眼（.yysvg）
+     五枚全是**内联 SVG**：symbol 的 <use> 影子 DOM 选不中内部子路径，做不了
+     「刻面单独流光」这种局部动画；顶栏右上角「我的」也是同款内联元婴（21px 一起动）。
+     题材是《凡人修仙传》主角韩立的物：丹炉 / 灵石 / 蜂云剑阵（横竖双剑） / 星盘 / 元婴。
+     **双色**（主体 currentColor + 鎏金/丹血点缀）是这一版的关键 ——
+     25px 上颜色本身是最强辨识信号，单色描边怎么调都读不出「法器」。
+     25px 下靠剪影+颜色分家；选中色玉青（--tab-on）。
      「定时任务」那个 tab 已删（2026-10-22 用户：「定时任务tab先删除」）——
      功能本身没删：会话菜单里的「定时任务」仍然能唤起，只是不再占一个底部入口
      （那一页本来也只有一句「还没有这个接口」的说明，占着导航反而误导）。
-     中间那枚「＋」不是 tab：它没有 data-tab、不参与 setActive，点了就是新建会话。
+     中间那枚不是 tab：它没有 data-tab、不参与 setActive，点了就是新建会话。
      **只有图标、没有文字**（2026-10-22 用户：「底栏只保留图标不需要文字了」）：
-     语义靠 aria-label 承担；图标本身已用"清单 / 文档"的轮廓分家，缩到 25px 仍可辨。 -->
+     语义靠 aria-label 承担。 -->
 <nav class="tabbar" id="tabbar" hidden>
-  <button class="tab" type="button" data-tab="tasks" aria-label="任务"><span class="icw"><svg width="25" height="25"><use href="#i-task"/></svg></span></button>
+  <i class="eave eave-l" aria-hidden="true"></i><i class="eave eave-r" aria-hidden="true"></i>
+  <button class="tab" type="button" data-tab="tasks" aria-label="任务"><span class="icw"><svg class="furnsvg" width="26" height="26" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+        <defs>
+          <linearGradient id="i-furn-fire" x1="0" y1="0" x2="0" y2="1">
+            <stop offset="0" stop-color="#FFE08A"/><stop offset=".35" stop-color="#FF9A3C"/><stop offset="1" stop-color="#E23B2E"/>
+          </linearGradient></defs>
+        <!-- 青烟：两缕从敞口升起、飘散淡出（不是火，只动 opacity + 轻微位移） -->
+        <g class="fabsmoke" fill="none" stroke="var(--muted,#CBD5E1)" stroke-width=".85" stroke-linecap="round">
+          <path d="M11.3 3.4c-.8-.9-.3-1.7.4-2.2"/>
+          <path d="M13.5 2.6c.8-.8.4-1.7-.3-2.2"/>
+        </g>
+        <!-- 火星：从火尖窜出、飞散 -->
+        <g class="fabspk" fill="#FFC93C" stroke="none">
+          <circle cx="9.9" cy="5" r=".34"/>
+          <circle cx="14.1" cy="4.8" r=".3"/>
+          <circle cx="12" cy="3.1" r=".26"/>
+        </g>
+        <!-- ① 丹炉实心剪影：双立耳（描边弯角）压在炉体后 -->
+        <path class="fablear" d="M6.2 7.8C4.9 6.4 4.6 3.5 6.2 2.2"/>
+        <path class="fablear" d="M17.8 7.8C19.1 6.4 19.4 3.5 17.8 2.2"/>
+        <!-- ② 鼓腹：实心，从口沿圆鼓到三足 -->
+        <path class="fabpot" d="M5.9 7.6c-.8 3.6-.2 6.9 1.8 9.4 1.1 1.6 8.5 1.6 9.6 0 2-2.5 2.6-5.8 1.8-9.4z"/>
+        <!-- 炉腹鎏金腰带：一圈錾金线，25px 下多一道细节就不像"灰疙瘩" -->
+        <path class="fabbelt" d="M6.3 12.6c1.2 1.3 3.6 2 5.7 2s4.5-.7 5.7-2" stroke="var(--q-gold,#E8C77A)" stroke-width=".9" fill="none"/>
+        <!-- ③ 炉膛：深色开口 + 鎏金口沿（椭圆=敞口），火只从这口里冒出来 -->
+        <ellipse class="fabmouth" cx="12" cy="7.6" rx="5.7" ry="1.6"/>
+        <ellipse class="fabrim" cx="12" cy="7.6" rx="5.7" ry="1.6"/>
+        <!-- ④ 炉内丹火：三舌异速舔动，根扎在膛里、窜出口沿 -->
+        <g class="fabfire">
+          <path class="fabflame" d="M12 3.4c1.6 2 2.5 3.2 2.5 4.3 0 1.7-1.1 2.7-2.5 2.7s-2.5-1-2.5-2.7c0-1.1.9-2.3 2.5-4.3z" fill="url(#i-furn-fire)" stroke="none"/>
+          <path class="fabflame" d="M8.9 4.8c1 1.3 1.5 2.1 1.5 3 0 1-.7 1.8-1.5 1.8s-1.5-.8-1.5-1.8c0-.9.5-1.7 1.5-3z" fill="url(#i-furn-fire)" stroke="none"/>
+          <path class="fabflame" d="M15.1 4.8c1 1.3 1.5 2.1 1.5 3 0 1-.7 1.8-1.5 1.8s-1.5-.8-1.5-1.8c0-.9.5-1.7 1.5-3z" fill="url(#i-furn-fire)" stroke="none"/>
+          <path class="fabcore" d="M12 6c.8 1 1.2 1.6 1.2 2.2 0 .8-.5 1.3-1.2 1.3s-1.2-.5-1.2-1.3c0-.6.4-1.2 1.2-2.2z" fill="#FFE08A" stroke="none"/>
+        </g>
+        <!-- ⑤ 三足 -->
+        <path class="fableg" d="M8.2 16.6 7.3 20.4M11.4 17.4v3M14.6 16.6l.9 3.8"/>
+      </svg></span></button>
   <!-- 需求 tab 常驻：不做能力位控制（用户 2026-10-22：「移动端永远显示」）。
        老 core 上点进来会由 reqs.js 的 501 分支给出明确文案，
        不会是一片空白 —— 入口固定比入口忽隐忽现更好理解。 -->
-  <button class="tab" type="button" data-tab="reqs" aria-label="需求"><span class="icw"><svg width="25" height="25"><use href="#i-req"/></svg></span></button>
+  <button class="tab" type="button" data-tab="reqs" aria-label="需求"><span class="icw"><svg class="gemsvg" width="26" height="26" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+      <!-- 灵石（2026-10-24 用户：「除了第一个全部换」→ 玉简换成灵石）：
+           实心宝石剪影 + 刻面；动画：整石轻晃 + 刻面强闪 + 右上星芒明灭。
+           **刻面线不能用鎏金**（2026-10-25 实测）：刻面线画在宝石实心剪影**之上**，
+           所以要跟剪影比，而不是跟底栏比 —— 金(1.20 深 / 2.32 浅) 比主体还暗，线直接消失，
+           整颗宝石读起来就是一块纯色块。改与主体反相的 `--canvas`：深色下 8.5、浅色下 8.3，
+           两套主题都能读出「金刚石切面」。星芒在宝石之外，仍用鎏金。 -->
+      <path d="M7.6 4.6h8.8L21.6 11.4 12 20.6 2.4 11.4z" fill="currentColor" stroke="none"/>
+      <path class="gemspk" d="M7.6 4.6 12 9.2l4.4-4.6M2.4 11.4h19.2M12 9.2v11.4M12 20.6 9.2 15.2M12 20.6l2.8-5.4" stroke="var(--gem-facet,var(--canvas))" stroke-width="1.2" fill="none"/>
+      <path class="gemspk" d="M9.4 6.2 12 8.4l2.6-2.2" stroke="var(--gem-facet,var(--canvas))" stroke-width="1.2" fill="none"/>
+      <path class="gemstar" d="M20.6 1.4l1.1 2 2 1.1-2 1.1-1.1 2-1.1-2-2-1.1 2-1.1z" fill="var(--q-gold,#E8C77A)" stroke="none"/>
+    </svg></span></button>
   <span class="tabfab">
-    <button class="tabfab__b" type="button" id="btnFabNew" aria-label="新建会话"><svg width="30" height="30"><use href="#i-plus"/></svg></button>
+    <button class="tabfab__b" type="button" id="btnFabNew" aria-label="新建会话">
+      <svg class="swdsvg" width="52" height="52" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+        <!-- 青竹蜂云剑阵 · 横竖双剑（2026-10-24 用户：「剑没动画 可以横竖两个像加号」
+             →「两个剑颜色不要一样 也不要这么动画」→「剑不要旋转再细长一些 动画设计其他效果」
+             →「两个剑柄不要连一起」→「剑再长一些 动画效果明显一点」
+             →「剑体动画不需要 形状现在也不够精致圆滑」）：
+             一竖一横两口**细长**飞剑交叉成「✚」，两口不同色：竖剑深色（currentColor，
+             跟选中态联动）、横剑淡金（--q-gold-lt，金雷竹原著「淡金色」）。
+             **尺寸：SVG 元素 52px，图形可见边占 68px 圆的 ~70%（用户：「太大了 70即可」）**
+             —— 68 * 0.7 = 47.6px 可见宽，52 * (23.45/24) = 50.8px，
+             留 ~3px 安全余量给外发光。
+             图形在 viewBox 内**居中**（四边留白实测 L25 R18 T26 B24 @58px / 3x 像素），
+             不然放大后会明显偏。
+             **形状是「竹叶形」细长飞剑**（2026-10-25 用户：「韩立的青竹蜂云剑不是这样的」
+             → 原著设定：金雷竹炼制、剑身细长轻盈**形似竹叶**、青碧色隐现金雷）：
+               最宽处偏根部 ~1/3，向尖端与根端**双向收窄**（两头收才是竹叶；
+               根端平头藏进鎏金剑格后）；刃上两道**竹节纹**短线（鎏金/玉青）替代血槽；
+               剑格 = 圆头小方（rx 满，圆滑）；剑柄 = 细杆 + 鎏金剑首圆珠。
+             动画只发生在**剑之外**（飞出的灵气光点 + 中心炸开的气环），
+             **剑身上不挂任何动画**（用户：「剑体动画不需要」）。 -->
+        <!-- 竖剑（弧刃，近黑 / currentColor） -->
+        <path d="M12 .55C12.35 3.2 12.8 5.2 12.8 7.5C12.8 11.5 12.4 15.5 12.4 18.2H11.6C11.6 15.5 11.2 11.5 11.2 7.5C11.2 5.2 11.65 3.2 12 .55z" fill="currentColor" stroke="none"/>
+        <path d="M11.5 6.2h1.0v.3h-1.0z" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".55"/><path d="M11.45 9.4h1.1v.32h-1.1z" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".65"/><path d="M11.55 13.8h.9v.32h-.9z" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".65"/><rect x="11.93" y="3" width=".14" height="14.4" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".3"/><circle cx="12.35" cy="8.6" r=".13" fill="var(--q-gold,#E8C77A)" stroke="none" opacity=".9"/><circle cx="11.7" cy="11.9" r=".11" fill="var(--q-gold,#E8C77A)" stroke="none" opacity=".8"/><circle cx="12.3" cy="15.2" r=".12" fill="var(--q-gold,#E8C77A)" stroke="none" opacity=".85"/><path d="M12.55 9.7l-.45.85h.5l-.5.95" fill="none" stroke="var(--q-gold,#E8C77A)" stroke-width=".16" stroke-linecap="round" stroke-linejoin="round" opacity=".85"/><circle cx="12" cy="1.7" r=".13" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".9"/>
+        <rect class="swdgv" x="9.3" y="18" width="5.4" height="1.7" rx=".85" fill="var(--q-gold,#E8C77A)" stroke="none"/><path d="M12 18.45l.38.4-.38.4-.38-.4z" fill="currentColor" stroke="none" opacity=".8"/><circle cx="9.95" cy="18.85" r=".2" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".75"/><circle cx="14.05" cy="18.85" r=".2" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".75"/>
+        <rect x="11.15" y="19.5" width="1.7" height="1.9" rx=".8" fill="currentColor" stroke="none"/><rect x="11.0" y="19.66" width="2.0" height=".26" rx=".13" fill="var(--q-gold,#E8C77A)" stroke="none"/><path d="M11.3 20.35l1.45-.3M11.3 20.85l1.45-.3M11.35 21.3l1.3-.26" stroke="var(--q-bottle-rim,#D9FBE8)" stroke-width=".13" stroke-linecap="round" opacity=".55" fill="none"/>
+        <circle cx="12" cy="22.1" r="1.35" fill="var(--q-gold,#E8C77A)" stroke="none"/><circle cx="12" cy="22.1" r=".72" fill="none" stroke="var(--q-bottle-rim,#D9FBE8)" stroke-width=".14" opacity=".65"/><circle cx="12" cy="22.1" r=".18" fill="currentColor" stroke="none"/>
+        <!-- 横剑（弧刃，淡金） -->
+        <path d="M23.45 12C20.8 12.35 18.8 12.8 16.5 12.8C12.5 12.8 8.5 12.4 5.8 12.4V11.6C8.5 11.6 12.5 11.2 16.5 11.2C18.8 11.2 20.8 11.65 23.45 12z" fill="var(--q-gold-lt,#F2DCA2)" stroke="none"/>
+
+        <path d="M9.1 11.55h.9v.32h-.9z" fill="var(--q-gold-deep,#B98A2E)" stroke="none" opacity=".6"/><path d="M13.5 11.55h1.1v.32h-1.1z" fill="var(--q-gold-deep,#B98A2E)" stroke="none" opacity=".6"/><path d="M18.55 11.85h.8v.3h-.8z" fill="var(--q-gold-deep,#B98A2E)" stroke="none" opacity=".5"/><rect x="6.9" y="11.93" width="13" height=".14" fill="var(--q-gold-deep,#B98A2E)" stroke="none" opacity=".5"/><circle cx="14.9" cy="11.62" r=".12" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".9"/><circle cx="17.6" cy="12.35" r=".11" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".8"/><circle cx="10.9" cy="12.3" r=".11" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".8"/><path d="M14.3 11.5l.85.45h-.5l.9.5" fill="none" stroke="var(--q-bottle-rim,#D9FBE8)" stroke-width=".16" stroke-linecap="round" stroke-linejoin="round" opacity=".9"/><circle cx="22.4" cy="12" r=".13" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".95"/>
+        <rect class="swdgh" x="4.3" y="9.3" width="1.7" height="5.4" rx=".85" fill="var(--q-gold,#E8C77A)" stroke="none"/><path d="M5.15 11.22l.4.38-.4.38-.38-.38z" fill="currentColor" stroke="none" opacity=".8"/><circle cx="5.15" cy="9.95" r=".2" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".75"/><circle cx="5.15" cy="14.05" r=".2" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none" opacity=".75"/>
+        <rect x="2.6" y="11.15" width="1.9" height="1.7" rx=".8" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none"/><rect x="4.44" y="11.0" width=".26" height="2.0" rx=".13" fill="var(--q-gold,#E8C77A)" stroke="none"/><path d="M3.65 11.3l.3 1.45M3.15 11.3l-.3 1.45M2.7 11.35l.26 1.3" stroke="var(--q-gold,#E8C77A)" stroke-width=".13" stroke-linecap="round" opacity=".55" fill="none"/>
+        <circle cx="1.9" cy="12" r="1.35" fill="var(--q-gold,#E8C77A)" stroke="none"/><circle cx="1.9" cy="12" r=".72" fill="none" stroke="currentColor" stroke-width=".14" opacity=".5"/><circle cx="1.9" cy="12" r=".18" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none"/>
+        <!-- 中心剑气方环：自交叉点炸开淡出 -->
+        <rect class="swdring" x="9.4" y="9.4" width="5.2" height="5.2" rx="1.6" fill="none" stroke="var(--q-bottle-rim,#D9FBE8)" stroke-width=".8"/>
+        <!-- 剑鸣灵气：四枚光点从交叉点沿四个剑向飞出 -->
+        <g class="swdqi" fill="var(--q-bottle-rim,#D9FBE8)" stroke="none">
+          <circle class="qi-up" cx="12" cy="12" r=".5"/>
+          <circle class="qi-dn" cx="12" cy="12" r=".5"/>
+          <circle class="qi-lf" cx="12" cy="12" r=".5"/>
+          <circle class="qi-rt" cx="12" cy="12" r=".5"/>
+        </g>
+      </svg>
+    </button>
   </span>
-  <button class="tab" type="button" data-tab="discover" aria-label="发现"><span class="icw"><svg width="25" height="25"><use href="#i-compass"/></svg></span></button>
-  <button class="tab" type="button" data-tab="mine" aria-label="我的"><span class="icw"><svg width="25" height="25"><use href="#i-user"/></svg></span></button>
+  <button class="tab" type="button" data-tab="discover" aria-label="发现"><span class="icw"><svg class="starsvg" width="26" height="26" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+      <!-- 星盘（2026-10-24 用户：「除了第一个全部换」→ 血玉蛛换成星盘）：
+            「发现」= 观星探秘；外圈刻度环缓转，盘心丹血宝石一明一灭 -->
+      <circle class="staring" cx="12" cy="12" r="8.8" stroke="currentColor" stroke-width="1.6" stroke-dasharray="1.7 2.5" fill="none"/>
+      <circle cx="12" cy="12" r="6.2" fill="currentColor" stroke="none" opacity=".22"/>
+      <circle cx="12" cy="12" r="6.2" stroke="currentColor" stroke-width="1.6" fill="none"/>
+      <path d="M12 5.8v12.4M5.8 12h12.4" stroke="var(--q-gold,#E8C77A)" stroke-width="1.1"/>
+      <circle class="starcore" cx="12" cy="12" r="2.2" fill="var(--q-blood,#E23B2E)" stroke="none"/>
+      <circle cx="7.4" cy="7.4" r=".5" fill="var(--q-gold,#E8C77A)" stroke="none"/>
+      <circle cx="16.6" cy="7.4" r=".5" fill="var(--q-gold,#E8C77A)" stroke="none"/>
+      <circle cx="7.4" cy="16.6" r=".5" fill="var(--q-gold,#E8C77A)" stroke="none"/>
+      <circle cx="16.6" cy="16.6" r=".5" fill="var(--q-gold,#E8C77A)" stroke="none"/>
+    </svg></span></button>
+  <button class="tab" type="button" data-tab="mine" aria-label="我的"><span class="icw"><svg class="yysvg" width="28" height="28" viewBox="1.6 0.7 20.8 20.8" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+      <!-- 元婴 · 宝宝人形（2026-10-24 用户：「我的换元婴设计 要有宝宝人形」→ 酒葫芦换成元婴；
+            「元婴还没动画」→ 加强：颠幅加大 + 摇头晃脑 + 明灭加深；
+            「元婴要有五官」→ 头部开孔镂空五官）：
+           元婴出窍打坐（凡人修仙传：元婴=丹田中盘坐的小人，可出窍悬空）：
+           背光环 + 盘腿交叉 + 丹田金丹 + 蒲团浮空 —— 四个「打坐」符号全用上；
+           剪影内部细节一律对比色（鎏金/浅玉），同色细节在剪影里读不出。
+           **五官用镂空（fill-rule:evenodd 在头部剪影上开孔）而不是画实色** ——
+           头部填充是 currentColor（随主题/选中态变），实色五官会跟头同色消失；
+           镂空透出背景，任何主题、任何选中态都读得出是眼睛和嘴。
+             眼 = 两个圆孔、嘴 = 下弯的笑口、腮红 = 丹血朱两颊；
+             眨眼 = 一块与头同色的「眼帘」盖在眼孔上（opacity 0→1），只有同色才看不出接缝。
+           动画：呼吸般的轻颠（整组 translateY -1px）+ 金丹明灭（修炼吐纳）
+           + 顶髻明灭 + 偶尔眨眼（打坐也要眨眼）。
+           顶栏右上角「我的」是同款内联（21px，class 共用）—— **两处标记必须同步**。 -->
+      <g class="yybaby">
+        <!-- 元婴打坐 · 定稿（2026-10-25「完全不行」→ 四案比选，F 案胜出）：
+           一体剪影（肩窄→袖外张→盘腿宽平底），盘腿上缘走浅玉弧线，
+           两端金手搭膝，丹田金丹+灵光环；莲花座案因花瓣糊成金坨被否。 -->
+        <g class="yyhead">
+          <path d="M12 3.9a4.0 4.0 0 1 0 0 8.0 4.0 4.0 0 1 0 0-8.0z
+                   M10.5 6.05a.6 .6 0 1 0 0 1.2 .6 .6 0 1 0 0-1.2z
+                   M13.5 6.05a.6 .6 0 1 0 0 1.2 .6 .6 0 1 0 0-1.2z
+                   M10.75 9.35Q12 11.6 13.25 9.35Q12 10.25 10.75 9.35Z"
+                fill="currentColor" fill-rule="evenodd" stroke="none"/>
+          <circle cx="7.8" cy="7.7" r=".48" fill="currentColor" stroke="none"/>
+          <circle cx="16.2" cy="7.7" r=".48" fill="currentColor" stroke="none"/>
+          <ellipse class="yyblush" cx="8.95" cy="8.9" rx=".7" ry=".42" fill="var(--q-blood,#E23B2E)" stroke="none" opacity=".42"/>
+          <ellipse class="yyblush" cx="15.05" cy="8.9" rx=".7" ry=".42" fill="var(--q-blood,#E23B2E)" stroke="none" opacity=".42"/>
+          <circle cx="12" cy="5.2" r=".27" fill="var(--q-blood,#E23B2E)" stroke="none" opacity=".9"/>
+          <rect class="yylid" x="9.65" y="6.15" width="4.7" height="1.8" rx=".65" fill="currentColor" stroke="none" opacity="0"/>
+          <circle class="yyknot" cx="12" cy="2.85" r=".9" fill="var(--q-gold,#E8C77A)" stroke="none"/>
+        </g>
+                                <path d="M12 11.9c-1.95 0-3.25 1.15-3.85 2.9-.42 1.25-.95 2.3-1.9 3.0v2.05h11.5v-2.05c-.95-.7-1.48-1.75-1.9-3.0-.6-1.75-1.9-2.9-3.85-2.9z" fill="currentColor" stroke="none"/>
+                <circle cx="7.0" cy="18.45" r="2.15" fill="currentColor" stroke="none"/>
+                <circle cx="17.0" cy="18.45" r="2.15" fill="currentColor" stroke="none"/>
+                <rect x="7.0" y="17.6" width="10.0" height="2.9" fill="currentColor" stroke="none"/>
+<!-- 禅定印 · canvas 细线（2026-10-25 配色定稿）：
+             两条掌缘弧 + 拇指三角，用 --canvas 描线而不是填金/填孔 ——
+             填金在选中绿上只有 1.29，填孔在 28px 下糊成一团黑；
+             细线两头都不犯：暗底当亮线、亮底当暗线，且不占体积。
+             金丹垫 canvas 暗衬后才立得住（朱 vs 绿 2.0 → 朱 vs 暗衬 4.0）。 -->
+        <g fill="none" stroke="var(--canvas,#0B1512)" stroke-width=".62" stroke-linecap="round">
+          <path d="M9.15 16.45q.55 2.4 2.85 2.4"/>
+          <path d="M14.85 16.45q-.55 2.4-2.85 2.4"/>
+          <path d="M10.45 16.15 12 14.5 13.55 16.15"/>
+        </g>
+        <!-- 金丹：卧在印心，外面垫一圈 canvas 暗衬 —— 朱在绿身上只有 2.0，
+             垫了暗衬才有 4.0（深）/ 4.5（浅），28px 才立得住；明灭 = 吐纳 -->
+        <circle cx="12" cy="16.15" r=".78" fill="var(--canvas,#0B1512)" stroke="none"/>
+        <circle class="yypill" cx="12" cy="16.15" r=".5" fill="var(--q-blood,#E23B2E)" stroke="none"/>
+      </g>
+    </svg></span></button>
 </nav>
 <!-- 第三方库归口 shared/vendor（与内核共用一份）：markdown 渲染栈要用 marked + DOMPurify；
      highlight.js 由内核按需加载，地址在下面给（内核自己不知道页面的相对根；
@@ -1233,9 +1918,22 @@ button.setrow{font-family:inherit}
 <script src="shared/host-glue.js"></script>
 <script src="shared/conversation.js"></script>
 <script src="shared/transport-http.js"></script>
+<!-- 会话↔需求关系图谱的专业图谱组件（vendor，与 html2canvas 同目录）：
+     cytoscape.js（UMD，内置力导向 cose / 缩放 / 拖拽 / 命中测试）+ fCoSE 布局扩展
+     （依赖 layout-base / cose-base，按序加载后 cytoscape.use() 注册）。 -->
+<script src="vendor/layout-base.js"></script>
+<script src="vendor/cose-base.js"></script>
+<script src="vendor/cytoscape-fcose.js"></script>
+<script src="vendor/cytoscape.min.js"></script>
 <!-- 需求页（独立子页面模块）：只在这里加载并注册 window.MagicReqs，
      真正的 DOM/逻辑都在 reqs.js，主 IIFE 末尾 mount 时把宿主能力注入进去。 -->
 <script src="reqs.js"></script>
+<!-- 需求页的「页面完成情况」截图与标注（reqshot.js）：开抽屉 → 打开页面（中转）→
+     截图 → 标注 → 写回需求文档。宿主只提供浏览器/网络这几件能力。 -->
+<script src="reqshot.js"></script>
+<!-- 脚本页（独立子页面模块）：只在这里加载并注册 window.MagicScripts，
+     真正的 DOM/逻辑都在 scripts.js，主 IIFE 末尾 mount 时把宿主能力注入进去。 -->
+<script src="scripts.js"></script>
 <script>
 (function () {
   'use strict';
@@ -1276,12 +1974,20 @@ button.setrow{font-family:inherit}
   var pluginDetailEl = document.getElementById('pluginDetail');
   var pluginDetailTitle = document.getElementById('pluginDetailTitle');
   var pluginDetailBody = document.getElementById('pluginDetailBody');
+  var knowledgeEl = document.getElementById('knowledge');
+  var knowledgeListEl = document.getElementById('knowledgeList');
+  var knowledgeDetailEl = document.getElementById('knowledgeDetail');
+  var knowledgeDetailTitle = document.getElementById('knowledgeDetailTitle');
+  var knowledgeDetailBody = document.getElementById('knowledgeDetailBody');
+  var scriptsEl = document.getElementById('scripts');
+  var scriptDetailEl = document.getElementById('scriptDetail');
   var brEl = document.getElementById('browser');
   var brFrame = document.getElementById('brFrame');
   var brAddr = document.getElementById('brAddr');
   var brForm = document.getElementById('brForm');
-  var brShield = document.getElementById('brShield');
   var brStar = document.getElementById('brStar');
+  var brRelayBtn = document.getElementById('brRelay');
+  var brShotBtn = document.getElementById('brShot');
   var readerEl = document.getElementById('reader');
   var rdTitle = document.getElementById('rdTitle');
   var rdSub = document.getElementById('rdSub');
@@ -1358,6 +2064,10 @@ button.setrow{font-family:inherit}
         取到 undefined，但一取 .indexOf 就抛异常，整个页面初始化会在这里断掉。 */
   var CORE_FEATURES = [];
   function teamSupported() { return CORE_FEATURES.indexOf('feature.session.team') >= 0; }
+  /* 需求截图能力位（2026-10-25）：core 支持「把页面完成情况截图写进需求文档」。
+     与 feature.requirements **分开** —— core 可能支持需求聚合但还不支持截图，
+     那样就把相机徽标藏起来，而不是给一个点了必然 501 的入口。 */
+  function hasReqShotFeature() { return CORE_FEATURES.indexOf('feature.requirement.shots') >= 0; }
   function loadTeamPref() {
     var o = { sessions: {}, fresh: false, routes: {}, rules: {}, parallel: 4, split: 'standard', splitCode: false, adaptive: true };
     try {
@@ -1510,6 +2220,70 @@ button.setrow{font-family:inherit}
     saveHostingPref();
   }
 
+  /* ── 思考模式（2026-10-24 用户：「移动端会话中可配置思考模式 默认开最高」）──
+     与团队 / 托管同一套形状：**挂在会话上**，每条会话各记自己的档位；没记过 = 最高档。
+     新会话还没拿到 session_id 时先记在 `fresh`（首帧带回 id 就落到那条会话上）。
+     `off` 不走 --reasoning（core 把它归一成「不传参数」= 引擎默认，仍会思考），
+     而是下发 noThinking，让 core 用各引擎的官方关闭开关（见 internal/agent/engine.go）。 */
+  var REASONING_KEY = 'magic.reasoning.sessions.v1';
+  var REASONING_DEFAULT = 'max';
+  /* 只暴露**跨引擎有共识**的 5 档（2026-10-24 用户：「思考模式应该无法支持6档」）：
+     xhigh / minimal 只有 codebuddy / codex 认，claude 会把 minimal 降成 low，
+     UI 上留着只会让同一档在不同引擎表现不一致。core 仍接受这两个值（老会话记录 /
+     已排队条目照常下发），只是移动端不再提供入口。 */
+  var REASONING_LEVELS = [
+    { v: 'max', label: '最高', desc: '默认' },
+    { v: 'high', label: '高', desc: '复杂任务' },
+    { v: 'medium', label: '中', desc: '日常' },
+    { v: 'low', label: '低', desc: '快问快答' },
+    { v: 'off', label: '关闭', desc: '不思考' }
+  ];
+  function validReasoning(v) {
+    for (var i = 0; i < REASONING_LEVELS.length; i++) if (REASONING_LEVELS[i].v === v) return true;
+    return false;
+  }
+  function reasoningLabel(v) {
+    for (var i = 0; i < REASONING_LEVELS.length; i++) if (REASONING_LEVELS[i].v === v) return REASONING_LEVELS[i].label;
+    return '最高';
+  }
+  function loadReasoningPref() {
+    var o = { sessions: {}, fresh: '' };
+    try {
+      var m = JSON.parse(localStorage.getItem(REASONING_KEY) || '{}');
+      if (m && typeof m === 'object' && !Array.isArray(m)) {
+        Object.keys(m).forEach(function (sid) { if (validReasoning(m[sid])) o.sessions[String(sid)] = m[sid]; });
+      }
+    } catch (e) {}
+    return o;
+  }
+  function saveReasoningPref() {
+    /* 与团队 / 托管同一条容量护栏：最多 400 条，超出按 key 顺序丢（只影响容量）。 */
+    var ids = Object.keys(REASONING.sessions || {});
+    if (ids.length > 400) {
+      ids.slice(0, ids.length - 400).forEach(function (sid) { delete REASONING.sessions[sid]; });
+    }
+    try { localStorage.setItem(REASONING_KEY, JSON.stringify(REASONING.sessions || {})); } catch (e) {}
+    schedulePushPrefs();
+    paintRunSettings();
+  }
+  var REASONING = loadReasoningPref();
+  /* 当前打开的那条会话生效的档位（切换 / 新建会话时由 mountConversation 重设）。 */
+  var REASONING_CUR = REASONING_DEFAULT;
+  /* 这条会话的档位：session_id / run_id 任一有显式记录就用它，否则最高档。
+     不沿父链继承 —— 思考档位是这条会话自己的运行参数，与团队的开关语义不同。 */
+  function reasoningOnFor(sid, s) {
+    if (!sid) return REASONING.fresh || REASONING_DEFAULT;
+    var cur = s || sessionByAnyId(sid);
+    if (cur) {
+      var keys = [sidOf(cur), cur.session_id, cur.run_id];
+      for (var i = 0; i < keys.length; i++) {
+        var k = keys[i];
+        if (k && Object.prototype.hasOwnProperty.call(REASONING.sessions, String(k))) return REASONING.sessions[String(k)];
+      }
+    }
+    return REASONING.sessions[String(sid)] || REASONING_DEFAULT;
+  }
+
   /* ══════════ 环境（多连接）══════════
      2026-10-22 用户：「移动端要支持环境切换 可以有多个连接」。
      一台手机可以记住多台桌面（家里 / 公司 / 另一台机器），任务页标题就是切换入口。
@@ -1798,8 +2572,10 @@ button.setrow{font-family:inherit}
      ⚠️ 分桶键用稳定 eid（见 ensureEnvId），不是 url|token（令牌会轮换）、也不是 host:port
         （换 IP/端口/隧道域名就变成另一台，现场全丢）。老数据按 host 哈希做一次迁移。 */
   var ENV_SCOPE_KEYS = [
-    'magic.ws', 'magic.taskmode', 'magic.hosting.sessions.v1', 'magic.engine', 'magic.model',
+    'magic.ws', 'magic.taskmode', 'magic.hosting.sessions.v1', 'magic.reasoning.sessions.v1', 'magic.engine', 'magic.model',
+    'magic.fallback.engine', 'magic.fallback.model',
     'magic.suggest.engine', 'magic.suggest.model',
+    'magic.suggest.fallback.engine', 'magic.suggest.fallback.model',
     'magic.theme', 'magic.font', 'magic.notify',
     'magic.pinned', 'magic.spaces', 'magic.browser.stars.v1',
     'magic.team.sessions.v1', 'magic.team.routes.v1', 'magic.team.rules.v1',
@@ -1908,8 +2684,10 @@ button.setrow{font-family:inherit}
        · 本地任何一处改了，防抖推回远端。
      纯设备偏好（主题/字体/通知）**不同步** —— 那是手机自己的事。 */
   var PREF_SYNC_KEYS = [
-    'magic.engine', 'magic.model', 'magic.suggest.engine', 'magic.suggest.model', 'magic.ws', 'magic.spaces', 'magic.pinned',
-    'magic.hosting.sessions.v1',
+    'magic.engine', 'magic.model', 'magic.fallback.engine', 'magic.fallback.model',
+    'magic.suggest.engine', 'magic.suggest.model',
+    'magic.suggest.fallback.engine', 'magic.suggest.fallback.model', 'magic.ws', 'magic.spaces', 'magic.pinned',
+    'magic.hosting.sessions.v1', 'magic.reasoning.sessions.v1',
     'magic.team.sessions.v1', 'magic.team.routes.v1', 'magic.team.rules.v1',
     'magic.team.parallel', 'magic.team.split', 'magic.team.splitcode', 'magic.team.adaptive'
   ];
@@ -2259,7 +3037,7 @@ button.setrow{font-family:inherit}
   }
 
   /* ══════════ 视图：启动页 → 会话列表 → 会话 ══════════ */
-  function hideAll() { launcherEl.hidden = true; historyEl.hidden = true; mineEl.hidden = true; reqsEl.hidden = true; reqDetailEl.hidden = true; discoverEl.hidden = true; teamPageEl.hidden = true; runSettingsPageEl.hidden = true; pluginsEl.hidden = true; pluginDetailEl.hidden = true; sessionEl.hidden = true; }
+  function hideAll() { launcherEl.hidden = true; historyEl.hidden = true; mineEl.hidden = true; reqsEl.hidden = true; reqDetailEl.hidden = true; discoverEl.hidden = true; teamPageEl.hidden = true; runSettingsPageEl.hidden = true; pluginsEl.hidden = true; pluginDetailEl.hidden = true; knowledgeEl.hidden = true; knowledgeDetailEl.hidden = true; scriptsEl.hidden = true; scriptDetailEl.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);
@@ -2296,12 +3074,27 @@ button.setrow{font-family:inherit}
     if (window.MagicReqs && window.MagicReqs.show) window.MagicReqs.show();
   }
   function showDiscover() { hideAll(); discoverEl.hidden = false; tabbarEl.hidden = false; setActive('discover'); }
+  /* 脚本页：内容与逻辑在 scripts.js（独立子页面模块），这里只负责切页。
+     进页面即拉一次清单（GET /desk/scripts，只读、不启停任何东西）；
+     启停与日志流由 scripts.js 自己管。 */
+  function showScripts() {
+    hideAll(); scriptsEl.hidden = false; tabbarEl.hidden = true;
+    if (window.MagicScripts && window.MagicScripts.show) window.MagicScripts.show();
+  }
+  function showScriptDetail() { hideAll(); scriptDetailEl.hidden = false; tabbarEl.hidden = true; }
   function showMine() {
     hideAll(); mineEl.hidden = false; tabbarEl.hidden = false; setActive('mine');
     mineDevice.textContent = histSubtitle || '本机';
     paintSuggestPref();
     var ns = document.getElementById('notifyState');
-    if (ns) { var p = notifyPermState(); ns.textContent = p === 'plugin' ? '已接入' : (p === 'granted' ? '已开启' : '未开启'); }
+    /* 权限状态只能问原生才知道（异步）—— 先按缓存画一个，再探一次回来刷新。
+       旧写法把「插件对象在」当成「已接入」，其实那只说明 Capacitor 运行时注入了，
+       传输层通不通是另一回事（用户看到的「已开启」其实什么也没开）。 */
+    if (ns) ns.textContent = notifyStateLabel();
+    notifyProbe().then(function () {
+      var n2 = document.getElementById('notifyState');
+      if (n2) n2.textContent = notifyStateLabel();
+    });
     markSeg(segTheme, PREFS.theme); markSeg(segFont, PREFS.font); markSeg(segMode, TASK_MODE);
     paintRunPref();
     refreshVpn();
@@ -2697,6 +3490,267 @@ button.setrow{font-family:inherit}
     } catch (e) {}
   }
 
+  /* ══════════ 发现 → 知识库（OpenViking 上下文数据库）══════════
+     数据全部来自桌面端 `GET /desk/knowledge`：装没装、本机版本多少、PyPI 最新版本多少，
+     都由服务端探测后宣布。本页不自己判断状态 —— 那样两端会各说一套。
+
+     安装/升级走 `POST /desk/knowledge/{id}/{action}` 的 SSE：命令是**服务端写死的**，
+     手机只传 id 与动作；输出逐行回来，所以看得见在动，失败也能把 stderr 摊出来。
+
+     与「插件」页的差别只有一个实质点：**有版本**。所以列表上多一枚「可升级」徽标，
+     而「未安装 / 已安装 / 可升级」三态都由服务端说了算。 */
+  var KNOWLEDGE = [];             // 最近一次 GET /desk/knowledge 的结果
+  var KNOWLEDGE_BUSY = {};        // id → 正在跑的动作（防重复点）
+  var KNOWLEDGE_LOG = {};         // id → 上次安装/升级的日志文本（收尾重画后仍看得到）
+
+  function loadKnowledge() {
+    /* 已经有缓存就立刻画一遍（从详情返回时不闪「读取中」），再后台刷新真实状态。 */
+    if (KNOWLEDGE.length) renderKnowledge();
+    else knowledgeListEl.innerHTML = '<div class="history__hint">读取中…</div>';
+    fetch(BASE + '/desk/knowledge', { headers: pluginHeaders() })
+      .then(function (r) {
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        return r.json();
+      })
+      .then(function (j) {
+        KNOWLEDGE = (j && j.knowledge) || [];
+        renderKnowledge();
+      })
+      .catch(function (e) {
+        knowledgeListEl.innerHTML = '';
+        knowledgeListEl.appendChild(hEl('div', 'history__hint',
+          '读取知识库目录失败：' + (e && e.message ? e.message : e) +
+          '。需要桌面端为较新版本（/desk/knowledge）。'));
+      });
+  }
+
+  function renderKnowledge() {
+    knowledgeListEl.innerHTML = '';
+    if (!KNOWLEDGE.length) {
+      knowledgeListEl.appendChild(hEl('div', 'history__hint', '桌面端没有返回任何知识库。'));
+      return;
+    }
+    knowledgeListEl.appendChild(hEl('div', 'history__group', '上下文数据库'));
+    KNOWLEDGE.forEach(function (k) {
+      var row = hEl('button', 'plugin'); row.type = 'button';
+      var ico = hEl('span', 'plugin__ico' + (k.installed ? ' is-on' : ''));
+      ico.innerHTML = '<svg width="22" height="22"><use href="#i-db"/></svg>';
+      var col = hEl('span', 'plugin__col');
+      col.appendChild(hEl('span', 'plugin__t', k.name));
+      col.appendChild(hEl('span', 'plugin__s', k.tagline || ''));
+      row.appendChild(ico); row.appendChild(col);
+      row.appendChild(knowledgeBadges(k));
+      row.onclick = function () { showKnowledgeDetail(k.id); };
+      knowledgeListEl.appendChild(row);
+    });
+    knowledgeListEl.appendChild(hEl('div', 'pd__note',
+      '安装与升级在**桌面端**执行（手机只发起），装完还需配 ~/.openviking/ov.conf 才能真的开始检索。'));
+  }
+
+  /* 徽标：未安装 / 已安装 vX / 可升级 vY。
+     「可升级」用描边那枚（.pbadge--new）—— 底色会和「已安装」的绿撞。 */
+  function knowledgeBadges(k) {
+    if (!k.installed) return hEl('span', 'pbadge pbadge--off', '未安装');
+    var wrap = document.createElement('span');
+    wrap.style.display = 'flex';
+    wrap.style.flex = '0 0 auto';
+    wrap.style.gap = '4px';
+    wrap.appendChild(hEl('span', 'pbadge pbadge--on',
+      '已安装' + (k.version ? ' v' + k.version : '')));
+    if (k.upgradeAvailable && k.latestVersion) {
+      wrap.appendChild(hEl('span', 'pbadge pbadge--new', '可升级 v' + k.latestVersion));
+    }
+    return wrap;
+  }
+
+  function knowledgeById(id) {
+    for (var i = 0; i < KNOWLEDGE.length; i++) if (KNOWLEDGE[i].id === id) return KNOWLEDGE[i];
+    return null;
+  }
+
+  function showKnowledge() {
+    hideAll(); knowledgeEl.hidden = false; tabbarEl.hidden = true;
+    loadKnowledge();
+  }
+
+  function showKnowledgeDetail(id) {
+    var k = knowledgeById(id);
+    if (!k) { showKnowledge(); return; }
+    hideAll(); knowledgeDetailEl.hidden = false; tabbarEl.hidden = true;
+    knowledgeDetailTitle.textContent = k.name;
+    renderKnowledgeDetail(k);
+  }
+
+  function renderKnowledgeDetail(k) {
+    var box = knowledgeDetailBody;
+    box.innerHTML = '';
+    var wrap = hEl('div', 'pd');
+
+    var head = hEl('div', 'pd__head');
+    head.appendChild(hEl('span', 'pd__name', k.name));
+    head.appendChild(knowledgeBadges(k));
+    wrap.appendChild(head);
+    wrap.appendChild(hEl('p', 'pd__tag', k.tagline || ''));
+
+    /* 状态说明（服务端给的那句「为什么是这个状态」） */
+    if (k.note) wrap.appendChild(hEl('div', 'pd__note', k.note));
+    if (k.bin) wrap.appendChild(hEl('div', 'pd__note', '命令：' + k.bin));
+    if (k.latestVersion) {
+      wrap.appendChild(hEl('div', 'pd__note', '最新版本：v' + k.latestVersion +
+        (k.upgradeAvailable ? '（本机可升级）' : '')));
+    }
+    if (k.pythonPath) {
+      wrap.appendChild(hEl('div', 'pd__note',
+        'Python：' + k.pythonPath + (k.pythonVersion ? '（' + k.pythonVersion + '）' : '')));
+    }
+
+    wrap.appendChild(pdSection('介绍', hEl('p', 'pd__p', k.description || '')));
+    if (k.requirements) wrap.appendChild(pdSection('环境要求', hEl('p', 'pd__p', k.requirements)));
+
+    /* 没装 → 装；装了且有新版 → 升；装了但已是最新 → 仍然给「升级」（能装回滚后的新版本，
+       而且界面上的按钮文案要与服务端给的 upgrade 命令一致，不自己发明动作）。 */
+    var wantUpgrade = k.upgradeAvailable;
+    var cmd = wantUpgrade ? k.upgrade : (k.installed ? k.upgrade : k.install);
+    var cmdLabel = wantUpgrade ? '升级' : (k.installed ? '重新安装' : '一键安装');
+    var action = wantUpgrade || k.installed ? 'upgrade' : 'install';
+    var cmdSec = hEl('div', 'pd__sec');
+    cmdSec.appendChild(hEl('div', 'pd__h', cmdLabel + '命令（在桌面端执行）'));
+    var pre = hEl('pre', 'pd__code', cmd || '（服务端没有给出安装命令）');
+    cmdSec.appendChild(pre);
+
+    var actions = hEl('div', 'pd__actions');
+    var goBtn = hEl('button', 'btn btn--filled',
+      KNOWLEDGE_BUSY[k.id] ? '正在' + KNOWLEDGE_BUSY[k.id] + '…' : cmdLabel);
+    goBtn.type = 'button';
+    goBtn.disabled = !!KNOWLEDGE_BUSY[k.id] || !cmd;
+    goBtn.onclick = function () { runKnowledgeAction(k.id, action); };
+    var copyBtn = hEl('button', 'btn btn--outlined', '复制命令');
+    copyBtn.type = 'button';
+    copyBtn.onclick = function () { copyText(cmd || '', '命令已复制'); };
+    actions.appendChild(goBtn); actions.appendChild(copyBtn);
+    cmdSec.appendChild(actions);
+
+    var log = hEl('pre', 'pd__log');
+    log.textContent = KNOWLEDGE_LOG[k.id] || '';
+    log.hidden = !log.textContent;
+    cmdSec.appendChild(log);
+    wrap.appendChild(cmdSec);
+    k.__log = log;
+
+    /* 让它干活：预填一段话到输入框（不直接发 —— 问题得用户自己填） */
+    var useSec = hEl('div', 'pd__sec');
+    useSec.appendChild(hEl('div', 'pd__h', '用起来'));
+    var useBtn = hEl('button', 'btn btn--filled', '新建会话并让它干活');
+    useBtn.type = 'button';
+    useBtn.style.marginTop = '0';
+    useBtn.onclick = function () { useKnowledge(k); };
+    useSec.appendChild(useBtn);
+    if (k.examples && k.examples.length) {
+      var ex = hEl('pre', 'pd__code', k.examples.join('\n'));
+      ex.style.marginTop = '10px';
+      useSec.appendChild(ex);
+    }
+    useSec.appendChild(hEl('div', 'pd__note',
+      '会话里由 Agent 在桌面端执行这些命令；长任务可以在任务列表里看进度。'));
+    wrap.appendChild(useSec);
+
+    if (k.homepage) {
+      var home = hEl('button', 'setrow');
+      home.appendChild(hEl('span', 'setrow__l', '项目主页'));
+      home.appendChild(hEl('span', 'setrow__v', k.homepage));
+      home.onclick = function () { closeHostSheet(); openBrowser(k.homepage); };
+      var card = hEl('div', 'setcard'); card.appendChild(home);
+      wrap.appendChild(card);
+    }
+
+    box.appendChild(wrap);
+  }
+
+  /* 安装 / 升级：POST 出去，按 SSE 逐行画日志（命令由服务端定，本页只传 id 与动作）。 */
+  function runKnowledgeAction(id, action) {
+    if (KNOWLEDGE_BUSY[id]) { toast('已有任务在跑，等它结束'); return; }
+    var k = knowledgeById(id);
+    var log = k && k.__log;
+    KNOWLEDGE_BUSY[id] = action;
+    KNOWLEDGE_LOG[id] = '▶ 开始' + (action === 'install' ? '安装' : '升级') + '…\n';
+    if (log) { log.hidden = false; log.textContent = KNOWLEDGE_LOG[id]; }
+    renderKnowledgeDetailButtonState(k, action);
+
+    fetch(BASE + '/desk/knowledge/' + encodeURIComponent(id) + '/' + action,
+          { method: 'POST', headers: pluginHeaders() })
+      .then(function (resp) {
+        if (!resp.ok || !resp.body) throw new Error('HTTP ' + resp.status);
+        var reader = resp.body.getReader(), dec = new TextDecoder(), buf = '';
+        return (function pump() {
+          return reader.read().then(function (chunk) {
+            if (chunk.done) return null;
+            buf += dec.decode(chunk.value, { stream: true });
+            var blocks = buf.split('\n\n');
+            buf = blocks.pop();
+            blocks.forEach(function (b) {
+              var name = '', data = '';
+              b.split('\n').forEach(function (ln) {
+                if (ln.indexOf('event: ') === 0) name = ln.slice(7).trim();
+                else if (ln.indexOf('data: ') === 0) data += ln.slice(6);
+              });
+              if (!data) return;
+              var ev; try { ev = JSON.parse(data); } catch (e) { return; }
+              var line = '';
+              if (name === 'step') line = '\n$ ' + ev.command + '\n';
+              else if (name === 'line') line = ev.line + '\n';
+              else if (name === 'end') {
+                line = ev.ok ? '\n✔ 完成\n' : ('\n✘ 失败：' + (ev.error || ('退出码 ' + ev.code)) + '\n');
+                if (ev.knowledge) {
+                  KNOWLEDGE = KNOWLEDGE.map(function (x) { return x.id === ev.knowledge.id ? ev.knowledge : x; });
+                  renderKnowledge();
+                }
+              }
+              if (!line) return;
+              KNOWLEDGE_LOG[id] = (KNOWLEDGE_LOG[id] || '') + line;
+              if (log) { log.textContent = KNOWLEDGE_LOG[id]; log.scrollTop = log.scrollHeight; }
+            });
+            return pump();
+          });
+        })();
+      })
+      .then(function () { delete KNOWLEDGE_BUSY[id]; toast(action === 'install' ? '安装流程结束' : '升级流程结束'); })
+      .catch(function (e) {
+        delete KNOWLEDGE_BUSY[id];
+        KNOWLEDGE_LOG[id] = (KNOWLEDGE_LOG[id] || '') + '\n✘ ' + (e && e.message ? e.message : e) + '\n';
+        if (log) { log.textContent = KNOWLEDGE_LOG[id]; log.scrollTop = log.scrollHeight; }
+        toast('执行失败：' + (e && e.message ? e.message : e));
+      })
+      .then(function () {
+        /* 收尾后按服务端最新状态重画这一页（按钮文案要从「一键安装」变「升级」） */
+        var fresh = knowledgeById(id);
+        if (fresh && !knowledgeDetailEl.hidden) renderKnowledgeDetail(fresh);
+      });
+  }
+
+  function renderKnowledgeDetailButtonState(k, action) {
+    if (!k) return;
+    var btns = knowledgeDetailBody.querySelectorAll('.pd__actions .btn');
+    if (btns[0]) {
+      btns[0].disabled = true;
+      btns[0].textContent = '正在' + (action === 'install' ? '安装' : '升级') + '…';
+    }
+  }
+
+  /* 用它干活：新开会话，把「要问什么」预填进输入框（用户补问题后自己发）。 */
+  function useKnowledge(k) {
+    newConversation();
+    var text = k.usePrompt || ('用 ' + k.cli + ' 查知识库。\n问题：');
+    var ta = convEl.querySelector('textarea');
+    if (!ta) { toast('输入框还没准备好，请重试'); return; }
+    ta.value = text;
+    ta.dispatchEvent(new Event('input', { bubbles: true }));
+    ta.focus();
+    try {
+      var i = text.indexOf('：\n');
+      if (i >= 0) ta.setSelectionRange(i + 2, i + 2);
+    } catch (e) {}
+  }
+
   /* ══════════ 内置浏览器 ══════════
      用 iframe 内嵌第三方站点（对方没设 X-Frame-Options 才显示得出来）。
      导航栈只记我们主动打开的层级 —— 跨源页面内部跳转读不到，
@@ -2724,10 +3778,10 @@ button.setrow{font-family:inherit}
     try { return new URL(u).host; } catch (e) { return u; }
   }
   function brPaint() {
+    brPaintRelay();
     var u = brStack[brStack.length - 1] || HOME_URL;
     if (document.activeElement === brAddr) return;
     brAddr.value = siteName(u);
-    brShield.classList.toggle('is-plain', !/^https:/i.test(u));
     brStar.classList.toggle('is-on', loadStars().indexOf(u) >= 0);
   }
   function brNav(url) {
@@ -2736,13 +3790,20 @@ button.setrow{font-family:inherit}
     brLoad(url);
     brPaint();
   }
-  /* 中转地址：iframe 经桌面端 /b/ 取页面，走**桌面端的网络**，而不是手机直连。
-     BASE/TOKEN 都空（本地兜底页 / 未配对）时退回直连，行为与以前一致。
-     「我的 → 网络代理」开着时，全机流量已经过隧道；此时再让浏览器单独走 /b/ 中转没有意义，
-     反而会让页内资源分两个出口（Google 那种风控就是被这个坑到的），所以直接用原始地址。 */
-  function vpnActive() { return VPN_ON === true; }
+  /* ── 桌面端中转开关（2026-10-25 用户：「加开关，保留能力」）──
+     默认**直连**。开了才走 /b/ 中转：页面由桌面端代取并改写，换来三样直连给不了的 ——
+     桌面独有站点 / 内网服务、被站点拒绝内嵌的页面（中转剥 X-Frame-Options/CSP）、
+     浏览器 MCP 的 relay 注入（magic-client browse 的驱动通道）。
+     刻意**不挂**在「我的 → 网络代理」上：那个开关起的是整机 TUN，桌面端没开 SOCKS5
+     出口时一开手机整机断网（连回桌面端的链路一起断），中转跟着陪葬；且中转+隧道
+     双出口正是当年 Google 风控的坑。两个开关各管各的：网络代理管整机，这个管浏览器。 */
+  var BR_RELAY_KEY = 'magic.browser.relay.v1';
+  function brRelayOn() {
+    try { return localStorage.getItem(BR_RELAY_KEY) === '1'; } catch (e) { return false; }
+  }
+  /* 中转地址：iframe 经桌面端 /b/ 取页面，走**桌面端的网络**。BASE/TOKEN 都空
+     （未配对）时退回直连。令牌拼在 URL 里 —— 转发上游前桌面端会剥掉（stripMagicToken）。 */
   function brProxyURL(u) {
-    if (vpnActive()) return u;   // 网络代理已开：整机都走隧道，这里不必再中转
     try {
       var b = BASE || (/^https?:$/i.test(location.protocol) ? location.origin : '');
       if (!b || !TOKEN) return u;
@@ -2753,14 +3814,54 @@ button.setrow{font-family:inherit}
              (a.search ? a.search + '&' + q : '?' + q);
     } catch (e) { return u; }
   }
-  function brLoad(u) { brFrame.src = brProxyURL(u); }
+  /* iframe 加载：**默认直连**，走手机自己的网络 —— 内置浏览器首先得是个浏览器
+     （2026-10-25 用户：「没开网络代理时就应该直连啊」）。brRelayOn 开时走 /b/ 中转。 */
+  function brLoad(u) { brFrame.src = brRelayOn() ? brProxyURL(u) : u; }
+  function brPaintRelay() {
+    if (brRelayBtn) brRelayBtn.classList.toggle('is-on', brRelayOn());
+  }
+  function brToggleRelay() {
+    if (!BASE || !TOKEN) { toast('未配对桌面端，用不了中转'); return; }
+    var on = !brRelayOn();
+    try { localStorage.setItem(BR_RELAY_KEY, on ? '1' : '0'); } catch (e) {}
+    brPaintRelay();
+    toast(on ? '已走桌面端中转（MCP 可用）' : '已切回手机直连');
+    if (brStack.length) brReload();   // 立刻按新方式重载当前页
+  }
   function openBrowser(url) {
     brStack = [url || HOME_URL];
     brLoad(brStack[0]);
     brPaint();
+    brResetFloat();
     brEl.hidden = false;
   }
-  function closeBrowser() { brEl.hidden = true; brStack = []; brFrame.src = 'about:blank'; }
+  function closeBrowser() {
+    brEl.hidden = true; brStack = []; brFrame.src = 'about:blank';
+    brResetFloat();
+    /* 截图流程收尾：关掉浏览器就意味着这次截图不做了 —— 把通道与按钮都收掉，
+       否则下一次打开浏览器还挂着一个指向旧任务的截图入口。 */
+    if (window.MagicReqShot && window.MagicReqShot.reset) window.MagicReqShot.reset();
+  }
+  /* 内核「HTML 产物卡点击」入口（19-attachments 经 MagicHost.openBrowser 调）：
+     同源地址（/desk/media 供的本地 HTML 产物）直接进 iframe —— 走 /b/ 中转会把它当外站
+     再抓一遍，多一跳还可能丢 ?token=；其余网址照常 openBrowser（远站按 brRelayOn 决定
+     直连还是走中转）。 */
+  try {
+    window.MagicHost = window.MagicHost || {};
+    window.MagicHost.openBrowser = function (u) {
+      u = String(u || '');
+      if (!u) return;
+      if (BASE && TOKEN && u.indexOf(location.origin) === 0 && /^https?:\/\//i.test(u)) {
+        brStack = [u];
+        brFrame.src = u;
+        brPaint();
+        brResetFloat();
+        brEl.hidden = false;
+        return;
+      }
+      openBrowser(u);
+    };
+  } catch (e) {}
   function brBack() {
     if (brStack.length > 1) { brStack.pop(); brLoad(brStack[brStack.length - 1]); brPaint(); }
     else closeBrowser();
@@ -2840,6 +3941,157 @@ button.setrow{font-family:inherit}
     brTyped(v);
   });
   brAddr.addEventListener('blur', function () { brPaint(); });
+
+  /* ── 悬浮形态（2026-10-24）：全屏 ↔ 悬浮卡片 ↔ 悬浮球 ──
+     三态间 iframe 的 src 不动 —— 只是几何变化，页面不重载；只有 closeBrowser() 才清 src。
+     悬浮球挂起时 #browser 整体 hidden 但 brStack 保留，点球恢复。
+     位置记忆：卡片 magic.browser.float.v1、球 magic.browser.ball.v1（localStorage）。
+     悬浮态顶栏是拖拽把手（touch-action:none，见 .browser.is-float .browser__top），
+     把手上的按钮照常可点 —— pointerdown 命中 button/input 时不启动拖拽。 */
+  var brBall = document.getElementById('brBall');
+  var BR_FLOAT_KEY = 'magic.browser.float.v1';
+  var BR_BALL_KEY = 'magic.browser.ball.v1';
+  var brMode = 'full';
+  var brDragState = null;   // {kind:'card'|'ball', dx, dy, moved, pid}
+
+  function brLoadPos(key) {
+    try { var v = JSON.parse(localStorage.getItem(key) || 'null'); return v && typeof v.x === 'number' ? v : null; }
+    catch (e) { return null; }
+  }
+  function brSavePos(key, v) { try { localStorage.setItem(key, JSON.stringify(v)); } catch (e) {} }
+  function brClampX(x, w) { return Math.max(6, Math.min(x, window.innerWidth - w - 6)); }
+  function brClampY(y, h) { return Math.max(6, Math.min(y, window.innerHeight - h - 6)); }
+
+  function brApplyFloatPos() {
+    var saved = brLoadPos(BR_FLOAT_KEY);
+    var w = brEl.offsetWidth, h = brEl.offsetHeight;
+    var x = saved ? saved.x : (window.innerWidth - w - 12);
+    var y = saved ? saved.y : (window.innerHeight - h - 70);
+    brEl.style.left = brClampX(x, w) + 'px';
+    brEl.style.top = brClampY(y, h) + 'px';
+  }
+  function brApplyBallPos() {
+    var saved = brLoadPos(BR_BALL_KEY);
+    var x = saved ? saved.x : (window.innerWidth - 52);
+    var y = saved ? saved.y : Math.round(window.innerHeight * 0.6);
+    brBall.style.left = brClampX(x, 46) + 'px';
+    brBall.style.top = brClampY(y, 46) + 'px';
+  }
+
+  function brSetMode(m) {
+    if (!brStack.length) m = 'full';
+    brMode = m;
+    if (m === 'ball') {
+      brEl.hidden = true;
+      brBall.hidden = false;
+      brApplyBallPos();
+      return;
+    }
+    brBall.hidden = true;
+    brEl.hidden = false;
+    var isFloat = m === 'float';
+    brEl.classList.toggle('is-float', isFloat);
+    if (isFloat) { brApplyFloatPos(); brFitStage(); }
+    else { brEl.style.left = ''; brEl.style.top = ''; brUnfitStage(); }
+  }
+
+  /* 复位到全屏初始态：openBrowser（新开一站）与 closeBrowser（彻底关）都走这里。 */
+  function brResetFloat() {
+    brMode = 'full';
+    brEl.classList.remove('is-float');
+    brEl.style.left = ''; brEl.style.top = '';
+    brBall.hidden = true;
+    brUnfitStage();
+  }
+
+  /* ── 悬浮态的等比缩放 ──
+     舞台扛 **16:9**（顶栏菜单行不算进比例，见 .browser.is-float .browser__stage），
+     只有手机屏宽的一小截到 90vw。页面若直接按舞台宽排版，等于塞进一个又窄
+     又矮的窗口 —— 布局挤、字小、还容易被裁。所以反过来做（与 magic-test 的
+     「虚拟桌面等比缩小铺满舞台」同一路子）：
+       1) iframe 用一个**固定的 16:9 虚拟视口**渲染页面：宽 BR_VW（480，手机竖屏
+          常见 CSS 视口宽；<768 站点走移动版布局），高 = 宽×9/16；
+       2) 再用 CSS transform: scale 把它整体等比缩到舞台宽度上（origin 0 0）。
+     于是：缩放后高度 = 舞台高度（16:9 对齐，不露白不裁切）、比例不变形、
+     界面上就是「同比例缩小显示」。
+     系数：舞台 90vw ≈ 392 宽时 k ≈ 0.82，14px 字缩完 ≈ 11.5 CSS px。
+     代价：卡片里一次只看得见虚拟视口这一段；页面自身仍可上下滚（滚的是
+     iframe 内部，transform 下的触摸坐标由浏览器换算，能正常滚）。 */
+  var BR_VW = 480;
+  function brFitStage() {
+    var stage = document.getElementById('brStage');
+    if (!stage) return;
+    var sw = stage.clientWidth;
+    if (!sw) return;
+    /* 虚拟视口固定 16:9（480×270）：舞台也是 16:9，缩放后正好铺满，不多不少。
+       高度若跟着舞台走会算错 —— 缩放后高度 ≠ 舞台高度，底部会露白/裁切。 */
+    var vh = Math.round(BR_VW * 9 / 16);
+    brFrame.style.width = BR_VW + 'px';
+    brFrame.style.height = vh + 'px';
+    var k = sw / BR_VW;                        // 等比缩放系数
+    brFrame.style.transform = 'scale(' + k + ')';
+  }
+  function brUnfitStage() {
+    brFrame.style.width = '';
+    brFrame.style.height = '';
+    brFrame.style.transform = '';
+  }
+
+  /* 通用拖拽：handle 上按下 → 移动 target（left/top 内联），抬起时落盘。
+     点按（位移 < 6px）回调 tap；canDrag() 为假时不启动（全屏态不可拖）。
+     把手内的 button/input 不触发拖拽。 */
+  function brMakeDraggable(handle, target, canDrag, onTap, onSave) {
+    handle.addEventListener('pointerdown', function (e) {
+      /* 把手自身（如悬浮球是个 button）不算「命中控件」，内部的才算 */
+      if (e.target !== handle && e.target.closest('button,input,form')) return;
+      if (brDragState || (canDrag && !canDrag())) return;
+      brDragState = { dx: e.clientX - target.offsetLeft, dy: e.clientY - target.offsetTop,
+                      moved: false, pid: e.pointerId, target: target, onTap: onTap, onSave: onSave };
+      try { handle.setPointerCapture(e.pointerId); } catch (err) {}
+      e.preventDefault();
+    });
+    handle.addEventListener('pointermove', function (e) {
+      var st = brDragState;
+      if (!st || st.pid !== e.pointerId) return;
+      var x = e.clientX - st.dx, y = e.clientY - st.dy;
+      if (!st.moved && Math.abs(x - st.target.offsetLeft) < 5 && Math.abs(y - st.target.offsetTop) < 5) return;
+      st.moved = true;
+      st.target.style.left = Math.max(0, x) + 'px';
+      st.target.style.top = Math.max(0, y) + 'px';
+    });
+    function finish(e) {
+      var st = brDragState;
+      if (!st || st.pid !== e.pointerId) return;
+      brDragState = null;
+      if (!st.moved) { if (st.onTap) st.onTap(); return; }
+      st.onSave(st.target.offsetLeft, st.target.offsetTop);
+    }
+    handle.addEventListener('pointerup', finish);
+    handle.addEventListener('pointercancel', finish);
+  }
+
+  (function () {
+    var top = brEl.querySelector('.browser__top');
+    /* 悬浮卡片的拖拽把手 = 顶栏；全屏态 canDrag() 为假，完全不干预。 */
+    brMakeDraggable(top, brEl, function () { return brMode === 'float'; }, null, function (x, y) {
+      brSavePos(BR_FLOAT_KEY, { x: x, y: y });
+    });
+    /* 悬浮球：拖动换位置，点按恢复悬浮卡片，双击回全屏。 */
+    brMakeDraggable(brBall, brBall, null, function () { brSetMode('float'); }, function (x, y) {
+      brSavePos(BR_BALL_KEY, { x: x, y: y });
+    });
+    brBall.addEventListener('dblclick', function () { brSetMode('full'); });
+  })();
+
+  document.getElementById('brFloat').addEventListener('click', function () {
+    brSetMode(brMode === 'float' ? 'full' : 'float');
+  });
+  document.getElementById('brExpand').addEventListener('click', function () { brSetMode('full'); });
+  document.getElementById('brMin').addEventListener('click', function () { brSetMode('ball'); });
+  window.addEventListener('resize', function () {
+    if (brMode === 'float') { brApplyFloatPos(); brFitStage(); }
+    else if (brMode === 'ball') brApplyBallPos();
+  });
   function takeSeg(seg, key, apply) {
     seg.addEventListener('click', function (e) {
       var b = e.target && e.target.closest ? e.target.closest('.seg__b') : null;
@@ -2993,6 +4245,55 @@ button.setrow{font-family:inherit}
       : '会话托管已关闭');
   }
 
+  /* 写当前会话的思考档位（session_id ↔ run_id 只留一条，与托管同一口径）。 */
+  function writeReasoningFor(v) {
+    var key = convSessionKey();
+    if (key) {
+      var s = sessionByAnyId(key);
+      if (s) {
+        [s.session_id, s.run_id].forEach(function (k) {
+          if (k && String(k) !== key) delete REASONING.sessions[String(k)];
+        });
+      }
+      REASONING.sessions[key] = v;
+    } else {
+      REASONING.fresh = v;          // 新会话还没有 id：先记着，首帧带回 id 再落库
+    }
+    REASONING_CUR = v;
+    saveReasoningPref();
+  }
+  function bindFreshReasoning(sid) {
+    if (!REASONING.fresh || !sid) return;
+    REASONING.sessions[String(sid)] = REASONING.fresh;
+    REASONING.fresh = '';
+    saveReasoningPref();
+  }
+  /* 引擎对推理档位的支持情况（以 /desk/engines 每行的 reasoning 字段为准）：
+     true / false / null（清单里还没有这个引擎 = 未知）。
+     ⚠️ 未知时**不下发**：老 CLI 不认识这个 flag，传了会 exit 2 打死整轮；
+     不传时 core 自己的默认档就是 max，与「默认最高」一致。 */
+  function reasoningSupportState(engine) {
+    var n = String(engine || '');
+    if (!n) return null;
+    var lists = [(conv && conv.state && conv.state.engines) || [], ENGINES || []];
+    for (var j = 0; j < lists.length; j++) {
+      var list = lists[j];
+      for (var i = 0; i < list.length; i++) {
+        if (list[i] && String(list[i].engine) === n) return !!list[i].reasoning;
+      }
+    }
+    return null;
+  }
+  function reasoningOfEngine(engine) { return reasoningSupportState(engine) === true; }
+  /* 把档位写进下发体：off = 真正关闭思考（noThinking，core 用各引擎官方开关），
+     其余档走 reasoning；引擎不支持时两样都不带。 */
+  function applyReasoningTo(payload, engine, level) {
+    if (!payload || !reasoningOfEngine(engine)) return;
+    var v = level || REASONING_DEFAULT;
+    if (v === 'off') payload.noThinking = true;
+    else payload.reasoning = v;
+  }
+
   function mountConversation(sid, s) {
     /* 同一条会话、同一个空间：组件还活着，画面也还在 —— 直接把这一屏端回来。
        以前这里无条件 destroy() + create() + innerHTML=''，于是「返回列表 → 再点进来」
@@ -3004,6 +4305,8 @@ button.setrow{font-family:inherit}
           （2026-10-22 用户：「排队中的任务重新从会话列表进入就看不到了」）。 */
     if (conv && sid && WS === convWs && sameConvId(sid, convSid)) {
       convSid = sid;                    // 列表那边可能已经从 run_id 切到 session_id
+      /* 同一屏也可能换了别名（run_id ↔ session_id）：思考档位按会话记录重读一次。 */
+      REASONING_CUR = reasoningOnFor(sid, s);
       /* same:true —— 上面已经确认是同一屏会话。组件按字面判 id 会把别名当成
          「换了会话」→ clearQueue() 删掉排队追问（本次报障的病根之一）。 */
       try { conv.setSession(sid, s, { same: true }); } catch (e) {}
@@ -3020,14 +4323,20 @@ button.setrow{font-family:inherit}
        老会话的开关由 teamOnFor / hostingOnFor 从它自己那份记录里取；新会话从「关」起。 */
     TEAM.fresh = false;
     HOSTING.fresh = false;
+    REASONING.fresh = '';
+    /* 这条会话生效的思考档位（没记过 = 最高）。 */
+    REASONING_CUR = reasoningOnFor(sid, s);
     try {
       var transport = wrapTransportForJobs(window.MagicTransportHttp({ base: BASE, token: TOKEN, client: 'mobile' }));
       conv = window.MagicConversation.create({
         el: convEl, transport: transport, titleEl: titleEl, workspace: WS,
         engine: RUN_PREF.engine, model: RUN_PREF.model,
+        /* 主备：新会话立即带上（主引擎失败时 core 自动降级）。 */
+        fallbackEngine: RUN_PREF.fbEngine, fallbackModel: RUN_PREF.fbModel,
         /* 建议功能默认关闭：只有「我的 → 建议引擎」里显式选了引擎才传非空值；
            模型为空 = 引擎默认（建议生成对 llm 用 no-think 变体作默认值）。 */
         suggestEngine: SUGGEST.engine, suggestModel: SUGGEST.model,
+        suggestFallbackEngine: SUGGEST.fbEngine, suggestFallbackModel: SUGGEST.fbModel,
         showPermission: false, showAttach: true, beforeAsk: gateAsk,
         onInterrupt: cancelWaitingAsk,
         /* 组件内排队也要落库（2026-10-21 用户：「非团队的串行排队也没落库」）：
@@ -3063,6 +4372,7 @@ button.setrow{font-family:inherit}
         onEvent: function (ev) {
           bindFreshTeam(ev && ev.session_id);
           bindFreshHosting(ev && ev.session_id);
+          bindFreshReasoning(ev && ev.session_id);
         },
         /* 菜单里的「定时任务」还在，但底部那个 tab 已经删了（2026-10-22 用户：
            「定时任务tab先删除」）。现在点它给一句说明，而不是跳去一张只有一个占位符的页 ——
@@ -3128,7 +4438,7 @@ button.setrow{font-family:inherit}
        而设置面板显示的空间名也跟着串。空 workspace = 默认，同样要写回（写成 ''）。 */
     WS = (s && s.workspace) || '';
     saveWs();
-    showSession(s && s.workspace ? basename(s.workspace) : histSubtitle);
+    showSession(s && s.workspace ? spaceLabel(s.workspace) : histSubtitle);
     mountConversation(sid, s);
     /* 灰白档 = 状态未知（或列表快照过期）：进详情时补拉一次，见 refreshRowStatus。
        其它档（运行中 / 等审批 / 已完成 / 失败 / 已取消）列表已经说清楚了，不必再打一发。 */
@@ -3227,16 +4537,82 @@ button.setrow{font-family:inherit}
       if (!TOKEN) return;                                 // 还没配对，拉也拉不到
       var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
       var seq = CONN_SEQ;
-      fetch(BASE + '/desk/sessions', { headers: hdr })
+      /* 排队 / 运行状态变化也要能触发重绘：旧服务端的排队作业根本不在 /desk/sessions 里；
+         新服务端虽然有登记行（RegisterQueued），但「排队 → 开跑」的占位替换也靠这里
+         把本地那条「等待中」撤掉（见 syncServerJobs）。 */
+      var pList = fetch(BASE + '/desk/sessions', { headers: hdr })
+        .then(function (r) { return r.ok ? r.json() : null; });
+      var pJobs = SERVER_JOBS ? fetch(BASE + '/desk/jobs?limit=200', { headers: hdr })
         .then(function (r) { return r.ok ? r.json() : null; })
-        .then(function (list) {
+        .catch(function () { return null; }) : Promise.resolve(null);
+      Promise.all([pList, pJobs])
+        .then(function (a) {
           if (seq !== CONN_SEQ) return;   // 响应回来时已经切到另一台桌面了
-          if (!Array.isArray(list)) return;
-          if (sessionSig(list) === sessionSig(LAST_SESSIONS)) return;   // 没变 → 不动 DOM
-          loadSessions(true);                            // 变了才走完整刷新（含标题归纳 / 健康），且不许闪
+          var list = a[0];
+          /* 上一帧还是失败态、这次拉通了 → 安静重拉一次把失败块换回列表。
+             不做这个的话，失败态永远不会自己恢复：签名比对里 LAST_SESSIONS 还是旧值，
+             「没变就不重绘」恰好把失败块钉在屏幕上（只能退出重进）。 */
+          if (LIST_FAIL && Array.isArray(list)) { LIST_FAIL = false; loadSessions(true); return; }
+          if (Array.isArray(list) && sessionSig(list) !== sessionSig(LAST_SESSIONS)) {
+            loadSessions(true);          // 变了才走完整刷新（含标题归纳 / 健康），且不许闪
+            return;
+          }
+          if (serverJobsSig(a[1] && a[1].jobs) !== LAST_JOBS_SIG) loadSessions(true);
         }).catch(function () {});
     }, 5000);
   }
+  /* ── 列表加载失败态（2026-10-25）──
+     以前是拼一行灰字「读取会话失败：Failed to fetch」，没有任何出路 —— 重试要退出重进，
+     改地址要去标题菜单找铅笔。现在给一块完整的失败态：图标 + 人话原因 + 可复制地址 +
+     重试 / 编辑环境按钮。 LIST_FAIL 同时是自动恢复的开关（见 startListPoll 的说明）。 */
+  var LIST_FAIL = false;
+  /* 失败原因的中文化：fetch 的网络类失败在 WebView 里就是一句英文 "Failed to fetch"，
+     直接抛给用户读不通。归中文化先例（client-ui/shared/conv/19-attachments.js attErrText）：
+     网络类归成一句人话，HTTP 状态码按常见原因给提示，其余保留原文（截断）。 */
+  function netFailText(why) {
+    var raw = String(why || '').trim();
+    if (/failed to fetch|networkerror|load failed|network error|timed?\s?out|err_(connection|network)/i.test(raw))
+      return '手机和桌面端可能不在同一个网络，或桌面端没在运行。';
+    if (/HTTP\s*40[13]/i.test(raw))
+      return '配对令牌不对或已失效，重新配对试试。';
+    if (/HTTP\s*404/i.test(raw))
+      return '桌面端服务不存在，版本可能太旧，去桌面端升级一下。';
+    if (/HTTP\s*5\d\d/i.test(raw))
+      return '桌面端服务出错了，看看桌面端的日志。';
+    return raw ? shortReason(raw, 80) : '连接失败。';
+  }
+  function paintListFail(why, addr) {
+    LIST_FAIL = true;
+    var box = hEl('div', 'netfail');
+    var ico = hEl('span', 'netfail__ico');
+    ico.appendChild(svgUse('#i-plug', 26));
+    box.appendChild(ico);
+    box.appendChild(hEl('div', 'netfail__t', '连不上桌面端'));
+    var whyEl = hEl('div', 'netfail__why', netFailText(why));
+    /* 完整原文挂 title：长按/悬停能看到浏览器原始报错（与排队行 stalled 同一口径）。 */
+    if (why) whyEl.title = String(why);
+    box.appendChild(whyEl);
+    /* 地址必须带上（失败要能定位到「打的是哪里」），点按即复制，方便去桌面端核对。 */
+    if (addr) {
+      var addrEl = hEl('button', 'netfail__addr', addr);
+      addrEl.type = 'button';
+      addrEl.title = '点按复制地址';
+      addrEl.onclick = function () { copyText(addr, '地址已复制'); };
+      box.appendChild(addrEl);
+    }
+    var acts = hEl('div', 'netfail__acts');
+    var retry = hEl('button', 'btn btn--filled', '重试');
+    retry.type = 'button';
+    retry.onclick = function () { loadSessions(); };
+    acts.appendChild(retry);
+    var cur = activeConn();
+    var edit = hEl('button', 'btn btn--outlined', '编辑环境');
+    edit.type = 'button';
+    edit.onclick = function () { openEnvEditor(cur); };
+    acts.appendChild(edit);
+    box.appendChild(acts);
+    historyList.replaceChildren(box);
+  }
   function loadSessions(quiet) {
     var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
     var seq = CONN_SEQ;   // 切环境后旧请求可能才回来：序号对不上就不许改这一台的画面
@@ -3254,8 +4630,14 @@ button.setrow{font-family:inherit}
       .then(function (r) { return r.ok ? r.json() : {}; }).catch(function () { return {}; });
     var pDirs = fetch(BASE + '/desk/dirs', { headers: hdr })
       .then(function (r) { return r.ok ? r.json() : {}; }).catch(function () { return {}; });
-    Promise.all([pList, pTitles, pHealth, pDirs]).then(function (a) {
+    /* 服务端作业队列：新服务端**受理即登记**（排队行已经在 /desk/sessions 里），旧服务端
+       还没登记 —— 这份快照是那种情况下的兜底（见 syncServerJobs，命中登记表的会跳过）。
+       老服务端 404 → null，整段自然跳过。 */
+    var pJobs = fetch(BASE + '/desk/jobs?limit=200', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
+    Promise.all([pList, pTitles, pHealth, pDirs, pJobs]).then(function (a) {
       if (seq !== CONN_SEQ) return;
+      LIST_FAIL = false;   // 拉通了：失败态到此为止（手动重试成功也要清，否则轮询会多做一次冗余重拉）
       TITLES = a[1] || {};
       DW = (a[2] && a[2].defaultWorkspace) || '';
       DW_READY = true;
@@ -3290,6 +4672,11 @@ button.setrow{font-family:inherit}
       });
       paintTeamPref();
       ROOT_DIRS = (((a[3] && a[3].dirs) || [])).filter(function (d) { return String(d.name).indexOf('magic-') === 0; });
+      /* 服务端排队作业并进列表（见 syncServerJobs 的说明）。必须排在 renderSessions
+         **之前**：它改的是 PENDING，用户看到的第一帧就该带着「等待中」那几行。
+         会话清单一起传：判断某条作业「跑起来了没」要看登记表（见 jobLanded）。 */
+      LAST_JOBS_SIG = serverJobsSig(a[4] && a[4].jobs);
+      syncServerJobs(a[4] && a[4].jobs, Array.isArray(a[0]) ? a[0] : null);
       renderSessions(Array.isArray(a[0]) ? a[0] : []);
       /* 排队任务的接续要等 DW 到手（空间键靠它归一）—— 首次列表到手正是这个时刻。
          幂等：QUEUE_RESTORED 保证只接一次。之前若因 DW 未就绪被跳过，这里补上。 */
@@ -3308,9 +4695,7 @@ button.setrow{font-family:inherit}
       /* 失败原因要带上**实际打的地址**：Photo/WebView 里 "Failed to fetch" 只说「没连上」，
          而真正的原因通常是「这台手机到那个 IP 不通」（换了网络 / 环境里存的是别的网段）。
          不写地址的话，用户和应用都无从判断该改哪一边。 */
-      var why = (e && e.message ? e.message : String(e));
-      var addr = BASE || location.origin || '(同源)';
-      historyList.innerHTML = '<div class="history__hint">读取会话失败：' + why + '<br>地址：' + addr + '</div>';
+      paintListFail(e && e.message ? e.message : String(e), BASE || location.origin || '(同源)');
     });
   }
   /* ── 会话列表：**置顶 / 任务 / 空间** 三段（对齐截图）──
@@ -3319,6 +4704,10 @@ button.setrow{font-family:inherit}
      任务：最近会话（默认前 8，可「展开更多」）；
      空间：会话里出现过的 workspace（点行=按空间筛选任务，＋=在该空间新建）。 */
   var LAST_SESSIONS = [];
+  /* 上一次看到的服务端作业队列签名（见 serverJobsSig / startListPoll）：
+     排队中的任务在旧服务端上不会进 /desk/sessions（新服务端受理即登记，见 core 的
+     RegisterQueued），只比会话签名的话队列入队 / 出队都不会重绘。 */
+  var LAST_JOBS_SIG = '';
   var SEC_COLLAPSED = {};
   var TASKS_EXPANDED = false;
   var WS_OPEN = {};
@@ -3338,19 +4727,69 @@ button.setrow{font-family:inherit}
   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 = []; }
+  try { CUSTOM_SPACES = normSpaces(JSON.parse(localStorage.getItem('magic.spaces') || '[]')); } catch (e) { CUSTOM_SPACES = []; }
+  /* 自定义空间：每项 = {path, alias}。alias = 用户给这个目录起的**显示名**（可以为空）。
+     ⚠️ 显示口径统一走 spaceLabel()：**有别名显示别名，没有就显示最后一级文件夹名，
+        永远不显示整条路径** —— /Users/x/work/某某项目 这种一长串路径在手机上一行放不下，
+        用户扫一眼也认不出「到底是哪个目录」（用户 2026-10-24：「否则显示最后1级的文件夹不要路径」）。
+     ⚠️ 老数据（'magic.spaces' 里）是**纯路径字符串数组**：读的时候归一化成 {path, alias:''}，
+        写回去也是对象数组。服务端 /desk/prefs 只当不透明字符串存（不解析里面的形状），
+        所以改形状不动契约（CLIENT-CONTRACT §移动端环境配置：字段由移动端定义）。 */
+  function normSpaces(v) {
+    var arr = Array.isArray(v) ? v : [];
+    var out = [], seen = {};
+    arr.forEach(function (it) {
+      var p = (it && typeof it === 'object') ? String(it.path || '') : String(it || '');
+      if (!p) return;
+      p = reqNormDir(p);          // 统一分隔符 + 去尾斜杠：与服务端登记的 workspace 同一口径，
+      if (!p || seen[spaceKey(p)]) return;  // 否则同一个空间会在列表里出现两行
+      seen[spaceKey(p)] = 1;
+      out.push({ path: p, alias: (it && typeof it === 'object') ? String(it.alias || '') : '' });
+    });
+    return out;
+  }
   function saveSpaces() { try { localStorage.setItem('magic.spaces', JSON.stringify(CUSTOM_SPACES)); } catch (e) {} schedulePushPrefs(); }
+  /* 某个路径是不是自定义空间：是就返回那一项（带 alias），不是返回 null。
+     ⚠️ 比路径前先归一（分隔符 + 尾斜杠 + 盘符大小写）：用户手输的「/work/proj/」
+        与服务端登记的「\work\proj」是同一个空间，别名得认得出。 */
+  function customSpaceOf(p) {
+    var k = spaceKey(p);
+    for (var i = 0; i < CUSTOM_SPACES.length; i++) { if (spaceKey(CUSTOM_SPACES[i].path) === k) return CUSTOM_SPACES[i]; }
+    return null;
+  }
+  /* 空间显示名：别名 > 最后一级文件夹名（**不显示路径**）。 */
+  function spaceLabel(p) {
+    var it = customSpaceOf(p);
+    if (it && it.alias) return it.alias;
+    return basename(p) || String(p || '');
+  }
   /* 空间候选 = 根目录下的 magic-* + 自定义 + 会话里出现过的 workspace（去重、保序）。
+     ⚠️ 去重要按**比较口径**（spaceKey）而不是原字符串：服务端给的是 Windows 原样
+        （D:\workspace\x），自定义空间是归一后的（D:/workspace/x）—— 同一个目录会
+        以两种写法各出现一次，列表里多出一行重复项（用户会以为有两个空间）。
      ⚠️ 会话的 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); } }
+    function add(p) {
+      if (!p) return;
+      var k = spaceKey(p);
+      if (seen[k]) return;
+      seen[k] = 1;
+      out.push(p);
+    }
     (ROOT_DIRS || []).forEach(function (d) { add(d.path); });
-    CUSTOM_SPACES.forEach(add);
-    (LAST_SESSIONS || []).forEach(function (s) { add(s && s.workspace); });
+    CUSTOM_SPACES.forEach(function (s) { add(s.path); });
+    (LAST_SESSIONS || []).forEach(function (s) {
+      /* 会话带来的 workspace 要过 isRealSpaceDir：团队轮次目录（<空间>/.magic/team/run-x
+         及其下的 a1/t1 子代理目录）是这一轮的临时工作区，跑完就没 —— 混进选择器后
+         既不是自定义空间（没有 ✕ 可删）也打不开，用户以为「删不掉」
+         （2026-10-24 报「两个 t1 删不掉」，口径与需求页 isRealSpaceDir 一致）。 */
+      if (!isRealSpaceDir(s && s.workspace)) return;
+      add(s.workspace);
+    });
     return out;
   }
   /* 会话里哪些是**顶层会话**（不是别人的子会话）。
@@ -3374,10 +4813,20 @@ button.setrow{font-family:inherit}
       return !(pk && pk !== sidOf(s));
     });
   }
-  /* 路径归一：只去尾部斜杠，不做 realpath —— 与 core 登记表里的 workspace 同一口径。
-     任务页 / 需求页共用（需求页已拆到 reqs.js，那边自带一份同名实现；这里留着
-     是因为 isRealSpaceDir / isTeamRunDir 还服务于任务页的空间分组）。 */
-  function reqNormDir(p) { return String(p || '').replace(/\/+$/, ''); }
+  /* 路径归一：**统一分隔符 + 去尾部斜杠**。
+     ⚠️ 必须统一 '\\' → '/'：桌面可能是 Windows，路径是 D:\workspace\magic-agent，
+        而用户手输的往往是 D:/workspace/magic-agent —— 两者是同一个目录，
+        不归一就认不出是同一个空间（别名贴不上、勾打不上、需求页空间数对不上）。
+        注意这只是**比较口径**，不改要发给 core 的原路径（core 自己会 Abs/Clean）。
+     ⚠️ 需求页（reqs.js）自带一份同名实现 —— 改动两处要同步，否则两页口径就分叉了。 */
+  function reqNormDir(p) { return String(p || '').replace(/\\/g, '/').replace(/\/+$/, ''); }
+  /* 空间键（比较用）：在归一之上再修**盘符大小写**。
+     Windows 上 d: 与 D: 是同一个盘（用户手输常常是小写），但路径其余部分大小写敏感
+     —— Linux 上 Foo 与 foo 是两个目录，不能一起小写。 */
+  function spaceKey(p) {
+    var s = reqNormDir(p);
+    return s.replace(/^([a-z]):/, function (m, d) { return d.toUpperCase() + ':'; });
+  }
   /* 一个目录算不算「空间」：得是**用户认得的工作区**。
      根目录 / 不是空间（哪怕历史上有会话在那儿跑过）—— 需求页显示它只会让人
      以为「/ 是个项目」（用户 2026-10-22：「没有空间的不需要」）。
@@ -3390,7 +4839,9 @@ button.setrow{font-family:inherit}
     return true;
   }
   /* 团队模式的运行目录：<空间>/.magic/team/run-xxx[/子代理目录]。
-     这些是团队**这一轮**的工作区，跑完就没了 —— 不是用户意义上的空间。 */
+     这些是团队**这一轮**的工作区，跑完就没了 —— 不是用户意义上的空间。
+     ⚠️ 用归一后的路径来判：桌面可能是 Windows，团队运行目录是
+        D:\work\x\.magic\team\run-1 —— 不统一分隔符就认不出，需求页会把它当真空间。 */
   function isTeamRunDir(dir) {
     var d = reqNormDir(dir);
     return d.indexOf('/.magic/team/') >= 0;
@@ -3407,7 +4858,7 @@ button.setrow{font-family:inherit}
      （它确实跑在那儿：core 用调用方 cwd）。 */
   function projectOf(s) {
     var w = (s && s.workspace) || DW || '';
-    return w ? basename(w) : '';
+    return w ? spaceLabel(w) : '';
   }
   /* 搜索口径：标题 / 工程名 / 引擎 / 模型 / 首问，任一处命中即可（大小写不敏感）。 */
   function taskMatches(s) {
@@ -3478,6 +4929,38 @@ button.setrow{font-family:inherit}
   }
   /* 列表分段用：手动置顶 ∪ 运行中自动置顶。 */
   function isListPinned(s) { return isPinned(s) || isAutoPinned(s); }
+  /* ── 列表去重：排队条目该不该自己占一行 ──
+     ROW_IDS = 这一次列表里已经画出来的会话 id（含 run_id / session_id 两种写法）；
+     LIST_ALIAS = 两种写法 → 规范 id（session_id 优先），与 renderSessions 里认父的
+     KEY2SID、pendingOfConv 的 sameConvId 是**同一套别名口径**。
+     ⚠️ 必须按别名判（2026-10-24 用户：「临时置顶也有重复显示」）：排队条目里的
+        `p.session` 是**提交那一刻**手里的 id —— 那会儿引擎还没吐出 session_id，
+        存进去的是 run_id；而会话行的 sidOf 早已换成 session_id。只比字面就把同一个
+        会话认成两条：运行中的那条自动置顶进「置顶」段，排队那条又在「任务 / 空间」里
+        画一行「追问排队中」—— 用户看到的就是「置顶里有一条，下面还重复一条」。 */
+  var ROW_IDS = {}, LIST_ALIAS = {};
+  function buildRowIds(rows) {
+    ROW_IDS = {}; LIST_ALIAS = {};
+    (rows || []).forEach(function (s) {
+      var sid = sidOf(s);
+      if (!sid) return;
+      ROW_IDS[sid] = 1; LIST_ALIAS[sid] = sid;
+      if (s.run_id) { ROW_IDS[String(s.run_id)] = 1; LIST_ALIAS[String(s.run_id)] = sid; }
+      if (s.session_id) { ROW_IDS[String(s.session_id)] = 1; LIST_ALIAS[String(s.session_id)] = sid; }
+    });
+  }
+  /* 排队条目归属哪条会话行（空 = 新任务，不属于任何已有会话）。 */
+  function pendOwnerKey(p) {
+    if (!p || !p.session) return '';
+    var id = String(p.session);
+    return String(LIST_ALIAS[id] || id);
+  }
+  /* true = 列表里已有它的会话行 → 不单独占一行，只在那行上挂「追问排队中」角标。 */
+  function pendOwnedByRow(p) {
+    var key = pendOwnerKey(p);
+    if (key) return !!ROW_IDS[key];
+    return !!(ROW_IDS[p.id] || (p.job && ROW_IDS[p.job]));
+  }
   /* 置顶段 / 搜索结果的排序：**人工置顶在前 → 运行中自动置顶 → 普通**，同类按 updated_at 倒序。
      用户 2026-10-22 定稿：「应该在人工置顶的后面」—— 自动置顶只是临时把在跑的活提上来，
      不能压过用户自己钉的会话；跑完 isAutoPinned 变 false，它回到普通分段。 */
@@ -3499,6 +4982,10 @@ button.setrow{font-family:inherit}
     if (rowScrimEl) { rowScrimEl.remove(); rowScrimEl = null; }
   }
   function openRowMenu(anchorEl, s) {
+    /* 排队行是**预登记**（core 的 RegisterQueued）：改名 / 置顶都会落在临时 id 上，
+       真开跑后 id 换成 core 的 run_id，这些操作全部失效；「删除」也只删登记占位、
+       停不掉作业。与其给一组骗人的动作，不如明说它在排队。 */
+    if (statusOf(s) === 'queued') { toast('排队中 · 轮到时自动开始'); return; }
     closeRowMenu();
     rowScrimEl = document.createElement('div'); rowScrimEl.className = 'rowmenu__scrim';
     rowScrimEl.onclick = closeRowMenu;
@@ -3614,18 +5101,27 @@ button.setrow{font-family:inherit}
        waiting_approval     → wait  琥珀（活着的等待）
        done / idle          → done  绿（idle = 常驻会话本轮跑完、进程还在等追加，
                                     与 PC 左栏的「已完成」同口径）
-       failed / gone        → fail  红（gone = 记录写着在跑、进程已不在）
+       failed               → fail  红（引擎报错结束）
+       gone                 → stop  石褐（记录写着在跑、进程已不在 —— 服务重启 / 终端
+                                    关闭把它带走了，是**断连**，不是引擎故障）
        cancelled / interrupted → stop 石褐（人为收工 / 被打断，不是故障）
        其它（空 / 陌生值）  → idle  灰白兜底
      ⚠️ 2026-10-23 之前 failed / cancelled / gone 全落进 idle，列表上是一片白 ——
-        用户分不清「正常结束」和「挂了」（报障：「这两个会话为什么是白色」）。 */
+        用户分不清「正常结束」和「挂了」（报障：「这两个会话为什么是白色」）。
+     ⚠️ 2026-10-24 用户：「会话全部断连 红色」—— gone 曾被并进红档，于是服务重启
+        一次就把所有被带走的会话涂成故障色。gone 与 failed 必须分开：前者是中断，
+        后者才是失败。 */
   function statusOf(s) {
     var st = String((s && (s.status || s.state)) || '');
     if (st === 'running' || s.alive === true) return 'run';
     if (st === 'waiting_approval') return 'wait';
+    /* queued：已受理、还没开跑（服务端作业队列的预登记，见 core 的 RegisterQueued）。
+       它不是「没发生过」的灰白行 —— 用户刚发出去、正在排队，要看得见（紫色等待样式，
+       与列表里那条「等待中」同一个视觉语言）。 */
+    if (st === 'queued') return 'queued';
     if (st === 'done' || st === 'idle') return 'done';
-    if (st === 'failed' || st === 'gone') return 'fail';
-    if (st === 'cancelled' || st === 'interrupted' || st === 'stopped') return 'stop';
+    if (st === 'failed') return 'fail';
+    if (st === 'gone' || st === 'cancelled' || st === 'interrupted' || st === 'stopped') return 'stop';
     return 'idle';
   }
   /* 会话行图标：团队会话=双人图形（mode:"team"），其余**设备形状按来源端**
@@ -3733,7 +5229,14 @@ button.setrow{font-family:inherit}
     if (kids.length && kidsOpenOf(sid)) {
       var box = document.createElement('div');
       box.className = 'sblock__kids';
-      kids.forEach(function (k) { box.appendChild(sessionRow(k, true)); });
+      /* 每个子行单独包一层：折线的竖段 / 肘段画在 .sblock__kid 的伪元素上
+         （末行只画到中点，收口成 └）。 */
+      kids.forEach(function (k) {
+        var branch = document.createElement('div');
+        branch.className = 'sblock__kid';
+        branch.appendChild(sessionRow(k, true));
+        box.appendChild(branch);
+      });
       wrap.appendChild(box);
     }
     return wrap;
@@ -3743,14 +5246,16 @@ button.setrow{font-family:inherit}
     b.type = 'button'; b.className = 'srow' + (sub ? ' srow--sub' : '');
     b.setAttribute('data-sid', sidOf(s));   // ensureTitle 就地改标题时要按 id 找这一行
     var run = statusOf(s) === 'run';
+    var queued = statusOf(s) === 'queued';
     b.appendChild(sessionIcon(s));
     var col = elSpan('srow__col');
     col.appendChild(elSpan('srow__t', titleOf(s)));
     var sid = sidOf(s);
-    /* 副标题 = 引擎 · 模型；运行中换成「运行中 · 第 N 步」。
+    /* 副标题 = 引擎 · 模型；运行中换成「运行中 · 第 N 步」，排队中说明还在等。
        进度只改这一个文本节点（RUN_ROWS.subEl 指向它）。 */
     var subEl = elSpan('srow__s', run ? runningSub(s, RUN_STEPS[sid] || 0)
-                                       : [s.engine || '', qaModelText(s.model)].filter(Boolean).join(' · '));
+      : queued ? '等待中 · 上一个完成后自动开始'
+      : [s.engine || '', qaModelText(s.model, s.engine)].filter(Boolean).join(' · '));
     col.appendChild(subEl);
     /* 排队与团队标记都不在这里做：两者都做在图标里（见 sessionIcon），行尾不再挂角标。 */
     b.appendChild(col);
@@ -3812,7 +5317,13 @@ button.setrow{font-family:inherit}
        （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); };
+    b.onclick = function () {
+      if (lp) { lp = false; return; }
+      /* 排队行还没有会话日志（真开跑才有）—— 点开只会是一张空白页。
+         如实说一句，等它轮到了列表自己会换成真正的会话行。 */
+      if (queued) { toast('排队中 · 轮到时自动开始'); return; }
+      openSession(sidOf(s), s);
+    };
     return b;
   }
   /* 空间组：标题行 = 「📁 空间名 · 引擎 ⌄ +」，展开就把该空间的会话内联列在下面。 */
@@ -3825,7 +5336,7 @@ button.setrow{font-family:inherit}
     var eng = '';
     for (var i = 0; i < list.length; i++) { if (list[i] && list[i].engine) { eng = String(list[i].engine); break; } }
     var waiting = list.filter(function (x) { return x && x.pendingWait; }).length;
-    tog.appendChild(elSpan('wsrow__l', basename(key) + (eng ? ' · ' + eng : '')));
+    tog.appendChild(elSpan('wsrow__l', spaceLabel(key) + (eng ? ' · ' + eng : '')));
     /* 折叠状态也要看得见「这个空间有任务在排队」—— 徽标不随展开/折叠消失。 */
     if (waiting) tog.appendChild(elSpan('wsrow__badge', waiting + ' 等待中'));
     /* 默认展开规则：组里有等待中的任务就展开（否则它藏在折叠组里 = 用户以为没显示）；
@@ -3871,10 +5382,74 @@ button.setrow{font-family:inherit}
       if (s.run_id) KEY2SID[s.run_id] = sid;
       if (s.session_id) KEY2SID[s.session_id] = sid;
     });
+    /* ── 同一会话的多张记录并成一组 ──
+       团队主会话**每轮都会换 session_id**（第 2 轮记录里的 session_id 可能是第 1 轮的
+       run_id，第 3 轮又换成一个新 UUID），而子任务的两根父指针分别指向不同轮：
+       `parent_run_id` = 这一轮的主 run，`parent_session_id` = 上一轮留下的会话 id。
+       只按 sidOf 去重，同一会话的两轮就各画一行 —— 运行中的那条自动进「置顶」，
+       旧的那条（done）落「任务」，看着就是「临时置顶的会话显示两个」
+       （2026-10-24 用户报障）。这里用子任务的**两根父指针**把两轮并成一组。 */
+    var UF = {};
+    function ufFind(x) {
+      if (!x) return '';
+      if (UF[x] === undefined) { UF[x] = x; return x; }
+      var p = x;
+      while (UF[p] !== p) p = UF[p];
+      while (UF[x] !== p) { var n = UF[x]; UF[x] = p; x = n; }
+      return p;
+    }
+    function ufUnion(a, b) {
+      var ra = ufFind(a), rb = ufFind(b);
+      if (ra && rb && ra !== rb) UF[rb] = ra;
+    }
+    rows.forEach(function (s) { ufFind(sidOf(s)); });
+    rows.forEach(function (s) {
+      var a = KEY2SID[s.parent_session_id || ''] || '';
+      var b = KEY2SID[s.parent_run_id || ''] || '';
+      if (a && b && a !== b) ufUnion(a, b);
+    });
+    /* 每组只显示**一条**：人工置顶优先 → 活着（运行中 / 等审批）→ updated_at 新。
+       ⚠️ 人工置顶排第一是为了「钉的是哪一轮就显示哪一轮」—— 否则折叠后用户会以为置顶掉了。 */
+    function rowRank(s) {
+      var rank = isPinned(s) ? 4 : 0;
+      var st = statusOf(s);
+      if (st === 'run') rank += 2; else if (st === 'wait') rank += 1;
+      return rank;
+    }
+    var groupBest = {};
+    rows.forEach(function (s) {
+      var g = ufFind(sidOf(s));
+      var cur = groupBest[g];
+      if (!cur) { groupBest[g] = s; return; }
+      var rs = rowRank(s), rc = rowRank(cur);
+      if (rs > rc) { groupBest[g] = s; return; }
+      if (rs === rc && String(s.updated_at || s.started_at || '')
+        .localeCompare(String(cur.updated_at || cur.started_at || '')) > 0) groupBest[g] = s;
+    });
+    var GROUP_KEY = {};   // 组根 → 显示那条的 sid
+    Object.keys(groupBest).forEach(function (g) { GROUP_KEY[g] = sidOf(groupBest[g]); });
+    function groupKeyOfId(id) {
+      var sid = KEY2SID[id || ''] || '';
+      if (!sid) return '';
+      return GROUP_KEY[ufFind(sid)] || '';
+    }
+    /* 所有 id（各轮的 run_id / session_id）→ 组里显示那条的 sid：认父、「排队追问」都按它。
+       子会话自己的 id 不进来 —— 它只在父行展开时出现，排队追问仍要能单独看见。 */
+    var GROUP_ALIAS = {};
+    rows.forEach(function (s) {
+      var sid = sidOf(s);
+      var own = GROUP_KEY[ufFind(sid)] || sid;
+      var pk = groupKeyOfId(parentKeyOf(s));
+      if (pk && pk !== own) return;         // 子会话
+      GROUP_ALIAS[sid] = own;
+      if (s.run_id) GROUP_ALIAS[s.run_id] = own;
+      if (s.session_id) GROUP_ALIAS[s.session_id] = own;
+    });
     CHILD_OF = {}; CHILD_IDS = {};
     var top = [];
     rows.forEach(function (s) {
-      var pk = KEY2SID[parentKeyOf(s)] || '';
+      if (groupBest[ufFind(sidOf(s))] !== s) return;   // 同组的其他轮不单独显示
+      var pk = GROUP_ALIAS[parentKeyOf(s)] || '';
       if (pk && pk !== sidOf(s)) {
         (CHILD_OF[pk] = CHILD_OF[pk] || []).push(s);
         CHILD_IDS[sidOf(s)] = 1;
@@ -3894,13 +5469,24 @@ button.setrow{font-family:inherit}
        宁可多一行也不能让排队的任务从界面上消失（那正是上次报障「排队任务丢了」）。
        ⚠️ 这段必须排在**渲染置顶之前**：置顶行也是 sessionRow，算晚了角标就丢了。 */
     var PEND_VIS = PENDING.filter(function (p) { return !p.hide; });
-    var rowIds = {};
     FUP = {};                     // 模块级：sessionRow 要用（见其上方注释）
-    rows.forEach(function (s) { rowIds[sidOf(s)] = 1; });
+    /* 「这一行在不在列表里」按别名表判（见 buildRowIds / pendOwnedByRow 的说明）——
+       运行中自动置顶的那条与它的排队追问必须落在**同一行**上。 */
+    buildRowIds(rows);
+    /* 折叠掉的旧轮 / 各轮别名也要算「这一行已经在列表里」：排队条目手里可能是旧轮的 id。 */
+    Object.keys(GROUP_ALIAS).forEach(function (id) {
+      if (!id || !GROUP_ALIAS[id]) return;
+      ROW_IDS[id] = 1;
+      LIST_ALIAS[id] = GROUP_ALIAS[id];
+    });
     PEND_VIS.forEach(function (p) {
-      if (p.session && rowIds[p.session]) (FUP[p.session] = FUP[p.session] || []).push(p);
+      var key = pendOwnerKey(p);
+      if (key && ROW_IDS[key]) (FUP[key] = FUP[key] || []).push(p);
     });
-    var PEND_ROWS = PEND_VIS.filter(function (p) { return !p.session || !rowIds[p.session]; });
+    /* 服务端已先登记的排队作业（core 的 RegisterQueued，run_id = request_id / job id）：
+       会话行已经把这条画出来了（state=queued），本地这条就不要再占一行 ——
+       两行会让用户以为发重了（与「追问排队不占一行」同一个口径）。 */
+    var PEND_ROWS = PEND_VIS.filter(function (p) { return !pendOwnedByRow(p); });
     /* 一次性构建到 DocumentFragment，最后 replaceChildren 单次替换 —— 无「先清空」的中间空态，
        所以删除、折叠、展开等重绘都不闪。 */
     var frag = document.createDocumentFragment();
@@ -3971,11 +5557,17 @@ button.setrow{font-family:inherit}
       }
     }
 
-    /* 空间：按 workspace 分组（且未置顶的会话） */
+    /* 空间：按 workspace 分组（且未置顶的会话）。
+       ⚠️ 分组键用**归一后的空间键**（spaceKey）：服务端登记的 workspace 是
+          D:\workspace\x，而用户选的自定义空间是归一后的 D:/workspace/x ——
+          按原字符串分组，同一个目录会裂成两个空间组，组头显示的还是同一个
+          文件夹名（用户看到两个同名空间，以为有两个项目）。
+          下发给 core 的路径另有 p.w（**原样**，见 addPending 的说明），不受影响。 */
     var bySpace = {};
     rest.forEach(function (s) {
       var w = s.workspace; if (!w) return;
-      (bySpace[w] = bySpace[w] || []).push(s);
+      var k = spaceKey(w);
+      (bySpace[k] = bySpace[k] || []).push(s);
     });
     /* 等待中的新任务：显式空间 → 放进该空间组**最上面**（状态最需要被看见）。
        不能只靠上面的 rest 建 key：某空间只有排队任务、还没有任何会话时，bySpace 里
@@ -3983,7 +5575,8 @@ button.setrow{font-family:inherit}
        用 PEND_ROWS 而不是 PEND_VIS：并进原会话行的追问不该再在空间组里插一行。 */
     PEND_ROWS.forEach(function (p) {
       if (!p.explicit || !p.ws) return;
-      (bySpace[p.ws] = bySpace[p.ws] || []).unshift(p);
+      var k = spaceKey(p.ws);
+      (bySpace[k] = bySpace[k] || []).unshift(p);
     });
     /* 空间排序键：组内最新一条会话的 updated_at；组里只有排队任务时用它的 at。
        混入排队行后不能再用 bySpace[key][0].updated_at（第一条可能是排队行，没有该字段）。 */
@@ -4019,7 +5612,11 @@ button.setrow{font-family:inherit}
     document.removeEventListener('keydown', onHostKey, true);
   }
   function hEl(tag, cls, text) { var n = document.createElement(tag); if (cls) n.className = cls; if (text != null) n.textContent = text; return n; }
-  function basename(p) { var s = String(p || '').split('/').filter(Boolean); return s.pop() || String(p); }
+  /* 取最后一级文件名/目录名。
+     ⚠️ 必须同时按 '/' 与 '\\' 切：桌面可能是 Windows，路径是 D:\workspace\magic-agent，
+        只按 '/' 切会切不动 —— 整条路径被当成名字显示，「只显示最后一级」这条要求等于没做
+        （用户 2026-10-24：「否则显示最后1级的文件夹不要路径」）。 */
+  function basename(p) { var s = String(p || '').replace(/\\/g, '/').split('/').filter(Boolean); return s.pop() || String(p); }
 
   /* ══════════ 产物阅读（产物卡「查看」）══════════
      PC 宿主自己绑了点击 → 右侧标签栏；移动端此前没人接这一下，所以「查看」点了没反应。
@@ -4103,8 +5700,18 @@ button.setrow{font-family:inherit}
       }
       var text = String(r.text == null ? '' : r.text);
       if (/\.(?:md|markdown)$/i.test(abs) && typeof mdToHtmlOnly === 'function') {
+        /* 需求文档里的「页面完成情况」截图写的是**本机绝对路径**
+           （core 落盘在 ~/.magic-agent/requirements/… 下）。
+           ⚠️ 直接进 markdown 渲染会被 DOMPurify 的协议白名单**摘掉 src**
+           （默认只放行 http/https/mailto/tel/cid/xmpp）—— 界面上只剩一枚破图。
+           所以先改写成 <img data-reqshot="绝对路径">（data-* 消毒放行），
+           渲染后再把 src 补成回读地址。 */
+        var mdText = text;
+        if (window.MagicReqShot && window.MagicReqShot.rewriteShotImages) {
+          try { mdText = window.MagicReqShot.rewriteShotImages(text); } catch (e) {}
+        }
         var box = hEl('div', 'md-body');
-        try { box.innerHTML = mdToHtmlOnly(text); } catch (e) { box.textContent = text; }
+        try { box.innerHTML = mdToHtmlOnly(mdText); } catch (e) { box.textContent = text; }
         rdBody.appendChild(box);
         if (typeof highlightIn === 'function') { try { highlightIn(box); } catch (e) {} }
         /* 文档里的本机图片：换成回读地址（移动端 fileUrl 自带 w=480，慢网也出得来）。 */
@@ -4115,6 +5722,13 @@ button.setrow{font-family:inherit}
             var u = window.desk.mediaUrl(src.replace(/^file:\/\//, ''));
             if (u) im.src = u;
           });
+          /* 需求截图：src 在 data-reqshot 里（见上面的注释）。 */
+          Array.prototype.forEach.call(box.querySelectorAll('img[data-reqshot]'), function (im) {
+            var p = im.getAttribute('data-reqshot') || '';
+            if (!p) return;
+            var u = window.desk.mediaUrl(p);
+            if (u) im.src = u;
+          });
         }
       } else {
         var pre = document.createElement('pre');
@@ -4172,8 +5786,12 @@ button.setrow{font-family:inherit}
     build(body);
   }
   /* selected：当前生效项打勾。**必须画出来**——底部抽屉关掉再开只需要一眼，不需要
-     用户记住上次点了哪一行；没有勾时「点了没反应」和「点了已生效」长得一模一样。 */
-  function hRow(body, label, value, onClick, danger, selected) {
+     用户记住上次点了哪一行；没有勾时「点了没反应」和「点了已生效」长得一模一样。
+     action：可选的**行内小动作**（自定义空间的「✎ 改名」/「✕ 删除」）。传数组 = 多个动作并列。
+     ⚠️ 行本身是 <button>，里面**不能再塞 <button>**（HTML 不允许嵌套按钮，浏览器解析时
+        会把外层按钮提前闭合，小动作就没了）—— 所以动作渲染成 <span role="button">，
+        点它时 stopPropagation，免得顺手把整行也点了（整行 = 选中这个空间）。 */
+  function hRow(body, label, value, onClick, danger, selected, action) {
     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';
@@ -4183,15 +5801,30 @@ button.setrow{font-family:inherit}
       if (danger) v.style.color = 'var(--error-text)';
       b.appendChild(v);
     }
+    (Array.isArray(action) ? action : (action ? [action] : [])).forEach(function (act) {
+      if (!act) return;
+      var a = hEl('span', 'pick__act', act.label);
+      a.setAttribute('role', 'button');
+      a.setAttribute('aria-label', act.title || act.label);
+      a.onclick = function (e) {
+        if (e && e.stopPropagation) e.stopPropagation();
+        if (e && e.preventDefault) e.preventDefault();
+        act.onClick();
+      };
+      b.appendChild(a);
+    });
     if (onClick) { b.appendChild(hEl('span', 'pick__chev', '›')); b.onclick = onClick; }
     else { b.style.cursor = 'default'; }
     body.appendChild(b);
   }
-  /* 单行文本输入抽屉（重命名 / 自定义路径共用）。
+  /* 单行文本输入抽屉（重命名 / 自定义路径 / 空间别名共用）。
      ⚠️ **不用 window.prompt**：悬浮球（Electron 小窗）与 Android WebView 都没实现它，
         调用只会静默返回 null —— 表现就是「点击无效」且抽屉原样不动（2026-10-23 报障）。
         这里换成抽屉里的真输入框，样式沿用启动页那套 .field / .btn；空值给红字提示，
-        不再静默 return（否则和上面的 bug 长得一模一样）。 */
+        不再静默 return（否则和上面的 bug 长得一模一样）。
+     opt.allowEmpty：允许空值（**别名留空 = 不用别名**，不是错误）。
+     opt.secondary：第二个输入框（自定义空间的「别名」）。有它时 onOk 收到两个值
+        (主值, 次值)；没有时 onOk 仍只收到一个值 —— 老调用方不受影响。 */
   function openTextInputSheet(opt, onOk) {
     openHostSheet(opt.title || '', function (body) {
       var f = hEl('div', 'field');
@@ -4206,13 +5839,30 @@ button.setrow{font-family:inherit}
       body.appendChild(f);
       var err = hEl('div', 'field__err'); err.hidden = true;
       body.appendChild(err);
+      var inp2 = null;
+      if (opt.secondary) {
+        var f2 = hEl('div', 'field');
+        var lab2 = document.createElement('label');
+        lab2.textContent = opt.secondary.label || '';
+        f2.appendChild(lab2);
+        inp2 = document.createElement('input');
+        inp2.type = 'text';
+        inp2.value = opt.secondary.value || '';
+        if (opt.secondary.placeholder) inp2.placeholder = opt.secondary.placeholder;
+        inp2.setAttribute('autocapitalize', 'off');
+        inp2.setAttribute('autocorrect', 'off');
+        inp2.setAttribute('spellcheck', 'false');
+        f2.appendChild(inp2);
+        body.appendChild(f2);
+      }
       var ok = hEl('button', 'btn btn--filled', '确定'); ok.type = 'button';
       body.appendChild(ok);
       function commit() {
         var v = String(inp.value || '').trim();
-        if (!v) { err.textContent = opt.emptyHint || '不能为空'; err.hidden = false; inp.focus(); return; }
+        if (!v && !opt.allowEmpty) { err.textContent = opt.emptyHint || '不能为空'; err.hidden = false; inp.focus(); return; }
+        var v2 = inp2 ? String(inp2.value || '').trim() : '';
         closeHostSheet();
-        if (onOk) onOk(v);
+        if (onOk) onOk(v, v2);
       }
       ok.onclick = commit;
       inp.onkeydown = function (e) { if (e.key === 'Enter') { e.preventDefault(); commit(); } };
@@ -4226,7 +5876,7 @@ button.setrow{font-family:inherit}
         仍然在说「你这个默认就是那个目录」。而 client 进程的 cwd 本身就在某个 magic-* 里，
         那个目录又同时是空间列表的一项 —— 文案一带上名字，用户立刻读成「我把那个空间
         选成了默认」。这里是一条**归属**声明，不是路径提示：默认 = 不属于任何空间。 */
-  function wsLabel() { return WS ? (basename(WS) || WS) : '默认（不属于任何空间）'; }
+  function wsLabel() { return WS ? (spaceLabel(WS) || WS) : '默认（不属于任何空间）'; }
   /* 运行设置页的四个值：设备只读；工作空间来自 WS；权限 / 团队读当前会话组件。
      组件没挂载时给「沿用默认 / 关闭」，不编造。 */
   function paintRunSettings() {
@@ -4239,6 +5889,9 @@ button.setrow{font-family:inherit}
     /* 全权限在本页也用红色行（与抽屉里 hRow 的 danger 同一口径）。 */
     var permBtn = document.getElementById('btnRsPermission');
     if (permBtn) permBtn.classList.toggle('setrow--danger', !!(conv && conv.permissionTier && conv.permissionTier() === 'full'));
+    /* 思考模式（2026-10-24）：按当前这条会话的档位显示，默认最高。 */
+    var r = document.getElementById('rsReasoning');
+    if (r) r.textContent = reasoningLabel(REASONING_CUR) + (REASONING_CUR === REASONING_DEFAULT ? '（默认）' : '');
     var t = document.getElementById('rsTeam');
     if (t) t.textContent = (conv && conv.teamLabel) ? conv.teamLabel() : '关闭';
     /* 会话托管（2026-10-23，按会话）：与团队模式并列在同一张卡里。
@@ -4287,8 +5940,13 @@ button.setrow{font-family:inherit}
 
   /* 空间的归一键：**空 workspace 与桌面默认空间是同一个空间**（core 不传 -w 时用 cwd，
      登记表里那条记录的 workspace 就是空 —— 两边必须归一到同一个键，否则「默认空间里
-     已经有一条在跑」会被判成另一空间而照样并行）。 */
-  function wsKey(w) { return w || DW; }
+     已经有一条在跑」会被判成另一空间而照样并行）。
+     ⚠️ 这个键是**纯客户端的比较键**（分组 / 串行队列 / 判忙），下发给 core 的路径另有
+        p.w（原样，见 addPending 的说明）—— 所以在这里统一归一是安全的。
+     ⚠️ 归一（含分隔符与盘符大小写）是必需的：会话里的 workspace 是服务端登记的
+        D:\workspace\x，用户选的自定义空间是 D:/workspace/x —— 字面不等，串行门就
+        认不出「这个空间已经在跑了」，于是同一个空间并行跑了两轮。 */
+  function wsKey(w) { return spaceKey(w || DW); }
   function wsOf(s) { return wsKey(s && s.workspace); }
   /* 「这个空间有任务在跑」的判据。waiting_approval **不算**（沿用旧口径）：
      它卡在等审批 / 等回答上，用户可能一直不理，算进去就等于把整个空间永久锁死；
@@ -4299,6 +5957,146 @@ button.setrow{font-family:inherit}
   function serialQ(ws) {
     return SERIAL[ws] || (SERIAL[ws] = { tail: Promise.resolve(), held: 0, waiters: 0 });
   }
+  /* ── 服务端排队作业 → 列表里的「等待中」行（2026-10-24）──
+     用户报障：「串行模式下新发出的多个会话列表中看不见」。
+     根因：串行由**服务端**裁决（见 SERVER_JOBS），排队中的作业**还没开跑**，
+     core 也就还没写会话登记表 —— 它既不在 /desk/sessions 里，也不一定还留在这端的
+     本地 PENDING 里（App 重启后 restoreQueue 把它交给服务端就删了本地行）。
+     于是「发出去的几条里只有正在跑的那条看得见」。
+     现在把 GET /desk/jobs 的 queued 作业并进 PENDING 渲染：谁排在队里、排第几，
+     在列表上都能看见（换设备 / 重开 App / 别的客户端发的都一样）。
+     ⚠️ 与本地行的关系按 request_id 认：同一次提交**只画一行** —— 本地那条带附件、
+        团队配置和取消入口，比服务端作业更完整，只把它的 hide 翻掉（服务端都确认在排队了，
+        这条就该露面，不依赖那条可能已经错过的 SSE `queued` 事件）。
+     ⚠️ fromJob 行只是**渲染缓存**：不写 localStorage（saveQueue 会跳过）、不参与
+        restoreQueue 重发（它没有本地 id，按它重发会多起一个作业）。
+     ⚠️ 反向对账也在这里做（2026-10-24 用户：「等待中然后到运行出现了两个，等待中没消失」）：
+        本地那条「等待中」原先只等 SSE 的 open 来删，用户离开会话页后流被 cancel，
+        open 永远不来 → 会话行已经在跑，本地还挂着一条假的「等待中」。现在只要服务端作业
+        不再排队、且登记表里确实看得见它，就把本地行撤掉（见 jobLanded）。 */
+  var SERVER_ROW_MIN_AGE_MS = 1200;   // 刚提交的别闪一下「等待中」再消失（空闲空间通常 1s 内就开跑）
+  function jobTimeMs(t) {
+    if (!t) return 0;
+    var d = new Date(String(t));      // 服务端给的是 RFC3339
+    return isNaN(d.getTime()) ? 0 : d.getTime();
+  }
+  /* 队列签名：排队 / 运行中的作业（状态、位置变了才值得重绘）。
+     ⚠️ running 也要算进来：本地那条「等待中」的撤销要靠作业状态变化来触发对账
+     （见 syncServerJobs），只认 queued 的话「排队 → 开跑」这一步不会重画，
+     那一行就一直停在「等待中」。 */
+  function serverJobsSig(jobs) {
+    if (!Array.isArray(jobs)) return '';
+    return jobs.filter(function (j) { return j && (j.state === 'queued' || j.state === 'running'); })
+      .map(function (j) { return String(j.id) + ':' + j.state + ':' + (j.position || 0); })
+      .sort().join('|');
+  }
+  function syncServerJobs(jobs, sessions) {
+    if (!SERVER_JOBS || !Array.isArray(jobs)) return;
+    var now = Date.now();
+    var localOf = {};
+    PENDING.forEach(function (p) {
+      if (!p || p.fromJob || p.gone) return;
+      if (p.id) localOf[p.id] = p;
+      if (p.requestId) localOf[p.requestId] = p;
+    });
+    /* 新服务端**受理即登记**（core 的 RegisterQueued，run_id = request_id，缺省 job id）：
+       这条作业已经在 /desk/sessions 里有一行「queued」了，别再画一条 fromJob 行
+       —— 旧服务端没有登记行，才需要这份快照兜底。 */
+    var registered = {};
+    (sessions || []).forEach(function (s) {
+      if (!s) return;
+      var sid = sidOf(s);
+      if (sid) registered[String(sid)] = 1;
+      if (s.run_id) registered[String(s.run_id)] = 1;
+      if (s.session_id) registered[String(s.session_id)] = 1;
+    });
+    var rows = [], dead = [], touched = false;
+    jobs.forEach(function (j) {
+      if (!j || !j.id) return;
+      /* 本端同一次提交（request_id = 本地条目的 id，见 gateAsk / submitQueuedJob）。 */
+      var lp = (j.request_id && localOf[j.request_id]) || null;
+      if (lp) {
+        lp.job = j.id;
+        lp.pos = j.position || 0;
+        /* ⚠️ 2026-10-24 用户：「等待中然后到运行出现了两个，等待中没消失」：
+           本地这条「等待中」原先只在 SSE 的 open 到达时删。可用户一点进会话再退出来，
+           组件就把那条流 cancel 掉了（conversation.js 的 destroy）—— 此后服务端开跑
+           再也不会有任何事件回到这边，行就永远停在「等待中」，而会话行已经在跑（自动置顶）。
+           所以非排队态一律以**服务端作业 + 登记表**为准对账：
+             · 真的跑起来了 → 撤掉本地行（会话行接手显示）；
+             · 没跑起来就终结（failed / expired / cancelled）→ 标成可重试的「未能启动」，
+               绝不静默消失（与 fireQueued 的判据同一口径）。 */
+        if (j.state !== 'queued') {
+          if (jobLanded(j, sessions)) { lp.gone = true; dead.push(lp.id); return; }
+          if (j.state === 'running') return;            // 登记表还没落盘：下一拍再看
+          if (j.state === 'failed') {
+            if (!lp.stalled) {
+              lp.stalled = true;
+              lp.stalledReason = j.error || '服务端启动失败';
+              lp.hide = false;
+              /* 只有 owner='host' 才走 enqueueDispatch 的重试入口（见 pendingRow 的点击）。 */
+              lp.owner = 'host';
+              touched = true;
+            }
+          } else {
+            lp.gone = true;
+            dead.push(lp.id);                           // cancelled / expired：这条不会再跑了
+          }
+          return;
+        }
+        if (lp.hide) { lp.hide = false; touched = true; }
+        return;
+      }
+      if (j.state !== 'queued') return;
+      /* 服务端受理即登记（见上）：run_id 用 request_id；request_id 不适合当文件名时
+         服务端会退回 job id，所以两个都要认。 */
+      if (registered[String(j.request_id || '')] || registered[String(j.id)]) return;
+      /* 刚进队的那 1 秒里它可能马上就被调度器拉起来：此时画一行「等待中」再秒删，
+         正是用户 2026-10-22 抱怨的「没排队也先显示排队状态再切回」。 */
+      if (now - jobTimeMs(j.created_at) < SERVER_ROW_MIN_AGE_MS) return;
+      rows.push({
+        id: 'srv-' + j.id, fromJob: true, job: j.id, requestId: j.request_id || '',
+        /* 归组口径与本地条目一致：显式选了空间才进「空间」段（服务端把空 workspace
+           归一成了 cwd，不能直接当成显式选择，否则默认任务会凭空多出一个空间组）。 */
+        ws: wsKey(j.explicit_workspace ? j.workspace : ''),
+        w: j.explicit_workspace ? j.workspace : '',
+        explicit: !!j.explicit_workspace, pendingWait: true, hide: false, owner: 'server',
+        session: j.session || '', prompt: j.prompt || '', engine: j.engine || '',
+        model: j.model || '', team: j.team || null, hosted: !!j.hosted,
+        pos: j.position || 0, at: jobTimeMs(j.created_at)
+      });
+    });
+    rows.sort(function (a, b) { return (a.at || 0) - (b.at || 0); });   // FIFO，与队列顺序一致
+    if (dead.length) {
+      var gone = {};
+      dead.forEach(function (id) { gone[id] = 1; });
+      PENDING = PENDING.filter(function (p) { return p && !gone[p.id]; });
+      /* 磁盘上也要一并删掉，否则下次启动它又冒出来（与 dropPending / cancelPending 同一口径）。 */
+      dead.forEach(purgeQueue);
+      touched = true;
+    }
+    var had = PENDING.filter(function (p) { return p && p.fromJob; });
+    var sig = function (arr) {
+      return arr.map(function (p) { return p.id + ':' + (p.pos || 0); }).join('|');
+    };
+    if (!touched && sig(had) === sig(rows)) return;
+    PENDING = PENDING.filter(function (p) { return !p || !p.fromJob; }).concat(rows);
+    renderSessions(LAST_SESSIONS);
+  }
+  /* 服务端这条作业是否**真的跑起来了**（与 fireQueued 同一口径：收到 open 不等于跑起来）。
+     两条判据：① 作业自己带了 session_id / run_id（core 收尾时回填）；
+     ② 登记表里看得见它 —— 追问看原会话，新任务看「t0 之后开始的同空间记录」。 */
+  function jobLanded(j, sessions) {
+    if (j.session_id || j.run_id) return true;
+    if (!Array.isArray(sessions)) return false;
+    var startMs = jobTimeMs(j.started_at);
+    var ws = wsKey(j.explicit_workspace ? j.workspace : '');
+    return sessions.some(function (s) {
+      if (!s || wsOf(s) !== ws) return false;
+      if (j.session) return sameConvId(sidOf(s), j.session);
+      return startMs ? startedAfter(s, startMs) : false;
+    });
+  }
   function addPending(ws, info, hide) {
     /* explicit：**显式选了空间**才归进「空间」段；默认（不指定）落「任务」段 ——
        与 renderSessions 里会话按 `workspace` 是否为空分组的判定保持一致。
@@ -4312,6 +6110,9 @@ button.setrow{font-family:inherit}
               session: info.session || '',
               prompt: info.prompt || '', engine: info.engine || '',
               model: info.model || '', permission: info.permission || '',
+              /* reasoning：思考档位快照（2026-10-24）。排队 / 重启恢复时按提交那一刻的
+                 档位重发 —— 用户在等待期间改了档位，已排队的那条不该被悄悄改档。 */
+              reasoning: REASONING_CUR,
               /* team：重发时原样还原团队配置（见 fireQueued）——
                  丢了它这条排队任务就会从「团队」静默降级成单任务。 */
               team: info.team || null,
@@ -4393,6 +6194,8 @@ button.setrow{font-family:inherit}
     var baseAsk = t.ask;
     t.ask = function (payload, h) {
       var p = payload || {};
+      /* 思考模式：每一轮都按**当前这条会话**的档位下发（默认最高，见 REASONING_CUR）。 */
+      applyReasoningTo(p, p.engine, REASONING_CUR);
       var pend = pendingOf(p.prompt);
       var rid = (pend && pend.id) || ('q' + Date.now() + '-' + Math.floor(Math.random() * 100000));
       p.request_id = rid;
@@ -4472,11 +6275,11 @@ button.setrow{font-family:inherit}
     /* 只落**持久**字段：hide / gone 是这一次页面会话里的显示态，存下去会让「关掉 App 时
        正好还没到 300ms」的那条永远隐藏 —— 队列里有它、列表上却看不见，最难查的一种。
        id 保留：恢复时据此与内存里已有的条目去重。 */
-    var mineRows = PENDING.map(function (p) {
+    var mineRows = PENDING.filter(function (p) { return p && !p.fromJob; }).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,
+               permission: p.permission || '', reasoning: p.reasoning || '', team: p.team || null,
                attachments: p.attachments || [], atts: p.atts || [],
                /* owner 刻意不落盘：重启后所有残留条目都由 restoreQueue 交给宿主
                   （enqueueDispatch），语义与 'host' 一致 —— 存下来反而会让「上次是
@@ -4502,7 +6305,11 @@ button.setrow{font-family:inherit}
   function syncPendingFromDisk() {
     var disk = loadQueue();
     var keep = [];
-    PENDING.forEach(function (p) { if (p && (p.dispatching || p.owner === 'conv')) keep.push(p); });
+    /* fromJob 行来自服务端队列快照，不在磁盘上：这里若丢掉它们，列表要等下一次
+       loadSessions 才补回来（中间空一截）。其余按磁盘为准。 */
+    PENDING.forEach(function (p) {
+      if (p && (p.dispatching || p.owner === 'conv' || p.fromJob)) keep.push(p);
+    });
     var ids = {};
     keep.forEach(function (p) { ids[p.id] = 1; });
     PENDING = disk.filter(function (p) { return !ids[p.id]; }).concat(keep);
@@ -4729,10 +6536,47 @@ button.setrow{font-family:inherit}
     renderSessions(LAST_SESSIONS);
     return true;
   }
-  /* 「这一轮还在排队吗」——组件问宿主：真在排队就别去调 control（那条路没有 askId）。 */
+  /* 任务模式切换要「马上生效」：已排队、还没开跑的作业跟着新模式走 —— 不然串行切并行后，
+     旧条目还带着提交那一刻的 serial 快照，在服务端继续排独占队，直到整条串行队消化完。
+     本地串行门（!SERVER_JOBS）不用管：waitForSlot 每一拍都看 TASK_MODE，最多 3s 自己生效。 */
+  function applyTaskModeToQueued(v) {
+    if (!SERVER_JOBS) return;
+    var serial = (v === 'serial');
+    PENDING.forEach(function (p) {
+      if (!p || p.gone || p.cancelled) return;
+      /* fromJob 行也一起改：它是服务端队列里的快照（App 重启后本端那条已被
+         restoreQueue 交走，列表上就只剩这一行）。任务模式是**环境级**设置
+         （magic.taskmode 按环境分桶、随 /desk/prefs 同步），同环境里排着的作业
+         都该跟着新模式走 —— 只改本端本地条目的话，重启后切并行对它们无效，
+         症状正是「切了没马上生效」。
+         ⚠️ fromJob 行有 job id，updateJobSerial 走 /desk/jobs/{id}/update：
+            按 job id 定位，不会误伤别人的作业（本地条目按 request_id 定位，
+            那条路才需要防撞车，见 pendingOf 的注释）。 */
+      updateJobSerial(p, serial);
+    });
+  }
+  /* 服务端改模式：有 job id 走作业路由；还没拿到（queued 事件未到）就按 request_id 改。
+     只对排队中的生效 —— 已开跑的作业服务端回 updated=false，不打断。 */
+  function updateJobSerial(p, serial) {
+    try {
+      var hdr = TOKEN ? { 'X-Magic-Token': TOKEN, 'Content-Type': 'application/json' } : { 'Content-Type': 'application/json' };
+      if (p.job) {
+        fetch(BASE + '/desk/jobs/' + encodeURIComponent(p.job) + '/update', { method: 'POST', headers: hdr,
+          body: JSON.stringify({ serial: serial }) }).catch(function () {});
+      } else {
+        fetch(BASE + '/desk/jobs/update', { method: 'POST', headers: hdr,
+          body: JSON.stringify({ request_id: p.requestId || p.id, serial: serial }) }).catch(function () {});
+      }
+    } catch (e) {}
+  }
+  /* 「这一轮还在排队吗」——组件问宿主：真在排队就别去调 control（那条路没有 askId）。
+     ⚠️ fromJob 行是服务端队列里的**别人的/上次的**作业（见 syncServerJobs），按 prompt
+        撞上就把它当成这一轮的 request_id，会把这条新提交撞成别人的幂等键。跳过。 */
   function pendingOf(prompt) {
     for (var i = 0; i < PENDING.length; i++) {
-      if (!PENDING[i].gone && PENDING[i].prompt === prompt) return PENDING[i];
+      var p = PENDING[i];
+      if (!p || p.gone || p.fromJob) continue;
+      if (p.prompt === prompt) return p;
     }
     return null;
   }
@@ -4772,7 +6616,9 @@ button.setrow{font-family:inherit}
     /* 重启恢复的条目一律归宿主下发：它们的主人（会话组件）已经不在了，
        再标成 'conv' 就没人会认领（见 adoptPendingFor 的判据）。 */
     list.forEach(function (p) { p.owner = 'host'; });
-    PENDING = list;
+    /* 服务端队列快照生成的 fromJob 行不落盘、也不由这里重发（它没有本地 id，
+       按它提交会多起一个作业）；保留它们，由下一次 syncServerJobs 重新对账。 */
+    PENDING = list.concat(PENDING.filter(function (p) { return p && p.fromJob; }));
     renderSessions(LAST_SESSIONS);
     if (!SERVER_JOBS) {
       list.forEach(function (p) { enqueueDispatch(p); });
@@ -4801,6 +6647,7 @@ button.setrow{font-family:inherit}
     if (p.w) body.workspace = p.w;
     if (p.session) body.session = p.session;
     if (p.permission) body.permission = p.permission;
+    applyReasoningTo(body, p.engine, p.reasoning);
     if (p.team) body.team = p.team;
     if (p.hosted) body.hosted = true;
     if (p.attachments && p.attachments.length) body.attachments = p.attachments;
@@ -4872,11 +6719,18 @@ button.setrow{font-family:inherit}
     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 };
+    /* 幂等键：与本地排队行同一个 id（gateAsk / submitQueuedJob 也用它）。
+       ① 服务端按它认出「还是这一条」，重试不会多跑一遍；
+       ② 列表侧 syncServerJobs 靠它把本地「等待中」和 /desk/jobs 里的同一作业认成
+          一行 —— 不带的话，恢复队列重发时本地行 + 服务端快照行会各画一条。 */
+    if (p.id) payload.request_id = p.id;
     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;
+    /* 思考档位同样用提交那一刻的快照；引擎不支持时 applyReasoningTo 自己会跳过。 */
+    applyReasoningTo(payload, p.engine, p.reasoning);
     /* 团队配置是在发送那一刻快照下来的（见 addPending）：重发必须带上，
        否则这条排队任务会被当成普通单任务跑。 */
     if (p.team) payload.team = p.team;
@@ -5034,8 +6888,23 @@ button.setrow{font-family:inherit}
   }
 
   /* ── 通知：配置 + 真触发 ──
-     优先级：Capacitor LocalNotifications（App 内系统通知）→ Web Notification（浏览器已授权）→ 应用内 toast。
-     ⚠️ App 关闭时 JS 不跑、触发不了；「任务完成 / 待确认」通知需要 App 在运行。 */
+     两条通道，按环境自动选：
+       ① App 内（Capacitor LocalNotifications）→ **系统通知**（通知栏里那条）；
+       ② 浏览器（Web Notification）→ 系统通知（手机浏览器支持；**Android WebView 不支持**，
+          所以 App 内这条路根本不存在，别拿它当 App 内的兜底）；
+       都不行 → 应用内 toast（一条灰条，App 内也看得到）。
+     ⚠️ App 被系统杀掉时 JS 不跑、触发不了 ——「任务完成 / 待确认」通知需要 App 在运行。
+
+    ⚠️ **远程页面里 Capacitor 运行时不在**（根因已从 APK 的 smali 逐行确认，2026-10-25）：
+    APK 壳配对后加载的是桌面的 /m/ 远程页。Capacitor 的 JS 注入有两条路：
+    ① DOCUMENT_START_SCRIPT（现代 WebView 都支持）——只注册给壳自己的 origin（http://localhost）；
+    ② 本地服务器代理时的 jsInjector —— 在 ① 生效的分支里被置成 **null**。
+    两条路对远程页都不通：远程页被原样代理、**一个字节的 JS 都没注入**，
+    所以远程页里 window.Capacitor 根本不存在（这就是「没有可用的系统通知通道」的根因）。
+    但**传输层**在：useLegacyBridge 走 addJavascriptInterface("androidBridge")，
+    注入**所有 frame**（App 内 APK 下载用的 window.MagicUpdate 就是这么工作的）。
+    所以远程页自己补一个最小桥（notifyNativeShim）：androidBridge.postMessage 发原生消息、
+    window.Capacitor.fromNative 收响应 —— 纯前端修复，改本页即可，**无需重打 APK**。 */
   var NOTIFY = { result: true, confirm: true, sched: true };
   try {
     var _nv = JSON.parse(localStorage.getItem('magic.notify') || '{}');
@@ -5044,19 +6913,178 @@ button.setrow{font-family:inherit}
     }
   } catch (e) {}
   function saveNotify() { try { localStorage.setItem('magic.notify', JSON.stringify(NOTIFY)); } catch (e) {} }
+  /* 通道探测结果（缓存）。权限状态只能问原生才知道，是异步的：
+     BRIDGE: 'unknown' | 'alive' | 'dead'（传输层不通）| 'none'（压根没有原生通道）
+     PERM:   'unknown' | 'granted' | 'denied' | 'prompt'（还没问过用户） */
+  var NOTIFY_BRIDGE = 'unknown', NOTIFY_PERM = 'unknown';
+  /* 传输层不通时 promise 永不 settle，只能靠超时判定。原生是同机调用，1.5s 足够宽。 */
+  var NOTIFY_TIMEOUT_MS = 1500;
   function notifyPlugin() {
     try { var C = window.Capacitor; return (C && C.Plugins && C.Plugins.LocalNotifications) || null; } catch (e) { return null; }
   }
-  function notifyPermState() {
-    if (notifyPlugin()) return 'plugin';
+  /* 远程页兜底桥：window.Capacitor 不在、但 androidBridge 在（legacy 桥注入所有 frame）。
+     自建最小 Capacitor 响应面：nativePromise 发原生消息（{callbackId, pluginId, methodName,
+     options}），fromNative 收原生回调（{callbackId, success, data|error}）—— 协议与
+     Capacitor MessageHandler 的 legacy 桥逐字段对齐。只挂 fromNative/nativePromise，
+     **不**伪造 Plugins.*，保证 notifyPlugin()/诊断永远能区分「真运行时」和「自建桥」。
+     返回带 __shim 的插件对象；环境不对（没有 androidBridge）返回 null。 */
+  var NOTIFY_SHIM = null; /* null=未探测，false=探测过、不可用，否则是插件对象 */
+  function notifyNativeShim() {
+    if (NOTIFY_SHIM !== null) return NOTIFY_SHIM || null;
+    NOTIFY_SHIM = false;
+    try {
+      var B = window.androidBridge;
+      if (B && typeof B.postMessage === 'function') {
+        var cap = window.Capacitor = window.Capacitor || {};
+        if (typeof cap.fromNative !== 'function') {
+          var cbs = {}, seq = 0;
+          cap.fromNative = function (raw) {
+            try {
+              var d = typeof raw === 'string' ? JSON.parse(raw) : raw;
+              var c = cbs[d.callbackId];
+              if (c) { delete cbs[d.callbackId]; if (d.success) c.resolve(d.data); else c.reject(d.error); }
+            } catch (e) {}
+          };
+          cap.nativePromise = function (pid, m, o) {
+            return new Promise(function (res, rej) {
+              var id = 'shim' + (++seq);
+              cbs[id] = { resolve: res, reject: rej };
+              try { B.postMessage(JSON.stringify({ callbackId: id, pluginId: pid, methodName: m, options: o || {} })); }
+              catch (e) { delete cbs[id]; rej(e); }
+            });
+          };
+        }
+        if (typeof cap.nativePromise === 'function') {
+          NOTIFY_SHIM = {
+            __shim: true,
+            schedule: function (o) { return cap.nativePromise('LocalNotifications', 'schedule', o); },
+            checkPermissions: function () { return cap.nativePromise('LocalNotifications', 'checkPermissions', {}); },
+            requestPermissions: function () { return cap.nativePromise('LocalNotifications', 'requestPermissions', {}); }
+          };
+        }
+      }
+    } catch (e) { NOTIFY_SHIM = false; }
+    return NOTIFY_SHIM || null;
+  }
+  /* 用通道一律走这个：真运行时优先，不在再试自建桥。 */
+  function notifyNativePlugin() { return notifyPlugin() || notifyNativeShim(); }
+  /* 通道诊断：把「为什么没有原生通道」说清楚，别只丢一句「没有可用通道」。
+     两种完全不同的断点，用户看到的现象一模一样：
+       · 'no-runtime'  → window.Capacitor 压根不存在 —— **Capacitor 运行时没注入到本页**。
+         典型场景：APK 壳加载的是**桌面的远程 /m/ 页**，而 Capacitor 的 JS 注入
+         只发生在它自己的本地服务器（uriMatcher 只认已注册的 authority）上，
+         远程页被原样返回、没被注入。
+       · 'no-plugin'   → 运行时在，但 Plugins 里没有 LocalNotifications（插件没装/没注册）。
+     别的场景（传输层不通 / 权限问题）由 notifyProbe 的 alive/dead 与权限状态覆盖。 */
+  function notifyDiagnose() {
+    var d = { runtime: false, plugins: [], hasPlugin: false, shim: false, bridge: NOTIFY_BRIDGE, perm: NOTIFY_PERM, origin: location.origin, href: location.href };
+    try {
+      var C = window.Capacitor;
+      d.runtime = !!(C && C.Plugins);
+      if (d.runtime) d.plugins = Object.keys(C.Plugins);
+      d.hasPlugin = !!notifyPlugin();
+    } catch (e) {}
+    /* 自建桥探测放最后：它会往 window 上挂 Capacitor.fromNative（但不挂 Plugins），
+       runtime/hasPlugin 的判断必须在它之前完成，否则第二次打开诊断会把自建桥误认成真运行时。 */
+    d.shim = !d.hasPlugin && !!notifyNativeShim();
+    if (!d.runtime && d.shim) d.why = 'shim';
+    else if (!d.runtime) d.why = 'no-runtime';
+    else if (!d.hasPlugin) d.why = 'no-plugin';
+    else if (NOTIFY_BRIDGE === 'dead') d.why = 'transport-dead';
+    else d.why = 'ok';
+    return d;
+  }
+  function notifyDiagText() {
+    var d = notifyDiagnose();
+    var lines = [
+      '诊断：' + (d.why === 'no-runtime' ? 'Capacitor 运行时没注入本页'
+        : d.why === 'shim' ? '运行时没注入本页，已用 androidBridge 自建桥（通知可发，先点授权）'
+        : d.why === 'no-plugin' ? '运行时在，但没有 LocalNotifications 插件'
+        : d.why === 'transport-dead' ? '运行时与插件都在，传输层不通'
+        : '通道正常'),
+      '页面来源：' + d.origin,
+      '插件清单：' + (d.plugins.length ? d.plugins.join(', ') : '（无）'),
+      '传输层：' + d.bridge + '　权限：' + d.perm
+    ];
+    if (d.why === 'no-runtime') {
+      lines.push('原因：Capacitor 的 JS 注入只发生在它自己的本地服务器上，' +
+        '桌面远程页（/m/）被原样返回、没注入 —— 这是壳加载远程页时的固有限制。');
+    } else if (d.why === 'shim') {
+      lines.push('说明：这是桌面远程页，壳的运行时注入不到这里；' +
+        '本页已通过 androidBridge（legacy 桥，对所有 frame 可见）自建通知通道。');
+    }
+    return lines.join('\n');
+  }
+  function notifyWebPerm() {
     try { if (window.Notification) return Notification.permission; } catch (e) {}
+    return 'unsupported';
+  }
+  /* 原生有没有 Web Notification 这条路：App 里**没有**（WebView 不支持），
+     只有真浏览器打开 /m/ 时才有。所以 App 内不许拿它当兜底。 */
+  function notifyHasWeb() {
+    if (notifyNativePlugin()) return false;
+    try { return !!window.Notification; } catch (e) { return false; }
+  }
+  function notifyWithTimeout(p) {
+    return Promise.race([
+      p.then(function (v) { return { ok: true, v: v }; }, function (e) { return { ok: false, v: e }; }),
+      new Promise(function (res) { setTimeout(function () { res({ ok: false, timeout: true }); }, NOTIFY_TIMEOUT_MS); })
+    ]);
+  }
+  /* 探一次原生通道：传输层活着吗？通知权限给了吗？ */
+  function notifyProbe() {
+    var P = notifyNativePlugin();
+    if (!P || !P.checkPermissions) { NOTIFY_BRIDGE = 'none'; NOTIFY_PERM = 'unknown'; return Promise.resolve(); }
+    return notifyWithTimeout(Promise.resolve(P.checkPermissions())).then(function (r) {
+      if (r.timeout) { NOTIFY_BRIDGE = 'dead'; NOTIFY_PERM = 'unknown'; return; }
+      NOTIFY_BRIDGE = 'alive';
+      var d = (r.ok && r.v) ? (r.v.display || r.v.granted) : null;
+      NOTIFY_PERM = d === 'granted' ? 'granted' : (d === 'denied' ? 'denied' : (d === 'prompt' ? 'prompt' : 'denied'));
+    });
+  }
+  /* 这一格该怎么写：优先看原生通道（App 内），没有原生再看浏览器通道。 */
+  function notifyPermState() {
+    if (notifyNativePlugin()) {
+      if (NOTIFY_BRIDGE === 'dead') return 'dead';
+      if (NOTIFY_PERM === 'granted') return 'granted';
+      if (NOTIFY_PERM === 'denied') return 'denied';
+      if (NOTIFY_PERM === 'prompt') return 'prompt';
+      return 'unknown';
+    }
+    var w = notifyWebPerm();
+    if (w === 'granted') return 'granted';
+    if (w === 'denied') return 'denied';
+    if (w === 'default') return 'prompt';
     return 'unknown';
   }
+  function notifyStateLabel() {
+    var st = notifyPermState();
+    if (st === 'granted') return '已开启';
+    if (st === 'denied') return '已拒绝';
+    if (st === 'prompt') return '去授权';
+    if (st === 'dead') return '未接入';
+    return '—';
+  }
   function requestNotifyPermission() {
-    var P = notifyPlugin();
-    if (P && P.requestPermissions) { try { return Promise.resolve(P.requestPermissions()); } catch (e) {} }
-    try { if (window.Notification && Notification.permission === 'default') return Notification.requestPermission(); } catch (e) {}
-    return Promise.resolve();
+    var P = notifyNativePlugin();
+    if (P && P.requestPermissions) {
+      return notifyWithTimeout(Promise.resolve(P.requestPermissions())).then(function (r) {
+        if (r.timeout) { NOTIFY_BRIDGE = 'dead'; return null; }
+        NOTIFY_BRIDGE = 'alive';
+        var d = (r.ok && r.v) ? (r.v.display || r.v.granted) : null;
+        NOTIFY_PERM = d === 'granted' ? 'granted' : (d === 'denied' ? 'denied' : 'prompt');
+        return NOTIFY_PERM;
+      });
+    }
+    try {
+      if (window.Notification && Notification.permission === 'default') {
+        return Promise.resolve(window.Notification.requestPermission()).then(function (p) {
+          NOTIFY_PERM = p === 'granted' ? 'granted' : (p === 'denied' ? 'denied' : 'prompt');
+          return NOTIFY_PERM;
+        });
+      }
+    } catch (e) {}
+    return Promise.resolve(null);
   }
   var toastEl = null, toastT = null;
   function toast(msg) {
@@ -5068,20 +7096,47 @@ button.setrow{font-family:inherit}
   }
   function notify(kind, title, body) {
     if (!NOTIFY[kind]) return;
-    var P = notifyPlugin();
+    var msg = title + (body ? '：' + body : '');
+    var P = notifyNativePlugin();
     if (P && P.schedule) {
-      try { P.schedule({ notifications: [{ id: Math.floor(Math.random() * 1e9), title: title, body: body }] }); return; } catch (e) {}
+      /* 原生通道：走系统通知（通知栏里那条）。
+         ⚠️ **不传 schedule 字段 = 立即显示**（插件的 isScheduled() 为 false 时直接
+         notificationManager.notify()）；传了 schedule.at 反而是「排到那个时刻」，
+         那是定时任务的事、不是「现在弹一条」。
+         ⚠️ 远程页面里传输层不通时，这个 promise 永不 settle —— 所以给个超时兜底，
+         超时按失败处理、落到 toast。**不能因为「调了没抛错」就当成功**（静默失败过一次）。 */
+      var p;
+      try {
+        p = Promise.resolve(P.schedule({ notifications: [{ id: notifyNextId(), title: title, body: body }] }));
+      } catch (e) { p = Promise.reject(e); }
+      notifyWithTimeout(p).then(function (r) {
+        if (r.ok) return;                 // 系统通知已发出
+        /* 通知没发出去：别装作发了，落到应用内 toast，用户至少看得到。 */
+        toast(msg);
+      });
+      return;
     }
-    try {
-      if (window.Notification) {
+    /* 浏览器通道：只有真浏览器打开 /m/ 时才有（App 内 WebView 不支持 Notification）。 */
+    if (notifyHasWeb()) {
+      try {
         if (Notification.permission === 'granted') { new Notification(title, { body: body }); return; }
         if (Notification.permission !== 'denied') {
-          Notification.requestPermission().then(function (p) { if (p === 'granted') { try { new Notification(title, { body: body }); } catch (e) {} } });
+          Notification.requestPermission().then(function (p) {
+            if (p === 'granted') { try { new Notification(title, { body: body }); } catch (e) { toast(msg); } }
+            else toast(msg);
+          }, function () { toast(msg); });
           return;
         }
-      }
-    } catch (e) {}
-    toast(title + (body ? '：' + body : ''));
+      } catch (e) {}
+    }
+    toast(msg);
+  }
+  /* 通知 id：插件要求是 Java int（超范围会整条 call 被 reject），且同 id 会覆盖前一条。
+     用一个自增计数配随机起点，避开 int 上界与重复。 */
+  var NOTIFY_ID_SEQ = Math.floor(Math.random() * 100000);
+  function notifyNextId() {
+    NOTIFY_ID_SEQ = (NOTIFY_ID_SEQ + 1) % 2000000000;
+    return NOTIFY_ID_SEQ;
   }
   function nToggle(body, label, on, onSet) {
     var row = document.createElement('div'); row.className = 'setrow';
@@ -5090,14 +7145,72 @@ button.setrow{font-family:inherit}
     t.onclick = function () { on = !on; t.classList.toggle('is-on', on); onSet(on); };
     row.appendChild(t); body.appendChild(row);
   }
+  /* 「发一条测试通知」：把通道通没通**当场验给用户看**。
+     没有这个入口，用户只能对着一个状态字猜 —— 静默失败过一次（传输层不通时
+     promise 永不 settle，页面看起来一切正常，但通知根本没发出去）。
+     返回 'sent' | 'timeout' | 'failed' | 'web' | 'toast'，便于自测断言。 */
+  function notifyTest() {
+    var P = notifyNativePlugin();
+    if (!P) {
+      /* 没有原生通道：把**原因**说清楚（见 notifyDiagnose）。
+         只说「没有可用的系统通知通道」的话，用户既不知道该重装 App、
+         也不知道是自己没连上桌面 —— 白白折腾。 */
+      var d = notifyDiagnose();
+      var why = d.why === 'no-runtime'
+        ? '当前页面没有系统通知通道（App 加载的是桌面远程页）'
+        : (d.why === 'no-plugin' ? '当前 App 未安装通知插件' : '当前没有可用的系统通知通道');
+      toast(why + '，已改用应用内提示');
+      return Promise.resolve('toast');
+    }
+    if (P && P.schedule) {
+      var p;
+      try {
+        p = Promise.resolve(P.schedule({ notifications: [{ id: notifyNextId(), title: 'Magic Agent', body: '系统通知工作正常' }] }));
+      } catch (e) { p = Promise.reject(e); }
+      return notifyWithTimeout(p).then(function (r) {
+        if (r.ok) { toast('测试通知已发送，请查看系统通知栏'); return 'sent'; }
+        if (r.timeout) { toast('通知通道未响应，已改用应用内提示'); return 'timeout'; }
+        var msg = (r.v && (r.v.message || r.v.error)) || '未知错误';
+        toast('测试通知发送失败：' + msg);
+        return 'failed';
+      });
+    }
+    if (notifyHasWeb()) {
+      try {
+        if (Notification.permission === 'granted') { new Notification('Magic Agent', { body: '系统通知工作正常' }); toast('测试通知已发送'); return 'web'; }
+        return Notification.requestPermission().then(function (p2) {
+          if (p2 === 'granted') { try { new Notification('Magic Agent', { body: '系统通知工作正常' }); } catch (e) {} }
+          toast(p2 === 'granted' ? '测试通知已发送' : '未获得通知权限');
+          return 'web';
+        }, function () { toast('未获得通知权限'); return 'toast'; });
+      } catch (e) {}
+    }
+    toast('当前没有可用的系统通知通道，已改用应用内提示');
+    return Promise.resolve('toast');
+  }
   function openNotifySettings() {
-    openHostSheet('消息通知设置', function (body) {
+    openHostSheet('消息通知', function (body) {
       var st = notifyPermState();
-      var label = st === 'plugin' ? '已接入' : (st === 'granted' ? '已开启' : (st === 'denied' ? '已拒绝' : '去授权'));
-      hRow(body, '系统消息通知', label, function () { requestNotifyPermission().then(function () { openNotifySettings(); }); });
+      /* ① 系统通知（权限行）：状态一眼可见，点了去授权；授权完重开本页刷新状态。 */
+      hRow(body, '系统通知', notifyStateLabel(), function () {
+        requestNotifyPermission().then(function () { openNotifySettings(); });
+      });
+      /* 传输层不通时把原因说清楚：用户点「去授权」什么也不会发生，
+         没有这一行就只能对着一个永远不变的「未开启」发呆。 */
+      if (st === 'dead') {
+        var tip = elSpan('pick__d', '系统通知通道不可用（App 与桌面未连通），将使用应用内提示');
+        tip.style.display = 'block'; tip.style.margin = '2px 0 6px';
+        body.appendChild(tip);
+      }
+      /* ② 通知内容开关：用户来这个页面的主要目的，放前面。
+         ⚠️ 「定时任务通知」开关撤掉（2026-10-25 用户定调）：定时任务功能本身不存在
+         （tab 已删、core 无调度 API，notify('sched') 0 处调用），开关是假承诺。
+         NOTIFY.sched 数据字段保留 —— 真做了定时任务时开关挂回来即可。 */
       nToggle(body, '任务结果通知', NOTIFY.result, function (v) { NOTIFY.result = v; saveNotify(); });
       nToggle(body, '任务待确认通知', NOTIFY.confirm, function (v) { NOTIFY.confirm = v; saveNotify(); });
-      nToggle(body, '定时任务通知', NOTIFY.sched, function (v) { NOTIFY.sched = v; saveNotify(); });
+      /* 「发一条测试通知」「通道诊断」两个入口 2026-10-25 用户定调撤掉（通道已通，
+         正式 UI 不需要调试工具）。底层 notifyTest()/notifyDiagnose() 保留 ——
+         通道再出问题时把它们挂回任意入口就能当场自证。 */
     });
   }
 
@@ -5123,32 +7236,126 @@ button.setrow{font-family:inherit}
       }).catch(function () {});
   }
 
+  /* 思考模式选择器：写**当前这条会话**的档位（默认最高）。 */
+  function openReasoningPicker() {
+    openHostSheet('思考模式', function (body) {
+      REASONING_LEVELS.forEach(function (it) {
+        hRow(body, it.label, it.desc, function () {
+          writeReasoningFor(it.v);
+          closeHostSheet();
+          paintRunSettings();
+          toast('思考模式：' + it.label);
+        }, false, REASONING_CUR === it.v);
+      });
+      var eng = (conv && conv.state && conv.state.engine) || '';
+      var sup = reasoningSupportState(eng);
+      var hint = hEl('div', 'history__hint',
+        sup === false
+          ? (eng + ' 没有推理档位参数，core 会静默忽略；换 claude / codebuddy / codex 等引擎才生效。')
+          : (sup === null
+            ? '发送时按引擎能力自动判断：支持的引擎下发此档位，不支持的沿用引擎默认。'
+            : '只对这一条会话生效，默认最高。'));
+      hint.style.textAlign = 'left';
+      body.appendChild(hint);
+    });
+  }
   /* 工作空间选择：默认 / 根目录下 magic-* / 自定义 / 会话里出现过的，一行一个，外加「自定义路径…」。
      ⚠️ 当前生效的那一条要打勾（hRow 的 selected）：抽屉里没有任何选中标记时，
         点完「默认」看不出变化，用户无从判断到底选没选上（2026-10-21 报「无法选择默认」）。
      ⚠️ 首项文案 = 「默认（不属于任何空间）」：默认的语义是**不归属任何空间目录**，
-        不是「用某个默认目录」。写「不指定」容易被读成「没选」，写目录名更会被读成「选了那个目录」。 */
+        不是「用某个默认目录」。写「不指定」容易被读成「没选」，写目录名更会被读成「选了那个目录」。
+     ⚠️ 一律显示**短名**（别名 > 最后一级文件夹名），不显示路径：路径一长就撑爆一行，
+        而且用户认的是「哪个项目」，不是「哪个绝对路径」。 */
   function openWorkspacePicker() {
     var keys = collectSpaceKeys();
     openHostSheet('选择工作空间', function (body) {
       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(); paintRunSettings(); }, false, WS === w);
+        var it = customSpaceOf(w);
+        var isCustom = !!it;
+        /* 打勾要比**空间键**而不是原字符串：WS 可能是用户手输的「D:/work/proj/」，
+           列表里这一行却是服务端登记的「D:\work\proj」—— 字面不等，勾就打不上，
+           用户会以为「点了没生效」（2026-10-21 报「无法选择默认」是同一类毛病）。 */
+        hRow(body, spaceLabel(w), isCustom ? '自定义' : null, function () { WS = w; saveWs(); applyWs(); closeHostSheet(); paintRunSettings(); }, false, !!WS && spaceKey(WS) === spaceKey(w),
+          /* 自定义空间行尾两枚动作：「✎」起别名、「✕」删除（行本身仍是「选中这个空间」）。
+             删除只把它从自定义清单里摘掉，**不动磁盘上的目录**；如果当前生效的 WS
+             正是它，回落到「默认」（不然运行设置页还挂着一条已删空间的残影）。 */
+          isCustom ? [
+            { label: '✎', title: '设置别名', onClick: function () { openSpaceAliasSheet(it); } },
+            { label: '✕', title: '删除空间', onClick: function () { openSpaceDeleteSheet(it); } }
+          ] : null);
       });
       hRow(body, '自定义路径…', '＋', openCustomPathSheet);
     });
   }
-  /* 自定义路径：复用单行输入抽屉（见 openTextInputSheet 上方的 prompt 说明）。 */
+  /* 自定义空间的别名：给目录起一个**显示名**，之后各处显示它而不是路径。
+     留空 = 回到「最后一级文件夹名」（见 spaceLabel）。 */
+  function openSpaceAliasSheet(item) {
+    openTextInputSheet({
+      title: '空间别名',
+      value: item.alias || '',
+      placeholder: '留空 = 用文件夹名',
+      allowEmpty: true
+    }, function (alias) {
+      item.alias = String(alias || '').trim();
+      saveSpaces();
+      /* 别名一改，所有显示它的地方都要跟着变：运行设置页 / 空间选择器 / 任务页分组头。 */
+      paintRunSettings();
+      renderSessions(LAST_SESSIONS);
+      openWorkspacePicker();   // 回到选择器，让用户当场看见新名字
+    });
+  }
+  /* 删除自定义空间：二次确认后从清单摘掉（**只删登记，不删目录** —— 磁盘上的文件
+     原样不动，用户的代码/文档不能因为一个 UI 操作消失）。当前生效的 WS 正是它时
+     回落「默认」，并当场把对话组件的 workspace 也清掉（否则下一轮还会带着已删空间发）。 */
+  function openSpaceDeleteSheet(item) {
+    openHostSheet('删除空间', function (body) {
+      var tip = hEl('div', 'pick__d', '从空间列表移除「' + spaceLabel(item.path) + '」？目录里的文件不会被删除。');
+      tip.style.textAlign = 'left';
+      tip.style.lineHeight = '1.6';
+      body.appendChild(tip);
+      var del = hEl('button', 'btn btn--filled', '删除'); del.type = 'button';
+      /* 危险按钮配色走主题的 error 三色组（浅色 = 红底浅粉字，深色 = 浅红底深红字），
+         两套主题都成立 —— 不写死色值（这份 UI 有浅/深双主题）。 */
+      del.style.background = 'var(--error-text)';
+      del.style.borderColor = 'var(--error-text)';
+      del.style.color = 'var(--error-surface)';
+      body.appendChild(del);
+      del.onclick = function () {
+        var k = spaceKey(item.path);
+        CUSTOM_SPACES = CUSTOM_SPACES.filter(function (s) { return spaceKey(s.path) !== k; });
+        saveSpaces();
+        if (spaceKey(WS) === k) { WS = ''; saveWs(); applyWs(); }
+        closeHostSheet();
+        paintRunSettings();
+        renderSessions(LAST_SESSIONS);
+        openWorkspacePicker();   // 回到选择器，让用户当场看见它没了
+      };
+    });
+  }
+  /* 自定义路径：路径 + 可选的别名（复用单行输入抽屉，见 openTextInputSheet 上方说明）。 */
   function openCustomPathSheet() {
     openTextInputSheet({
       title: '自定义路径',
       value: SPACES_ROOT || DW || '',
       placeholder: '/绝对路径',
-      emptyHint: '请输入工作空间的绝对路径'
-    }, function (p) {
-      if (CUSTOM_SPACES.indexOf(p) < 0) { CUSTOM_SPACES.push(p); saveSpaces(); }
-      WS = p; saveWs(); applyWs(); loadSessions(); paintRunSettings();
+      emptyHint: '请输入工作空间的绝对路径',
+      secondary: { label: '别名（可选）', placeholder: '留空 = 用文件夹名' }
+    }, function (p, alias) {
+      var path = String(p || '').trim();
+      if (!path) return;
+      /* 落库用**归一后的**路径（统一分隔符 + 去尾斜杠）：与服务端登记的 workspace
+         同一口径，否则同一个目录会以两种写法各存一份（列表里出现两行重复项），
+         而且别名贴不上 —— 「D:/work/proj」与「D:\work\proj」是同一个目录。 */
+      path = reqNormDir(path);
+      if (!path) return;
+      var it = customSpaceOf(path);
+      if (!it) { it = { path: path, alias: '' }; CUSTOM_SPACES.push(it); }
+      /* 别名可以留空 = 回到「最后一级文件夹名」（见 spaceLabel）；
+         但已经起过名的空间，再次走这里**不要**把别名抹掉（否则改个路径就把名字弄丢了）。 */
+      if (String(alias || '').trim()) it.alias = String(alias).trim();
+      saveSpaces();
+      WS = path; saveWs(); applyWs(); loadSessions(); paintRunSettings();
     });
   }
 
@@ -5161,58 +7368,84 @@ button.setrow{font-family:inherit}
      不能回落到 RUN_PREF.engine —— 那等于「配了默认编码引擎就自动有建议」，
      与用户「默认不配置就不开启」相反。 */
   function loadSuggestPref() {
-    var o = { engine: '', model: '' };
+    var o = { engine: '', model: '', fbEngine: '', fbModel: '' };
     try {
       o.engine = String(localStorage.getItem('magic.suggest.engine') || '').trim();
       o.model = String(localStorage.getItem('magic.suggest.model') || '').trim();
+      o.fbEngine = String(localStorage.getItem('magic.suggest.fallback.engine') || '').trim();
+      o.fbModel = String(localStorage.getItem('magic.suggest.fallback.model') || '').trim();
     } catch (e) {}
     if (!o.engine) o.model = '';
+    if (!o.fbEngine) o.fbModel = '';
     return o;
   }
   function saveSuggestPref() {
     try {
       localStorage.setItem('magic.suggest.engine', SUGGEST.engine || '');
       localStorage.setItem('magic.suggest.model', SUGGEST.model || '');
+      localStorage.setItem('magic.suggest.fallback.engine', SUGGEST.fbEngine || '');
+      localStorage.setItem('magic.suggest.fallback.model', SUGGEST.fbModel || '');
     } catch (e) {}
     schedulePushPrefs();
     paintSuggestPref();
   }
   function paintSuggestPref() {
-    var e = document.getElementById('suggestEngine');
-    var m = document.getElementById('suggestModel');
-    if (e) e.textContent = SUGGEST.engine || '不开启';
-    if (m) m.textContent = SUGGEST.engine ? (qaModelText(SUGGEST.model) || '引擎默认') : '跟随引擎';
+    if (!document.getElementById('suggestEngine')) return;
+    var main = SUGGEST.engine
+      ? (SUGGEST.engine + (SUGGEST.model ? ' · ' + qaModelText(SUGGEST.model, SUGGEST.engine) : ''))
+      : '不开启';
+    paintEnginePair(document.getElementById('suggestEngine'), main, fallbackLine(SUGGEST.fbEngine, SUGGEST.fbModel));
   }
   function applySuggestToLive() {
     if (conv && typeof conv.setSuggestEngine === 'function') {
-      conv.setSuggestEngine(SUGGEST.engine, SUGGEST.model);
+      conv.setSuggestEngine(SUGGEST.engine, SUGGEST.model, SUGGEST.fbEngine, SUGGEST.fbModel);
     }
     paintSuggestPref();
     paintRunSettings();
   }
 
   function loadRunPref() {
-    var o = { engine: '', model: '' };
+    var o = { engine: '', model: '', fbEngine: '', fbModel: '' };
     try {
       o.engine = localStorage.getItem('magic.engine') || '';
       o.model = localStorage.getItem('magic.model') || '';
+      o.fbEngine = String(localStorage.getItem('magic.fallback.engine') || '').trim();
+      o.fbModel = String(localStorage.getItem('magic.fallback.model') || '').trim();
     } catch (e) {}
     if (!o.engine) o.model = '';
+    if (!o.fbEngine) o.fbModel = '';
     return o;
   }
   function saveRunPref() {
     try {
       localStorage.setItem('magic.engine', RUN_PREF.engine || '');
       localStorage.setItem('magic.model', RUN_PREF.model || '');
+      localStorage.setItem('magic.fallback.engine', RUN_PREF.fbEngine || '');
+      localStorage.setItem('magic.fallback.model', RUN_PREF.fbModel || '');
     } catch (e) {}
     schedulePushPrefs();
     paintRunPref();
   }
   function paintRunPref() {
-    var e = document.getElementById('defaultEngine');
-    var m = document.getElementById('defaultModel');
-    if (e) e.textContent = RUN_PREF.engine || '自动（首个可用）';
-    if (m) m.textContent = RUN_PREF.engine ? (qaModelText(RUN_PREF.model) || '引擎默认') : '跟随引擎';
+    if (!document.getElementById('defaultEngine')) return;
+    /* 不再有「自动 / 引擎默认」这两档可选项：没选模型就只显示引擎名，空值写成「未设置」。 */
+    var main = RUN_PREF.engine
+      ? (RUN_PREF.engine + (RUN_PREF.model ? ' · ' + qaModelText(RUN_PREF.model, RUN_PREF.engine) : ''))
+      : '未设置';
+    paintEnginePair(document.getElementById('defaultEngine'), main, fallbackLine(RUN_PREF.fbEngine, RUN_PREF.fbModel));
+  }
+  /* 备用那一行（第二行，小一档）：没配就空串 = 不画。
+     ⚠️ 不要和主引擎挤在同一行 —— `setrow__v` 是单行省略，长组合会被截成
+     「主 ｜ …」，用户根本看不到备用（2026-10-24 报障）。 */
+  function fallbackLine(engine, model) {
+    if (!engine) return '';
+    return '备 ' + engine + (model ? ' · ' + qaModelText(model, engine) : '');
+  }
+  function paintEnginePair(el, mainText, fbText) {
+    if (!el) return;
+    el.innerHTML = '';
+    el.appendChild(hEl('span', 'setrow__pair-main', mainText));
+    if (fbText) el.appendChild(hEl('span', 'setrow__pair-fb', fbText));
   }
 
   /* 团队模式配置（「我的」）══════════
@@ -5229,10 +7462,11 @@ button.setrow{font-family:inherit}
     /* 摘要与子页面同一口径：计划 + 7 个角色里单独配过引擎**或规则**的项数。
        旧版按类别配过的路由仍然生效（core 仍认），但不在界面上重复计数。 */
     var custom = 0;
-    if (((TEAM.routes || {}).plan || {}).engine) custom++;
+    var planRt = (TEAM.routes || {}).plan || {};
+    if (planRt.engine || planRt.fallbackEngine) custom++;
     teamRoleList().forEach(function (r) {
       var rt = (TEAM.routes || {})['role:' + r.name];
-      if ((rt && rt.engine) || ((TEAM.rules || {})['role:' + r.name])) custom++;
+      if ((rt && (rt.engine || rt.fallbackEngine)) || ((TEAM.rules || {})['role:' + r.name])) custom++;
     });
     paintTeamRoles(teamRoleList());
     var sum = document.getElementById('teamSummary');
@@ -5250,10 +7484,12 @@ button.setrow{font-family:inherit}
     var planSub = '拆解：' + ({ coarse: '少', standard: '标准', fine: '细' }[TEAM.split] || '标准')
       + (TEAM.adaptive !== false ? ' · 自动补任务' : '')
       + (TEAM.splitCode ? ' · 简单代码也拆' : '');
-    var sig = (show ? '1' : '0') + '|plan|' + planSub + '|' + (plan.engine || '') + '|' + (plan.model || '') + '|'
+    var sig = (show ? '1' : '0') + '|plan|' + planSub + '|' + (plan.engine || '') + '|' + (plan.model || '')
+      + '|' + (plan.fallbackEngine || '') + '|' + (plan.fallbackModel || '') + '|'
       + roles.map(function (r) {
         var rt = (TEAM.routes || {})['role:' + r.name] || {};
-        return r.name + '|' + teamRoleDuty(r) + '|' + (rt.engine || '') + '|' + (rt.model || '');
+        return r.name + '|' + teamRoleDuty(r) + '|' + (rt.engine || '') + '|' + (rt.model || '')
+          + '|' + (rt.fallbackEngine || '') + '|' + (rt.fallbackModel || '');
       }).join(',');
     if (sig === TEAM_ROLE_SIG) return;
     TEAM_ROLE_SIG = sig;
@@ -5277,8 +7513,14 @@ button.setrow{font-family:inherit}
     row.appendChild(main);
     var v = hEl('button', 'setrow__vbtn');
     v.type = 'button';
-    v.appendChild(hEl('span', 'setrow__v',
-      rt.engine ? (rt.engine + (rt.model ? ' · ' + qaModelText(rt.model) : '')) : '跟随主引擎'));
+    /* 主备都显示：主一行、备一行（与「我的」默认引擎那两行同构）。
+       挤成一行会被省略号截断，备用等于没显示（2026-10-24 报障）。 */
+    var mainTxt = rt.engine ? (rt.engine + (rt.model ? ' · ' + qaModelText(rt.model, rt.engine) : '')) : '跟随主引擎';
+    var fbTxt = fallbackLine(rt.fallbackEngine, rt.fallbackModel);
+    var val = hEl('span', 'setrow__v setrow__v--pair');
+    val.appendChild(hEl('span', 'setrow__pair-main', mainTxt));
+    if (fbTxt) val.appendChild(hEl('span', 'setrow__pair-fb', fbTxt));
+    v.appendChild(val);
     v.appendChild(hEl('span', 'setrow__chev', '›'));
     v.onclick = function () {
       openTeamEnginePicker(key,
@@ -5306,7 +7548,6 @@ button.setrow{font-family:inherit}
      这里问的是「这类活谁擅长」，所以不写「交给 core 自动路由」—— 说「自动」会让人以为
      不配也能跑，而实际语义是「跟主引擎一致」。 */
   function openTeamEnginePicker(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', '正在探测引擎与模型…');
@@ -5314,7 +7555,7 @@ button.setrow{font-family:inherit}
       body.appendChild(hint);
       fetchEngines().then(function (list) {
         if (hint.parentNode) hint.remove();
-        var avail = list.filter(function (x) { return x.ok; });
+        var avail = pickableEngines(list);
         if (!avail.length) {
           var d = hEl('div', 'history__hint', '没有可用引擎：先在桌面上装一个（magic-agent --engines 会给出安装命令）。');
           d.style.textAlign = 'left';
@@ -5323,54 +7564,93 @@ button.setrow{font-family:inherit}
         }
         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 = isRole
-          ? '只选这一类活交给谁；「这类任务适合什么」在团队模式页的「规则」卡里改。'
-          : '计划阶段负责把任务拆成子任务，交给更擅长规划、上下文更长的引擎更稳；拆解规则在「规则」卡里改。';
-        var tip = hEl('div', 'history__hint', tipText);
-        tip.style.textAlign = 'left';
-        body.appendChild(tip);
+        /* 主 / 备两档共用一套「引擎 → 模型」级联：顶上分段切目标，下面的点击落到
+           当前那一档（2026-10-24 用户：「所有引擎设置都允许设置主备两个」）。 */
+        var mode = 'main';
+        var seg = hEl('span', 'seg');
+        seg.style.margin = '0 12px 8px';
+        [['main', '主引擎'], ['fallback', '备用']].forEach(function (p) {
+          var b = hEl('button', 'seg__b' + (mode === p[0] ? ' is-on' : ''), p[1]);
+          b.type = 'button';
+          b.setAttribute('data-v', p[0]);
+          b.onclick = function () {
+            mode = p[0];
+            /* 换档 = 从「已保存的那一个」重新开始浏览（不沿用另一档的浏览位置）。 */
+            browse[mode] = '';
+            markSeg(seg, mode);
+            paint();
+          };
+          seg.appendChild(b);
+        });
+        body.appendChild(seg);
         var wrap = hEl('div', 'pick__cols');
         var left = hEl('div', 'pick__col');
         var right = hEl('div', 'pick__col pick__col--r');
         wrap.appendChild(left); wrap.appendChild(right); body.appendChild(wrap);
+        var curEng = avail[0];
+        /* 每一档「此刻在浏览哪个引擎」：点左列只切右列（还没落定），不能因为重画
+           又跳回已保存的那一个 —— 否则点备用后选任何引擎都会被立刻弹回去，
+           表现就是「备用选不了」（2026-10-24 报障）。 */
+        var browse = { main: '', fallback: '' };
+        function cur() {
+          var rt = (TEAM.routes || {})[key] || {};
+          if (mode === 'fallback') return { engine: rt.fallbackEngine || '', model: rt.fallbackModel || '' };
+          return { engine: rt.engine || '', model: rt.model || '' };
+        }
+        function pick(engine, model) {
+          /* 选完**不关**抽屉：主 / 备在同一屏里一次配完（2026-10-24 用户口径）。 */
+          if (mode === 'fallback') setTeamFallback(key, engine, model, true);
+          else setTeamRoute(key, engine, model, true);
+          browse[mode] = engine || '';   // 清空后回到默认浏览位置
+          paint();
+        }
         function paint() {
           left.innerHTML = ''; right.innerHTML = '';
-          var auto = hEl('button', 'pick__citem' + (!cur.engine ? ' is-on' : ''));
+          var c = cur();
+          var want = browse[mode] || c.engine;
+          curEng = avail.filter(function (en) { return en.engine === want; })[0] || avail[0];
+          browse[mode] = curEng.engine;
+          var offLabel = mode === 'fallback' ? '不设备用' : '跟随主引擎';
+          var offDesc = mode === 'fallback'
+            ? (kind === 'plan' ? '计划阶段跟随主引擎，失败不降级' : '与主引擎一致，失败不降级')
+            : (kind === 'plan' ? '计划阶段走主引擎' : '不单独指定，和主引擎一致');
+          var auto = hEl('button', 'pick__citem' + (!c.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, '', ''); };
+          auto.appendChild(hEl('span', 'pick__cl', offLabel));
+          auto.appendChild(hEl('span', 'pick__cd', offDesc));
+          auto.onclick = function () { pick('', ''); };
           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' : ''));
+              + (c.engine === en.engine ? ' is-on' : '')
+              + (en.engine === curEng.engine && c.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(); };
+            b.appendChild(hEl('span', 'pick__cd', engineSubLine(en)));
+            /* 账号剩余积分（codebuddy 系才有 credit_left，见 core --engines）。 */
+            if (en.credit_left) {
+              b.appendChild(hEl('span', 'pick__cd pick__cd--credit', '剩余 ' + en.credit_left + (en.credit_suffix || ' 积分')));
+            }
+            /* 每日积分：没领就画「领取」（点它只领积分，不切引擎）；已领显示状态。 */
+            if (en.checkin_today === false) {
+              var chip = hEl('span', 'pick__cd pick__cd--credit pick__claim',
+                en._claimBusy ? '领取中…' : ('领取 ' + (en.checkin_credit || '') + ' 积分'));
+              chip.addEventListener('click', function (ev) {
+                ev.preventDefault(); ev.stopPropagation();
+                claimCheckinFor(en, paint);
+              });
+              b.appendChild(chip);
+            }
+            b.onclick = function () { browse[mode] = en.engine; 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' : ''));
+          qaModelsOrdered(ENGINES, curEng.engine, curEng.models || []).forEach(function (mm) {
+            var b = hEl('button', 'pick__citem' + (c.engine === curEng.engine && c.model === mm ? ' is-on' : ''));
             b.type = 'button';
             modelItem(b, curEng.engine, mm);
-            b.onclick = function () { setTeamRoute(key, curEng.engine, mm); };
+            b.onclick = function () { pick(curEng.engine, mm); };
             right.appendChild(b);
           });
         }
@@ -5474,18 +7754,54 @@ button.setrow{font-family:inherit}
     row.appendChild(t);
     return row;
   }
-  function setTeamRoute(key, engine, model) {
+  function setTeamRoute(key, engine, model, keepOpen) {
     TEAM.routes = TEAM.routes || {};
-    if (!engine) delete TEAM.routes[key];
-    else TEAM.routes[key] = model ? { engine: engine, model: model } : { engine: engine };
+    var prev = TEAM.routes[key] || {};
+    var next = {};
+    if (engine) {
+      next.engine = engine;
+      if (model) next.model = model;
+    }
+    /* 主备是两份独立配置：改主引擎不能把已经配好的备用一起清掉。 */
+    if (prev.fallbackEngine) {
+      next.fallbackEngine = prev.fallbackEngine;
+      if (prev.fallbackModel) next.fallbackModel = prev.fallbackModel;
+    }
+    if (Object.keys(next).length) TEAM.routes[key] = next;
+    else delete TEAM.routes[key];
     saveTeamPref();
     applyTeamToLive();
+    if (keepOpen) return;
     closeHostSheet();
     var r = (TEAM.routes || {})[key];
     var label = teamRouteLabel(key);
-    toast(r ? (label + '交给 ' + r.engine + (r.model ? ' · ' + qaModelText(r.model) : ''))
+    toast(r && r.engine ? (label + '交给 ' + r.engine + (r.model ? ' · ' + qaModelText(r.model, r.engine) : ''))
             : (label + '：跟随主引擎'));
   }
+  /* 备用引擎（2026-10-24）：主引擎失败且零产出时降级到这一路。
+     与主引擎分开存，换主引擎不动备用；空 = 不降级。 */
+  function setTeamFallback(key, engine, model, keepOpen) {
+    TEAM.routes = TEAM.routes || {};
+    var prev = TEAM.routes[key] || {};
+    var next = {};
+    if (prev.engine) {
+      next.engine = prev.engine;
+      if (prev.model) next.model = prev.model;
+    }
+    if (engine) {
+      next.fallbackEngine = engine;
+      if (model) next.fallbackModel = model;
+    }
+    if (Object.keys(next).length) TEAM.routes[key] = next;
+    else delete TEAM.routes[key];
+    saveTeamPref();
+    applyTeamToLive();
+    if (keepOpen) return;
+    closeHostSheet();
+    toast(engine
+      ? (teamRouteLabel(key) + '备用：' + engine + (model ? ' · ' + qaModelText(model, engine) : ''))
+      : (teamRouteLabel(key) + '：不设备用（失败不降级）'));
+  }
   /* 配置改了要同步到活着的组件（组件每轮现读 teamConfig，改完下一轮就生效）。
      ⚠️ 这里**不碰开关**：开关是每条会话自己的状态，改「哪类任务交给谁」不该顺手把
         当前会话的团队模式打开/关掉。 */
@@ -5511,13 +7827,20 @@ button.setrow{font-family:inherit}
   /* 一行模型（左名字、右倍率）：名字过长只挤自己，倍率列不会跟着抖
      （`.pick__crow` 样式见 shared/conversation.css）。
      倍率本身不在宿主里再算一遍 —— 直接用内核的 qaModelCredit（它认 core 原样
-     snake_case 与 PC 归一后的 camelCase，且**没数据就返回空串**，不编「×1」）。 */
+     snake_case 与 PC 归一后的 camelCase，且**没数据就返回空串**，不编「×1」）。
+     dsh 补第二层路由名：同名模型可能挂在多条路由下，只给末段分不出来。 */
   function modelItem(b, engine, id) {
     var row = hEl('span', 'pick__crow');
-    row.appendChild(hEl('span', 'pick__cl', qaModelText(id)));
+    row.appendChild(hEl('span', 'pick__cl', qaModelText(id, engine)));
     var credit = qaModelCredit(ENGINES, engine, id);
     if (credit) row.appendChild(hEl('span', 'pick__cr', credit));
     b.appendChild(row);
+    /* 第二行：供应商（dsh 是路由名，其余引擎用 core 的 model_vendors）与套餐额度
+       合并成一行，例如「MiniMax · 5h 100% · 周 0%」—— 用户口径：和供应商在一行即可。 */
+    var quota = qaModelQuota(ENGINES, engine, id);
+    var sub = qaModelRoute(id, engine) || qaModelVendor(ENGINES, engine, id);
+    var extra = [sub, quota].filter(Boolean).join(' · ');
+    if (extra) b.appendChild(hEl('span', 'pick__cd' + (quota ? ' pick__cd--credit' : ''), extra));
   }
   /* 引擎清单：走 client 的 /desk/engines（= core --engines 的原样 JSON，含 models）。
      ⚠️ 这个请求会真的起各引擎的只读子命令探测模型，慢（秒级），所以只在打开选择器时拉，
@@ -5554,6 +7877,65 @@ button.setrow{font-family:inherit}
       throw e;
     });
   }
+  /* 进选择器的引擎：探测成功、**已登录**且**能列出模型**。没登录 / 取不到清单的
+     （如 trae、登出后的 codebuddy-ai）不出现 —— 「登录了几个账号就显示几个」
+     （2026-10-25 用户要求）。 */
+  function pickableEngines(list) {
+    return (list || []).filter(function (en) {
+      if (!en || !en.ok) return false;
+      if (en.logged_in === false) return false;
+      return (en.models || []).length > 0 || !en.models_note;
+    });
+  }
+  /* 引擎行副标题：有模型报数量，否则「引擎默认」；多账号引擎前面带上登录的账号昵称
+     （codebuddy 系的 account 字段），一眼看出这行是哪个号。 */
+  function engineSubLine(en) {
+    var n = (en.models || []).length;
+    var head = n ? (n + ' 个模型') : '引擎默认';
+    return en.account ? (en.account + ' · ' + head) : head;
+  }
+  /* 领取每日积分（codebuddy 系）：走插件侧 /desk/checkin → core --checkin。
+     业务失败（今天已领）也是 200，ok:false + message，按普通提示显示。 */
+  function claimCheckin(engine) {
+    var hdr = TOKEN
+      ? { 'X-Magic-Token': TOKEN, 'Content-Type': 'application/json' }
+      : { 'Content-Type': 'application/json' };
+    return fetch(BASE + '/desk/checkin', {
+      method: 'POST', headers: hdr, body: JSON.stringify({ engine: engine })
+    }).then(function (r) {
+      return r.json().then(function (j) {
+        if (!r.ok) {
+          var err = new Error((j && (j.error || j.message)) || ('HTTP ' + r.status));
+          err.status = r.status;
+          throw err;
+        }
+        return j;
+      });
+    });
+  }
+  /* 点「领取」后就地更新这一行并重画（不重探整份引擎清单）。
+     领取结果**不弹任何提示**（2026-10-25 用户要求）：成功/已领只把状态翻成「今日已领」，
+     失败静默恢复按钮。 */
+  function claimCheckinFor(en, repaint) {
+    if (en._claimBusy) return;
+    en._claimBusy = true;
+    repaint();
+    claimCheckin(en.engine).then(function (res) {
+      en._claimBusy = false;
+      if (res && res.ok) {
+        en.checkin_today = true;
+        en.checkin_credit = '';
+        if (res.credit_left) en.credit_left = res.credit_left;
+      } else if (res && res.checked_today) {
+        en.checkin_today = true;
+        en.checkin_credit = '';
+      }
+      repaint();
+    }, function () {
+      en._claimBusy = false;
+      repaint();
+    });
+  }
   /* 缓存提示（stale-while-revalidate：插件立刻回上次的清单，同时在后台重探）。无缓存返回 null。 */
   function enginesStaleHint() {
     if (!ENGINES_STALE_AT) return null;
@@ -5566,12 +7948,13 @@ button.setrow{font-family:inherit}
     el.style.textAlign = 'left';
     return el;
   }
-  /* 「我的 → 建议引擎」：单列，首项「不开启」。不展示模型 —— 建议是纯文本短任务，
-     选模型只会让界面更复杂；建议生成对 llm 会用不思考的变体作默认值。 */
-  /* 「我的 → 建议引擎 / 模型」：与默认引擎同一个二列抽屉（左引擎 · 右模型）。
-     首项「不开启」；点左列只浏览、点右列才落定。llm 放最前，模型为空时建议生成用 no-think 变体作默认值。 */
-  function openSuggestEnginePicker() {
-    openHostSheet('建议引擎 / 模型', function (body) {
+  /* ── 引擎设置抽屉：**一次点击里配主 + 备**（2026-10-24 用户：「这样布局太浪费了，
+     要在一次点击里面设置两个」）。
+     顶部「主引擎 / 备用」分段；选完**不关抽屉**，切到另一档继续配，关掉即生效。
+     默认引擎与建议引擎共用（「建议引擎」= 纯文本短任务，llm 放最前、空模型用 no-think 变体）。
+     cfg: getMain/getFallback/setMain/setFallback + 两档的文案（见下面两个入口）。 */
+  function openPairEngineSheet(title, cfg) {
+    openHostSheet(title, function (body) {
       body.innerHTML = '';
       var hint = hEl('div', 'history__hint', '正在探测引擎与模型…');
       hint.style.textAlign = 'left';
@@ -5580,13 +7963,8 @@ button.setrow{font-family:inherit}
         if (hint.parentNode) hint.remove();
         var stale = enginesStaleHint();
         if (stale) body.appendChild(stale);
-        var avail = (list || []).filter(function (x) { return x && x.ok; });
-        /* 推荐的放最上面：llm 是建议这条旁路最快的引擎。 */
-        avail.sort(function (a, b) {
-          if (a.engine === 'llm') return -1;
-          if (b.engine === 'llm') return 1;
-          return String(a.engine).localeCompare(String(b.engine));
-        });
+        var avail = pickableEngines(list);
+        if (cfg.sort) avail.sort(cfg.sort);
         if (!avail.length) {
           var d = hEl('div', 'history__hint',
             '没有可用引擎：先在这台机器上装一个（终端跑 magic-agent --engines 会给出安装命令）。');
@@ -5594,68 +7972,116 @@ button.setrow{font-family:inherit}
           body.appendChild(d);
           return;
         }
-        buildEngineCascade(body, avail, {
-          prefs: SUGGEST,
-          pick: pickSuggestPref,
-          offLabel: '不开启',
-          offDesc: '不生成下一轮建议（默认）',
-          modelDefaultDesc: '不指定模型（建议生成用 no-think 变体）',
+        var mode = 'main';
+        var seg = hEl('span', 'seg');
+        seg.style.margin = '0 12px 8px';
+        [['main', '主引擎'], ['fallback', '备用']].forEach(function (p) {
+          var b = hEl('button', 'seg__b' + (mode === p[0] ? ' is-on' : ''), p[1]);
+          b.type = 'button';
+          b.setAttribute('data-v', p[0]);
+          b.onclick = function () { mode = p[0]; markSeg(seg, mode); render(); };
+          seg.appendChild(b);
         });
-        /* 建议生成一律不思考。各引擎都走官方关闭参数；某些模型路由不支持时
-           才在超时/报错后降级 llm，不预先吞掉用户的选择。 */
-        var nk = hEl('div', 'history__hint',
-          '建议生成固定关闭思考：claude --thinking disabled、codex effort none、llm reasoning_effort=none（显式模型不换；空模型用 no-think 变体）、codebuddy alwaysThinkingEnabled=false、dsh reasoningEffort=off；引擎失败才降级 llm。');
-        nk.style.textAlign = 'left';
-        body.appendChild(nk);
+        /* 两档都不再画说明文字（主/备引擎的说明、建议引擎的说明都不需要）。 */
+        var holder = hEl('div', '');
+        body.appendChild(seg);
+        body.appendChild(holder);
+        function render() {
+          variantRender(holder, avail, mode, cfg, render);
+        }
+        render();
+        if (cfg.footNote) {
+          var nk = hEl('div', 'history__hint', cfg.footNote);
+          nk.style.textAlign = 'left';
+          body.appendChild(nk);
+        }
       }, function (e) {
         hint.textContent = '拉取引擎清单失败：' + ((e && e.message) || e);
         var retry = hEl('button', 'pick__citem', '重试');
         retry.type = 'button';
-        retry.onclick = function () { openSuggestEnginePicker(); };
+        retry.onclick = function () { openPairEngineSheet(title, cfg); };
         body.appendChild(retry);
       });
     });
   }
-  function pickSuggestPref(engine, model) {
-    SUGGEST.engine = String(engine || '').trim();
-    SUGGEST.model = (SUGGEST.engine && model) ? String(model).trim() : '';
-    saveSuggestPref();
-    applySuggestToLive();
-    closeHostSheet();
-    toast(SUGGEST.engine
-      ? ('建议引擎：' + SUGGEST.engine + ' · ' + (qaModelText(SUGGEST.model) || '引擎默认模型'))
-      : '已关闭建议功能');
+  /* 一档的「引擎 → 模型」级联（主 / 备共用）。选完调 cfg.set*，然后整块重画
+     （抽屉不关 —— 用户还要接着配另一档）。 */
+  function variantRender(holder, avail, mode, cfg, again) {
+    holder.innerHTML = '';
+    var isMain = mode === 'main';
+    var prefs = isMain ? cfg.getMain() : cfg.getFallback();
+    buildEngineCascade(holder, avail, {
+      prefs: prefs,
+      pick: function (engine, model) {
+        if (isMain) cfg.setMain(engine, model);
+        else cfg.setFallback(engine, model);
+        again();
+      },
+      offLabel: isMain ? cfg.mainOffLabel : cfg.fbOffLabel,
+      offDesc: isMain ? cfg.mainOffDesc : cfg.fbOffDesc,
+      modelDefaultDesc: isMain ? cfg.modelDesc : cfg.fbModelDesc,
+      /* 「自动 / 引擎默认」只在**主档**按需去掉（备用档要保留「不设置」才能清空降级）。 */
+      hideOff: isMain && !!cfg.hideMainOff,
+      hideModelDefault: isMain && !!cfg.hideMainModelDefault
+    });
+  }
+  function openSuggestEnginePicker() {
+    openPairEngineSheet('建议引擎 / 模型', {
+      sort: function (a, b) {
+        if (a.engine === 'llm') return -1;
+        if (b.engine === 'llm') return 1;
+        return String(a.engine).localeCompare(String(b.engine));
+      },
+      getMain: function () { return { engine: SUGGEST.engine, model: SUGGEST.model }; },
+      getFallback: function () { return { engine: SUGGEST.fbEngine, model: SUGGEST.fbModel }; },
+      setMain: function (engine, model) {
+        SUGGEST.engine = String(engine || '').trim();
+        SUGGEST.model = (SUGGEST.engine && model) ? String(model).trim() : '';
+        saveSuggestPref();
+        applySuggestToLive();
+      },
+      setFallback: function (engine, model) {
+        SUGGEST.fbEngine = String(engine || '').trim();
+        SUGGEST.fbModel = (SUGGEST.fbEngine && model) ? String(model).trim() : '';
+        saveSuggestPref();
+        applySuggestToLive();
+      },
+      mainOffLabel: '不开启',
+      mainOffDesc: '不生成下一轮建议（默认）',
+      fbOffLabel: '不设置',
+      fbOffDesc: '主建议引擎失败时直接落到 llm 兜底',
+      modelDesc: '不指定模型（建议生成用 no-think 变体）',
+      fbModelDesc: '建议备用引擎自己的默认模型'
+    });
   }
 
   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();
+    openPairEngineSheet('默认引擎 / 模型', {
+      sort: function (a, b) { return String(a.engine).localeCompare(String(b.engine)); },
+      /* 默认引擎不再提供「自动（首个可用）」与「引擎默认」两项：用户直接选引擎 + 模型
+         （2026-10-24 用户：「引擎不需要自动 模型不需要引擎默认」）。 */
+      hideMainOff: true,
+      hideMainModelDefault: true,
+      getMain: function () { return { engine: RUN_PREF.engine, model: RUN_PREF.model }; },
+      getFallback: function () { return { engine: RUN_PREF.fbEngine, model: RUN_PREF.fbModel }; },
+      setMain: function (engine, model) {
+        RUN_PREF.engine = String(engine || '').trim();
+        RUN_PREF.model = (RUN_PREF.engine && model) ? String(model).trim() : '';
+        saveRunPref();
+        applyRunPrefToLive();
+      },
+      setFallback: function (engine, model) {
+        RUN_PREF.fbEngine = String(engine || '').trim();
+        RUN_PREF.fbModel = (RUN_PREF.fbEngine && model) ? String(model).trim() : '';
+        saveRunPref();
+        applyRunPrefToLive();
+      },
+      mainOffLabel: '自动',
+      mainOffDesc: '首个可用引擎',
+      fbOffLabel: '不设置',
+      fbOffDesc: '主引擎失败时不降级',
+      modelDesc: '不指定模型，由引擎自己挑',
+      fbModelDesc: '备用引擎自己的默认模型'
     });
   }
   /* 二列级联（左引擎 · 右该引擎的模型），与对话框里那套同构：
@@ -5680,12 +8106,16 @@ button.setrow{font-family:inherit}
 
     function paint() {
       left.innerHTML = ''; right.innerHTML = '';
-      var off = hEl('button', 'pick__citem' + (!prefs.engine ? ' is-on' : ''));
-      off.type = 'button';
-      off.appendChild(hEl('span', 'pick__cl', offLabel));
-      off.appendChild(hEl('span', 'pick__cd', offDesc));
-      off.onclick = function () { pick('', ''); };
-      left.appendChild(off);
+      /* 引擎列保留「N 个模型」这行小字（它不是主备说明）；列宽已在 CSS 里收窄，
+         右列因此能把长模型名显示全。 */
+      if (!o.hideOff) {
+        var off = hEl('button', 'pick__citem' + (!prefs.engine ? ' is-on' : ''));
+        off.type = 'button';
+        off.appendChild(hEl('span', 'pick__cl', offLabel));
+        off.appendChild(hEl('span', 'pick__cd', offDesc));
+        off.onclick = function () { pick('', ''); };
+        left.appendChild(off);
+      }
 
       avail.forEach(function (en) {
         var n = (en.models || []).length;
@@ -5696,19 +8126,35 @@ button.setrow{font-family:inherit}
           + (en.engine === cur.engine && prefs.engine !== en.engine ? ' is-cur' : ''));
         b.type = 'button';
         b.appendChild(hEl('span', 'pick__cl', en.engine));
-        b.appendChild(hEl('span', 'pick__cd', n ? (n + ' 个模型') : '引擎默认'));
+        b.appendChild(hEl('span', 'pick__cd', engineSubLine(en)));
+        /* 账号剩余积分（codebuddy 系才有 credit_left，见 core --engines）。 */
+        if (en.credit_left) {
+          b.appendChild(hEl('span', 'pick__cd pick__cd--credit', '剩余 ' + en.credit_left + (en.credit_suffix || ' 积分')));
+        }
+        /* 每日积分：没领就画「领取」（点它只领积分，不切引擎）；已领显示状态。 */
+        if (en.checkin_today === false) {
+          var chip2 = hEl('span', 'pick__cd pick__cd--credit pick__claim',
+            en._claimBusy ? '领取中…' : ('领取 ' + (en.checkin_credit || '') + ' 积分'));
+          chip2.addEventListener('click', function (ev) {
+            ev.preventDefault(); ev.stopPropagation();
+            claimCheckinFor(en, paint);
+          });
+          b.appendChild(chip2);
+        }
         b.onclick = function () { cur = en; paint(); };
         left.appendChild(b);
       });
 
-      var d = hEl('button', 'pick__citem' + (prefs.engine === cur.engine && !prefs.model ? ' is-on' : ''));
-      d.type = 'button';
-      d.appendChild(hEl('span', 'pick__cl', '引擎默认'));
-      d.appendChild(hEl('span', 'pick__cd', modelDefaultDesc));
-      d.onclick = function () { pick(cur.engine, ''); };
-      right.appendChild(d);
+      if (!o.hideModelDefault) {
+        var d = hEl('button', 'pick__citem' + (prefs.engine === cur.engine && !prefs.model ? ' is-on' : ''));
+        d.type = 'button';
+        d.appendChild(hEl('span', 'pick__cl', '引擎默认'));
+        d.appendChild(hEl('span', 'pick__cd', modelDefaultDesc));
+        d.onclick = function () { pick(cur.engine, ''); };
+        right.appendChild(d);
+      }
 
-      (cur.models || []).forEach(function (mm) {
+      qaModelsOrdered(ENGINES, cur.engine, cur.models || []).forEach(function (mm) {
         var b = hEl('button', 'pick__citem' + (prefs.engine === cur.engine && prefs.model === mm ? ' is-on' : ''));
         b.type = 'button';
         /* 显示剥掉 `custom-local:` 前缀（`mm` 本身是完整 id，选中时原样存进 prefs），
@@ -5727,7 +8173,7 @@ button.setrow{font-family:inherit}
     applyRunPrefToLive();
     closeHostSheet();
     toast(RUN_PREF.engine
-      ? ('默认引擎：' + RUN_PREF.engine + ' · ' + (qaModelText(RUN_PREF.model) || '引擎默认模型'))
+      ? ('默认引擎：' + RUN_PREF.engine + ' · ' + (qaModelText(RUN_PREF.model, RUN_PREF.engine) || '引擎默认模型'))
       : '默认引擎：自动（首个可用）');
   }
   /* 改默认值只同步**还没发过任务的新会话**；历史会话保持它自己的引擎，
@@ -5736,11 +8182,13 @@ button.setrow{font-family:inherit}
     if (!conv || !conv.state || conv.state.session) return;
     var eng = RUN_PREF.engine;
     if (!eng) {
-      var first = ENGINES.filter(function (x) { return x.ok; })[0];
+      var first = pickableEngines(ENGINES)[0];
       eng = first ? first.engine : '';
     }
     if (conv.setEngine) conv.setEngine(eng);
     if (conv.setModel) conv.setModel(eng ? (RUN_PREF.engine ? RUN_PREF.model : '') : '');
+    /* 主备：备用与主引擎的选择相互独立（只配备用也能生效）。 */
+    if (conv.setFallback) conv.setFallback(RUN_PREF.fbEngine, RUN_PREF.fbModel);
   }
   /* 会话里点了具体模型/「引擎默认」→ 记住成默认（组件 onPick 回调）。 */
   function rememberRunPick(engine, model) {
@@ -5778,6 +8226,74 @@ button.setrow{font-family:inherit}
     Promise.all(jobs.map(function (p) { return p.catch(function () {}); })).then(done, done);
   }
 
+  /* ══════════ 重启桌面端服务 ══════════
+     2026-10-24 用户：「在移动端我的中增加1个重启按钮 点击后触发magic-client重启」。
+
+     链路（见 internal/client/restart.go）：POST /desk/restart → 桌面端**先立标志、
+     先答 200**（重复点击答 already_pending，不会再起第二个助手），1 秒后由**进程内
+     定时器**拉起一个脱离终端的 `magic-client restart` 助手停旧实例、按状态文件里的
+     参数拉起新实例（端口 / 令牌沿用，手机里存的地址不用改）。
+
+     ⚠️ 会话是桌面端起的子进程：重启会把**正在跑的所有会话**一起中断 → 点之前必须确认。
+     ⚠️ 判断「好了没」：旧实例认账时 /desk/health 会带 restarting=true（它马上要下线，
+        可当成「看到下线」），再探到**不带** restarting 的 200 才算新实例起来了。 */
+  function restartClient() {
+    if (!TOKEN && !BASE) { toast('还没连接桌面'); return; }
+    if (!window.confirm('重启桌面端服务？\n\n正在运行的会话会被中断（状态会变成「中断」，重新打开会话可继续）。')) return;
+    var btn = document.getElementById('btnRestartClient');
+    var val = document.getElementById('restartClientState');
+    if (btn) btn.disabled = true;
+    if (val) val.textContent = '重启中…';
+    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
+    var done = function (label, msg) {
+      if (val) val.textContent = label;
+      if (btn) btn.disabled = false;
+      if (msg) toast(msg);
+    };
+    fetch(BASE + '/desk/restart', { method: 'POST', headers: hdr })
+      .then(function (r) {
+        if (r.ok) return null;
+        return r.json().catch(function () { return {}; }).then(function (d) {
+          throw new Error((d && d.error) || ('HTTP ' + r.status));
+        });
+      })
+      .then(function () { return waitRestartBack(); })
+      .then(function () {
+        done('重启', '桌面端已重启');
+        loadSessions(true);   // 新实例的会话表（状态已按重启后的实况归一过）
+      })
+      .catch(function (e) {
+        done('重启', '重启未确认：' + (e && e.message ? e.message : e));
+      });
+  }
+  /* 等桌面端**真的换了一代**：旧实例认账（health.restarting=true）或连不上都算「看到
+     下线」，再看到 200（不带 restarting 标志）才算新实例起来。60 秒等不到就当失败 ——
+     实测正常 3-7 秒；但客户端与 watchdog 抢着拉起时见过 30 秒以上（两个实例抢端口，
+     输的那个要等 ready 超时），别让按钮永远停在「重启中…」。 */
+  function waitRestartBack() {
+    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
+    var deadline = Date.now() + 60000;
+    var sawDown = false, settled = false;
+    return new Promise(function (resolve, reject) {
+      (function tick() {
+        if (settled) return;
+        fetch(BASE + '/desk/health', { headers: hdr, cache: 'no-store' })
+          .then(function (r) { return r.ok ? r.json() : null; })
+          .then(function (d) {
+            if (!d) { sawDown = true; return; }                 // 连不上：旧实例真的走了
+            if (d.restarting) { sawDown = true; return; }       // 旧实例认账（restarting 标志）：定时器到点就下线
+            if (sawDown) { settled = true; return resolve(d); } // 不带标志的 200 = 新一代
+          })
+          .catch(function () { sawDown = true; })
+          .then(function () {
+            if (settled) return;                      // 已确认恢复：不再空转探活
+            if (Date.now() > deadline) { settled = true; return reject(new Error('等桌面端恢复超时')); }
+            setTimeout(tick, 400);
+          });
+      })();
+    });
+  }
+
   /* ══════════ 接线 ══════════ */
   document.getElementById('btnConnect').onclick = function () {
     var target = parseTarget(addrEl.value);
@@ -5810,6 +8326,7 @@ button.setrow{font-family:inherit}
   on('btnRsWorkspace', function () { openWorkspacePicker(); });
   /* 权限 / 团队沿用会话组件里那唯一一份选择器（浮层盖在本页之上）；选完就地重画。 */
   on('btnRsPermission', function () { if (conv && conv.openPermissionPicker) conv.openPermissionPicker(); });
+  on('btnRsReasoning', openReasoningPicker);
   on('btnRsTeam', function () { if (conv && conv.openTeamPicker) conv.openTeamPicker(); });
   /* 会话托管（2026-10-23，按会话）：只有开 / 关两档，直接翻当前这条会话。 */
   on('btnRsHosting', toggleHostingHere);
@@ -5845,10 +8362,82 @@ button.setrow{font-family:inherit}
       getBase: function () { return BASE; },
       getToken: function () { return TOKEN; },
       getRootDirs: function () { return ROOT_DIRS; },
-      getCustomSpaces: function () { return CUSTOM_SPACES; },
+      /* 空间清单给的是**路径数组**（需求页只拿它判「这个空间还在不在」）；
+         别名另开一个口子（getSpaceAlias），免得需求页去拆对象。 */
+      getCustomSpaces: function () { return CUSTOM_SPACES.map(function (s) { return s.path; }); },
+      getSpaceAlias: function (dir) { var it = customSpaceOf(dir); return it ? (it.alias || '') : ''; },
       getRunPref: function () { return RUN_PREF; },
       isRealSpaceDir: isRealSpaceDir,
-      topLevelSessions: topLevelSessions
+      topLevelSessions: topLevelSessions,
+      /* core 不支持截图能力位时，相机徽标整个不出现（不给「点了必然 501」的死入口）。 */
+      canShot: hasReqShotFeature,
+      /* 「页面完成情况」截图的入口（reqshot.js 用）。core 不支持这个能力位时
+         徽标干脆不出现 —— 与其给一个点了必然 501 的按钮，不如不给。 */
+      openShot: function (task) {
+        if (!hasReqShotFeature()) { toast('当前桌面端不支持需求截图，请升级'); return; }
+        if (window.MagicReqShot && window.MagicReqShot.open) window.MagicReqShot.open(task);
+      },
+      /* 存完截图后刷新需求清单（徽标上的「待截图 / N 图」要跟着变）。 */
+      refreshReqs: function () { if (window.MagicReqs && window.MagicReqs.show) window.MagicReqs.show(); }
+    });
+  }
+  /* 需求页的「页面完成情况」截图与标注（reqshot.js）：宿主只给这几件能力 ——
+     浏览器（必须走中转，截图能力靠中转注入的 relay）、抽屉、令牌、以及清单刷新。 */
+  if (window.MagicReqShot && window.MagicReqShot.mount) {
+    window.MagicReqShot.mount({
+      hEl: hEl,
+      elSpan: elSpan,
+      toast: toast,
+      openSheet: openHostSheet,
+      closeSheet: closeHostSheet,
+      getBase: function () { return BASE; },
+      getToken: function () { return TOKEN; },
+      /* 打开页面（走中转）：截图能力**只存在于中转链路** ——
+         手机直连的外站页面里没有 relay，截不了。所以这里强制走 brProxyURL。 */
+      openBrowseProxy: function (u) {
+        brStack = [u];
+        brFrame.src = u;
+        brPaint();
+        brResetFloat();
+        brEl.hidden = false;
+      },
+      proxyURL: function (u) { return brProxyURL(u); },
+      /* 强制打开中转开关（截图的前提）；用完可以由用户自己关回去。 */
+      setRelayOn: function (on) {
+        try { localStorage.setItem(BR_RELAY_KEY, on ? '1' : '0'); } catch (e) {}
+        brPaintRelay();
+      },
+      /* 当前中转开关的状态（截图流程结束时还原成用户自己的选择）。 */
+      relayOn: function () { return brRelayOn(); },
+      /* 浏览器工具栏上的「截图」按钮：只在截图流程里出现。 */
+      setShotBtn: function (on) { if (brShotBtn) brShotBtn.hidden = !on; }
+    });
+  }
+  /* 脚本页（scripts.js）：内容与逻辑不在本文件，这里只注入宿主能力并挂载一次。
+     getter 形式传 BASE/TOKEN —— 切环境后这些值会变，不能传快照。
+     ⚠️ openSheet / closeSheet 借宿主的抽屉（.field / .btn 样式都在宿主那一套里，
+        自己再造一套会出现「两种输入框」）。 */
+  if (window.MagicScripts && window.MagicScripts.mount) {
+    window.MagicScripts.mount({
+      rootEl: scriptsEl,
+      detailEl: scriptDetailEl,
+      hEl: hEl,
+      elSpan: elSpan,
+      svgUse: svgUse,
+      toast: toast,
+      hideAll: hideAll,
+      setActive: setActive,
+      showRoot: function () {
+        hideAll();
+        scriptsEl.hidden = false;
+        tabbarEl.hidden = true;
+      },
+      showDetail: showScriptDetail,
+      backToDiscover: showDiscover,
+      openSheet: openHostSheet,
+      closeSheet: closeHostSheet,
+      getBase: function () { return BASE; },
+      getToken: function () { return TOKEN; }
     });
   }
   Array.prototype.forEach.call(tabbarEl.querySelectorAll('.tab'), function (b) {
@@ -5868,6 +8457,10 @@ button.setrow{font-family:inherit}
   on('dscBrowser', function () { openBrowser(HOME_URL); });
   on('dscApps', function () { openComingSheet('应用', '暂无可用应用。桌面端发布的应用会出现在这里。'); });
   on('dscPlugins', function () { showPlugins(); });
+  on('dscScripts', function () { showScripts(); });
+  on('dscKnowledge', function () { showKnowledge(); });
+  on('btnKnowledgeBack', function () { showDiscover(); });
+  on('btnKnowledgeDetailBack', function () { showKnowledge(); });
   on('btnPluginsBack', function () { showDiscover(); });
   on('btnPluginDetailBack', function () { showPlugins(); });
   on('dscSkill', function () { openComingSheet('SKILL', '暂无可用 SKILL。技能包上线后将在此展示。'); });
@@ -5879,21 +8472,27 @@ button.setrow{font-family:inherit}
   on('brRefresh', brReload);
   on('brShare', brShare);
   on('brStar', brToggleStar);
+  on('brRelay', brToggleRelay);
+  /* 截图按钮：需求页「页面完成情况」流程专用（reqshot.js 发指令、收图）。
+     浏览器关掉时收尾 —— 别留一个半开的截图通道。 */
+  on('brShot', function () {
+    if (window.MagicReqShot && window.MagicReqShot.capture) window.MagicReqShot.capture();
+  });
+  brPaintRelay();
   on('btnNotify', openNotifySettings);
   on('btnDefaultEngine', openDefaultEnginePicker);
-  on('btnDefaultModel', openDefaultEnginePicker);
   on('btnSuggestEngine', openSuggestEnginePicker);
-  on('btnSuggestModel', openSuggestEnginePicker);
   /* 团队模式配置（「我的」→ 子页面）：计划 + 7 个角色，行由 paintTeamRoles 动态渲染，
      行的点击在渲染时绑定（见 addTeamRouteRow / addTeamRuleRow），这里只留入口与返回。 */
   on('btnTeamPage', showTeamPage);
   on('btnTeamBack', showMine);
   on('btnLogout', disconnect);
   on('btnUpgrade', reloadApp);
+  on('btnRestartClient', restartClient);
   on('btnMineVersion', checkAppUpdate);
   if (segTheme) takeSeg(segTheme, 'magic.theme', function (v) { PREFS.theme = v; applyThemePref(v); });
   if (segFont) takeSeg(segFont, 'magic.font', function (v) { PREFS.font = v; applyFontPref(v); });
-  if (segMode) takeSeg(segMode, 'magic.taskmode', function (v) { TASK_MODE = v; });
+  if (segMode) takeSeg(segMode, 'magic.taskmode', function (v) { TASK_MODE = v; applyTaskModeToQueued(v); });
 
   /* 会话托管（2026-10-23 起按会话）：入口在会话页 → 任务运行设置（见 btnRsHosting）。
      「我的」里不再有全局开关 —— 曾经那枚 `tglHosting` 写的是设备级 `magic.hosting`，
@@ -5903,7 +8502,7 @@ button.setrow{font-family:inherit}
      把整机流量经隧道送到桌面端的 SOCKS5 出口：TUN → 内核 → 桌面端 → 互联网。
      只在 App 壳里可用（需要原生 VpnService）；网页环境如实说不支持。 */
   var tglVpn = document.getElementById('tglVpn');
-  var VPN_ON = false;          // 网络代理是否真的在跑（浏览器据此决定要不要再走 /b/ 中转）
+  var VPN_ON = false;          // 网络代理是否真的在跑（开关状态；浏览器默认直连，见 brLoad）
   function vpnBase() {
     var b = BASE;
     if (!b && /^https?:$/i.test(location.protocol)) b = location.origin;